mlmm-toolkit 0.2.2.dev0__py3-none-any.whl

pysisyphus/line_searches/HagerZhang.py

@@ -0,0 +1,184 @@
+import numpy as np
+
+from pysisyphus.line_searches.LineSearch import LineSearch, \
+                                                LineSearchNotConverged
+
+
+class HagerZhang(LineSearch):
+
+    def __init__(self, *args, alpha_prev=None, f_prev=None, dphi0_prev=None,
+                 quad_step=False, eps=1e-6, theta=0.5, gamma=0.5, rho=5,
+                 psi_0=.01, psi_1=.1, psi_2=2., psi_low=0.1, psi_hi=10,
+                 Delta=.7, omega=1e-3, max_bisects=10, **kwargs):
+
+        kwargs["cond"] = "wolfe"
+        super().__init__(*args, **kwargs)
+
+        self.alpha_prev = alpha_prev
+        self.f_prev = f_prev
+        self.dphi0_prev = dphi0_prev
+        self.quad_step = quad_step
+
+        self.eps = eps
+        self.theta = theta
+        self.gamma = gamma
+        self.rho = rho
+        self.psi_0 = psi_0
+        self.psi_1 = psi_1
+        self.psi_2 = psi_2
+        self.psi_low = psi_low
+        self.psi_hi = psi_hi
+        self.Delta = Delta
+        self.omega = omega
+        self.max_bisects = max_bisects
+
+    def prepare_line_search(self):
+        super().prepare_line_search()
+
+        self.epsk = self.eps * abs(self.get_fg("f", 0.))
+
+    def bisect(self, a, b):
+        """Bisect interval [a, b]."""
+        for i in range(self.max_bisects):
+            # U3 a.
+            d = (1 - self.theta)*a + self.theta*b
+            dphi_d = self.get_phi_dphi("g", d)
+            if dphi_d >= 0:
+                return a, d
+
+            phi_d = self.get_phi_dphi("f", d)
+            # U3 b.
+            # If (dphi_d > 0) we would already have returned above...
+            if phi_d <= self.phi0 + self.epsk:
+                a = d
+            # U3 c.
+            elif phi_d > self.phi0 + self.epsk:
+                b = d
+        raise Exception("Bisect failed!")
+
+    def interval_update(self, a, b, c):
+        """Narrows down the bracketing interval."""
+        # U0
+        if not (a < c < b):
+            return a, b
+
+        phi_c, dphi_c = self.get_phi_dphi("fg", c)
+        # U1, sign of slope projection changed. We already passed the minimum.
+        if dphi_c >= 0:
+            return a, c
+        # U2, we are moving towards the minimum.
+        elif phi_c <= self.phi0 + self.epsk:
+            return c, b
+
+        # U3, phi_c increased above phi0, so we probably passed the minimum.
+        return self.bisect(a, c)
+
+    def secant(self, a, b):
+        """Take secant step."""
+        dphia = self.get_phi_dphi("g", a)
+        dphib = self.get_phi_dphi("g", b)
+        return (a*dphib - b*dphia) / (dphib - dphia)
+
+    def double_secant(self, a, b):
+        """Take secant² step."""
+        c = self.secant(a, b)
+        A, B = self.interval_update(a, b, c)
+        cB_close = np.isclose(c, B)
+        cA_close = np.isclose(c, A)
+
+        if cB_close:
+            c_dash = self.secant(b, B)
+        elif cA_close:
+            c_dash = self.secant(a, A)
+
+        if cB_close or cA_close:
+            a_dash, b_dash = self.interval_update(A, B, c_dash)
+        else:
+            a_dash, b_dash = A, B
+        return a_dash, b_dash
+
+    def bracket(self, c):
+        """Generate initial interval [a, b] that satisfies the opposite
+        slope condition (dphi(a) < 0, dphi(b) > 0).
+        """
+        cs = list()
+        p0epsk = self.phi0 + self.epsk
+        for j in range(10):
+            cs.append(c)
+
+            dphi_j = self.get_phi_dphi("g", c)
+
+            if (dphi_j >= 0) and (j == 0):
+                return 0, c
+
+            phi_j = self.get_phi_dphi("f", c)
+            if dphi_j >= 0:
+                phi_inds = np.array([self.get_fg("f", c) for c in cs[:-1]]) <= p0epsk
+                # See https://stackoverflow.com/a/8768734
+                ci = len(phi_inds) - phi_inds[::-1].argmax() - 1
+                return cs[ci], c
+            elif phi_j > p0epsk:
+                return self.bisect(0, c)
+
+            c *= self.rho
+
+    def norm_inf(self, arr):
+        """Returns infinity norm of given array."""
+        return np.linalg.norm(arr, np.inf)
+
+    def initial(self):
+        """Get an initial guess for alpha."""
+        if (~np.isclose(self.x0, np.zeros_like(self.x0))).any():
+            c = self.psi_0 * self.norm_inf(self.x0)/self.norm_inf(self.g0)
+        elif not np.isclose(self.f0, 0):
+            c = self.psi_0 * self.f0 / self.norm_inf(self.g0)**2
+        else:
+            c = 1
+        return c
+
+    def take_quad_step(self, alpha, g0_):
+        """Try to get alpha for minimum step from quadratic interpolation."""
+        fact = max(self.psi_low, g0_/(self.dphi0*self.psi_2))
+        alpha_ = min(fact, self.psi_hi) * alpha
+        phi_ = self.get_phi_dphi("f", alpha_)
+        denom = 2*((phi_-self.phi0)/alpha_ - self.dphi0)
+        f_temp = self.get_fg("f", alpha_)
+        if denom > 0.:
+            c = -self.dphi0*alpha_ / denom
+            if f_temp > self.get_fg("f", 0):
+                c = max(c, alpha_*1e-10)
+        else:
+            c = alpha
+        return c
+
+    def run_line_search(self):
+        if self.alpha_init is None and self.alpha_prev:
+            alpha_init = self.alpha_prev
+        elif self.alpha_init is None and self.alpha_prev is None:
+            alpha_init = self.initial()
+        else:
+            alpha_init = self.alpha_init
+
+        if self.quad_step:
+            g0_ = -2*abs(self.get_fg("f", 0)/alpha_init) if (self.dphi0_prev is None) \
+                  else self.dphi0_prev
+            alpha_init = self.take_quad_step(self.psi_2*alpha_init, g0_)
+        # This may raise LineSearchConverged
+        _ = self.get_phi_dphi("fg", alpha_init)
+
+        # TODO: cubic interpolation for better alpha_init
+        ak, bk = self.bracket(alpha_init)
+        for k in range(self.max_cycles):
+            if self.cond_func(ak):
+                break
+            # secant² step
+            a, b = self.double_secant(ak, bk)
+            if (b - a) > self.gamma*(bk - ak):
+                # Bisection step
+                c = (a + b)/2
+                a, b = self.interval_update(a, b, c)
+            ak, bk = a, b
+        else:
+            raise LineSearchNotConverged
+
+        return ak

