torchzero 0.1.8__py3-none-any.whl → 0.3.1__py3-none-any.whl

torchzero/modules/projections/projection.py

@@ -0,0 +1,218 @@
+import math
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+from typing import Any, Literal
+import warnings
+import torch
+
+from ...core import Chainable, Module, Vars
+from ...utils import vec_to_tensors
+
+
+def _make_projected_closure(closure, vars: Vars, projection: "Projection",
+                           params: list[torch.Tensor], projected_params: list[torch.Tensor]):
+
+    def projected_closure(backward=True):
+        unprojected_params = projection.unproject(projected_params, vars, current='params')
+
+        with torch.no_grad():
+            for p, new_p in zip(params, unprojected_params):
+                p.set_(new_p) # pyright: ignore[reportArgumentType]
+
+        if backward:
+            loss = closure()
+            grads = [p.grad if p.grad is not None else torch.zeros_like(p) for p in params]
+            projected_grads = projection.project(grads, vars, current='grads')
+            for p, g in zip(projected_params, projected_grads):
+                p.grad = g
+
+        else:
+            loss = closure(False)
+
+        return loss
+
+    return projected_closure
+
+
+class Projection(Module, ABC):
+    """
+    Base class for projections.
+    This is an abstract class, to use it, subclass it and override `project` and `unproject`.
+
+    Args:
+        modules (Chainable): modules that will be applied in the projected domain.
+        project_update (bool, optional): whether to project the update. Defaults to True.
+        project_params (bool, optional):
+            whether to project the params. This is necessary for modules that use closure. Defaults to False.
+        project_grad (bool, optional): whether to project the gradients (separately from update). Defaults to False.
+        defaults (dict[str, Any] | None, optional): dictionary with defaults. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        modules: Chainable,
+        project_update=True,
+        project_params=False,
+        project_grad=False,
+        defaults: dict[str, Any] | None = None,
+    ):
+        super().__init__(defaults)
+        self.set_child('modules', modules)
+        self.global_state['current_step'] = 0
+        self._project_update = project_update
+        self._project_params = project_params
+        self._project_grad = project_grad
+        self._projected_params = None
+
+    @abstractmethod
+    def project(self, tensors: list[torch.Tensor], vars: Vars, current: Literal['params', 'grads', 'update']) -> Iterable[torch.Tensor]:
+        """projects `tensors`. Note that this can be called multiple times per step with `params`, `grads`, and `update`."""
+
+    @abstractmethod
+    def unproject(self, tensors: list[torch.Tensor], vars: Vars, current: Literal['params', 'grads', 'update']) -> Iterable[torch.Tensor]:
+        """unprojects `tensors`. Note that this can be called multiple times per step with `params`, `grads`, and `update`."""
+
+    @torch.no_grad
+    def step(self, vars: Vars):
+        projected_vars = vars.clone(clone_update=False)
+        update_is_grad = False
+
+        # closure will calculate projected update and grad if needed
+        if self._project_params and vars.closure is not None:
+            if self._project_update and vars.update is not None: projected_vars.update = list(self.project(vars.update, vars=vars, current='update'))
+            else:
+                update_is_grad = True
+            if self._project_grad and vars.grad is not None: projected_vars.grad = list(self.project(vars.grad, vars=vars, current='grads'))
+
+        # project update and grad, unprojected attributes are deleted
+        else:
+            if self._project_update:
+                if vars.update is None:
+                    # update is None, meaning it will be set to `grad`.
+                    # we can project grad and use it for update
+                    grad = vars.get_grad()
+                    projected_vars.grad = list(self.project(grad, vars=vars, current='grads'))
+                    if self._project_grad: projected_vars.update = [g.clone() for g in projected_vars.grad]
+                    else: projected_vars.update = projected_vars.grad.copy() # don't clone because grad shouldn't be used
+                    del vars.update
+                    update_is_grad = True
+
+                else:
+                    update = vars.get_update()
+                    projected_vars.update = list(self.project(update, vars=vars, current='update'))
+                    del update, vars.update
+
+            if self._project_grad and projected_vars.grad is None:
+                grad = vars.get_grad()
+                projected_vars.grad = list(self.project(grad, vars=vars, current='grads'))
+
+        original_params = None
+        if self._project_params:
+            original_params = [p.clone() for p in vars.params]
+            projected_params = self.project(vars.params, vars=vars, current='params')
+
+        else:
+            # make fake params for correct shapes and state storage
+            # they reuse update or grad storage for memory efficiency
+            projected_params = projected_vars.update if projected_vars.update is not None else projected_vars.grad
+            assert projected_params is not None
+
+        if self._projected_params is None:
+            # 1st step - create objects for projected_params. They have to remain the same python objects
+            # to support per-parameter states which are stored by ids.
+            self._projected_params = [p.view_as(p).requires_grad_() for p in projected_params]
+        else:
+            # set storage to new fake params while ID remains the same
+            for empty_p, new_p in zip(self._projected_params, projected_params):
+                empty_p.set_(new_p.view_as(new_p).requires_grad_()) # pyright: ignore[reportArgumentType]
+
+        # project closure
+        if self._project_params:
+            closure = vars.closure; params = vars.params
+            projected_vars.closure = _make_projected_closure(closure, vars=vars, projection=self, params=params,
+                                                             projected_params=self._projected_params)
+
+        else:
+            projected_vars.closure = None
+
+        # step
+        projected_vars.params = self._projected_params
+        projected_vars = self.children['modules'].step(projected_vars)
+
+        # empty fake params storage
+        # this doesn't affect update/grad because it is a different python object, set_ changes storage on an object
+        if not self._project_params:
+            for p in self._projected_params:
+                p.set_(torch.empty(0, device=p.device, dtype=p.dtype)) # pyright: ignore[reportArgumentType]
+
+        # unproject
+        unprojected_vars = projected_vars.clone(clone_update=False)
+        unprojected_vars.closure = vars.closure
+        unprojected_vars.params = vars.params
+        if unprojected_vars.grad is None: unprojected_vars.grad = vars.grad
+
+        if self._project_update:
+            assert projected_vars.update is not None
+            unprojected_vars.update = list(self.unproject(projected_vars.update, vars=vars, current='grads' if update_is_grad else 'update'))
+            del projected_vars.update
+
+        # unprojecting grad doesn't make sense?
+        # if self._project_grad:
+        #     assert projected_vars.grad is not None
+        #     unprojected_vars.grad = list(self.unproject(projected_vars.grad, vars=vars))
+
+        del projected_vars
+
+        if original_params is not None:
+            for p, o in zip(unprojected_vars.params, original_params):
+                p.set_(o) # pyright: ignore[reportArgumentType]
+
+        return unprojected_vars
+
+
+
+class FlipConcatProjection(Projection):
+    """
+    for testing
+    """
+
+    def __init__(self, modules: Chainable, project_update=True, project_params=False, project_grad=False):
+        super().__init__(modules, project_update=project_update, project_params=project_params, project_grad=project_grad)
+
+    @torch.no_grad
+    def project(self, tensors, vars, current):
+        return [torch.cat([u.view(-1) for u in tensors], dim=-1).flip(0)]
+
+    @torch.no_grad
+    def unproject(self, tensors, vars, current):
+        return vec_to_tensors(vec=tensors[0].flip(0), reference=vars.params)
+
+
+class NoopProjection(Projection):
+    """an example projection which doesn't do anything for testing"""
+
+    def __init__(self, modules: Chainable, project_update=True, project_params=False, project_grad=False):
+        super().__init__(modules, project_update=project_update, project_params=project_params, project_grad=project_grad)
+
+    @torch.no_grad
+    def project(self, tensors, vars, current):
+        return tensors
+
+    @torch.no_grad
+    def unproject(self, tensors, vars, current):
+        return tensors
+
+class MultipyProjection(Projection):
+    """an example projection which multiplies everything by 2"""
+
+    def __init__(self, modules: Chainable, project_update=True, project_params=False, project_grad=False):
+        super().__init__(modules, project_update=project_update, project_params=project_params, project_grad=project_grad)
+
+    @torch.no_grad
+    def project(self, tensors, vars, current):
+        return torch._foreach_mul(tensors, 2)
+
+    @torch.no_grad
+    def unproject(self, tensors, vars, current):
+        return torch._foreach_div(tensors, 2)
+

