PROTOTYPE: damped Newton steps for the positions and the B factors in refinement (RUGNUX_NEWTON)

Behind environment switches, off by default; nothing changes without them.
- RefinementNewton (RefinementMinimiser.h): Levenberg-Marquardt steps, (H + lambda D) d = -g by
  preconditioned CG, accepted on the target.
- H = the X-ray curvature per atom as a multiple of I (XrayXyzCurvatureShape, the B shape's
  counterpart, calibrated once per trial by central differences: 2 counted evaluations) plus the
  restraints' Hessian: by differences of their gradient (RUGNUX_NEWTON=1) or Gauss-Newton
  (RUGNUX_NEWTON_GN=1, RestraintGaussNewton: J = g / sqrt(2E) per record, planes per atom).
- RUGNUX_NEWTON_XYZ / _B iterations per macro-cycle (10 / 6), _CGMAX, _CGTOL, _CLIP, _RELSTOP,
  _TRACE; RUGNUX_NEWTON=2 an L-BFGS with the Newton H as H0 (worse, kept for the record).
- RUGNUX_REFINE_STATS: MINSTAT/TRIALSTAT/TRIALSSET/WEIGHTSTAT lines on stderr (evaluation budget).
- EvaluateRestraints: the per-record terms moved into RecordTerm (same operations, same order).

Measured (refine-only, CPU one round, 6 sets): evaluations -40..-63% at equal R-free on average;
on the GPU protocol R-free worse on 4 of 6 sets. Not for production as is.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
This commit is contained in:
leonarski_fandClaude Opus 5.5 committed 2026-11-16 08:08:58 +01:00
1 parent aaafc03ee6
commit 28bf8e3aeb
4 files changed
+571 -44

No files matched your search