pysisyphus/line_searches/LineSearch.py

@@ -0,0 +1,232 @@
+import abc
+from collections import namedtuple
+import logging
+
+import numpy as np
+
+
+class LineSearchConverged(Exception):
+    def __init__(self, alpha):
+        self.alpha = alpha
+
+
+class LineSearchNotConverged(Exception):
+    pass
+
+
+LineSearchResult = namedtuple(
+    "LineSearchResult",
+    "converged alpha f_new g_new f_evals df_evals dphi0",
+    # defaults=( None, None, None, None,   None,    None),
+)
+
+
+class LineSearch(metaclass=abc.ABCMeta):
+    def __init__(
+        self,
+        p,
+        cond="armijo",
+        x0=None,
+        geometry=None,
+        f=None,
+        df=None,
+        alpha_init=None,
+        f0=None,
+        g0=None,
+        c1=0.1,
+        c2=0.9,
+        max_cycles=10,
+        alpha_min=1e-6,
+    ):
+        self.p = p
+        self.geometry = geometry
+        self.f = f
+        self.df = df
+
+        geometry_supplied = self.geometry is not None
+        assert geometry_supplied or (
+            x0 is not None
+        ), "Supply either 'geometry' or the starting coordinates 'x0'!"
+        assert geometry_supplied or (self.f and self.df), (
+            "Supply either 'geometry' with a calculator or the two functions "
+            "'f' and 'df' to calculate the energy and its gradient!"
+        )
+
+        self.x0 = x0
+        if self.geometry:
+            self.f = lambda coords: self.geometry.get_energy_at(coords)
+            self.df = lambda coords: -self.geometry.get_energy_and_forces_at(coords)[
+                "forces"
+            ]
+            self.x0 = self.geometry.coords.copy()
+
+        self.alpha_init = alpha_init
+        self.f0 = f0
+        self.g0 = g0
+        self.c1 = c1
+        self.c2 = c2
+        self.max_cycles = max_cycles
+        self.alpha_min = alpha_min
+
+        # Store calculated energies & gradients
+        self.alpha_fs = {}
+        self.alpha_dfs = {}
+        self.f_evals = 0
+        self.df_evals = 0
+
+        self.dphis = {}
+
+        self.cond_funcs = {
+            "armijo": self.sufficiently_decreased,
+            "wolfe": self.wolfe_condition,
+            "strong_wolfe": self.strong_wolfe_condition,
+        }
+        self.can_eval_cond_funcs = {
+            "armijo": lambda alpha: alpha in self.alpha_fs,
+            "wolfe": self.got_alpha_phi_dphi,
+            "strong_wolfe": self.got_alpha_phi_dphi,
+        }
+        self.cond_func = self.cond_funcs[cond]
+        self.can_eval_cond_func = self.can_eval_cond_funcs[cond]
+
+        self.logger = logging.getLogger("optimizer")
+
+    def log(self, message):
+        self.logger.debug(message)
+
+    def prepare_line_search(self):
+        if self.f0 is None:
+            self.phi0 = self.get_phi_dphi("f", 0)
+        else:
+            self.phi0 = self.f0
+            self.alpha_fs[0.0] = self.f0
+        if self.g0 is None:
+            self.dphi0 = self.get_phi_dphi("g", 0)
+        else:
+            self.dphi0 = self.g0.dot(self.p)
+            self.alpha_dfs[0.0] = self.g0
+
+    def check_alpha(self, alpha):
+        if (alpha != 0.0) and (np.isnan(alpha) or (alpha < self.alpha_min)):
+            raise LineSearchNotConverged()
+
+    def _phi(self, alpha):
+        alpha = float(alpha)
+        self.check_alpha(alpha)
+        try:
+            f_alpha = self.alpha_fs[alpha]
+        except KeyError:
+            self.log(f"\tEvaluating energy for alpha={alpha:.6f}")
+            f_alpha = self.f(self.x0 + alpha * self.p)
+            self.f_evals += 1
+            self.alpha_fs[alpha] = f_alpha
+        return f_alpha
+
+    def _dphi(self, alpha):
+        alpha = float(alpha)
+        self.check_alpha(alpha)
+        try:
+            df_alpha = self.alpha_dfs[alpha]
+            dphi_ = df_alpha.dot(self.p)
+        except KeyError:
+            self.log(f"\tEvaluating gradient for alpha={alpha:.6f}")
+            df_alpha = self.df(self.x0 + alpha * self.p)
+            self.df_evals += 1
+            self.alpha_dfs[alpha] = df_alpha
+            dphi_ = df_alpha.dot(self.p)
+            self.dphis[alpha] = dphi_
+        return dphi_
+
+    def got_alpha_phi_dphi(self, alpha):
+        return (alpha in self.alpha_fs) and (alpha in self.alpha_dfs)
+
+    def get_phi_dphi(self, what, alpha, check=True):
+        """Wrapper that handles function/gradient evaluations."""
+        alpha = float(alpha)
+        whats = "f g fg".split()
+        assert what in whats
+        calc_funcs = {
+            "f": self._phi,
+            "g": self._dphi,
+        }
+        result = [calc_funcs[w](alpha) for w in what]
+        # Check if we got both phi and dphi for alpha now. If so we
+        # can check if the chosen condition (Wolfe/approx. Wolfe) is
+        # satisfied.
+        if (
+            check
+            and (alpha > 0.0)
+            and self.can_eval_cond_func(alpha)
+            and self.cond_func(alpha)
+        ):
+            self.log(f"Line search condition is satisfied for α={alpha:.6f}.")
+            raise LineSearchConverged(alpha)
+        # Dont return a list if only f or g was requested.
+        if len(what) == 1:
+            result = result[0]
+        return result
+
+    def get_fg(self, what, alpha):
+        """Lookup raw function/gradient values for a given alpha."""
+        whats = "f g fg".split()
+        assert what in whats
+        lookups = {
+            "f": self.alpha_fs,
+            "g": self.alpha_dfs,
+        }
+        result = [lookups[w][alpha] for w in what]
+        if len(what) == 1:
+            result = result[0]
+        return result
+
+    def sufficiently_decreased(self, alpha):
+        """Sufficient decrease/Armijo condition."""
+        return self._phi(alpha) <= (self.phi0 + self.c1 * alpha * self.dphi0)
+
+    def curvature_condition(self, alpha):
+        return self._dphi(alpha) >= self.c2 * self.dphi0
+
+    def strong_curvature_condition(self, alpha):
+        return abs(self._dphi(alpha)) <= -self.c2 * self.dphi0
+
+    def wolfe_condition(self, alpha):
+        """Normal, not strong, Wolfe condition."""
+        return self.sufficiently_decreased(alpha) and self.curvature_condition(alpha)
+
+    def strong_wolfe_condition(self, alpha):
+        """Strong wolfe condition."""
+        return self.sufficiently_decreased(alpha) and self.strong_curvature_condition(
+            alpha
+        )
+
+    @abc.abstractmethod
+    def run_line_search(self):
+        raise NotImplementedError
+
+    def run(self):
+        self.prepare_line_search()
+
+        # Normal termination
+        try:
+            self.log(f"Starting {self.__class__.__name__} line search.")
+            alpha = self.run_line_search()
+        # Termination in get_phi_dphi
+        except LineSearchConverged as lsc:
+            alpha = lsc.alpha
+        # Failed LineSearch
+        except LineSearchNotConverged:
+            alpha = None
+
+        result = LineSearchResult(
+            converged=bool(alpha),
+            alpha=alpha,
+            # The gradient at the endpoint of the line search may not
+            # have been evaluted, but the function value was always
+            # evaluated, except when the line search did not converge.
+            f_new=self.alpha_fs.get(alpha, None),
+            g_new=self.alpha_dfs.get(alpha, None),
+            f_evals=self.f_evals,
+            df_evals=self.df_evals,
+            dphi0=self.dphi0,
+        )
+        return result