torchzero/modules/projections/structural.py

@@ -0,0 +1,151 @@
+import math
+
+import numpy as np
+import torch
+
+from ...core import Chainable
+from ...utils import vec_to_tensors, TensorList
+from ..optimizers.shampoo import _merge_small_dims
+from .projection import Projection
+
+
+class VectorProjection(Projection):
+    """
+    flattens and concatenates all parameters into a vector
+    """
+    def __init__(self, modules: Chainable, project_update=True, project_params=False, project_grad=False):
+        super().__init__(modules, project_update=project_update, project_params=project_params, project_grad=project_grad)
+
+    @torch.no_grad
+    def project(self, tensors, vars, current):
+        return [torch.cat([u.view(-1) for u in tensors], dim=-1)]
+
+    @torch.no_grad
+    def unproject(self, tensors, vars, current):
+        return vec_to_tensors(vec=tensors[0], reference=vars.params)
+
+
+
+class TensorizeProjection(Projection):
+    """flattens and concatenates all parameters into a vector and then reshapes it into a tensor"""
+    def __init__(self, modules: Chainable, max_side: int, project_update=True, project_params=False, project_grad=False):
+        defaults = dict(max_side=max_side)
+        super().__init__(modules, defaults=defaults, project_update=project_update, project_params=project_params, project_grad=project_grad)
+
+    @torch.no_grad
+    def project(self, tensors, vars, current):
+        params = vars.params
+        max_side = self.settings[params[0]]['max_side']
+        num_elems = sum(t.numel() for t in tensors)
+
+        if num_elems < max_side:
+            self.global_state['remainder'] = 0
+            # return 1d
+            return [torch.cat([t.view(-1) for t in tensors])]
+
+
+        # determine appropriate shape to reshape into
+        ndims = math.ceil(math.log(num_elems, max_side)) # determine number of dims
+        dim_size = math.ceil(num_elems ** (1/ndims)) # average size of a dim with ndims
+        dims = [dim_size for _ in range(ndims)]
+        required_elems = math.prod(dims)
+
+        # add few extra zeros to vec to match a reshapable size
+        remainder = required_elems-num_elems
+        if remainder > 0: tensors = tensors + [torch.zeros(remainder, dtype=tensors[0].dtype, device=tensors[0].device)]
+        self.global_state['remainder'] = remainder
+
+        # flatten and reshape
+        vec = torch.cat([t.view(-1) for t in tensors])
+        return [vec.view(dims)]
+
+    @torch.no_grad
+    def unproject(self, tensors, vars, current):
+        remainder = self.global_state['remainder']
+        # warnings.warn(f'{tensors[0].shape = }')
+        vec = tensors[0].view(-1)
+        if remainder > 0: vec = vec[:-remainder]
+        return vec_to_tensors(vec, vars.params)
+
+class BlockPartition(Projection):
+    """splits parameters into blocks (for now flatttens them and chunks)"""
+    def __init__(self, modules: Chainable, max_size: int, batched: bool = False, project_update=True, project_params=False, project_grad=False):
+        defaults = dict(max_size=max_size, batched=batched)
+        super().__init__(modules, project_update=project_update, project_params=project_params, project_grad=project_grad, defaults=defaults)
+
+    @torch.no_grad
+    def project(self, tensors, vars, current):
+        partitioned = []
+        for p,t in zip(vars.params, tensors):
+            settings = self.settings[p]
+            max_size = settings['max_size']
+            n = t.numel()
+            if n <= max_size:
+                partitioned.append(t)
+                continue
+
+            t_flat = t.view(-1)
+
+            batched = settings['batched']
+            num_chunks = math.ceil(n / max_size)
+
+            if batched:
+                chunks_size = num_chunks * max_size
+                if num_chunks * max_size > n:
+                    t_flat = torch.cat([t_flat, torch.zeros(n-chunks_size, dtype=t_flat.dtype, device=t_flat.device)])
+                partitioned.append(t_flat.view(num_chunks, -1))
+
+            else:
+                partitioned.extend(t_flat.chunk(num_chunks))
+
+        return partitioned
+
+    @torch.no_grad
+    def unproject(self, tensors, vars, current):
+        ti = iter(tensors)
+        unprojected = []
+        for p in vars.params:
+            settings = self.settings[p]
+            n = p.numel()
+
+            if settings['batched']:
+                unprojected.append(next(ti).view(-1)[:n].view_as(p))
+
+            else:
+                chunks = []
+                t_n = 0
+                while t_n < n:
+                    t = next(ti)
+                    chunks.append(t)
+                    t_n += t.numel()
+
+                assert t_n == n
+                unprojected.append(torch.cat(chunks).view_as(p))
+
+        return unprojected
+
+
+class TensorNormsProjection(Projection):
+    def __init__(self, modules: Chainable, project_update=True, project_params=False, project_grad=False):
+        super().__init__(modules, project_update=project_update, project_params=project_params, project_grad=project_grad)
+
+    @torch.no_grad
+    def project(self, tensors, vars, current):
+        orig = self.get_state(f'{current}_orig', params=vars.params)
+        torch._foreach_copy_(orig, tensors)
+
+        norms = torch._foreach_norm(tensors)
+        self.get_state(f'{current}_orig_norms', params=vars.params, init=norms, cls=TensorList).set_(norms)
+
+        return [torch.stack(norms)]
+
+    @torch.no_grad
+    def unproject(self, tensors, vars, current):
+        orig = self.get_state(f'{current}_orig', params=vars.params)
+        orig_norms = torch.stack(self.get_state(f'{current}_orig_norms', params=vars.params))
+        target_norms = tensors[0]
+
+        orig_norms = torch.where(orig_norms == 0, 1, orig_norms)
+
+        torch._foreach_mul_(orig, (target_norms/orig_norms).detach().cpu().tolist())
+        return orig

