static gboolean
newton_improve (GnmNlsolve *nl, gnm_float *xs, gnm_float *y, gnm_float ymax)
{
GnmSolver *sol = nl->parent;
const int n = nl->vars->len;
gnm_float *g, **H, *d;
gboolean ok;
g = compute_gradient (nl, xs);
H = compute_hessian (nl, xs, g);
d = g_new (gnm_float, n);
ok = (gnm_linear_solve (H, g, n, d) == 0);
if (ok) {
int i;
gnm_float y2, *xs2 = g_new (gnm_float, n);
gnm_float f, best_f = -1;
ok = FALSE;
for (f = 1; f > 1e-4; f /= 2) {
int i;
for (i = 0; i < n; i++)
xs2[i] = xs[i] - f * d[i];
set_vector (nl, xs2);
y2 = get_value (nl);
if (nl->debug) {
print_vector ("xs2", xs2, n);
g_printerr ("Obj value %.15" GNM_FORMAT_g "\n",
y2);
}
if (y2 < ymax && gnm_solver_check_constraints (sol)) {
best_f = f;
ymax = y2;
break;
}
}
if (best_f > 0) {
for (i = 0; i < n; i++)
xs[i] = xs[i] - best_f * d[i];
*y = ymax;
ok = TRUE;
}
g_free (xs2);
} else {
if (nl->debug)
g_printerr ("Failed to solve Newton step.\n");
}
g_free (d);
g_free (g);
free_matrix (H, n);
return ok;
}
void sim_hess(struct state *state)
{
msg("HESSIAN JOB\n\n\n");
print_geometry(state->efp);
compute_energy(state, true);
print_energy(state);
print_gradient(state);
size_t n_frags, n_coord;
double *hess, *mass_hess, *eigen;
check_fail(efp_get_frag_count(state->efp, &n_frags));
n_coord = 6 * n_frags;
hess = xmalloc(n_coord * n_coord * sizeof(double));
compute_hessian(state, hess);
msg(" HESSIAN MATRIX\n\n");
print_matrix(n_coord, n_coord, hess);
mass_hess = xmalloc(n_coord * n_coord * sizeof(double));
mass_weight_hessian(state->efp, hess, mass_hess);
msg(" MASS-WEIGHTED HESSIAN MATRIX\n\n");
print_matrix(n_coord, n_coord, mass_hess);
msg(" NORMAL MODE ANALYSIS\n\n");
eigen = xmalloc(n_coord * sizeof(double));
if (efp_dsyev('V', 'U', (int)n_coord, mass_hess, (int)n_coord, eigen))
error("unable to diagonalize mass-weighted hessian matrix");
for (size_t i = 0; i < n_coord; i++) {
print_mode(i + 1, eigen[i]);
print_vector(n_coord, mass_hess + i * n_coord);
}
free(hess);
free(mass_hess);
free(eigen);
msg("HESSIAN JOB COMPLETED SUCCESSFULLY\n");
}
/* main loop */
static int run_grd(CRF_ENG_PTR crf_ptr) {
int r,iterate,old_valid,converged,conv_time,saved = 0;
double likelihood,old_likelihood = 0.0;
double crf_max_iterate = 0.0;
double tmp_epsilon,alpha0,gf_sd,old_gf_sd = 0.0;
config_crf(crf_ptr);
initialize_weights();
if (crf_learn_mode == 1) {
initialize_LBFGS();
printf("L-BFGS mode\n");
}
if (crf_learning_rate==1) {
printf("learning rate:annealing\n");
} else if (crf_learning_rate==2) {
printf("learning rate:backtrack\n");
} else if (crf_learning_rate==3) {
printf("learning rate:golden section\n");
}
if (max_iterate == -1) {
crf_max_iterate = DEFAULT_MAX_ITERATE;
} else if (max_iterate >= +1) {
crf_max_iterate = max_iterate;
}
for (r = 0; r < num_restart; r++) {
SHOW_PROGRESS_HEAD("#crf-iters", r);
initialize_crf_count();
initialize_lambdas();
initialize_visited_flags();
old_valid = 0;
iterate = 0;
tmp_epsilon = crf_epsilon;
LBFGS_index = 0;
conv_time = 0;
while (1) {
if (CTRLC_PRESSED) {
SHOW_PROGRESS_INTR();
RET_ERR(err_ctrl_c_pressed);
}
RET_ON_ERR(crf_ptr->compute_feature());
crf_ptr->compute_crf_probs();
likelihood = crf_ptr->compute_likelihood();
if (verb_em) {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\n", iterate, likelihood);
}
if (debug_level) {
prism_printf("After I-step[%d]:\n", iterate);
prism_printf("likelihood = %.9f\n", likelihood);
print_egraph(debug_level, PRINT_EM);
}
if (!isfinite(likelihood)) {
emit_internal_error("invalid log likelihood: %s (at iteration #%d)",
isnan(likelihood) ? "NaN" : "infinity", iterate);
RET_ERR(ierr_invalid_likelihood);
}
/* if (old_valid && old_likelihood - likelihood > prism_epsilon) {
emit_error("log likelihood decreased [old: %.9f, new: %.9f] (at iteration #%d)",
old_likelihood, likelihood, iterate);
RET_ERR(err_invalid_likelihood);
}*/
if (likelihood > 0.0) {
emit_error("log likelihood greater than zero [value: %.9f] (at iteration #%d)",
likelihood, iterate);
RET_ERR(err_invalid_likelihood);
}
if (crf_learn_mode == 1 && iterate > 0) restore_old_gradient();
RET_ON_ERR(crf_ptr->compute_gradient());
if (crf_learn_mode == 1 && iterate > 0) {
compute_LBFGS_y_rho();
compute_hessian(iterate);
} else if (crf_learn_mode == 1 && iterate == 0) {
initialize_LBFGS_q();
}
converged = (old_valid && fabs(likelihood - old_likelihood) <= prism_epsilon);
if (converged || REACHED_MAX_ITERATE(iterate)) {
break;
}
old_likelihood = likelihood;
old_valid = 1;
if (debug_level) {
prism_printf("After O-step[%d]:\n", iterate);
print_egraph(debug_level, PRINT_EM);
}
SHOW_PROGRESS(iterate);
if (crf_learning_rate == 1) { // annealing
tmp_epsilon = (annealing_weight / (annealing_weight + iterate)) * crf_epsilon;
} else if (crf_learning_rate == 2) { // line-search(backtrack)
if (crf_learn_mode == 1) {
gf_sd = compute_gf_sd_LBFGS();
} else {
gf_sd = compute_gf_sd();
}
if (iterate==0) {
alpha0 = 1;
} else {
alpha0 = tmp_epsilon * old_gf_sd / gf_sd;
}
if (crf_learn_mode == 1) {
tmp_epsilon = line_search_LBFGS(crf_ptr,alpha0,crf_ls_rho,crf_ls_c1,likelihood,gf_sd);
} else {
tmp_epsilon = line_search(crf_ptr,alpha0,crf_ls_rho,crf_ls_c1,likelihood,gf_sd);
}
if (tmp_epsilon < EPS) {
emit_error("invalid alpha in line search(=0.0) (at iteration #%d)",iterate);
RET_ERR(err_line_search);
}
old_gf_sd = gf_sd;
} else if (crf_learning_rate == 3) { // line-search(golden section)
if (crf_learn_mode == 1) {
tmp_epsilon = golden_section_LBFGS(crf_ptr,0,crf_golden_b);
} else {
tmp_epsilon = golden_section(crf_ptr,0,crf_golden_b);
}
}
crf_ptr->update_lambdas(tmp_epsilon);
iterate++;
}
SHOW_PROGRESS_TAIL(converged, iterate, likelihood);
if (r == 0 || likelihood > crf_ptr->likelihood) {
crf_ptr->likelihood = likelihood;
crf_ptr->iterate = iterate;
saved = (r < num_restart - 1);
if (saved) {
save_params();
}
}
}
if (crf_learn_mode == 1) clean_LBFGS();
INIT_VISITED_FLAGS;
return BP_TRUE;
}