@@ -6,6 +6,8 @@
#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <future>
#include <limits>
@@ -97,6 +99,12 @@ constexpr double MAX_STEP_XYZ = 0.3, MAX_STEP_B = 10.0;
// The loosest NCS restraint a trajectory step tries (A); looser than that, the copies are refined independently.
constexpr double NCS_SIGMA_MAX = 0.4;
// PROTOTYPE instrumentation (lane k): MINSTAT/TRIALSTAT/... lines on stderr where RUGNUX_REFINE_STATS is set.
bool RefineStats() {
static const bool on = getenv("RUGNUX_REFINE_STATS") != nullptr;
return on;
}
// The figure of merit of the likelihood, <cos(dphi)>, at X = 2 Fo D Fc / var: I1(X)/I0(X) for an acentric
// reflection, tanh(X / 2) for a centric one.
// Following Murshudov, Vagin & Dodson (1997) Acta Cryst. D53, 240-255
@@ -607,7 +615,13 @@ struct Context {
// The X-ray target's curvature in each atom's B, up to one factor (CalibrateBCurvature): the likelihood's
// curvature in |F_model| of the cycle, 2 (k_total D)^2 / var, summed in resolution shells, against the atom's own
// part of it, (s^2 / 4)^2 f(s)^2 exp(-B s^2 / 2). A hydrogen's is its parent's.
std::vector<double> XrayBCurvatureShape() const {
std::vector<double> XrayBCurvatureShape() const { return XrayCurvatureShape(rows, false); }
// The same for each of an atom's x, y and z: its own part of the likelihood's curvature in |F_model| is then
// (2 pi)^2 s^2 / 3 f(s)^2 exp(-B s^2 / 2), the reflections taken as spread evenly over directions - the X-ray
// block of the normal matrix as a multiple of I per atom (Murshudov, Vagin & Dodson 1997 keep the X-ray blocks
// of atoms on the diagonal). `r`: the row model the engine has (blurred or not).
std::vector<double> XrayXyzCurvatureShape(const XrayRowModel &r) const { return XrayCurvatureShape(r, true); }
std::vector<double> XrayCurvatureShape(const XrayRowModel &rows, bool xyz) const {
constexpr int SHELLS = 32;
double s2_max = 0;
for (double s2 : refl.inv_d2)
@@ -638,7 +652,10 @@ struct Context {
for (int k = 0; k < SHELLS; k++)
if (n[k] > 0) {
const double s2 = s2_sum[k] / n[k];
shape[i] += w[k] * f[k] * a.occ * a.occ * std::exp(-a.b_iso * s2 / 2.0) * s2 * s2 / 16.0;
if (xyz)
shape[i] += w[k] * f[k] * a.occ * a.occ * std::exp(-a.b_iso * s2 / 2.0) * s2 * (4.0 * M_PI * M_PI / 3.0);
else
shape[i] += w[k] * f[k] * a.occ * a.occ * std::exp(-a.b_iso * s2 / 2.0) * s2 * s2 / 16.0;
}
}
for (size_t i = 0; i < rider_parent.size(); i++)
@@ -675,6 +692,37 @@ struct Context {
return den > 0 ? std::max(num / den, 0.0) : 0.0;
}
// The factor that turns XrayXyzCurvatureShape() into the X-ray target's curvature, as CalibrateBCurvature() does
// for B: along a random +-1 direction of the positions of `params`, by central differences of the gradient.
// Two evaluations, counted.
double CalibrateXyzCurvature(const std::vector<int> &params, const std::vector<double> &shape) {
constexpr double EPS = 0.01; // A
const std::vector<gemmi::Position> p0 = Positions();
std::mt19937 rng(7);
std::vector<gemmi::Vec3> v(params.size());
for (gemmi::Vec3 &x : v)
x = gemmi::Vec3(rng() % 2 == 0 ? 1.0 : -1.0, rng() % 2 == 0 ? 1.0 : -1.0, rng() % 2 == 0 ? 1.0 : -1.0);
std::array<std::vector<std::array<double, 4>>, 2> g;
for (int side = 0; side < 2; side++) {
for (size_t k = 0; k < params.size(); k++)
atoms[params[k]]->pos = p0[params[k]] + gemmi::Position(v[k] * (side == 0 ? EPS : -EPS));
MoveRiders();
engine->Evaluate(Model(), &g[side]);
evaluations++;
FoldRiders(g[side]);
}
SetPositions(p0);
MoveRiders();
double num = 0, den = 0;
for (size_t k = 0; k < params.size(); k++) {
const int i = params[k];
num += (v[k].x * (g[0][i][0] - g[1][i][0]) + v[k].y * (g[0][i][1] - g[1][i][1]) +
v[k].z * (g[0][i][2] - g[1][i][2])) / (2 * EPS);
den += 3 * shape[i];
}
return den > 0 ? std::max(num / den, 0.0) : 0.0;
}
// F_model with the cycle's scale and solvent, for the atoms as they are now.
std::vector<std::complex<float>> FModel() {
engine->Fcalc(Model(), fcalc);
@@ -792,6 +840,29 @@ public:
return std::isfinite(*cost);
}
// The restraints' gradient alone at p, as Evaluate() makes it: for products with their Hessian by differences.
void RestraintGradient(const double *p, double *gradient) const {
Set(p);
std::vector<std::array<double, 4>> &gr = gr_;
ctx_.engine->EvaluateRestraints(restraint_set_, ctx_.XyzB(), &gr);
const int n = static_cast<int>(param_atoms_.size());
for (int k = 0; k < n; k++) {
const int i = param_atoms_[k];
if (mode_ == Mode::Xyz) {
gemmi::Vec3 g(gr[i][0], gr[i][1], gr[i][2]);
if (const SpecialPosition *sp = Special(i))
g = sp->projector.multiply(g);
gradient[3 * k] = g.x;
gradient[3 * k + 1] = g.y;
gradient[3 * k + 2] = g.z;
} else
gradient[k] = gr[i][3];
}
}
Mode GetMode() const { return mode_; }
double Weight() const { return weight_; }
const std::vector<int> &Atoms() const { return param_atoms_; }
private:
const SpecialPosition *Special(int atom) const {
const int k = topo_.special_index.empty() ? -1 : topo_.special_index[atom];
@@ -956,16 +1027,151 @@ std::vector<double> BDiagonal(const std::vector<double> &xray, const std::vector
// `minimiser` carries its memory from the call before; `diagonal` is the curvature it scales the steps by (none: 1).
template <typename Target>
void Minimise(Context &ctx, const Target &target, int iterations, RefinementMinimiser &minimiser,
std::vector<double> diagonal = {}) {
std::vector<double> diagonal = {}, const char *tag = "?") {
std::vector<double> p = target.Get();
if (p.empty())
return;
minimiser.SetDiagonal(diagonal.empty() ? std::vector<double>(p.size(), 1.0) : std::move(diagonal));
minimiser.Minimise([&](const std::vector<double> &x, double &f, std::vector<double> &g) {
const RefinementMinimiser::Outcome o = minimiser.Minimise([&](const std::vector<double> &x, double &f, std::vector<double> &g) {
return target.Evaluate(x.data(), &f, g.data());
},
p, iterations, MINIMISER_F_TOLERANCE, target.MaxStep(), [&]() { return ctx.Cancelled(); });
target.Set(p.data()); // where the minimiser ended, not where its last line search probed
if (RefineStats()) fprintf(stderr, "MINSTAT lbfgs.%s it=%d ev=%d lim=%d n=%zu f0=%.6g f1=%.6g\n", tag, o.iterations, o.evaluations,
iterations, p.size(), o.f_start, o.f_end);
}
bool NewtonHybrid();
// PROTOTYPE (RUGNUX_NEWTON=1): the positions or the B factors by damped Newton steps (RefinementNewton). H is the
// X-ray target's curvature per parameter (`xray`: per atom, already times the weight) plus the restraints' exact
// Hessian, its products by forward differences of their gradient; D is H's diagonal, the restraints' part of it
// probed by differences on atoms far apart in the list at a time (the atoms of one restraint are near in it).
void MinimiseNewton(Context &ctx, const AtomTarget &target, int iterations, RefinementNewton &newton,
const std::vector<double> &xray, RefinementMinimiser &lbfgs, const RestraintSet &set) {
std::vector<double> p = target.Get();
if (p.empty())
return;
const bool xyz = target.GetMode() == AtomTarget::Mode::Xyz;
const int per = xyz ? 3 : 1;
const size_t n = p.size();
const double eps = xyz ? 1e-4 : 0.1; // the largest change of a parameter in a difference (A, A^2)
std::vector<double> h(n);
for (size_t k = 0; k < n; k++)
h[k] = xray[target.Atoms()[k / per]];
std::vector<double> x_at, g_at(n), gp(n), xp(n);
auto restraint_hv = [&](const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv) {
if (x_at != x) {
x_at = x;
target.RestraintGradient(x.data(), g_at.data());
}
double v_max = 0;
for (double e : v)
v_max = std::max(v_max, std::fabs(e));
hv.assign(n, 0.0);
if (v_max == 0)
return;
const double t = eps / v_max;
for (size_t k = 0; k < n; k++)
xp[k] = x[k] + t * v[k];
target.RestraintGradient(xp.data(), gp.data());
for (size_t k = 0; k < n; k++)
hv[k] = (gp[k] - g_at[k]) / t;
};
// RUGNUX_NEWTON_GN=1: the restraints' Gauss-Newton Hessian (RestraintGaussNewton) instead of the exact one by
// differences - positive semi-definite, and its diagonal exact
static const bool gn = getenv("RUGNUX_NEWTON_GN") != nullptr;
std::vector<int> param_of(ctx.atoms.size(), -1);
for (size_t k = 0; k < target.Atoms().size(); k++)
param_of[target.Atoms()[k]] = static_cast<int>(k);
const int c0 = xyz ? 0 : 3;
RestraintJacobian jac;
std::vector<double> x_jac;
auto gn_hv = [&](const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv) {
if (x_jac != x) {
x_jac = x;
target.Set(x.data());
jac = RestraintGaussNewton(set, ctx.XyzB());
}
hv.assign(n, 0.0);
for (size_t r = 0; r + 1 < jac.start.size(); r++) {
double dot = 0;
for (int e = jac.start[r]; e < jac.start[r + 1]; e++)
if (const int k = param_of[jac.atom[e]]; k >= 0)
for (int c = 0; c < per; c++)
dot += jac.j[e][c0 + c] * v[per * k + c];
for (int e = jac.start[r]; e < jac.start[r + 1]; e++)
if (const int k = param_of[jac.atom[e]]; k >= 0)
for (int c = 0; c < per; c++)
hv[per * k + c] += dot * jac.j[e][c0 + c];
}
};
auto product = [&](const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv) {
if (gn)
gn_hv(x, v, hv);
else
restraint_hv(x, v, hv);
for (size_t k = 0; k < n; k++)
hv[k] += h[k] * v[k];
};
// the restraints' diagonal: every COLOURS-th atom at a time, one direction at a time
constexpr int COLOURS = 24;
std::vector<double> diagonal(n, 0.0), v(n), hv;
if (gn) {
target.Set(p.data());
x_jac = p;
jac = RestraintGaussNewton(set, ctx.XyzB());
for (size_t e = 0; e < jac.atom.size(); e++)
if (const int k = param_of[jac.atom[e]]; k >= 0)
for (int c = 0; c < per; c++)
diagonal[per * k + c] += jac.j[e][c0 + c] * jac.j[e][c0 + c];
}
for (int c = 0; c < (gn ? 0 : COLOURS); c++)
for (int dir = 0; dir < per; dir++) {
std::fill(v.begin(), v.end(), 0.0);
for (size_t k = static_cast<size_t>(per * c + dir); k < n; k += static_cast<size_t>(per * COLOURS))
v[k] = 1.0;
restraint_hv(p, v, hv);
for (size_t k = static_cast<size_t>(per * c + dir); k < n; k += static_cast<size_t>(per * COLOURS))
diagonal[k] = hv[k];
}
std::vector<double> sorted;
for (size_t k = 0; k < n; k++)
sorted.push_back(h[k] + std::max(diagonal[k], 0.0));
std::nth_element(sorted.begin(), sorted.begin() + n / 2, sorted.end());
const double floor = std::max(1e-3 * sorted[n / 2], 1e-12);
for (size_t k = 0; k < n; k++)
diagonal[k] = std::max(h[k] + std::max(diagonal[k], 0.0), floor);
if (const char *e = getenv("RUGNUX_NEWTON_CGMAX"))
newton.cg_max = std::atoi(e);
newton.clip_step = getenv("RUGNUX_NEWTON_CLIP") != nullptr;
newton.trace = getenv("RUGNUX_NEWTON_TRACE") != nullptr;
if (const char *e = getenv("RUGNUX_NEWTON_RELSTOP"))
newton.relative_stop = std::atof(e);
if (const char *e = getenv("RUGNUX_NEWTON_CGTOL"))
newton.cg_tolerance = std::atof(e);
const int cg_before = newton.cg_iterations;
if (NewtonHybrid()) {
lbfgs.SetPreconditioner([&](const std::vector<double> &x, std::vector<double> &q) {
std::vector<double> z;
RefinementNewton::Solve(product, diagonal, 0.0, x, q, z, newton.cg_max, newton.cg_tolerance,
newton.cg_iterations);
q.swap(z);
});
const RefinementMinimiser::Outcome o = lbfgs.Minimise(
[&](const std::vector<double> &x, double &f, std::vector<double> &g) { return target.Evaluate(x.data(), &f, g.data()); },
p, iterations, MINIMISER_F_TOLERANCE, target.MaxStep(), [&]() { return ctx.Cancelled(); });
lbfgs.SetPreconditioner(nullptr);
target.Set(p.data());
if (RefineStats()) fprintf(stderr, "MINSTAT hybrid.%s it=%d ev=%d lim=%d cg=%d f0=%.6g f1=%.6g\n", xyz ? "xyz" : "b", o.iterations,
o.evaluations, iterations, newton.cg_iterations - cg_before, o.f_start, o.f_end);
return;
}
const RefinementMinimiser::Outcome o = newton.Minimise(
[&](const std::vector<double> &x, double &f, std::vector<double> &g) { return target.Evaluate(x.data(), &f, g.data()); },
product, diagonal, p, iterations, MINIMISER_F_TOLERANCE, target.MaxStep(), [&]() { return ctx.Cancelled(); });
target.Set(p.data());
if (RefineStats()) fprintf(stderr, "MINSTAT newton.%s it=%d ev=%d lim=%d cg=%d f0=%.6g f1=%.6g\n", xyz ? "xyz" : "b", o.iterations,
o.evaluations, iterations, newton.cg_iterations - cg_before, o.f_start, o.f_end);
}
// Groups of atoms that move as rigid bodies (one per chain) against the X-ray target: per body an angle-axis
@@ -1144,6 +1350,18 @@ double BalancedWeight(Context &ctx, const std::vector<int> &refinable) {
std::vector<std::array<double, 4>> gx, gr;
ctx.engine->Evaluate(ctx.Model(), &gx);
std::vector<std::array<double, 4>> xyzb = ctx.XyzB();
{ // MEASUREMENT (lane k): the ratio of the gradients' norms at the model as given, unshaken
std::vector<std::array<double, 4>> g0;
ctx.engine->EvaluateRestraints(0, xyzb, &g0);
double a = 0, b = 0;
for (int i : refinable)
for (int c = 0; c < 3; c++) {
a += gx[i][c] * gx[i][c];
b += g0[i][c] * g0[i][c];
}
if (RefineStats()) fprintf(stderr, "WEIGHTSTAT unshaken_ratio=%.4g |gx|=%.4g |gr0|=%.4g\n", a > 0 ? std::sqrt(b / a) : 0.0,
std::sqrt(a), std::sqrt(b));
}
std::mt19937 rng(1);
std::normal_distribution<double> shake(0.0, 0.1);
for (std::array<double, 4> &a : xyzb)
@@ -1788,6 +2006,35 @@ double XrayGradientNorm(Context &ctx, const std::vector<int> &refinable) {
return n;
}
// PROTOTYPE switches: RUGNUX_NEWTON=1 the positions and the B factors by MinimiseNewton(), with
// RUGNUX_NEWTON_XYZ / RUGNUX_NEWTON_B iterations per macro-cycle.
bool NewtonOn() {
static const bool on = getenv("RUGNUX_NEWTON") != nullptr && std::string(getenv("RUGNUX_NEWTON")) != "0";
return on;
}
// RUGNUX_NEWTON=2: L-BFGS with the Newton H as its initial matrix instead of the damped Newton steps.
bool NewtonHybrid() {
static const bool on = getenv("RUGNUX_NEWTON") != nullptr && std::string(getenv("RUGNUX_NEWTON")) == "2";
return on;
}
int NewtonIterations(bool xyz) {
const char *e = getenv(xyz ? "RUGNUX_NEWTON_XYZ" : "RUGNUX_NEWTON_B");
return e != nullptr ? std::atoi(e) : (xyz ? 10 : 6);
}
// The X-ray curvature per atom in each of x, y, z at weight w, for the row model `rows` the engine has; `scale`
// calibrated at the first call of the trial (negative: not yet).
std::vector<double> NewtonXyzCurvature(Context &ctx, const std::vector<int> &refinable, const XrayRowModel &rows,
double w, double &scale) {
std::vector<double> shape = ctx.XrayXyzCurvatureShape(rows);
if (scale < 0) {
scale = ctx.CalibrateXyzCurvature(refinable, shape);
if (RefineStats()) fprintf(stderr, "NEWTONCAL xyz_scale=%.4g\n", scale);
}
for (double &x : shape)
x *= w * scale;
return shape;
}
TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const std::vector<gemmi::Position> &pos0,
const std::vector<double> &b0, const std::vector<AtomAniso> &aniso0, const Context::Fit *fit,
const TrialWeights &tw, int cycles, const RefinementSettings &settings, const NcsCopies *ncs,
@@ -1838,7 +2085,8 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
const AdpTarget tls_target(ctx, AdpTarget::Mode::Tls, refinable, 1.0, nullptr);
const AdpTarget u_target(ctx, AdpTarget::Mode::U, u_atoms, adp_w, &u_restraints);
RefinementMinimiser xyz_minimiser(20, ctx.nthreads), b_minimiser(20, ctx.nthreads), tls_minimiser(20, ctx.nthreads);
double xray_scale = 0;
RefinementNewton xyz_newton, b_newton;
double xray_scale = 0, xyz_scale = -1;
for (int cycle = 0; cycle < cycles && !ctx.Cancelled(); cycle++) {
PlaceRiders(ctx, topo);
if (cycle == 0 && fit != nullptr)
@@ -1852,10 +2100,13 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
if (adp_w > 0)
ctx.MoveOverallB();
if (!hold_positions) {
RestraintSet xyz_set;
{
const RestraintSet set = RestraintsNow(ctx, topo, ncs, ncs_sigma);
const RefinementStage s1("set_restraints");
ctx.engine->SetRestraints(0, set);
if (NewtonOn())
xyz_set = set;
}
const RefinementStage s2("minimise.xyz");
const double b_h = cycle < static_cast<int>(tw.blur.size()) ? tw.blur[cycle] : 0.0;
@@ -1870,15 +2121,22 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
ctx.engine->SetRowModel(blurred);
const double nh = XrayGradientNorm(ctx, refinable);
const AtomTarget xyz_h(ctx, AtomTarget::Mode::Xyz, refinable, nh > 0 ? w * std::sqrt(n0 / nh) : w, 0, topo);
Minimise(ctx, xyz_h, settings.xyz_iterations, xyz_minimiser);
if (NewtonOn())
MinimiseNewton(ctx, xyz_h, NewtonIterations(true), xyz_newton,
NewtonXyzCurvature(ctx, refinable, blurred, xyz_h.Weight(), xyz_scale), xyz_minimiser, xyz_set);
else
Minimise(ctx, xyz_h, settings.xyz_iterations, xyz_minimiser, {}, "xyz_blur");
ctx.engine->SetRowModel(ctx.rows);
} else
Minimise(ctx, xyz, settings.xyz_iterations, xyz_minimiser);
} else if (NewtonOn())
MinimiseNewton(ctx, xyz, NewtonIterations(true), xyz_newton,
NewtonXyzCurvature(ctx, refinable, ctx.rows, w, xyz_scale), xyz_minimiser, xyz_set);
else
Minimise(ctx, xyz, settings.xyz_iterations, xyz_minimiser, {}, "xyz");
}
if (kind == AdpHypothesis::Kind::Tls) {
ctx.ApplyTls(); // the bodies' U at the atoms as they are
const RefinementStage s4("minimise.tls");
Minimise(ctx, tls_target, settings.b_iterations, tls_minimiser);
Minimise(ctx, tls_target, settings.b_iterations, tls_minimiser, {}, "tls");
}
if (adp_w > 0 && kind == AdpHypothesis::Kind::Anisotropic) {
// each U's six elements take a third of the curvature of its B
@@ -1903,7 +2161,7 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
for (double h : BDiagonal(xray, restraint, u_atoms, adp_w))
diagonal.insert(diagonal.end(), 6, h);
const RefinementStage s3("minimise.u");
Minimise(ctx, u_target, settings.b_iterations, b_minimiser, diagonal);
Minimise(ctx, u_target, settings.b_iterations, b_minimiser, diagonal, "u");
} else if (adp_w > 0) {
const RestraintSet b_set = BRestraintsNow(ctx, topo);
ctx.engine->SetRestraints(1, b_set);
@@ -1913,8 +2171,13 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
for (double &x : xray)
x *= xray_scale;
const RefinementStage s3("minimise.b");
Minimise(ctx, b, settings.b_iterations, b_minimiser,
BDiagonal(xray, BRestraintCurvature(b_set, ctx.XyzB()), refinable, adp_w));
if (NewtonOn()) {
for (double &x : xray)
x *= adp_w;
MinimiseNewton(ctx, b, NewtonIterations(false), b_newton, xray, b_minimiser, b_set);
} else
Minimise(ctx, b, settings.b_iterations, b_minimiser,
BDiagonal(xray, BRestraintCurvature(b_set, ctx.XyzB()), refinable, adp_w), "b");
}
}
PlaceRiders(ctx, topo);
@@ -1959,6 +2222,8 @@ TrialOutcome RunTrial(TrialSlot slot, const std::vector<int> &refinable, const s
out.fit = ctx.Fitted();
out.ran = true;
out.evaluations = ctx.evaluations - evaluations_before;
if (RefineStats()) fprintf(stderr, "TRIALSTAT kind=%d adp_w=%.3g w=%.3g cycles=%d ev=%d rfree=%.4f\n", static_cast<int>(kind), adp_w, w, cycles,
out.evaluations, t.r_free);
return out;
}
@@ -2024,6 +2289,11 @@ std::vector<TrialOutcome> RunTrials(const std::vector<TrialSlot> &trial_slots,
for (const std::exception_ptr &e : errors)
if (e)
std::rethrow_exception(e);
int ev = 0;
for (const TrialOutcome &o : out)
ev += o.evaluations;
if (RefineStats()) fprintf(stderr, "TRIALSSET t=%.3f n=%zu cycles=%d ev=%d\n",
std::chrono::duration<double>(std::chrono::system_clock::now().time_since_epoch()).count(), out.size(), cycles, ev);
return out;
}
@@ -4,6 +4,7 @@
#pragma once
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <deque>
#include <functional>
@@ -34,6 +35,9 @@ public:
}
// The estimated diagonal of the Hessian; every element > 0.
void SetDiagonal(std::vector<double> h) { h_ = std::move(h); }
// PROTOTYPE: H0 as an operator instead of the diagonal, q = H0 q at x (null: the diagonal).
using Preconditioner = std::function<void(const std::vector<double> &x, std::vector<double> &q)>;
void SetPreconditioner(Preconditioner p) { precondition_ = std::move(p); }
struct Outcome {
int iterations = 0;
@@ -59,11 +63,11 @@ public:
for (int it = 0; it < iterations; it++) {
if (stop && stop())
break;
Direction(g, d);
Direction(x, g, d);
double gd = Dot(g, d);
if (!(gd < 0)) { // not a descent direction: the memory no longer fits, start again from the diagonal
Reset();
Direction(g, d);
Direction(x, g, d);
gd = Dot(g, d);
if (!(gd < 0))
break;
@@ -145,7 +149,11 @@ private:
// additions, so each sweep over the parameters takes the next pair's dot product while it applies the
// previous pair's update to q - the same operations on each element in the same order as a sweep for
// each would do, with the update's memory traffic hidden under the chain.
void Direction(const std::vector<double> &g, std::vector<double> &d) const {
void Direction(const std::vector<double> &x, const std::vector<double> &g, std::vector<double> &d) const {
if (precondition_) {
DirectionPreconditioned(x, g, d);
return;
}
const size_t n = g.size(), m = s_.size();
std::vector<double> &q = q_; // kept from call to call: made anew, its pages fault in every time
q.assign(g.begin(), g.end());
@@ -202,6 +210,27 @@ private:
d[k] = -q[k];
}
// The two-loop recursion plainly, with H0 the preconditioner (its own scale: no Oren-Shanno factor).
void DirectionPreconditioned(const std::vector<double> &x, const std::vector<double> &g, std::vector<double> &d) const {
const size_t m = s_.size();
std::vector<double> q = g, a(m);
for (size_t i = m; i-- > 0;) {
a[i] = Dot(s_[i], q) / sy_[i];
for (size_t k = 0; k < q.size(); k++)
q[k] -= a[i] * y_[i][k];
}
precondition_(x, q);
for (size_t i = 0; i < m; i++) {
const double b = Dot(y_[i], q) / sy_[i];
for (size_t k = 0; k < q.size(); k++)
q[k] += s_[i][k] * (a[i] - b);
}
d.resize(q.size());
for (size_t k = 0; k < q.size(); k++)
d[k] = -q[k];
}
Preconditioner precondition_;
size_t memory_, nthreads_;
std::deque<std::vector<double>> s_, y_;
std::deque<double> sy_; // s.y of each pair, as taken when it was kept
@@ -209,3 +238,144 @@ private:
mutable std::vector<double> q_; // Direction()'s working vector
std::vector<double> h_;
};
// Damped Newton steps (Levenberg-Marquardt): each iteration solves (H + lambda D) d = -g by conjugate gradients
// preconditioned with (1 + lambda) D, where H v is the caller's product with an approximation of the Hessian at the
// point of the last accepted evaluation and D an estimate of its diagonal, and takes d where it lowers f. lambda falls
// after a step the quadratic model predicted well and rises after one it did not; a step that does not lower f is
// solved again with the larger lambda, without a new gradient. Every iteration is one evaluation of the target where
// its step is taken.
// Following Levenberg (1944) Q. Appl. Math. 2, 164-168 and Marquardt (1963) J. SIAM 11, 431-441
class RefinementNewton {
public:
using Target = RefinementMinimiser::Target;
// hv = H v at x, the point of the last accepted evaluation.
using Product = std::function<void(const std::vector<double> &x, const std::vector<double> &v, std::vector<double> &hv)>;
using Outcome = RefinementMinimiser::Outcome;
int cg_iterations = 0; // summed over the calls, for the log
int cg_max = 50;
double cg_tolerance = 0.1;
bool clip_step = false;
bool trace = false;
double relative_stop = 0; // PROTOTYPE: stop where an iteration lowers f by less than this of all the calls' decrease so far // PROTOTYPE: each parameter's step clipped to max_step, not the whole step scaled
Outcome Minimise(const Target &target, const Product &product, const std::vector<double> &diagonal,
std::vector<double> &x, int iterations, double f_tolerance, double max_step,
const std::function<bool()> &stop = nullptr) {
const size_t n = x.size();
Outcome out;
double f = 0;
std::vector<double> g(n), d(n), x_new(n), g_new(n), hd(n), rhs(n);
if (!target(x, f, g))
return out;
out.evaluations++;
out.f_start = out.f_end = f;
for (int it = 0; it < iterations; it++) {
if (stop && stop())
break;
bool accepted = false;
double f_new = 0;
for (int attempt = 0; attempt < 6 && !accepted; attempt++) {
for (size_t k = 0; k < n; k++)
rhs[k] = -g[k];
Solve(product, diagonal, lambda_, x, rhs, d, cg_max, cg_tolerance, cg_iterations);
double d_max = 0;
for (double v : d)
d_max = std::max(d_max, std::fabs(v));
if (clip_step)
for (double &v : d)
v = std::clamp(v, -max_step, max_step);
else if (d_max > max_step)
for (double &v : d)
v *= max_step / d_max;
product(x, d, hd);
const double gd = Dot(g, d), predicted = -(gd + 0.5 * Dot(d, hd));
if (!(gd < 0))
break;
for (size_t k = 0; k < n; k++)
x_new[k] = x[k] + d[k];
const bool ok = target(x_new, f_new, g_new);
out.evaluations++;
const double rho = ok ? (f - f_new) / predicted : -1.0;
if (trace)
fprintf(stderr, "NTRACE it=%d att=%d dmax=%.3g lambda=%.3g pred=%.4g act=%.4g rho=%.3f\n", it, attempt,
d_max, lambda_, predicted, f - f_new, rho);
if (ok && f_new <= f + 1e-4 * gd) {
accepted = true;
if (rho > 0.75)
lambda_ = std::max(lambda_ / 3.0, 1e-4);
else if (rho < 0.25)
lambda_ *= 2.0;
} else
lambda_ = std::max(4.0 * lambda_, 0.1);
}
if (!accepted)
break;
const double decrease = f - f_new;
x.swap(x_new);
g.swap(g_new);
f = f_new;
out.iterations++;
out.f_end = f;
if (decrease <= f_tolerance * std::max(std::fabs(f), 1.0))
break;
if (relative_stop > 0 && decrease < relative_stop * (out.f_start - f))
break;
}
return out;
}
// d with (H + lambda D) d = rhs to `tolerance` of |rhs|, by conjugate gradients preconditioned with
// (1 + lambda) D; where a direction of negative curvature turns up, d as far as it got (the preconditioned rhs at
// first).
static void Solve(const Product &product, const std::vector<double> &diagonal, double lambda_,
const std::vector<double> &x, const std::vector<double> &rhs, std::vector<double> &d, int CG_MAX,
double tolerance, int &cg_iterations) {
const size_t n = rhs.size();
d.assign(n, 0.0);
std::vector<double> r(n), z(n), p(n), hp(n);
for (size_t k = 0; k < n; k++) {
r[k] = rhs[k];
z[k] = r[k] / ((1 + lambda_) * diagonal[k]);
}
p = z;
double rz = Dot(r, z);
const double r0 = std::sqrt(Dot(r, r));
for (int k = 0; k < CG_MAX; k++) {
cg_iterations++;
product(x, p, hp);
for (size_t j = 0; j < n; j++)
hp[j] += lambda_ * diagonal[j] * p[j];
const double php = Dot(p, hp);
if (!(php > 0)) {
if (k == 0)
d = z;
break;
}
const double a = rz / php;
for (size_t j = 0; j < n; j++) {
d[j] += a * p[j];
r[j] -= a * hp[j];
}
if (std::sqrt(Dot(r, r)) < tolerance * r0)
break;
for (size_t j = 0; j < n; j++)
z[j] = r[j] / ((1 + lambda_) * diagonal[j]);
const double rz_new = Dot(r, z);
for (size_t j = 0; j < n; j++)
p[j] = z[j] + rz_new / rz * p[j];
rz = rz_new;
}
}
private:
static double Dot(const std::vector<double> &a, const std::vector<double> &b) {
double s = 0;
for (size_t k = 0; k < a.size(); k++)
s += a[k] * b[k];
return s;
}
double lambda_ = 0.01; // kept from call to call, as the L-BFGS memory is
};
@@ -397,6 +397,48 @@ double RestraintValue(const RestraintSet &set, const RestraintRecord &r, const s
return NAN;
}
namespace {
// E of a restraint of the kinds over up to four atoms (not a plane, not a B similarity), its gradient in g[0..n).
double RecordTerm(const RestraintRecord &r, const std::vector<std::array<double, 4>> &xyzb, V3<double> g[4], int &n) {
const double ideal = r.ideal, sigma = r.sigma;
double e = 0;
n = 0;
switch (static_cast<RestraintKind>(r.kind)) {
case RestraintKind::Bond:
e = refine_math::BondTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), ideal, sigma, g);
n = 2;
break;
case RestraintKind::Angle:
e = refine_math::AngleTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]), ideal, sigma, g);
n = 3;
break;
case RestraintKind::Torsion:
e = refine_math::TorsionTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]),
At(xyzb, r.atom[3]), ideal, sigma, r.period, g);
n = 4;
break;
case RestraintKind::Chiral:
e = refine_math::ChiralTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]),
At(xyzb, r.atom[3]), ideal, sigma, g);
n = 4;
break;
case RestraintKind::NcsDistance:
e = refine_math::NcsDistanceTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]),
At(xyzb, r.atom[3]), sigma, ideal, g);
n = 4;
break;
case RestraintKind::Repulsion:
e = refine_math::RepulsionTerm(At(xyzb, r.atom[0]), Image(r, At(xyzb, r.atom[1])), ideal, sigma, g);
g[1] = FromImage(r, g[1]);
n = 2;
break;
default:
break;
}
return e;
}
} // namespace
double EvaluateRestraints(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb,
std::vector<std::array<double, 4>> *grad) {
double sum = 0;
@@ -405,36 +447,8 @@ double EvaluateRestraints(const RestraintSet &set, const std::vector<std::array<
V3<double> g[4] = {};
int n = 0;
double e = 0;
const double ideal = r.ideal, sigma = r.sigma;
const double sigma = r.sigma;
switch (static_cast<RestraintKind>(r.kind)) {
case RestraintKind::Bond:
e = refine_math::BondTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), ideal, sigma, g);
n = 2;
break;
case RestraintKind::Angle:
e = refine_math::AngleTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]), ideal, sigma, g);
n = 3;
break;
case RestraintKind::Torsion:
e = refine_math::TorsionTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]),
At(xyzb, r.atom[3]), ideal, sigma, r.period, g);
n = 4;
break;
case RestraintKind::Chiral:
e = refine_math::ChiralTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]),
At(xyzb, r.atom[3]), ideal, sigma, g);
n = 4;
break;
case RestraintKind::NcsDistance:
e = refine_math::NcsDistanceTerm(At(xyzb, r.atom[0]), At(xyzb, r.atom[1]), At(xyzb, r.atom[2]),
At(xyzb, r.atom[3]), sigma, ideal, g);
n = 4;
break;
case RestraintKind::Repulsion:
e = refine_math::RepulsionTerm(At(xyzb, r.atom[0]), Image(r, At(xyzb, r.atom[1])), ideal, sigma, g);
g[1] = FromImage(r, g[1]);
n = 2;
break;
case RestraintKind::Plane: {
const int m = r.atom[1];
px.resize(m);
@@ -460,6 +474,8 @@ double EvaluateRestraints(const RestraintSet &set, const std::vector<std::array<
}
break;
}
default:
e = RecordTerm(r, xyzb, g, n);
}
sum += e;
if (grad != nullptr)
@@ -473,6 +489,68 @@ double EvaluateRestraints(const RestraintSet &set, const std::vector<std::array<
return sum;
}
RestraintJacobian RestraintGaussNewton(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb) {
RestraintJacobian jac;
jac.start.push_back(0);
auto row = [&](int atom, double x, double y, double z, double b) {
jac.atom.push_back(atom);
jac.j.push_back({x, y, z, b});
};
std::vector<V3<double>> px, pg;
for (const RestraintRecord &r : set.records) {
const RestraintKind kind = static_cast<RestraintKind>(r.kind);
if (kind == RestraintKind::Plane) {
// each atom's distance from the plane a residual of its own, d r_i / d x_j = (delta_ij - 1/n) normal / sigma
// (the normal held), so one row per atom of the plane over all of them
const int m = r.atom[1];
px.resize(m);
pg.resize(m);
for (int k = 0; k < m; k++)
px[k] = At(xyzb, set.plane_atoms[r.atom[0] + k]);
refine_math::PlaneTerm(px.data(), m, static_cast<double>(r.sigma), pg.data());
const double c = std::sqrt(2.0) / r.sigma;
V3<double> nv{0, 0, 0};
for (int k = 0; k < m; k++) // the normal from the largest of the gradients (each is 2 r_k / sigma n)
if (refine_math::Norm(pg[k]) > refine_math::Norm(nv))
nv = pg[k];
if (refine_math::Norm(nv) == 0)
continue;
nv = (1.0 / refine_math::Norm(nv)) * nv;
for (int i = 0; i < m; i++) {
for (int k = 0; k < m; k++) {
const double f = c * ((i == k ? 1.0 : 0.0) - 1.0 / m);
row(set.plane_atoms[r.atom[0] + k], f * nv.x, f * nv.y, f * nv.z, 0);
}
jac.start.push_back(static_cast<int>(jac.atom.size()));
}
continue;
}
// E = residual^2 (or close to it): its gradient is 2 residual grad(residual), so J = g / sqrt(2 E) gives the
// Gauss-Newton term 2 grad(residual) grad(residual)^T = J J^T; nothing where E is 0
if (kind == RestraintKind::BSimilarity) {
double gi = 0, gj = 0;
const double e = refine_math::BSimilarityTerm(xyzb[r.atom[0]][3], xyzb[r.atom[1]][3],
static_cast<double>(r.sigma), gi, gj);
if (!(e > 0))
continue;
const double f = 1.0 / std::sqrt(2.0 * e);
row(r.atom[0], 0, 0, 0, f * gi);
row(r.atom[1], 0, 0, 0, f * gj);
} else {
V3<double> g[4] = {};
int n = 0;
const double e = RecordTerm(r, xyzb, g, n);
if (!(e > 0))
continue;
const double f = 1.0 / std::sqrt(2.0 * e);
for (int k = 0; k < n; k++)
row(r.atom[k], f * g[k].x, f * g[k].y, f * g[k].z, 0);
}
jac.start.push_back(static_cast<int>(jac.atom.size()));
}
return jac;
}
std::vector<double> BRestraintCurvature(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb) {
std::vector<double> h(xyzb.size(), 0.0);
for (const RestraintRecord &r : set.records)
@@ -49,6 +49,15 @@ double RestraintValue(const RestraintSet &set, const RestraintRecord &r, const s
double EvaluateRestraints(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb,
std::vector<std::array<double, 4>> *grad);
// PROTOTYPE: the Gauss-Newton approximation of the set's Hessian, sum over rows of J J^T: per row (a restraint's
// residual) its derivatives in (x, y, z, B) of the atoms atom[start[r] ... start[r + 1]).
struct RestraintJacobian {
std::vector<int> start;
std::vector<int> atom;
std::vector<std::array<double, 4>> j;
};
RestraintJacobian RestraintGaussNewton(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb);
// The diagonal of the Hessian of the set's B similarity restraints with respect to each atom's B, at `xyzb`.
std::vector<double> BRestraintCurvature(const RestraintSet &set, const std::vector<std::array<double, 4>> &xyzb);