torchzero/modules/quasi_newton/__init__.py

@@ -1,4 +1,7 @@
-r"""
-This includes modules that compute a step direction via quasi-newton methods.
-"""
-# from .hv_inv_fdm import HvInvFDM
+from .cg import PolakRibiere, FletcherReeves, HestenesStiefel, DaiYuan, LiuStorey, ConjugateDescent, HagerZhang, HybridHS_DY
+from .lbfgs import LBFGS
+from .olbfgs import OnlineLBFGS
+# from .experimental import ModularLBFGS
+
+from .quasi_newton import BFGS, SR1, DFP, BroydenGood, BroydenBad, Greenstadt1, Greenstadt2, ColumnUpdatingMethod, ThomasOptimalMethod, PSB, Pearson2, SSVM
+from .lsr1 import LSR1

torchzero/modules/quasi_newton/cg.py

@@ -0,0 +1,218 @@
+from abc import ABC, abstractmethod
+
+import torch
+
+from ...core import Chainable, Transform, apply
+from ...utils import TensorList, as_tensorlist
+
+
+class ConguateGradientBase(Transform, ABC):
+    """all CGs are the same except beta calculation"""
+    def __init__(self, defaults = None, clip_beta: bool = False, reset_interval: int | None = None, inner: Chainable | None = None):
+        if defaults is None: defaults = {}
+        defaults['reset_interval'] = reset_interval
+        defaults['clip_beta'] = clip_beta
+        super().__init__(defaults, uses_grad=False)
+
+        if inner is not None:
+            self.set_child('inner', inner)
+
+    def initialize(self, p: TensorList, g: TensorList):
+        """runs on first step when prev_grads and prev_dir are not available"""
+
+    @abstractmethod
+    def get_beta(self, p: TensorList, g: TensorList, prev_g: TensorList, prev_d: TensorList) -> float | torch.Tensor:
+        """returns beta"""
+
+    @torch.no_grad
+    def transform(self, tensors, params, grads, vars):
+        tensors = as_tensorlist(tensors)
+        params = as_tensorlist(params)
+
+        step = self.global_state.get('step', 0)
+        prev_dir, prev_grads = self.get_state('prev_dir', 'prev_grad', params=params, cls=TensorList)
+
+        # initialize on first step
+        if step == 0:
+            self.initialize(params, tensors)
+            prev_dir.copy_(tensors)
+            prev_grads.copy_(tensors)
+            self.global_state['step'] = step + 1
+            return tensors
+
+        # get beta
+        beta = self.get_beta(params, tensors, prev_grads, prev_dir)
+        if self.settings[params[0]]['clip_beta']: beta = max(0, beta) # pyright:ignore[reportArgumentType]
+        prev_grads.copy_(tensors)
+
+        # inner step
+        if 'inner' in self.children:
+            tensors = as_tensorlist(apply(self.children['inner'], tensors, params, grads, vars))
+
+        # calculate new direction with beta
+        dir = tensors.add_(prev_dir.mul_(beta))
+        prev_dir.copy_(dir)
+
+        # resetting
+        self.global_state['step'] = step + 1
+        reset_interval = self.settings[params[0]]['reset_interval']
+        if reset_interval is not None and (step+1) % reset_interval == 0:
+            self.reset()
+
+        return dir
+
+# ------------------------------- Polak-Ribière ------------------------------ #
+def polak_ribiere_beta(g: TensorList, prev_g: TensorList):
+    denom = prev_g.dot(prev_g)
+    if denom == 0: return 0
+    return g.dot(g - prev_g) / denom
+
+class PolakRibiere(ConguateGradientBase):
+    """Polak-Ribière-Polyak nonlinear conjugate gradient method. This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe(c2=0.1)` after this."""
+    def __init__(self, clip_beta=True, reset_interval: int | None = None, inner: Chainable | None = None):
+        super().__init__(clip_beta=clip_beta, reset_interval=reset_interval, inner=inner)
+
+    def get_beta(self, p, g, prev_g, prev_d):
+        return polak_ribiere_beta(g, prev_g)
+
+# ------------------------------ Fletcher–Reeves ----------------------------- #
+def fletcher_reeves_beta(gg, prev_gg):
+    if prev_gg == 0: return 0
+    return gg / prev_gg
+
+class FletcherReeves(ConguateGradientBase):
+    """Fletcher–Reeves nonlinear conjugate gradient method. This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe` after this."""
+    def __init__(self, reset_interval: int | None = None, clip_beta=False, inner: Chainable | None = None):
+        super().__init__(clip_beta=clip_beta, reset_interval=reset_interval, inner=inner)
+
+    def initialize(self, p, g):
+        self.global_state['prev_gg'] = g.dot(g)
+
+    def get_beta(self, p, g, prev_g, prev_d):
+        gg = g.dot(g)
+        beta = fletcher_reeves_beta(gg, self.global_state['prev_gg'])
+        self.global_state['prev_gg'] = gg
+        return beta
+
+# ----------------------------- Hestenes–Stiefel ----------------------------- #
+def hestenes_stiefel_beta(g: TensorList, prev_d: TensorList,prev_g: TensorList):
+    grad_diff = g - prev_g
+    denom = prev_d.dot(grad_diff)
+    if denom == 0: return 0
+    return (g.dot(grad_diff) / denom).neg()
+
+
+class HestenesStiefel(ConguateGradientBase):
+    """Hestenes–Stiefel nonlinear conjugate gradient method. This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe` after this."""
+    def __init__(self, reset_interval: int | None = None, clip_beta=False, inner: Chainable | None = None):
+        super().__init__(clip_beta=clip_beta, reset_interval=reset_interval, inner=inner)
+
+    def get_beta(self, p, g, prev_g, prev_d):
+        return hestenes_stiefel_beta(g, prev_d, prev_g)
+
+
+# --------------------------------- Dai–Yuan --------------------------------- #
+def dai_yuan_beta(g: TensorList, prev_d: TensorList,prev_g: TensorList):
+    denom = prev_d.dot(g - prev_g)
+    if denom == 0: return 0
+    return (g.dot(g) / denom).neg()
+
+class DaiYuan(ConguateGradientBase):
+    """Dai–Yuan nonlinear conjugate gradient method. This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe` after this."""
+    def __init__(self, reset_interval: int | None = None, clip_beta=False, inner: Chainable | None = None):
+        super().__init__(clip_beta=clip_beta, reset_interval=reset_interval, inner=inner)
+
+    def get_beta(self, p, g, prev_g, prev_d):
+        return dai_yuan_beta(g, prev_d, prev_g)
+
+
+# -------------------------------- Liu-Storey -------------------------------- #
+def liu_storey_beta(g:TensorList, prev_d:TensorList, prev_g:TensorList, ):
+    denom = prev_g.dot(prev_d)
+    if denom == 0: return 0
+    return g.dot(g - prev_g) / denom
+
+class LiuStorey(ConguateGradientBase):
+    """Liu-Storey nonlinear conjugate gradient method. This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe` after this."""
+    def __init__(self, reset_interval: int | None = None, clip_beta=False, inner: Chainable | None = None):
+        super().__init__(clip_beta=clip_beta, reset_interval=reset_interval, inner=inner)
+
+    def get_beta(self, p, g, prev_g, prev_d):
+        return liu_storey_beta(g, prev_d, prev_g)
+
+# ----------------------------- Conjugate Descent ---------------------------- #
+class ConjugateDescent(Transform):
+    """Conjugate Descent (CD). This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe` after this."""
+    def __init__(self, inner: Chainable | None = None):
+        super().__init__(defaults={}, uses_grad=False)
+
+        if inner is not None:
+            self.set_child('inner', inner)
+
+
+    @torch.no_grad
+    def transform(self, tensors, params, grads, vars):
+        g = as_tensorlist(tensors)
+
+        prev_d = self.get_state('prev_dir', params=params, cls=TensorList, init = torch.zeros_like)
+        if 'denom' not in self.global_state:
+            self.global_state['denom'] = torch.tensor(0.).to(g[0])
+
+        prev_gd = self.global_state.get('prev_gd', 0)
+        if prev_gd == 0: beta = 0
+        else: beta = g.dot(g) / prev_gd
+
+        # inner step
+        if 'inner' in self.children:
+            g = as_tensorlist(apply(self.children['inner'], g, params, grads, vars))
+
+        dir = g.add_(prev_d.mul_(beta))
+        prev_d.copy_(dir)
+        self.global_state['prev_gd'] = g.dot(dir)
+        return dir
+
+
+# -------------------------------- Hager-Zhang ------------------------------- #
+def hager_zhang_beta(g:TensorList, prev_d:TensorList, prev_g:TensorList,):
+    g_diff = g - prev_g
+    denom = prev_d.dot(g_diff)
+    if denom == 0: return 0
+
+    term1 = 1/denom
+    # term2
+    term2 = (g_diff - (2 * prev_d * (g_diff.pow(2).global_sum()/denom))).dot(g)
+    return (term1 * term2).neg()
+
+
+class HagerZhang(ConguateGradientBase):
+    """Hager-Zhang nonlinear conjugate gradient method,
+    This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe` after this."""
+    def __init__(self, reset_interval: int | None = None, clip_beta=False, inner: Chainable | None = None):
+        super().__init__(clip_beta=clip_beta, reset_interval=reset_interval, inner=inner)
+
+    def get_beta(self, p, g, prev_g, prev_d):
+        return hager_zhang_beta(g, prev_d, prev_g)
+
+
+# ----------------------------------- HS-DY ---------------------------------- #
+def hs_dy_beta(g: TensorList, prev_d: TensorList,prev_g: TensorList):
+    grad_diff = g - prev_g
+    denom = prev_d.dot(grad_diff)
+    if denom == 0: return 0
+
+    # Dai-Yuan
+    dy_beta = (g.dot(g) / denom).neg().clamp(min=0)
+
+    # Hestenes–Stiefel
+    hs_beta = (g.dot(grad_diff) / denom).neg().clamp(min=0)
+
+    return max(0, min(dy_beta, hs_beta)) # type:ignore
+
+class HybridHS_DY(ConguateGradientBase):
+    """HS-DY hybrid conjugate gradient method.
+    This requires step size to be determined via a line search, so put a line search like :code:`StrongWolfe` after this."""
+    def __init__(self, reset_interval: int | None = None, clip_beta=False, inner: Chainable | None = None):
+        super().__init__(clip_beta=clip_beta, reset_interval=reset_interval, inner=inner)
+
+    def get_beta(self, p, g, prev_g, prev_d):
+        return hs_dy_beta(g, prev_d, prev_g)

torchzero/modules/quasi_newton/experimental/__init__.py

@@ -0,0 +1 @@
+from .modular_lbfgs import ModularLBFGS