pysisyphus/line_searches/StrongWolfe.py

@@ -0,0 +1,108 @@
+# [1] Nocedal, Numerical Optimization
+
+from pysisyphus.line_searches.LineSearch import LineSearch, \
+                                                LineSearchNotConverged
+
+
+from pysisyphus.line_searches.interpol import interpol_alpha_quad, interpol_alpha_cubic
+
+
+class StrongWolfe(LineSearch):
+
+    def __init__(self, *args, alpha_max=10., fac=2, **kwargs):
+        """Wolfe line search.
+
+        Uses only energy & gradient evaluations.
+
+        See [1], Chapter 3, Line Search methods, Section 3.5 p. 60."""
+
+        kwargs["cond"] = "strong_wolfe"
+        super().__init__(*args, **kwargs)
+
+        self.alpha_max = float(alpha_max)
+        self.fac = fac
+
+    def zoom(self, alpha_lo, alpha_hi, phi_lo,
+             phi_alpha_=None, alpha_0_=None, max_cycles=10):
+        phi0, dphi0 = self.get_phi_dphi("fg", 0)
+
+        alphas = list()
+        phi_alphas = list()
+        if phi_alpha_:
+            phi_alphas = [phi_alpha_, ]
+        if alpha_0_:
+            alphas = [alpha_0_, ]
+
+        for j in range(max_cycles):
+            # Interpoaltion of alpha between alpha_lo, alpha_hi
+            #
+            # Try cubic interpolation if at least two additional alphas and
+            # corresponding phi_alpha values are available beside alpha = 0.
+            if len(phi_alphas) > 1:
+                alpha_prev = alphas[-1]
+                phi_alpha_prev = phi_alphas[-1]
+                alpha_j = interpol_alpha_cubic(phi0, dphi0,
+                                               phi_alpha_, phi_alpha_prev,
+                                               alpha_0_, alpha_prev
+                )
+            # Try quadratic interpolation if only one additional alpha and
+            # corresponding phi_alpha value are available beside alpha = 0.
+            elif len(phi_alphas) == 1:
+                alpha_j = interpol_alpha_quad(phi0, dphi0, phi_alpha_, alpha_0_)
+            # Fallback to simple bisection
+            else:
+                alpha_j = (alpha_lo + alpha_hi) / 2
+
+            phi_j = self.get_phi_dphi("f", alpha_j)
+            # Store the values so they can be reused for cubic interpolation
+            alphas.append(alpha_j)
+            phi_alphas.append(phi_j)
+
+            # True if alpha is still too big or if the function value
+            # increased compared to the previous cycle.
+            if not self.sufficiently_decreased(alpha_j) or (phi_j > phi_lo):
+                # Shrink interval to (alpha_lo, alpha_j)
+                alpha_hi = alpha_j
+                continue
+
+            # If line search converged LineSearchConverged will be raised in
+            # this call.
+            dphi_j = self.get_phi_dphi("g", alpha_j)
+
+            if (dphi_j * (alpha_hi - alpha_lo)) >= 0:
+                alpha_hi = alpha_lo
+            # Shrink interval to (alpha_j, alpha_hi)
+            alpha_lo = alpha_j
+
+    def run_line_search(self):
+        phi0, dphi0 = self.get_phi_dphi("fg", 0)
+
+        alpha_prev = 0
+        phi_prev = phi0
+        if self.alpha_init is not None:
+            alpha_i = self.alpha_init
+        else:
+            alpha_i = 1.0
+
+        for i in range(self.max_cycles):
+            phi_i = self.get_phi_dphi("f", alpha_i)
+            phi_rose = (phi_i >= phi_prev)
+            # In [1] this condition is given with (if not sufficiently_decreased ...)
+            # I guess this may give problems if the initial step is too small; then
+            # suff. decr. is also not fullfilled ...
+            if not self.sufficiently_decreased(alpha_i) or (phi_rose and i > 0):
+                return self.zoom(alpha_prev, alpha_i, phi_prev, phi_i, alpha_i)
+
+            dphi_i = self.get_phi_dphi("g", alpha_i)
+            if self.strong_curvature_condition(alpha_i):
+                break
+
+            if dphi_i >= 0:
+                return self.zoom(alpha_i, alpha_prev, phi_i, phi_alpha_=phi_i, alpha_0_=alpha_i)
+            alpha_prev = alpha_i
+            alpha_i = min(self.fac * alpha_i, self.alpha_max)
+        # Premature abort of the loop may happen through LineSearchConverged being raised
+        else:
+            raise LineSearchNotConverged
+
+        return alpha_i

