inline bool cg_int(arma::vec& init_out_vals, std::function<double (const arma::vec& vals_inp, arma::vec* grad_out, void* opt_data)> opt_objfn, void* opt_data, algo_settings_t* settings_inp) { // notation: 'p' stands for '+1'. // bool success = false; const size_t n_vals = init_out_vals.n_elem; // // CG settings algo_settings_t settings; if (settings_inp) { settings = *settings_inp; } const uint_t conv_failure_switch = settings.conv_failure_switch; const uint_t iter_max = settings.iter_max; const double err_tol = settings.err_tol; const uint_t cg_method = settings.cg_method; // update method const double cg_restart_threshold = settings.cg_restart_threshold; const double wolfe_cons_1 = 1E-03; // line search tuning parameters const double wolfe_cons_2 = 0.10; const bool vals_bound = settings.vals_bound; const arma::vec lower_bounds = settings.lower_bounds; const arma::vec upper_bounds = settings.upper_bounds; const arma::uvec bounds_type = determine_bounds_type(vals_bound, n_vals, lower_bounds, upper_bounds); // lambda function for box constraints std::function<double (const arma::vec& vals_inp, arma::vec* grad_out, void* box_data)> box_objfn \ = [opt_objfn, vals_bound, bounds_type, lower_bounds, upper_bounds] (const arma::vec& vals_inp, arma::vec* grad_out, void* opt_data) \ -> double { if (vals_bound) { arma::vec vals_inv_trans = inv_transform(vals_inp, bounds_type, lower_bounds, upper_bounds); double ret; if (grad_out) { arma::vec grad_obj = *grad_out; ret = opt_objfn(vals_inv_trans,&grad_obj,opt_data); // arma::mat jacob_matrix = jacobian_adjust(vals_inp,bounds_type,lower_bounds,upper_bounds); arma::vec jacob_vec = arma::diagvec(jacobian_adjust(vals_inp,bounds_type,lower_bounds,upper_bounds)); // *grad_out = jacob_matrix * grad_obj; // no need for transpose as jacob_matrix is diagonal *grad_out = jacob_vec % grad_obj; } else { ret = opt_objfn(vals_inv_trans,nullptr,opt_data); } return ret; } else { return opt_objfn(vals_inp,grad_out,opt_data); } }; // // initialization arma::vec x = init_out_vals; if (!x.is_finite()) { printf("cg error: non-finite initial value(s).\n"); return false; } if (vals_bound) { // should we transform the parameters? x = transform(x, bounds_type, lower_bounds, upper_bounds); } arma::vec grad(n_vals); // gradient box_objfn(x,&grad,opt_data); // double err = arma::accu(arma::abs(grad)); double err = arma::norm(grad, 2); if (err <= err_tol) { return true; } // double t_init = 1.0; // initial value for line search arma::vec d = - grad, d_p; arma::vec x_p = x, grad_p = grad; double t = line_search_mt(t_init, x_p, grad_p, d, &wolfe_cons_1, &wolfe_cons_2, box_objfn, opt_data); err = arma::norm(grad_p, 2); if (err <= err_tol) { init_out_vals = x_p; return true; } // // begin loop uint_t iter = 0; while (err > err_tol && iter < iter_max) { iter++; // double beta = cg_update(grad,grad_p,d,iter,cg_method,cg_restart_threshold); d_p = - grad_p + beta*d; t_init = t * (arma::dot(grad,d) / arma::dot(grad_p,d_p)); grad = grad_p; t = line_search_mt(t_init, x_p, grad_p, d, &wolfe_cons_1, &wolfe_cons_2, box_objfn, opt_data); // err = arma::norm(grad_p, 2); d = d_p; x = x_p; } // if (vals_bound) { x_p = inv_transform(x_p, bounds_type, lower_bounds, upper_bounds); } error_reporting(init_out_vals,x_p,opt_objfn,opt_data,success,err,err_tol,iter,iter_max,conv_failure_switch,settings_inp); // return success; }
bool mcmc::de_int(const arma::vec& initial_vals, arma::cube& draws_out, std::function<double (const arma::vec& vals_inp, void* target_data)> target_log_kernel, void* target_data, algo_settings_t* settings_inp) { bool success = false; const size_t n_vals = initial_vals.n_elem; // // DE settings algo_settings_t settings; if (settings_inp) { settings = *settings_inp; } const size_t n_pop = settings.de_n_pop; const size_t n_gen = settings.de_n_gen; const size_t n_burnin = settings.de_n_burnin; const bool jumps = settings.de_jumps; const double par_b = settings.de_par_b; // const double par_gamma = settings.de_par_gamma; const double par_gamma = 2.38 / std::sqrt(2.0*n_vals); const double par_gamma_jump = settings.de_par_gamma_jump; const arma::vec par_initial_lb = (settings.de_initial_lb.n_elem == n_vals) ? settings.de_initial_lb : initial_vals - 0.5; const arma::vec par_initial_ub = (settings.de_initial_ub.n_elem == n_vals) ? settings.de_initial_ub : initial_vals + 0.5; const bool vals_bound = settings.vals_bound; const arma::vec lower_bounds = settings.lower_bounds; const arma::vec upper_bounds = settings.upper_bounds; const arma::uvec bounds_type = determine_bounds_type(vals_bound, n_vals, lower_bounds, upper_bounds); // lambda function for box constraints std::function<double (const arma::vec& vals_inp, void* box_data)> box_log_kernel \ = [target_log_kernel, vals_bound, bounds_type, lower_bounds, upper_bounds] (const arma::vec& vals_inp, void* target_data) \ -> double { if (vals_bound) { arma::vec vals_inv_trans = inv_transform(vals_inp, bounds_type, lower_bounds, upper_bounds); return target_log_kernel(vals_inv_trans, target_data) + log_jacobian(vals_inp, bounds_type, lower_bounds, upper_bounds); } else { return target_log_kernel(vals_inp, target_data); } }; // arma::vec target_vals(n_pop); arma::mat X(n_pop,n_vals); #ifdef MCMC_USE_OPENMP #pragma omp parallel for #endif for (size_t i=0; i < n_pop; i++) { X.row(i) = par_initial_lb.t() + (par_initial_ub.t() - par_initial_lb.t())%arma::randu(1,n_vals); double prop_kernel_val = box_log_kernel(X.row(i).t(),target_data); if (!std::isfinite(prop_kernel_val)) { prop_kernel_val = neginf; } target_vals(i) = prop_kernel_val; } // // begin MCMC run draws_out.set_size(n_pop,n_vals,n_gen); int n_accept = 0; double par_gamma_run = par_gamma; for (size_t j=0; j < n_gen + n_burnin; j++) { double temperature_j = de_cooling_schedule(j,n_gen); if (jumps && ((j+1) % 10 == 0)) { par_gamma_run = par_gamma_jump; } #ifdef MCMC_USE_OPENMP #pragma omp parallel for #endif for (size_t i=0; i < n_pop; i++) { uint_t R_1, R_2; do { R_1 = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_pop-1))); } while(R_1==i); do { R_2 = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_pop-1))); } while(R_2==i || R_2==R_1); // arma::vec prop_rand = arma::randu(n_vals,1)*(2*par_b) - par_b; // generate a vector of U[-b,b] RVs arma::rowvec X_prop = X.row(i) + par_gamma_run * ( X.row(R_1) - X.row(R_2) ) + prop_rand; double prop_kernel_val = box_log_kernel(X_prop.t(),target_data); if (!std::isfinite(prop_kernel_val)) { prop_kernel_val = neginf; } // double comp_val = prop_kernel_val - target_vals(i); double z = arma::as_scalar(arma::randu(1,1)); if (comp_val > temperature_j * std::log(z)) { X.row(i) = X_prop; target_vals(i) = prop_kernel_val; if (j >= n_burnin) { n_accept++; } } } // if (j >= n_burnin) { draws_out.slice(j-n_burnin) = X; } if (jumps && ((j+1) % 10 == 0)) { par_gamma_run = par_gamma; } } success = true; // if (vals_bound) { #ifdef MCMC_USE_OPENMP #pragma omp parallel for #endif for (size_t ii = 0; ii < n_gen; ii++) { for (size_t jj = 0; jj < n_pop; jj++) { draws_out.slice(ii).row(jj) = arma::trans(inv_transform(draws_out.slice(ii).row(jj).t(), bounds_type, lower_bounds, upper_bounds)); } } } if (settings_inp) { settings_inp->de_accept_rate = static_cast<double>(n_accept) / static_cast<double>(n_pop*n_gen); } // return success; }
inline bool pso_int(arma::vec& init_out_vals, std::function<double (const arma::vec& vals_inp, arma::vec* grad_out, void* opt_data)> opt_objfn, void* opt_data, algo_settings_t* settings_inp) { bool success = false; const size_t n_vals = init_out_vals.n_elem; // // PSO settings algo_settings_t settings; if (settings_inp) { settings = *settings_inp; } const uint_t conv_failure_switch = settings.conv_failure_switch; const double err_tol = settings.err_tol; const bool center_particle = settings.pso_center_particle; const size_t n_pop = (center_particle) ? settings.pso_n_pop + 1 : settings.pso_n_pop; const size_t n_gen = settings.pso_n_gen; const uint_t check_freq = (settings.pso_check_freq > 0) ? settings.pso_check_freq : n_gen ; const uint_t inertia_method = settings.pso_inertia_method; double par_w = settings.pso_par_initial_w; const double par_w_max = settings.pso_par_w_max; const double par_w_min = settings.pso_par_w_min; const double par_damp = settings.pso_par_w_damp; const uint_t velocity_method = settings.pso_velocity_method; double par_c_cog = settings.pso_par_c_cog; double par_c_soc = settings.pso_par_c_soc; const double par_initial_c_cog = settings.pso_par_initial_c_cog; const double par_final_c_cog = settings.pso_par_final_c_cog; const double par_initial_c_soc = settings.pso_par_initial_c_soc; const double par_final_c_soc = settings.pso_par_final_c_soc; const arma::vec par_initial_lb = (settings.pso_initial_lb.n_elem == n_vals) ? settings.pso_initial_lb : init_out_vals - 0.5; const arma::vec par_initial_ub = (settings.pso_initial_ub.n_elem == n_vals) ? settings.pso_initial_ub : init_out_vals + 0.5; const bool vals_bound = settings.vals_bound; const arma::vec lower_bounds = settings.lower_bounds; const arma::vec upper_bounds = settings.upper_bounds; const arma::uvec bounds_type = determine_bounds_type(vals_bound, n_vals, lower_bounds, upper_bounds); // lambda function for box constraints std::function<double (const arma::vec& vals_inp, arma::vec* grad_out, void* box_data)> box_objfn \ = [opt_objfn, vals_bound, bounds_type, lower_bounds, upper_bounds] (const arma::vec& vals_inp, arma::vec* grad_out, void* opt_data) \ -> double { if (vals_bound) { arma::vec vals_inv_trans = inv_transform(vals_inp, bounds_type, lower_bounds, upper_bounds); return opt_objfn(vals_inv_trans,nullptr,opt_data); } else { return opt_objfn(vals_inp,nullptr,opt_data); } }; // // initialize arma::vec objfn_vals(n_pop); arma::mat P(n_pop,n_vals); #ifdef OPTIM_USE_OMP #pragma omp parallel for #endif for (size_t i=0; i < n_pop; i++) { if (center_particle && i == n_pop - 1) { P.row(i) = arma::sum(P.rows(0,n_pop-2),0) / static_cast<double>(n_pop-1); // center vector } else { P.row(i) = par_initial_lb.t() + (par_initial_ub.t() - par_initial_lb.t())%arma::randu(1,n_vals); } double prop_objfn_val = opt_objfn(P.row(i).t(),nullptr,opt_data); if (!std::isfinite(prop_objfn_val)) { prop_objfn_val = inf; } objfn_vals(i) = prop_objfn_val; if (vals_bound) { P.row(i) = arma::trans( transform(P.row(i).t(), bounds_type, lower_bounds, upper_bounds) ); } } arma::vec best_vals = objfn_vals; arma::mat best_vecs = P; double global_best_val = objfn_vals.min(); double global_best_val_check = global_best_val; arma::rowvec global_best_vec = P.row( objfn_vals.index_min() ); // // begin loop uint_t iter = 0; double err = 2.0*err_tol; arma::mat V = arma::zeros(n_pop,n_vals); while (err > err_tol && iter < n_gen) { iter++; // // parameter updating if (inertia_method == 1) { par_w = par_w_min + (par_w_max - par_w_min) * (iter + 1) / n_gen; } else { par_w *= par_damp; } if (velocity_method == 2) { par_c_cog = par_initial_c_cog - (par_initial_c_cog - par_final_c_cog) * (iter + 1) / n_gen; par_c_soc = par_initial_c_soc - (par_initial_c_soc - par_final_c_soc) * (iter + 1) / n_gen; } // // population loop #ifdef OPTIM_USE_OMP #pragma omp parallel for #endif for (size_t i=0; i < n_pop; i++) { if ( !(center_particle && i == n_pop - 1) ) { V.row(i) = par_w*V.row(i) + par_c_cog*arma::randu(1,n_vals)%(best_vecs.row(i) - P.row(i)) + par_c_soc*arma::randu(1,n_vals)%(global_best_vec - P.row(i)); P.row(i) += V.row(i); } else { P.row(i) = arma::sum(P.rows(0,n_pop-2),0) / static_cast<double>(n_pop-1); // center vector } // double prop_objfn_val = box_objfn(P.row(i).t(),nullptr,opt_data); if (!std::isfinite(prop_objfn_val)) { prop_objfn_val = inf; } objfn_vals(i) = prop_objfn_val; if (objfn_vals(i) < best_vals(i)) { best_vals(i) = objfn_vals(i); best_vecs.row(i) = P.row(i); } } uint_t min_objfn_val_index = best_vals.index_min(); double min_objfn_val = best_vals(min_objfn_val_index); if (min_objfn_val < global_best_val) { global_best_val = min_objfn_val; global_best_vec = best_vecs.row( min_objfn_val_index ); } if (iter%check_freq == 0) { err = std::abs(global_best_val - global_best_val_check) / (1.0 + std::abs(global_best_val)); if (global_best_val < global_best_val_check) { global_best_val_check = global_best_val; } } } // if (vals_bound) { global_best_vec = arma::trans( inv_transform(global_best_vec.t(), bounds_type, lower_bounds, upper_bounds) ); } error_reporting(init_out_vals,global_best_vec.t(),opt_objfn,opt_data,success,err,err_tol,iter,n_gen,conv_failure_switch,settings_inp); // return true; }
inline bool de_prmm_int(arma::vec& init_out_vals, std::function<double (const arma::vec& vals_inp, arma::vec* grad_out, void* opt_data)> opt_objfn, void* opt_data, algo_settings_t* settings_inp) { bool success = false; const size_t n_vals = init_out_vals.n_elem; // // DE settings algo_settings_t settings; if (settings_inp) { settings = *settings_inp; } const uint_t conv_failure_switch = settings.conv_failure_switch; const double err_tol = settings.err_tol; size_t n_pop = settings.de_n_pop; // const size_t check_freq = settings.de_check_freq; const double par_initial_F = settings.de_par_F; const double par_initial_CR = settings.de_par_CR; const arma::vec par_initial_lb = (settings.de_initial_lb.n_elem == n_vals) ? settings.de_initial_lb : init_out_vals - 0.5; const arma::vec par_initial_ub = (settings.de_initial_ub.n_elem == n_vals) ? settings.de_initial_ub : init_out_vals + 0.5; const double F_l = settings.de_par_F_l; const double F_u = settings.de_par_F_u; const double tau_F = settings.de_par_tau_F; const double tau_CR = settings.de_par_tau_CR; arma::vec F_vec(n_pop), CR_vec(n_pop); F_vec.fill(par_initial_F); CR_vec.fill(par_initial_CR); const uint_t max_fn_eval = settings.de_max_fn_eval; const uint_t pmax = settings.de_pmax; const size_t n_pop_best = settings.de_n_pop_best; const double d_eps = 0.5; size_t n_gen = std::ceil(max_fn_eval / (pmax*n_pop)); const bool vals_bound = settings.vals_bound; const arma::vec lower_bounds = settings.lower_bounds; const arma::vec upper_bounds = settings.upper_bounds; const arma::uvec bounds_type = determine_bounds_type(vals_bound, n_vals, lower_bounds, upper_bounds); // lambda function for box constraints std::function<double (const arma::vec& vals_inp, arma::vec* grad_out, void* box_data)> box_objfn \ = [opt_objfn, vals_bound, bounds_type, lower_bounds, upper_bounds] (const arma::vec& vals_inp, arma::vec* grad_out, void* opt_data) \ -> double { if (vals_bound) { arma::vec vals_inv_trans = inv_transform(vals_inp, bounds_type, lower_bounds, upper_bounds); return opt_objfn(vals_inv_trans,nullptr,opt_data); } else { return opt_objfn(vals_inp,nullptr,opt_data); } }; // // setup arma::vec objfn_vals(n_pop); arma::mat X(n_pop,n_vals), X_next(n_pop,n_vals); #ifdef OPTIM_USE_OMP #pragma omp parallel for #endif for (size_t i=0; i < n_pop; i++) { X_next.row(i) = par_initial_lb.t() + (par_initial_ub.t() - par_initial_lb.t())%arma::randu(1,n_vals); double prop_objfn_val = opt_objfn(X_next.row(i).t(),nullptr,opt_data); if (!std::isfinite(prop_objfn_val)) { prop_objfn_val = inf; } objfn_vals(i) = prop_objfn_val; if (vals_bound) { X_next.row(i) = arma::trans( transform(X_next.row(i).t(), bounds_type, lower_bounds, upper_bounds) ); } } double best_objfn_val_running = objfn_vals.min(); // double best_objfn_val_check = best_objfn_val_running; double best_val_main = best_objfn_val_running; double best_val_best = best_objfn_val_running; arma::rowvec best_sol_running = X_next.row( objfn_vals.index_min() ); arma::rowvec best_vec_main = best_sol_running; arma::rowvec best_vec_best = best_sol_running; arma::rowvec xchg_vec = best_sol_running; // uint_t n_reset = 1; uint_t iter = 0; double err = 2*err_tol; while (err > err_tol && iter < n_gen + 1) { iter++; // // population reduction step if (iter == n_gen && n_reset < 4) { size_t n_pop_temp = n_pop/2; arma::vec objfn_vals_reset(n_pop_temp); arma::mat X_reset(n_pop_temp,n_vals); #ifdef OPTIM_USE_OMP #pragma omp parallel for #endif for (size_t j=0; j < n_pop_temp; j++) { if (objfn_vals(j) < objfn_vals(j + n_pop_temp)) { X_reset.row(j) = X_next.row(j); objfn_vals_reset(j) = objfn_vals(j); } else { X_reset.row(j) = X_next.row(j + n_pop_temp); objfn_vals_reset(j) = objfn_vals(j + n_pop_temp); } } objfn_vals = objfn_vals_reset; X_next = X_reset; n_pop /= 2; n_gen *= 2; iter = 1; n_reset++; } X = X_next; // // first population: n_pop - n_pop_best #ifdef OPTIM_USE_OMP #pragma omp parallel for #endif for (size_t i=0; i < n_pop - n_pop_best; i++) { arma::vec rand_pars = arma::randu(4); if (rand_pars(0) < tau_F) { F_vec(i) = F_l + (F_u-F_l)*rand_pars(1); } if (rand_pars(2) < tau_CR) { CR_vec(i) = rand_pars(3); } // uint_t c_1, c_2, c_3; do { c_1 = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_pop-1))); } while(c_1==i); do { c_2 = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_pop-1))); } while(c_2==i || c_2==c_1); do { c_3 = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_pop-1))); } while(c_3==i || c_3==c_1 || c_3==c_2); // size_t j = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_vals-1))); arma::vec rand_unif = arma::randu(n_vals); arma::rowvec X_prop(n_vals); for (size_t k=0; k < n_vals; k++) { if ( rand_unif(k) < CR_vec(i) || k == j ) { double r_s = arma::as_scalar(arma::randu(1)); if ( r_s < 0.75 || n_pop >= 100 ) { X_prop(k) = X(c_3,k) + F_vec(i)*(X(c_1,k) - X(c_2,k)); } else { X_prop(k) = best_vec_main(k) + F_vec(i)*(X(c_1,k) - X(c_2,k)); } } else { X_prop(k) = X(i,k); } } // double prop_objfn_val = box_objfn(X_prop.t(),nullptr,opt_data); if (prop_objfn_val <= objfn_vals(i)) { X_next.row(i) = X_prop; objfn_vals(i) = prop_objfn_val; } else { X_next.row(i) = X.row(i); } } best_val_main = objfn_vals.rows(0,n_pop - n_pop_best - 1).min(); best_vec_main = X_next.rows(0,n_pop - n_pop_best - 1).row( objfn_vals.rows(0,n_pop - n_pop_best - 1).index_min() ); if (best_val_main < best_val_best) { xchg_vec = best_vec_main; } // // second population for (size_t i = n_pop - n_pop_best; i < n_pop; i++) { arma::vec rand_pars = arma::randu(4); if (rand_pars(0) < tau_F) { F_vec(i) = F_l + (F_u-F_l)*rand_pars(1); } if (rand_pars(2) < tau_CR) { CR_vec(i) = rand_pars(3); } // uint_t c_1, c_2; do { c_1 = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_pop-1))); } while(c_1==i); do { c_2 = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_pop-1))); } while(c_2==i || c_2==c_1); // size_t j = arma::as_scalar(arma::randi(1, arma::distr_param(0, n_vals-1))); arma::vec rand_unif = arma::randu(n_vals); arma::rowvec X_prop(n_vals); for (size_t k=0; k < n_vals; k++) { if ( rand_unif(k) < CR_vec(i) || k == j ) { X_prop(k) = best_vec_best(k) + F_vec(i)*(X(c_1,k) - X(c_2,k)); } else { X_prop(k) = X(i,k); } } // double prop_objfn_val = box_objfn(X_prop.t(),nullptr,opt_data); if (prop_objfn_val <= objfn_vals(i)) { X_next.row(i) = X_prop; objfn_vals(i) = prop_objfn_val; } else { X_next.row(i) = X.row(i); } } best_val_best = objfn_vals.rows(n_pop - n_pop_best, n_pop - 1).min(); best_vec_best = X_next.rows(n_pop - n_pop_best, n_pop - 1).row( objfn_vals.rows(n_pop - n_pop_best, n_pop - 1).index_min() ); if (best_val_best < best_val_main) { double the_sum = 0; for (size_t j=0; j < n_vals; j++) { double min_val = X.col(j).min(); the_sum += (best_vec_best(j) - min_val) / (xchg_vec(j) - min_val); } the_sum /= static_cast<double>(n_vals); if (std::abs(the_sum - 1.0) > d_eps) { best_vec_main = best_vec_best; } else { best_vec_best = best_vec_main; } } else { best_vec_best = best_vec_main; } // // assign running global minimum if (objfn_vals.min() < best_objfn_val_running) { best_objfn_val_running = objfn_vals.min(); best_sol_running = X_next.row( objfn_vals.index_min() ); } // if (iter%check_freq == 0) { // // err = std::abs(objfn_vals.min() - best_objfn_val) / (std::abs(best_objfn_val) + 1E-08); // err = std::abs(best_objfn_val_running - best_objfn_val_check); // // best_objfn_val_check = objfn_vals.min(); // if (best_objfn_val_running < best_objfn_val_check) { // best_objfn_val_check = best_objfn_val_running; // } // } } // if (vals_bound) { best_sol_running = arma::trans( inv_transform(best_sol_running.t(), bounds_type, lower_bounds, upper_bounds) ); } error_reporting(init_out_vals,best_sol_running.t(),opt_objfn,opt_data,success,err,err_tol,iter,n_gen,conv_failure_switch,settings_inp); // return true; }