Algorithm-LBFGS
view release on metacpan or search on metacpan
lbfgsfloatval_t finit, ftest1, dginit, dgtest;
lbfgsfloatval_t width, prev_width;
lbfgsfloatval_t stmin, stmax;
/* Check the input parameters for errors. */
if (*stp <= 0.) {
return LBFGSERR_INVALIDPARAMETERS;
}
/* Compute the initial gradient in the search direction. */
if (param->orthantwise_c != 0.) {
/* Use psuedo-gradients for orthant-wise updates. */
dginit = 0.;
for (i = 0;i < n;++i) {
/* Notice that:
(-s[i] < 0) <==> (g[i] < -param->orthantwise_c)
(-s[i] > 0) <==> (param->orthantwise_c < g[i])
as the result of the lbfgs() function for orthant-wise updates.
*/
if (s[i] != 0.) {
if (x[i] < 0.) {
/* Differentiable. */
dginit += s[i] * (g[i] - param->orthantwise_c);
} else if (0. < x[i]) {
/* Differentiable. */
dginit += s[i] * (g[i] + param->orthantwise_c);
} else if (s[i] < 0.) {
/* Take the left partial derivative. */
dginit += s[i] * (g[i] - param->orthantwise_c);
} else if (0. < s[i]) {
/* Take the right partial derivative. */
dginit += s[i] * (g[i] + param->orthantwise_c);
}
}
}
} else {
vecdot(&dginit, g, s, n);
}
/* Make sure that s points to a descent direction. */
if (0 < dginit) {
return LBFGSERR_INCREASEGRADIENT;
}
/* Initialize local variables. */
brackt = 0;
stage1 = 1;
finit = *f;
dgtest = param->ftol * dginit;
width = param->max_step - param->min_step;
prev_width = 2.0 * width;
/* Copy the value of x to the work area. */
veccpy(wa, x, n);
/*
The variables stx, fx, dgx contain the values of the step,
function, and directional derivative at the best step.
The variables sty, fy, dgy contain the value of the step,
function, and derivative at the other endpoint of
the interval of uncertainty.
The variables stp, f, dg contain the values of the step,
function, and derivative at the current step.
*/
stx = sty = 0.;
fx = fy = finit;
dgx = dgy = dginit;
for (;;) {
/*
Set the minimum and maximum steps to correspond to the
present interval of uncertainty.
*/
if (brackt) {
stmin = min2(stx, sty);
stmax = max2(stx, sty);
} else {
stmin = stx;
stmax = *stp + 4.0 * (*stp - stx);
}
/* Clip the step in the range of [stpmin, stpmax]. */
if (*stp < param->min_step) *stp = param->min_step;
if (param->max_step < *stp) *stp = param->max_step;
/*
If an unusual termination is to occur then let
stp be the lowest point obtained so far.
*/
if ((brackt && ((*stp <= stmin || stmax <= *stp) || param->max_linesearch <= count + 1 || uinfo != 0)) || (brackt && (stmax - stmin <= param->xtol * stmax))) {
*stp = stx;
}
/*
Compute the current value of x:
x <- x + (*stp) * s.
*/
veccpy(x, wa, n);
vecadd(x, s, *stp, n);
if (param->orthantwise_c != 0.) {
/* The current point is projected onto the orthant of the previous one. */
for (i = 0;i < n;++i) {
if (x[i] * wa[i] < 0.) {
x[i] = 0.;
}
}
}
/* Evaluate the function and gradient values. */
*f = proc_evaluate(instance, x, g, n, *stp);
if (0. < param->orthantwise_c) {
/* Compute L1-regularization factor and add it to the object value. */
norm = 0.;
for (i = 0;i < n;++i) {
norm += fabs(x[i]);
}
*f += norm * param->orthantwise_c;
}
++count;
vecdot(&dg, g, s, n);
ftest1 = finit + *stp * dgtest;
/* Test for errors and convergence. */
if (brackt && ((*stp <= stmin || stmax <= *stp) || uinfo != 0)) {
/* Rounding errors prevent further progress. */
return LBFGSERR_ROUNDING_ERROR;
}
if (*stp == param->max_step && *f <= ftest1 && dg <= dgtest) {
/* The step is the maximum value. */
return LBFGSERR_MAXIMUMSTEP;
}
if (*stp == param->min_step && (ftest1 < *f || dgtest <= dg)) {
/* The step is the minimum value. */
return LBFGSERR_MINIMUMSTEP;
}
if (brackt && (stmax - stmin) <= param->xtol * stmax) {
/* Relative width of the interval of uncertainty is at most xtol. */
return LBFGSERR_WIDTHTOOSMALL;
}
if (param->max_linesearch <= count) {
/* Maximum number of iteration. */
return LBFGSERR_MAXIMUMLINESEARCH;
}
if (*f <= ftest1 && fabs(dg) <= param->gtol * (-dginit)) {
/* The sufficient decrease condition and the directional derivative condition hold. */
return count;
}
/*
In the first stage we seek a step for which the modified
function has a nonpositive value and nonnegative derivative.
*/
if (stage1 && *f <= ftest1 && min2(param->ftol, param->gtol) * dginit <= dg) {
stage1 = 0;
}
/*
A modified function is used to predict the step only if
we have not obtained a step for which the modified
function has a nonpositive function value and nonnegative
derivative, and if a lower function value has been
obtained but the decrease is not sufficient.
*/
if (stage1 && ftest1 < *f && *f <= fx) {
/* Define the modified function and derivative values. */
fm = *f - *stp * dgtest;
fxm = fx - stx * dgtest;
fym = fy - sty * dgtest;
dgm = dg - dgtest;
dgxm = dgx - dgtest;
dgym = dgy - dgtest;
/*
Call update_trial_interval() to update the interval of
uncertainty and to compute the new step.
*/
uinfo = update_trial_interval(
&stx, &fxm, &dgxm,
&sty, &fym, &dgym,
stp, &fm, &dgm,
stmin, stmax, &brackt
);
/* Reset the function and gradient values for f. */
fx = fxm + stx * dgtest;
fy = fym + sty * dgtest;
dgx = dgxm + dgtest;
dgy = dgym + dgtest;
} else {
/*
Call update_trial_interval() to update the interval of
uncertainty and to compute the new step.
*/
uinfo = update_trial_interval(
&stx, &fx, &dgx,
&sty, &fy, &dgy,
stp, f, &dg,
stmin, stmax, &brackt
);
}
/*
Force a sufficient decrease in the interval of uncertainty.
*/
if (brackt) {
if (0.66 * prev_width <= fabs(sty - stx)) {
*stp = stx + 0.5 * (sty - stx);
}
prev_width = width;
width = fabs(sty - stx);
}
}
return LBFGSERR_LOGICERROR;
}
/**
* Define the local variables for computing minimizers.
*/
#define USES_MINIMIZER \
lbfgsfloatval_t a, d, gamma, theta, p, q, r, s;
/**
* Find a minimizer of an interpolated cubic function.
* @param cm The minimizer of the interpolated cubic.
* @param u The value of one point, u.
* @param fu The value of f(u).
* @param du The value of f'(u).
* @param v The value of another point, v.
* @param fv The value of f(v).
* @param du The value of f'(v).
*/
#define CUBIC_MINIMIZER(cm, u, fu, du, v, fv, dv) \
d = (v) - (u); \
theta = ((fu) - (fv)) * 3 / d + (du) + (dv); \
p = fabs(theta); \
q = fabs(du); \
r = fabs(dv); \
s = max3(p, q, r); \
/* gamma = s*sqrt((theta/s)**2 - (du/s) * (dv/s)) */ \
a = theta / s; \
gamma = s * sqrt(a * a - ((du) / s) * ((dv) / s)); \
if ((v) < (u)) gamma = -gamma; \
p = gamma - (du) + theta; \
q = gamma - (du) + gamma + (dv); \
r = p / q; \
(cm) = (u) + r * d;
/**
* Find a minimizer of an interpolated cubic function.
* @param cm The minimizer of the interpolated cubic.
* @param u The value of one point, u.
* @param fu The value of f(u).
* @param du The value of f'(u).
* @param v The value of another point, v.
* @param fv The value of f(v).
* @param du The value of f'(v).
* @param xmin The maximum value.
* @param xmin The minimum value.
*/
#define CUBIC_MINIMIZER2(cm, u, fu, du, v, fv, dv, xmin, xmax) \
d = (v) - (u); \
theta = ((fu) - (fv)) * 3 / d + (du) + (dv); \
p = fabs(theta); \
q = fabs(du); \
r = fabs(dv); \
s = max3(p, q, r); \
/* gamma = s*sqrt((theta/s)**2 - (du/s) * (dv/s)) */ \
a = theta / s; \
gamma = s * sqrt(max2(0, a * a - ((du) / s) * ((dv) / s))); \
if ((u) < (v)) gamma = -gamma; \
p = gamma - (dv) + theta; \
q = gamma - (dv) + gamma + (du); \
r = p / q; \
if (r < 0. && gamma != 0.) { \
(cm) = (v) - r * d; \
} else if (a < 0) { \
(cm) = (xmax); \
} else { \
(cm) = (xmin); \
}
/**
* Find a minimizer of an interpolated quadratic function.
* @param qm The minimizer of the interpolated quadratic.
* @param u The value of one point, u.
* @param fu The value of f(u).
* @param du The value of f'(u).
* @param v The value of another point, v.
* @param fv The value of f(v).
*/
#define QUARD_MINIMIZER(qm, u, fu, du, v, fv) \
a = (v) - (u); \
(qm) = (u) + (du) / (((fu) - (fv)) / a + (du)) / 2 * a;
/**
* Find a minimizer of an interpolated quadratic function.
* @param qm The minimizer of the interpolated quadratic.
* @param u The value of one point, u.
* @param du The value of f'(u).
* @param v The value of another point, v.
* @param dv The value of f'(v).
*/
#define QUARD_MINIMIZER2(qm, u, du, v, dv) \
a = (u) - (v); \
(qm) = (v) + (dv) / ((dv) - (du)) * a;
/**
* Update a safeguarded trial value and interval for line search.
*
* The parameter x represents the step with the least function value.
* The parameter t represents the current step. This function assumes
* that the derivative at the point of x in the direction of the step.
* If the bracket is set to true, the minimizer has been bracketed in
* an interval of uncertainty with endpoints between x and y.
*
* @param x The pointer to the value of one endpoint.
* @param fx The pointer to the value of f(x).
* @param dx The pointer to the value of f'(x).
* @param y The pointer to the value of another endpoint.
* @param fy The pointer to the value of f(y).
* @param dy The pointer to the value of f'(y).
* @param t The pointer to the value of the trial value, t.
* @param ft The pointer to the value of f(t).
* @param dt The pointer to the value of f'(t).
* @param tmin The minimum value for the trial value, t.
* @param tmax The maximum value for the trial value, t.
* @param brackt The pointer to the predicate if the trial value is
* bracketed.
* @retval int Status value. Zero indicates a normal termination.
*
* @see
* Jorge J. More and David J. Thuente. Line search algorithm with
* guaranteed sufficient decrease. ACM Transactions on Mathematical
* Software (TOMS), Vol 20, No 3, pp. 286-307, 1994.
*/
static int update_trial_interval(
lbfgsfloatval_t *x,
lbfgsfloatval_t *fx,
lbfgsfloatval_t *dx,
lbfgsfloatval_t *y,
lbfgsfloatval_t *fy,
lbfgsfloatval_t *dy,
lbfgsfloatval_t *t,
lbfgsfloatval_t *ft,
lbfgsfloatval_t *dt,
const lbfgsfloatval_t tmin,
const lbfgsfloatval_t tmax,
int *brackt
)
{
int bound;
int dsign = fsigndiff(dt, dx);
lbfgsfloatval_t mc; /* minimizer of an interpolated cubic. */
lbfgsfloatval_t mq; /* minimizer of an interpolated quadratic. */
lbfgsfloatval_t newt; /* new trial value. */
USES_MINIMIZER; /* for CUBIC_MINIMIZER and QUARD_MINIMIZER. */
/* Check the input parameters for errors. */
if (*brackt) {
if (*t <= min2(*x, *y) || max2(*x, *y) <= *t) {
/* The trival value t is out of the interval. */
return LBFGSERR_OUTOFINTERVAL;
}
if (0. <= *dx * (*t - *x)) {
/* The function must decrease from x. */
return LBFGSERR_INCREASEGRADIENT;
}
if (tmax < tmin) {
/* Incorrect tmin and tmax specified. */
return LBFGSERR_INCORRECT_TMINMAX;
}
}
/*
Case 2: a lower function value and derivatives of
opposite sign. The minimum is brackt. If the cubic
minimizer is closer to x than the quadratic (secant) one,
the cubic one is taken, else the quadratic one is taken.
*/
*brackt = 1;
bound = 0;
CUBIC_MINIMIZER(mc, *x, *fx, *dx, *t, *ft, *dt);
QUARD_MINIMIZER2(mq, *x, *dx, *t, *dt);
if (fabs(mc - *t) > fabs(mq - *t)) {
newt = mc;
} else {
newt = mq;
}
} else if (fabs(*dt) < fabs(*dx)) {
/*
Case 3: a lower function value, derivatives of the
same sign, and the magnitude of the derivative decreases.
The cubic minimizer is only used if the cubic tends to
infinity in the direction of the minimizer or if the minimum
of the cubic is beyond t. Otherwise the cubic minimizer is
defined to be either tmin or tmax. The quadratic (secant)
minimizer is also computed and if the minimum is brackt
then the the minimizer closest to x is taken, else the one
farthest away is taken.
*/
bound = 1;
CUBIC_MINIMIZER2(mc, *x, *fx, *dx, *t, *ft, *dt, tmin, tmax);
QUARD_MINIMIZER2(mq, *x, *dx, *t, *dt);
if (*brackt) {
if (fabs(*t - mc) < fabs(*t - mq)) {
newt = mc;
} else {
newt = mq;
}
} else {
if (fabs(*t - mc) > fabs(*t - mq)) {
newt = mc;
} else {
newt = mq;
}
}
} else {
/*
Case 4: a lower function value, derivatives of the
same sign, and the magnitude of the derivative does
not decrease. If the minimum is not brackt, the step
is either tmin or tmax, else the cubic minimizer is taken.
*/
bound = 0;
if (*brackt) {
CUBIC_MINIMIZER(newt, *t, *ft, *dt, *y, *fy, *dy);
} else if (*x < *t) {
newt = tmax;
} else {
newt = tmin;
}
}
/*
Update the interval of uncertainty. This update does not
depend on the new step or the case analysis above.
- Case a: if f(x) < f(t),
x <- x, y <- t.
- Case b: if f(t) <= f(x) && f'(t)*f'(x) > 0,
x <- t, y <- y.
- Case c: if f(t) <= f(x) && f'(t)*f'(x) < 0,
x <- t, y <- x.
*/
if (*fx < *ft) {
/* Case a */
*y = *t;
*fy = *ft;
*dy = *dt;
} else {
/* Case c */
if (dsign) {
*y = *x;
*fy = *fx;
*dy = *dx;
}
/* Cases b and c */
*x = *t;
*fx = *ft;
*dx = *dt;
}
/* Clip the new trial value in [tmin, tmax]. */
if (tmax < newt) newt = tmax;
if (newt < tmin) newt = tmin;
/*
Redefine the new trial value if it is close to the upper bound
of the interval.
*/
if (*brackt && bound) {
mq = *x + 0.66 * (*y - *x);
if (*x < *y) {
if (mq < newt) newt = mq;
} else {
if (newt < mq) newt = mq;
}
}
/* Return the new trial value. */
*t = newt;
return 0;
}
( run in 0.520 second using v1.01-cache-2.11-cpan-df04353d9ac )