SimTK::Real InteriorPointOptimizer::optimize( Vector &results ) { int n = getOptimizerSystem().getNumParameters(); int m = getOptimizerSystem().getNumConstraints(); Index index_style = 0; /* C-style; start counting of rows and column indices at 0 */ Index nele_hess = 0; Index nele_jac = n*m; /* always assume dense */ // Parameter limits Number *x_L = NULL, *x_U = NULL; if( getOptimizerSystem().getHasLimits() ) { getOptimizerSystem().getParameterLimits( &x_L, &x_U); } else { x_U = new Number[n]; x_L = new Number[n]; for(int i=0;i<n;i++) { x_U[i] = SimTK::Real(POSITIVE_INF); x_L[i] = SimTK::Real(NEGATIVE_INF); } } SimTK::Real *x = &results[0]; IpoptProblem nlp = CreateIpoptProblem(n, x_L, x_U, m, g_L, g_U, nele_jac, nele_hess, index_style, objectiveFuncWrapper, constraintFuncWrapper, gradientFuncWrapper, constraintJacobianWrapper, hessianWrapper); // If you want to verify which options are getting set in the optimizer, you can create a file ipopt.opt // with "print_user_options yes", and set print_level to (at least 1). It will then print the options to the screen. // sherm 100302: you have to set all of these tolerances to get IpOpt to change // its convergence criteria; see OptimalityErrorConvergenceCheck::CheckConvergence(). // We'll set acceptable tolerances to the same value to disable them. AddIpoptNumOption(nlp, "tol", convergenceTolerance); AddIpoptNumOption(nlp, "dual_inf_tol", convergenceTolerance); AddIpoptNumOption(nlp, "constr_viol_tol", constraintTolerance); AddIpoptNumOption(nlp, "compl_inf_tol", convergenceTolerance); AddIpoptNumOption(nlp, "acceptable_tol", convergenceTolerance); AddIpoptNumOption(nlp, "acceptable_dual_inf_tol", convergenceTolerance); AddIpoptNumOption(nlp, "acceptable_constr_viol_tol", constraintTolerance); AddIpoptNumOption(nlp, "acceptable_compl_inf_tol", convergenceTolerance); AddIpoptIntOption(nlp, "max_iter", maxIterations); AddIpoptStrOption(nlp, "mu_strategy", "adaptive"); AddIpoptStrOption(nlp, "hessian_approximation", "limited-memory"); // needs to be limited-memory unless you have explicit hessians AddIpoptIntOption(nlp, "limited_memory_max_history", limitedMemoryHistory); AddIpoptIntOption(nlp, "print_level", diagnosticsLevel); // default is 4 int i; static const char *advancedRealOptions[] = { "compl_inf_tol", "dual_inf_tol", "constr_viol_tol", "acceptable_tol", "acceptable_compl_inf_tol", "acceptable_constr_viol_tol", "acceptable_dual_inf_tol", "diverging_iterates_tol", "barrier_tol_factor", "obj_scaling_factor", "nlp_scaling_max_gradient", "bounds_relax_factor", "recalc_y_feas_tol", "mu_init", "mu_max_fact", "mu_max", "mu_min", "mu_linear_decrease_factor", "mu_superlinear_decrease_factor", "bound_frac", "bound_push", "bound_mult_init_val", "constr_mult_init_max", "constr_mult_init_val", "warm_start_bound_push", "warm_start_bound_frac", "warm_start_mult_bound_push", "warm_start_mult_init_max", "recalc_y_feas_tol", "expect_infeasible_problem_ctol", "soft_resto_pderror_reduction_factor", "required_infeasibility_reduction", "bound_mult_reset_threshold", "constr_mult_reset_threshold", "max_hessian_perturbation", "min_hessian_perturbation", "first_hessian_perturbation", "perturb_inc_fact_first", "perturb_inc_fact", "perturb_dec_fact", "jacobian_reqularization_value", "derivative_test_perturbation", "derivative_test_tol", 0}; Real value; for(i=0;advancedRealOptions[i];i++) { if(getAdvancedRealOption(advancedRealOptions[i],value)) AddIpoptNumOption(nlp, advancedRealOptions[i], value); } static const std::string advancedStrOptions[] = {"nlp_scaling_method", "honor_original_bounds", "check_derivatives_for_naninf", "mu_strategy", "mu_oracle", "fixed_mu_oracle", "alpha_for_y", "recalc_y", "expect_infeasible_problem", "print_options_documentation", "print_user_options", "start_with_resto", "evaluate_orig_obj_at_resto_trial", "hessian_approximation", "derivative_test", ""}; std::string svalue; for(i=0;!advancedStrOptions[i].empty();i++) { if(getAdvancedStrOption(advancedStrOptions[i], svalue)) AddIpoptStrOption(nlp, advancedStrOptions[i].c_str(), svalue.c_str()); } static const char* advancedIntOptions[] = {"quality_function_max_section_steps", "max_soc", "watchdog_shorted_iter_trigger", "watchdog_trial_iter_max", "max_refinement_steps", "min_refinement_steps", "limited_memory_max_history", "limited_memory_max_skipping", "derivative_test_print_all", 0}; int ivalue; for(i=0;advancedIntOptions[i];i++) { if(getAdvancedIntOption(advancedIntOptions[i], ivalue)) AddIpoptIntOption(nlp, advancedIntOptions[i], ivalue); } // Only makes sense to do a warm start if this is not the first call to optimize() (since we need // reasonable starting multiplier values) bool use_warm_start=false; if(getAdvancedBoolOption("warm_start", use_warm_start) && use_warm_start && !firstOptimization) { AddIpoptStrOption(nlp, "warm_start_init_point", "yes"); AddIpoptStrOption(nlp, "warm_start_entire_iterate", "yes"); //AddIpoptStrOption(nlp, "warm_start_same_structure", "yes"); // couldn't get this one to work } SimTK::Real obj; int status = IpoptSolve(nlp, x, NULL, &obj, mult_g, mult_x_L, mult_x_U, (void *)this ); FreeIpoptProblem(nlp); // Only delete these if they aren't pointing to existing parameter limits if( !getOptimizerSystem().getHasLimits() ) { delete [] x_U; delete [] x_L; } if(status == Solved_To_Acceptable_Level) { std::cout << "Ipopt: Solved to acceptable level" << std::endl; } else if (status != Solve_Succeeded) { if( status != NonIpopt_Exception_Thrown) { char buf[1024]; sprintf(buf, "Ipopt: %s (status %d)",applicationReturnStatusToString(status).c_str(),status); SimTK_THROW1(SimTK::Exception::OptimizerFailed, SimTK::String(buf)); } } firstOptimization = false; return(obj); }
void CMAESOptimizer::process_readpara_settings(cmaes_t& evo) const { // Termination criteria // ==================== // stopMaxIter // ----------- // maxIterations is a protected member variable of OptimizerRep. evo.sp.stopMaxIter = maxIterations; // stopTolFun // ---------- // convergenceTolerance is a protected member variable of OptimizerRep. evo.sp.stopTolFun = convergenceTolerance; // stopMaxFunEvals // --------------- int stopMaxFunEvals; if (getAdvancedIntOption("stopMaxFunEvals", stopMaxFunEvals)) { SimTK_VALUECHECK_NONNEG_ALWAYS(stopMaxFunEvals, "stopMaxFunEvals", "CMAESOptimizer::processSettingsAfterCMAESInit"); evo.sp.stopMaxFunEvals = stopMaxFunEvals; } // stopFitness // ----------- double stopFitness; if (getAdvancedRealOption("stopFitness", stopFitness)) { evo.sp.stStopFitness.flg = 1; evo.sp.stStopFitness.val = stopFitness; } // stopTolFunHist // -------------- double stopTolFunHist; if (getAdvancedRealOption("stopTolFunHist", stopTolFunHist)) { evo.sp.stopTolFunHist = stopTolFunHist; } // stopTolX // -------- double stopTolX; if (getAdvancedRealOption("stopTolX", stopTolX)) { evo.sp.stopTolX = stopTolX; } // stopTolXFactor // -------------- double stopTolUpXFactor; if (getAdvancedRealOption("stopTolUpXFactor", stopTolUpXFactor)) { evo.sp.stopTolUpXFactor = stopTolUpXFactor; } // maxtime // ======= double maxtime; if (getAdvancedRealOption("maxTimeFractionForEigendecomposition", maxtime)) { evo.sp.updateCmode.maxtime = maxtime; } }
Real LBFGSBOptimizer::optimize( Vector &results ) { int run_optimizer = 1; char task[61]; Real f; int *iwa; char csave[61]; bool lsave[4]; int isave[44]; Real dsave[29]; Real *wa; Real *lowerLimits, *upperLimits; const OptimizerSystem& sys = getOptimizerSystem(); int n = sys.getNumParameters(); int m = limitedMemoryHistory; Real *gradient; gradient = new Real[n]; iprint[0] = iprint[1] = iprint[2] = diagnosticsLevel; if( sys.getHasLimits() ) { sys.getParameterLimits( &lowerLimits, &upperLimits ); // Determine what kind of limits each parameter has. // nbd = 0, unbounded; 1, only lower; 2, both; 3 only upper for (int i=0; i < n; ++i) { if (lowerLimits[i] == -Infinity) nbd[i] = (upperLimits[i] == Infinity ? 0 : 3); else nbd[i] = (upperLimits[i] == Infinity ? 1 : 2); } } else { lowerLimits = 0; upperLimits = 0; for(int i=0;i<n;i++) nbd[i] = 0; // unbounded } iwa = new int[3*n]; wa = new Real[((2*m + 4)*n + 12*m*m + 12*m)]; Real factor; if( getAdvancedRealOption("factr", factor ) ) { SimTK_APIARGCHECK_ALWAYS(factor > 0,"LBFGSBOptimizer","optimize", "factr must be positive \n"); factr = factor; } strcpy( task, "START" ); while( run_optimizer ) { setulb_(&n, &m, &results[0], lowerLimits, upperLimits, nbd, &f, gradient, &factr, &convergenceTolerance, wa, iwa, task, iprint, csave, lsave, isave, dsave, 60, 60); if( strncmp( task, "FG", 2) == 0 ) { objectiveFuncWrapper( n, &results[0], true, &f, this); gradientFuncWrapper( n, &results[0], false, gradient, this); } else if( strncmp( task, "NEW_X", 5) == 0 ){ //objectiveFuncWrapper( n, &results[0], true, &f, (void*)this ); } else { run_optimizer = 0; if( strncmp( task, "CONV", 4) != 0 ){ delete[] gradient; delete[] iwa; delete[] wa; SimTK_THROW1(SimTK::Exception::OptimizerFailed , SimTK::String(task) ); } } } delete[] gradient; delete[] iwa; delete[] wa; return f; }