static VALUE rb_gsl_fminimizer_minimum(VALUE obj)
{
gsl_multimin_fminimizer *gmf = NULL;
double min;
Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf);
min = gsl_multimin_fminimizer_minimum(gmf);
return rb_float_new(min);
}
int
test_f(const char * desc, gsl_multimin_function *f, initpt_function initpt,
const gsl_multimin_fminimizer_type *T)
{
int status;
size_t i, iter = 0;
gsl_vector *x = gsl_vector_alloc (f->n);
gsl_vector *step_size = gsl_vector_alloc (f->n);
gsl_multimin_fminimizer *s;
fcount = 0; gcount = 0;
(*initpt) (x);
for (i = 0; i < f->n; i++)
gsl_vector_set (step_size, i, 1);
s = gsl_multimin_fminimizer_alloc(T, f->n);
gsl_multimin_fminimizer_set (s, f, x, step_size);
#ifdef DEBUG
printf("x "); gsl_vector_fprintf (stdout, s->x, "%g");
#endif
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
#ifdef DEBUG
printf("%i: \n",iter);
printf("x "); gsl_vector_fprintf (stdout, s->x, "%g");
printf("f(x) %g\n", gsl_multimin_fminimizer_minimum (s));
printf("size: %g\n", gsl_multimin_fminimizer_size (s));
printf("\n");
#endif
status = gsl_multimin_test_size (gsl_multimin_fminimizer_size (s),
1e-3);
}
while (iter < 5000 && status == GSL_CONTINUE);
status |= (fabs(s->fval) > 1e-5);
gsl_test(status, "%s, on %s: %d iter (fn=%d), f(x)=%g",
gsl_multimin_fminimizer_name(s),desc, iter, fcount, s->fval);
gsl_multimin_fminimizer_free(s);
gsl_vector_free(x);
gsl_vector_free(step_size);
return status;
}
static PyObject* multimin_multimin_minimum(PyObject *self,
PyObject *args
) {
if ( ((multimin_multiminObject*)self)->min==NULL || ((multimin_multiminObject*)self)->func==NULL) {
PyErr_SetString(PyExc_RuntimeError,"no function specified!");
return NULL;
}
return PyFloat_FromDouble(gsl_multimin_fminimizer_minimum(((multimin_multiminObject*)self)->min));
}
CAMLprim value ml_gsl_multimin_fminimizer_minimum(value ox, value T)
{
gsl_multimin_fminimizer *t=GSLMULTIMINFMINIMIZER_VAL(T);
if(Is_block(ox)) {
value x=Unoption(ox);
_DECLARE_VECTOR(x);
_CONVERT_VECTOR(x);
gsl_vector_memcpy(&v_x, gsl_multimin_fminimizer_x(t));
}
return copy_double(gsl_multimin_fminimizer_minimum(t));
}
double GSLOptimizer::optimize(unsigned int iter,
const gsl_multimin_fminimizer_type*t,
double ms, double mxs) {
fis_= get_optimized_attributes();
best_score_=std::numeric_limits<double>::max();
unsigned int n= get_dimension();
if (n ==0) {
IMP_LOG(TERSE, "Nothing to optimize" << std::endl);
return get_scoring_function()->evaluate(false);
}
gsl_multimin_fminimizer *s=gsl_multimin_fminimizer_alloc (t, n);
gsl_vector *x= gsl_vector_alloc(get_dimension());
update_state(x);
gsl_vector *ss= gsl_vector_alloc(get_dimension());
gsl_vector_set_all(ss, mxs);
gsl_multimin_function f= internal::create_f_function_data(this);
gsl_multimin_fminimizer_set (s, &f, x, ss);
try {
int status;
do {
--iter;
//update_state(x);
status = gsl_multimin_fminimizer_iterate(s);
if (status) {
IMP_LOG(TERSE, "Ending optimization because of state " << s
<< std::endl);
break;
}
double sz= gsl_multimin_fminimizer_size(s);
status= gsl_multimin_test_size(sz, ms);
update_states();
if (status == GSL_SUCCESS) {
IMP_LOG(TERSE, "Ending optimization because of small size " << sz
<< std::endl);
break;
}
} while (status == GSL_CONTINUE && iter >0);
} catch (AllDone){
}
gsl_vector *ret=gsl_multimin_fminimizer_x (s);
best_score_=gsl_multimin_fminimizer_minimum (s);
write_state(ret);
gsl_multimin_fminimizer_free (s);
gsl_vector_free (x);
return best_score_;
}
void
solve_by_simulation (struct experiment_params *params)
{
gsl_multimin_function func_info;
int iter;
double err;
func_info.n = params->minimizer_dimen;
func_info.f = compute_error_func;
func_info.params = params;
gsl_multimin_fminimizer_set (params->minimizer,
&func_info,
params->starting_point,
params->minimizer_step_sizes);
iter = 0;
while (1) {
iter++;
if (iter >= 200) {
fprintf (stderr, "can't find minimum\n");
exit (1);
}
if (gsl_multimin_fminimizer_iterate (params->minimizer)) {
fprintf (stderr, "iterate error\n");
exit (1);
}
err = gsl_multimin_fminimizer_minimum (params->minimizer);
if (fabs (err) < .001) {
if (vflag)
printf ("ok %d\n", iter);
break;
}
}
}
extern real fitGemRecomb(double *ct, double *time, double **ctFit,
const int nData, t_gemParams *params)
{
int nThreads, i, iter, status, maxiter;
real size, d2, tol, *dumpdata;
size_t p, n;
gemFitData *GD;
char *dumpstr, dumpname[128];
/* nmsimplex2 had convergence problems prior to gsl v1.14,
* but it's O(N) instead of O(N) operations, so let's use it if v >= 1.14 */
#ifdef HAVE_LIBGSL
gsl_multimin_fminimizer *s;
gsl_vector *x,*dx; /* parameters and initial step size */
gsl_multimin_function fitFunc;
#ifdef GSL_MAJOR_VERSION
#ifdef GSL_MINOR_VERSION
#if ((GSL_MAJOR_VERSION == 1 && GSL_MINOR_VERSION >= 14) || \
(GSL_MAJOR_VERSION > 1))
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex2;
#else
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
#endif /* #if ... */
#endif /* GSL_MINOR_VERSION */
#else
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
#endif /* GSL_MAJOR_VERSION */
fprintf(stdout, "Will fit ka and kd to the ACF according to the reversible geminate recombination model.\n");
#else /* HAVE_LIBGSL */
fprintf(stderr, "Sorry, can't do reversible geminate recombination without gsl. "
"Recompile using --with-gsl.\n");
return -1;
#endif /* HAVE_LIBGSL */
#ifdef HAVE_LIBGSL
#ifdef HAVE_OPENMP
nThreads = omp_get_num_procs();
omp_set_num_threads(nThreads);
fprintf(stdout, "We will be using %i threads.\n", nThreads);
#endif
iter = 0;
status = 0;
maxiter = 100;
tol = 1e-10;
p = 2; /* Number of parameters to fit. ka and kd. */
n = params->nFitPoints; /* params->nLin*2 */; /* Number of points in the reduced dataset */
if (params->D <= 0)
{
fprintf(stderr, "Fitting of D is not implemented yet. It must be provided on the command line.\n");
return -1;
}
/* if (nData<n) { */
/* fprintf(stderr, "Reduced data set larger than the complete data set!\n"); */
/* n=nData; */
/* } */
snew(dumpdata, nData);
snew(GD,1);
GD->n = n;
GD->y = ct;
GD->ctTheory=NULL;
snew(GD->ctTheory, nData);
GD->LinLog=NULL;
snew(GD->LinLog, n);
GD->time = time;
GD->ka = 0;
GD->kd = 0;
GD->tDelta = time[1]-time[0];
GD->nData = nData;
GD->params = params;
snew(GD->logtime,params->nFitPoints);
snew(GD->doubleLogTime,params->nFitPoints);
for (i=0; i<params->nFitPoints; i++)
{
GD->doubleLogTime[i] = (double)(getLogIndex(i, params));
GD->logtime[i] = (int)(GD->doubleLogTime[i]);
GD->doubleLogTime[i]*=GD->tDelta;
if (GD->logtime[i] >= nData)
{
fprintf(stderr, "Ayay. It seems we're indexing out of bounds.\n");
params->nFitPoints = i;
}
}
fitFunc.f = &gemFunc_residual2;
fitFunc.n = 2;
fitFunc.params = (void*)GD;
x = gsl_vector_alloc (fitFunc.n);
dx = gsl_vector_alloc (fitFunc.n);
gsl_vector_set (x, 0, 25);
gsl_vector_set (x, 1, 0.5);
gsl_vector_set (dx, 0, 0.1);
gsl_vector_set (dx, 1, 0.01);
s = gsl_multimin_fminimizer_alloc (T, fitFunc.n);
gsl_multimin_fminimizer_set (s, &fitFunc, x, dx);
gsl_vector_free (x);
gsl_vector_free (dx);
do {
iter++;
status = gsl_multimin_fminimizer_iterate (s);
if (status != 0)
gmx_fatal(FARGS,"Something went wrong in the iteration in minimizer %s:\n \"%s\"\n",
gsl_multimin_fminimizer_name(s), gsl_strerror(status));
d2 = gsl_multimin_fminimizer_minimum(s);
size = gsl_multimin_fminimizer_size(s);
params->ka = gsl_vector_get (s->x, 0);
params->kd = gsl_vector_get (s->x, 1);
if (status)
{
fprintf(stderr, "%s\n", gsl_strerror(status));
break;
}
status = gsl_multimin_test_size(size,tol);
if (status == GSL_SUCCESS) {
fprintf(stdout, "Converged to minimum at\n");
}
printf ("iter %5d: ka = %2.5f kd = %2.5f f() = %7.3f size = %.3f chi2 = %2.5f\n",
iter,
params->ka,
params->kd,
s->fval, size, d2);
if (iter%1 == 0)
{
eq10v2(GD->ctTheory, time, nData, params->ka, params->kd, params);
/* fixGemACF(GD->ctTheory, nFitPoints); */
sprintf(dumpname, "Iter_%i.xvg", iter);
for(i=0; i<GD->nData; i++)
{
dumpdata[i] = (real)(GD->ctTheory[i]);
if (!gmx_isfinite(dumpdata[i]))
{
gmx_fatal(FARGS, "Non-finite value in acf.");
}
}
dumpN(dumpdata, GD->nData, dumpname);
}
}
while ((status == GSL_CONTINUE) && (iter < maxiter));
/* /\* Calculate the theoretical ACF from the parameters one last time. *\/ */
eq10v2(GD->ctTheory, time, nData, params->ka, params->kd, params);
*ctFit = GD->ctTheory;
sfree(GD);
gsl_multimin_fminimizer_free (s);
return d2;
#endif /* HAVE_LIBGSL */
}
static void optimize_remd_parameters(t_remd_data *d, int maxiter,
real tol)
{
real size, d2;
int iter = 0;
int status = 0;
int i;
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_vector *x, *dx;
gsl_multimin_function my_func;
my_func.f = &my_f;
my_func.n = d->nparams;
my_func.params = (void *) d;
/* Starting point */
x = gsl_vector_alloc (my_func.n);
for (i = 0; (i < my_func.n); i++)
{
gsl_vector_set (x, i, d->params[i]);
}
/* Step size, different for each of the parameters */
dx = gsl_vector_alloc (my_func.n);
for (i = 0; (i < my_func.n); i++)
{
gsl_vector_set (dx, i, 0.1*d->params[i]);
}
T = gsl_multimin_fminimizer_nmsimplex;
s = gsl_multimin_fminimizer_alloc (T, my_func.n);
gsl_multimin_fminimizer_set (s, &my_func, x, dx);
gsl_vector_free (x);
gsl_vector_free (dx);
printf ("%5s", "Iter");
for (i = 0; (i < my_func.n); i++)
{
printf(" %12s", epnm(my_func.n, i));
}
printf (" %12s %12s\n", "NM Size", "Chi2");
do
{
iter++;
status = gsl_multimin_fminimizer_iterate (s);
if (status != 0)
{
gmx_fatal(FARGS, "Something went wrong in the iteration in minimizer %s",
gsl_multimin_fminimizer_name(s));
}
d2 = gsl_multimin_fminimizer_minimum(s);
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, tol);
if (status == GSL_SUCCESS)
{
printf ("Minimum found using %s at:\n",
gsl_multimin_fminimizer_name(s));
}
printf ("%5d", iter);
for (i = 0; (i < my_func.n); i++)
{
printf(" %12.4e", gsl_vector_get (s->x, i));
}
printf (" %12.4e %12.4e\n", size, d2);
}
while ((status == GSL_CONTINUE) && (iter < maxiter));
gsl_multimin_fminimizer_free (s);
}
static void func_iteration(gsl_multimin_fminimizer *s){
size_t iter = 0;
int status;
double size;
do{
iter++;
status = gsl_multimin_fminimizer_iterate(s); /* 繰り返し計算を1回行う。予期しない問題が発生した場合はエラーコードを返す。 */
if(status) break;
size = gsl_multimin_fminimizer_size(s); /* sのその時点での最小点の最良推定値を返す */
status = gsl_multimin_test_size(size, 1e-3); /* sizeが閾値(1e-3)より小さければGSL_SUCCESS を、そうでなければGSL_CONTINUEを返す。 */
if(status == GSL_SUCCESS){ LOG("converged to minimum at\n");}
LOG("%5zd p=%.5f n=%.5f p0=%.5f f() = %10.5f size = %f\n", iter, gsl_vector_get(s->x, 0), gsl_vector_get(s->x, 1), gsl_vector_get(s->x, 2), gsl_multimin_fminimizer_minimum(s), size);
}while(status == GSL_CONTINUE && iter < 1000);
return;
}
int FC_FUNC_(oct_minimize_direct, OCT_MINIMIZE_DIRECT)
(const int *method, const int *dim, double *point, const double *step,
const double *toldr, const int *maxiter, funcn f,
const print_f_fn_ptr write_info, double *minimum)
{
int iter = 0, status, i;
double size;
const gsl_multimin_fminimizer_type *T = NULL;
gsl_multimin_fminimizer *s = NULL;
gsl_vector *x, *ss;
gsl_multimin_function my_func;
param_fn_t p;
p.func = f;
my_func.f = &fn;
my_func.n = *dim;
my_func.params = (void *) &p;
/* Set the initial vertex size vector */
ss = gsl_vector_alloc (*dim);
gsl_vector_set_all (ss, *step);
/* Starting point */
x = gsl_vector_alloc (*dim);
for(i=0; i<*dim; i++) gsl_vector_set (x, i, point[i]);
switch(*method){
case 6:
T = gsl_multimin_fminimizer_nmsimplex;
break;
}
s = gsl_multimin_fminimizer_alloc (T, *dim);
gsl_multimin_fminimizer_set (s, &my_func, x, ss);
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if(status) break;
*minimum = gsl_multimin_fminimizer_minimum(s);
for(i=0; i<*dim; i++) point[i] = gsl_vector_get(gsl_multimin_fminimizer_x(s), i);
size = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (size, *toldr);
write_info(&iter, dim, minimum, &size, point);
}
while (status == GSL_CONTINUE && iter < *maxiter);
if(status == GSL_CONTINUE) status = 1025;
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
return status;
}
int OptimizationOptions::gslOptimize( NLSFunction *F, gsl_vector* x_vec,
gsl_matrix *v, IterationLogger *itLog ) {
const gsl_multifit_fdfsolver_type *Tlm[] =
{ gsl_multifit_fdfsolver_lmder, gsl_multifit_fdfsolver_lmsder };
const gsl_multimin_fdfminimizer_type *Tqn[] =
{ gsl_multimin_fdfminimizer_vector_bfgs,
gsl_multimin_fdfminimizer_vector_bfgs2,
gsl_multimin_fdfminimizer_conjugate_fr,
gsl_multimin_fdfminimizer_conjugate_pr };
const gsl_multimin_fminimizer_type *Tnm[] =
{ gsl_multimin_fminimizer_nmsimplex, gsl_multimin_fminimizer_nmsimplex2,
gsl_multimin_fminimizer_nmsimplex2rand };
int gsl_submethod_max[] = { sizeof(Tlm) / sizeof(Tlm[0]),
sizeof(Tqn) / sizeof(Tqn[0]),
sizeof(Tnm) / sizeof(Tnm[0]) };
int status, status_dx, status_grad, k;
double g_norm, x_norm;
/* vectorize x row-wise */
size_t max_ind, min_ind;
double max_val, min_val, abs_max_val = 0, abs_min_val;
if (this->method < 0 ||
this->method > sizeof(gsl_submethod_max)/sizeof(gsl_submethod_max[0]) ||
this->submethod < 0 ||
this->submethod > gsl_submethod_max[this->method]) {
throw new Exception("Unknown optimization method.\n");
}
if (this->maxiter < 0 || this->maxiter > 5000) {
throw new Exception("opt.maxiter should be in [0;5000].\n");
}
/* LM */
gsl_multifit_fdfsolver* solverlm;
gsl_multifit_function_fdf fdflm = { &(F->_f_ls), &(F->_df_ls), &(F->_fdf_ls),
F->getNsq(), F->getNvar(), F };
gsl_vector *g;
/* QN */
double stepqn = this->step;
gsl_multimin_fdfminimizer* solverqn;
gsl_multimin_function_fdf fdfqn = {
&(F->_f), &(F->_df), &(F->_fdf), F->getNvar(), F };
/* NM */
double size;
gsl_vector *stepnm;
gsl_multimin_fminimizer* solvernm;
gsl_multimin_function fnm = { &(F->_f), F->getNvar(), F };
/* initialize the optimization method */
switch (this->method) {
case SLRA_OPT_METHOD_LM: /* LM */
solverlm = gsl_multifit_fdfsolver_alloc(Tlm[this->submethod],
F->getNsq(), F->getNvar());
gsl_multifit_fdfsolver_set(solverlm, &fdflm, x_vec);
g = gsl_vector_alloc(F->getNvar());
break;
case SLRA_OPT_METHOD_QN: /* QN */
solverqn = gsl_multimin_fdfminimizer_alloc(Tqn[this->submethod],
F->getNvar() );
gsl_multimin_fdfminimizer_set(solverqn, &fdfqn, x_vec,
stepqn, this->tol);
status_dx = GSL_CONTINUE;
break;
case SLRA_OPT_METHOD_NM: /* NM */
solvernm = gsl_multimin_fminimizer_alloc(Tnm[this->submethod], F->getNvar());
stepnm = gsl_vector_alloc(F->getNvar());
gsl_vector_set_all(stepnm, this->step);
gsl_multimin_fminimizer_set( solvernm, &fnm, x_vec, stepnm );
break;
}
/* optimization loop */
Log::lprintf(Log::LOG_LEVEL_FINAL, "SLRA optimization:\n");
status = GSL_SUCCESS;
status_dx = GSL_CONTINUE;
status_grad = GSL_CONTINUE;
this->iter = 0;
switch (this->method) {
case SLRA_OPT_METHOD_LM:
gsl_blas_ddot(solverlm->f, solverlm->f, &this->fmin);
gsl_multifit_gradient(solverlm->J, solverlm->f, g);
gsl_vector_scale(g, 2);
{
gsl_vector *g2 = gsl_vector_alloc(g->size);
F->computeFuncAndGrad(x_vec, NULL, g2);
gsl_vector_sub(g2, g);
if (gsl_vector_max(g2) > 1e-10 || gsl_vector_min(g2) < -1e-10) {
Log::lprintf(Log::LOG_LEVEL_NOTIFY,
"Gradient error, max = %14.10f, min = %14.10f ...",
gsl_vector_max(g2), gsl_vector_min(g2));
print_vec(g2);
}
gsl_vector_free(g2);
}
if (itLog != NULL) {
itLog->reportIteration(0, solverlm->x, this->fmin, g);
}
break;
case SLRA_OPT_METHOD_QN:
this->fmin = gsl_multimin_fdfminimizer_minimum(solverqn);
if (itLog != NULL) {
itLog->reportIteration(0, solverqn->x, this->fmin, solverqn->gradient);
}
break;
case SLRA_OPT_METHOD_NM:
this->fmin = gsl_multimin_fminimizer_minimum( solvernm );
if (itLog != NULL) {
itLog->reportIteration(this->iter, solvernm->x, this->fmin, NULL);
}
break;
}
while (status_dx == GSL_CONTINUE &&
status_grad == GSL_CONTINUE &&
status == GSL_SUCCESS &&
this->iter < this->maxiter) {
if (this->method == SLRA_OPT_METHOD_LM && this->maxx > 0) {
if (gsl_vector_max(solverlm->x) > this->maxx ||
gsl_vector_min(solverlm->x) < -this->maxx ){
break;
}
}
this->iter++;
switch (this->method) {
case SLRA_OPT_METHOD_LM: /* Levenberg-Marquardt */
status = gsl_multifit_fdfsolver_iterate(solverlm);
gsl_multifit_gradient(solverlm->J, solverlm->f, g);
gsl_vector_scale(g, 2);
/* check the convergence criteria */
if (this->epsabs != 0 || this->epsrel != 0) {
status_dx = gsl_multifit_test_delta(solverlm->dx, solverlm->x,
this->epsabs, this->epsrel);
} else {
status_dx = GSL_CONTINUE;
}
status_grad = gsl_multifit_test_gradient(g, this->epsgrad);
gsl_blas_ddot(solverlm->f, solverlm->f, &this->fmin);
if (itLog != NULL) {
itLog->reportIteration(this->iter, solverlm->x, this->fmin, g);
}
break;
case SLRA_OPT_METHOD_QN:
status = gsl_multimin_fdfminimizer_iterate( solverqn );
/* check the convergence criteria */
status_grad = gsl_multimin_test_gradient(
gsl_multimin_fdfminimizer_gradient(solverqn), this->epsgrad);
status_dx = gsl_multifit_test_delta(solverqn->dx, solverqn->x,
this->epsabs, this->epsrel);
this->fmin = gsl_multimin_fdfminimizer_minimum(solverqn);
if (itLog != NULL) {
itLog->reportIteration(this->iter, solverqn->x, this->fmin, solverqn->gradient);
}
break;
case SLRA_OPT_METHOD_NM:
status = gsl_multimin_fminimizer_iterate( solvernm );
/* check the convergence criteria */
size = gsl_multimin_fminimizer_size( solvernm );
status_dx = gsl_multimin_test_size( size, this->epsx );
this->fmin = gsl_multimin_fminimizer_minimum( solvernm );
if (itLog != NULL) {
itLog->reportIteration(this->iter, solvernm->x, this->fmin, NULL);
}
break;
}
}
if (this->iter >= this->maxiter) {
status = EITER;
}
switch (this->method) {
case SLRA_OPT_METHOD_LM:
gsl_vector_memcpy(x_vec, solverlm->x);
if (v != NULL) {
gsl_multifit_covar(solverlm->J, this->epscov, v); /* ??? Different eps */
}
gsl_blas_ddot(solverlm->f, solverlm->f, &this->fmin);
break;
case SLRA_OPT_METHOD_QN:
gsl_vector_memcpy(x_vec, solverqn->x);
this->fmin = solverqn->f;
break;
case SLRA_OPT_METHOD_NM:
gsl_vector_memcpy(x_vec, solvernm->x);
this->fmin = solvernm->fval;
break;
}
/* print exit information */
if (Log::getMaxLevel() >= Log::LOG_LEVEL_FINAL) { /* unless "off" */
switch (status) {
case EITER:
Log::lprintf("SLRA optimization terminated by reaching "
"the maximum number of iterations.\n"
"The result could be far from optimal.\n");
break;
case GSL_ETOLF:
Log::lprintf("Lack of convergence: "
"progress in function value < machine EPS.\n");
break;
case GSL_ETOLX:
Log::lprintf("Lack of convergence: "
"change in parameters < machine EPS.\n");
break;
case GSL_ETOLG:
Log::lprintf("Lack of convergence: "
"change in gradient < machine EPS.\n");
break;
case GSL_ENOPROG:
Log::lprintf("Possible lack of convergence: no progress.\n");
break;
}
if (status_grad != GSL_CONTINUE && status_dx != GSL_CONTINUE) {
Log::lprintf("Optimization terminated by reaching the convergence "
"tolerance for both X and the gradient.\n");
} else {
if (status_grad != GSL_CONTINUE) {
Log::lprintf("Optimization terminated by reaching the convergence "
"tolerance for the gradient.\n");
} else {
Log::lprintf("Optimization terminated by reaching the convergence "
"tolerance for X.\n");
}
}
}
/* Cleanup */
switch (this->method) {
case SLRA_OPT_METHOD_LM: /* LM */
gsl_multifit_fdfsolver_free(solverlm);
gsl_vector_free(g);
break;
case SLRA_OPT_METHOD_QN: /* QN */
gsl_multimin_fdfminimizer_free(solverqn);
break;
case SLRA_OPT_METHOD_NM: /* NM */
gsl_multimin_fminimizer_free(solvernm);
gsl_vector_free(stepnm);
break;
}
return GSL_SUCCESS; /* <- correct with status */
}
void minimd(density_t * ndft){
int status;
int i;
double stepmin, minimum, g_initial;
char * output_string;
gsl_vector *ss;
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_multimin_function my_func;
size_t iter;
params_gsl_multimin_function_t params;
switch(gradient_free_mode){
case SIMPLEX :
output_string = (char *) malloc(25*sizeof(char));
params.nDFT = density_get_val(ndft);
my_func.n = ipf.npar;
my_func.f = my_f;
my_func.params = (void *) (¶ms);
/* Initial step sizes */
ss = gsl_vector_alloc (ipf.npar);
gsl_vector_set_all(ss, 0.1);
/* We use the Simplex algorithm from thee GNU Scientific Library (GSL)
in its optimized version nmsimplex2 */
T = gsl_multimin_fminimizer_nmsimplex2;
messages_basic("\n\n\nStarting the optimization.\n\n\n");
g_initial = my_f(ipf.gamma, ¶ms);
if(g_initial < epsilon_gvalue){
if(myid == 0) printf("The value of G for the starting gamma is %.12lg,\n", g_initial);
if(myid == 0) printf("which is already below the requested threshold of %.12lg\n", epsilon_gvalue);
parallel_end(EXIT_SUCCESS);
}
if(myid == 0) printf(" Starting from gamma = ");
if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (ipf.gamma, i));}
if(myid == 0) printf("\n G(gamma) = %.12lg\n", g_initial);
/* Initialization of the minimizer s for the function
my_func starting at the x point */
messages_basic("\n\nInitialization of the minimizer.\n\n\n");
s = gsl_multimin_fminimizer_alloc (T, ipf.npar);
gsl_multimin_fminimizer_set (s, &my_func, ipf.gamma, ss);
minimum = g_initial;
iter = 0;
do
{
iter++;
if(myid == 0) printf(" Iter = %d\n", (int)iter);
if(myid == 0) printf(" gamma = ");
if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (gsl_multimin_fminimizer_x(s), i));}
if(myid == 0) printf("\n starting G(gamma) = %15.10lg\n", minimum);
/* We make an iteration of the minimizer s */
status = gsl_multimin_fminimizer_iterate (s);
minimum = gsl_multimin_fminimizer_minimum(s);
if (status){
if(myid == 0) printf(" Breaking. Reason: %s\n", gsl_strerror(status));
break;
}
if(myid == 0) printf(" G(gamma) = %15.10f\n", minimum);
stepmin = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (stepmin, 1e-2);
}
while (status == GSL_CONTINUE && iter < 100);
if(myid == 0) printf("\n\nFinished optimization. status = %d (%s)\n", status, gsl_strerror(status));
if(myid == 0) printf(" Final gamma = ");
if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf ("%.5f ", gsl_vector_get (gsl_multimin_fminimizer_x(s), i));}
if(myid == 0) printf("\n With value: G(gamma) = %.12lg\n\n", gsl_multimin_fminimizer_minimum(s));
gsl_vector_memcpy(ipf.gamma, gsl_multimin_fminimizer_x(s));
sprintf(output_string, "pot");
ipf_write(ipf, ipf_ref, output_string);
gsl_multimin_fminimizer_free (s);
fflush(stdout);
gsl_vector_free(ss);
break;
case GENETIC_ALGORITHM :
output_string = (char *) malloc(75*sizeof(char));
sprintf(output_string, "python ga.py %f %f %f %f %f %f %d %d %d",
grid.l, grid.step, extpot.alpha, extpot.Lmin, extpot.Lmax,
extpot.delta, extpot.npotex, ipf.npar, ipf.poten_selector);
system(output_string);
free(output_string);
break;
}
}
void GslOptimizer::minimize_no_gradient( unsigned int dim, OptimizerMonitor* monitor )
{
// Set initial point
gsl_vector* x = gsl_vector_alloc(dim);
for (unsigned int i = 0; i < dim; i++) {
gsl_vector_set(x, i, (*m_initialPoint)[i]);
}
// Tell GSL which solver we're using
const gsl_multimin_fminimizer_type* type = NULL;
switch(m_solver_type)
{
case(NELDER_MEAD):
type = gsl_multimin_fminimizer_nmsimplex;
break;
case(NELDER_MEAD2):
type = gsl_multimin_fminimizer_nmsimplex2;
break;
case(NELDER_MEAD2_RAND):
type = gsl_multimin_fminimizer_nmsimplex2rand;
break;
case(FLETCHER_REEVES_CG):
case(POLAK_RIBIERE_CG):
case(BFGS):
case(BFGS2):
case(STEEPEST_DESCENT):
default:
// Wat?!
queso_error();
}
// Init solver
gsl_multimin_fminimizer* solver =
gsl_multimin_fminimizer_alloc(type, dim);
// Point GSL at the right functions
gsl_multimin_function minusLogPosterior;
minusLogPosterior.n = dim;
minusLogPosterior.f = &c_evaluate;
minusLogPosterior.params = (void *)(this);
// Needed for these gradient free algorithms.
gsl_vector* step_size = gsl_vector_alloc(dim);
for(unsigned int i = 0; i < dim; i++) {
gsl_vector_set(step_size, i, m_fstep_size[i]);
}
gsl_multimin_fminimizer_set(solver, &minusLogPosterior, x, step_size);
int status;
size_t iter = 0;
double size = 0.0;
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(solver);
if (status) {
if( m_objectiveFunction.domainSet().env().fullRank() == 0 )
{
std::cerr << "Error while GSL does optimisation. "
<< "See below for GSL error type." << std::endl;
std::cerr << "Gsl error: " << gsl_strerror(status) << std::endl;
}
break;
}
size = gsl_multimin_fminimizer_size(solver);
status = gsl_multimin_test_size (size, this->getTolerance());
if(monitor)
{
gsl_vector* x = gsl_multimin_fminimizer_x(solver);
std::vector<double> x_min(dim);
for( unsigned int i = 0; i < dim; i++)
x_min[i] = gsl_vector_get(x,i);
double f = gsl_multimin_fminimizer_minimum(solver);
monitor->append( x_min, f, size );
}
}
while ((status == GSL_CONTINUE) && (iter < this->getMaxIterations()));
for (unsigned int i = 0; i < dim; i++) {
(*m_minimizer)[i] = gsl_vector_get(solver->x, i);
}
// We're being good human beings and cleaning up the memory we allocated
gsl_vector_free(step_size);
gsl_multimin_fminimizer_free(solver);
gsl_vector_free(x);
return;
}
void simplex(struct s_best *p_best, struct s_data *p_data, void *p_params_simplex, double (*f_simplex)(const gsl_vector *, void *), double CONVERGENCE_STOP_SIMPLEX, int M, enum plom_print print_opt)
{
/* simplex algo using GSL. Straightforward adaptation of the GSL doc
example */
char str[255];
FILE *p_file_trace = NULL;
if(print_opt & PLOM_PRINT_BEST) {
p_file_trace = plom_fopen(SFR_PATH, GENERAL_ID, "trace", "w", header_trace, p_data);
}
double log_like = 0.0;
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex2;
gsl_multimin_fminimizer *simp = NULL;
gsl_multimin_function minex_func;
int iter = 0;
int status;
double size;
gsl_vector *x = gsl_vector_alloc(p_best->n_to_be_estimated);
gsl_vector *jump_sizes = gsl_vector_alloc(p_best->n_to_be_estimated);
int k;
for (k=0; k<p_best->n_to_be_estimated; k++) {
gsl_vector_set(x, k, gsl_vector_get(p_best->mean, p_best->to_be_estimated[k]));
gsl_vector_set(jump_sizes, k, sqrt(gsl_matrix_get(p_best->var, p_best->to_be_estimated[k], p_best->to_be_estimated[k]))); //note the sqrt !!
}
/* Initialize method and iterate */
minex_func.n = p_best->n_to_be_estimated;
minex_func.f = f_simplex;
minex_func.params = p_params_simplex;
simp = gsl_multimin_fminimizer_alloc(T, p_best->n_to_be_estimated );
gsl_multimin_fminimizer_set(simp, &minex_func, x, jump_sizes);
do
{
#if FLAG_JSON //for the webApp, we block at every iterations to prevent the client to be saturated with msg
block();
#endif
iter++;
status = gsl_multimin_fminimizer_iterate(simp);
if (status) break;
size = gsl_multimin_fminimizer_size(simp);
status = gsl_multimin_test_size(size, CONVERGENCE_STOP_SIMPLEX);
log_like = - gsl_multimin_fminimizer_minimum(simp);
if (!(print_opt & PLOM_QUIET)) {
if (status == GSL_SUCCESS) {
print_log ("converged to maximum !");
}
sprintf(str, "%5d logLike = %12.5f size = %.14f", iter, log_like, size);
print_log(str);
}
transfer_estimated(p_best, gsl_multimin_fminimizer_x(simp), p_data);
if(print_opt & PLOM_PRINT_BEST){
print_trace(p_file_trace, iter-1, p_best, p_data, log_like);
}
} while (status == GSL_CONTINUE && iter < M);
if(!(print_opt & PLOM_PRINT_BEST)){
p_file_trace = plom_fopen(SFR_PATH, GENERAL_ID, "trace", "w", header_trace, p_data);
print_trace(p_file_trace, iter-1, p_best, p_data, log_like);
}
plom_fclose(p_file_trace);
gsl_multimin_fminimizer_free(simp);
gsl_vector_free(x);
gsl_vector_free(jump_sizes);
}
/**
* The best member of the population will be used as starting point for the minimisation process. The algorithm will stop
* if the size of the simplex falls below the tol parameter, if the maximum number of iterations max_iter is exceeded or if
* the inner GSL routine call reports an error (which will be logged on std::cout). After the end of the minimisation process,
* the minimised decision vector will replace the best individual in the population, after being modified to fall within
* the problem bounds if necessary.
*
* @param[in,out] pop population to evolve.
*/
void gsl_derivative_free::evolve(population &pop) const
{
// Do nothing if the population is empty.
if (!pop.size()) {
return;
}
// Useful variables.
const problem::base &problem = pop.problem();
if (problem.get_f_dimension() != 1) {
pagmo_throw(value_error,"this algorithm does not support multi-objective optimisation");
}
if (problem.get_c_dimension()) {
pagmo_throw(value_error,"this algorithm does not support constrained optimisation");
}
const problem::base::size_type cont_size = problem.get_dimension() - problem.get_i_dimension();
if (!cont_size) {
pagmo_throw(value_error,"the problem has no continuous part");
}
// Extract the best individual.
const population::size_type best_ind_idx = pop.get_best_idx();
const population::individual_type &best_ind = pop.get_individual(best_ind_idx);
// GSL wrapper parameters structure.
objfun_wrapper_params params;
params.p = &problem;
// Integer part of the temporay decision vector must be filled with the integer part of the best individual,
// which will not be optimised.
params.x.resize(problem.get_dimension());
std::copy(best_ind.cur_x.begin() + cont_size, best_ind.cur_x.end(), params.x.begin() + cont_size);
params.f.resize(1);
// GSL function structure.
gsl_multimin_function gsl_func;
// Number of function components.
gsl_func.n = boost::numeric_cast<std::size_t>(cont_size);
gsl_func.f = &objfun_wrapper;
gsl_func.params = (void *)¶ms;
// Mimimizer.
gsl_multimin_fminimizer *s = 0;
// Starting point and step sizes.
gsl_vector *x = 0, *ss = 0;
// Here we start the allocations.
// Recast as size_t here, in order to avoid potential overflows later.
const std::size_t s_cont_size = boost::numeric_cast<std::size_t>(cont_size);
// Allocate and check the allocation results.
x = gsl_vector_alloc(s_cont_size);
ss = gsl_vector_alloc(s_cont_size);
const gsl_multimin_fminimizer_type *minimiser = get_gsl_minimiser_ptr();
pagmo_assert(minimiser);
s = gsl_multimin_fminimizer_alloc(minimiser,s_cont_size);
// Check the allocations.
check_allocs(x,ss,s);
// Starting point comes from the best individual.
for (std::size_t i = 0; i < s_cont_size; ++i) {
gsl_vector_set(x,i,best_ind.cur_x[i]);
}
// Set initial step sizes.
gsl_vector_set_all(ss,m_step_size);
// Init the solver.
gsl_multimin_fminimizer_set(s,&gsl_func,x,ss);
// Iterate.
std::size_t iter = 0;
int status;
double size;
try {
do
{
status = gsl_multimin_fminimizer_iterate(s);
++iter;
if (status) {
break;
}
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, m_tol);
if (m_screen_output) {
if (!((iter-1)%20)) {
std::cout << std::endl << std::left << std::setw(20) <<
"Iter." << std::setw(20) <<
"Best " << std::setw(20) <<
"Size "<< std::endl;
}
std::cout << std::left << std::setprecision(14) << std::setw(20) <<
iter << std::setw(20) <<
gsl_multimin_fminimizer_minimum(s) << std::setw(20) <<
size << std::endl;
}
} while (status == GSL_CONTINUE && iter < m_max_iter);
} catch (const std::exception &e) {
// Cleanup and re-throw.
cleanup(x,ss,s);
throw e;
} catch (...) {
// Cleanup and throw.
cleanup(x,ss,s);
pagmo_throw(std::runtime_error,"unknown exception caught in gsl_derivative_free::evolve");
}
// Free up resources.
cleanup(x,ss,s);
// Check the generated individual and change it to respect the bounds as necessary.
for (problem::base::size_type i = 0; i < cont_size; ++i) {
if (params.x[i] < problem.get_lb()[i]) {
params.x[i] = problem.get_lb()[i];
}
if (params.x[i] > problem.get_ub()[i]) {
params.x[i] = problem.get_ub()[i];
}
}
// Replace the best individual.
pop.set_x(best_ind_idx,params.x);
}