pysisyphus/line_searches/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "Backtracking",
+    "HagerZhang",
+    "StrongWolfe",
+]
+
+from pysisyphus.line_searches.Backtracking import Backtracking
+from pysisyphus.line_searches.HagerZhang import HagerZhang
+from pysisyphus.line_searches.StrongWolfe import StrongWolfe

pysisyphus/line_searches/interpol.py

@@ -0,0 +1,15 @@
+import numpy as np
+
+def interpol_alpha_quad(f_0, df_0, f_alpha_0, alpha_0):
+    return -df_0*alpha_0**2 / 2 / (f_alpha_0 - f_0 - df_0*alpha_0)
+
+
+def interpol_alpha_cubic(f_0, df_0, f_alpha_0, f_alpha_1, alpha_0, alpha_1):
+    quot = 1 / (alpha_0**2 * alpha_1**2 * (alpha_1 - alpha_0))
+    A = np.array(((alpha_0**2, -alpha_1**2),
+                  (-alpha_0**3, alpha_1**3)))
+    B = np.array(((f_alpha_1 - f_0 - df_0*alpha_1),
+                  (f_alpha_0 - f_0 - df_0*alpha_0)))
+    a, b = quot * A @ B
+    alpha_cubic = (-b + (b**2 - 3*a*df_0)**(0.5)) / (3*a)
+    return alpha_cubic

pysisyphus/modefollow/NormalMode.py

@@ -0,0 +1,40 @@
+from math import sqrt
+
+import numpy as np
+
+
+class NormalMode:
+    """See http://gaussian.com/vib/"""
+
+    def __init__(self, l, masses):
+        """NormalMode class.
+
+        Cartesian displacements are normalized to 1.
+
+        Parameters
+        ----------
+        l : np.array
+            Cartesian, non-mass-weighted displacements.
+        masses : np.array
+            Atomic masses.
+        """
+
+        self.l = np.array(l.flatten())
+        self.l /= np.linalg.norm(l)
+        self.masses = masses
+        assert self.l.shape == self.masses.shape
+
+    def __len__(self):
+        return self.l.size
+
+    @property
+    def red_mass(self):
+        return 1 / np.sum(np.square(self.l_mw) / self.masses)
+
+    def mw_norm_for_norm(self, norm=0.01):
+        return norm * sqrt(self.red_mass)
+
+    @property
+    def l_mw(self):
+        l_mw = self.l * np.sqrt(self.masses)
+        return l_mw / np.linalg.norm(l_mw)

pysisyphus/modefollow/__init__.py

@@ -0,0 +1,10 @@
+__all__ = [
+    "geom_davidson",
+    "geom_lanczos",
+    "NormalMode",
+]
+
+
+from pysisyphus.modefollow.davidson import geom_davidson
+from pysisyphus.modefollow.lanczos import geom_lanczos
+from pysisyphus.modefollow.NormalMode import NormalMode