Added throw NaN error for restart geometry steps

Author: lindonroberts

dfols/__init__.py

@@ -39,7 +39,7 @@
 from __future__ import absolute_import, division, print_function, unicode_literals
 
 # DFO-LS version
-__version__ = '1.6.3'
+__version__ = '1.6.4'
 
 # Main solver & exit flags
 from .solver import *

dfols/controller.py

@@ -596,11 +596,11 @@ def trust_region_step(self, params, criticality_measure=1e-2):
 
         return d, gopt, H, gnew, crvmin
 
-    def geometry_step(self, knew, adelt, number_of_samples, params):
+    def geometry_step(self, knew, adelt, number_of_samples, params, throw_error_on_nans=False):
         if self.do_logging:
             module_logger.debug("Running geometry-fixing step")
         try:
-            c, g = self.model.lagrange_gradient(knew)
+            c, g = self.model.lagrange_gradient(knew, throw_error_on_nans=throw_error_on_nans)
             # c = 1.0 if knew == self.model.kopt else 0.0  # based at xopt, just like d
             if self.model.projections:
                 # Solve problem: use projection onto arbitrary constraints, and ||xnew-xopt|| <= adelt
@@ -707,7 +707,7 @@ def choose_point_to_replace(self, d, skip_kopt=True):
         exit_info = None
 
         try:
-            cs, gs = self.model.lagrange_gradient(k=None)  # find all Lagrange polynomials for k in range(self.model.npt())
+            cs, gs = self.model.lagrange_gradient(k=None, throw_error_on_nans=False)  # find all Lagrange polynomials for k in range(self.model.npt())
         except LA.LinAlgError:
             exit_info = ExitInformation(EXIT_LINALG_ERROR, "Singular matrix when choosing point to replace")
             return knew, exit_info
@@ -872,9 +872,16 @@ def soft_restart(self, number_of_samples, nruns_so_far, params, x_in_abs_coords_
             # Determine which point to update (knew)
             knew = closest_points[i]
 
+            throw_error_on_nans = params("restarts.throw_error_on_nans")
+            # If throwing error on NaNs, can safely skip this on the first iteration, since we always force moving the base point
+            # So, the first two evaluations from a restart will always be the same (third may change depending on if
+            # second evaluation becomes the new base/current iterate or not)
+            if params("restarts.soft.move_xk") and i == 0:
+                throw_error_on_nans = False
+
             # Using adelt=delta in fix_geometry (adelt determines the ball to max lagrange poly in altmov)
             # [Only reason actual 'delta' is needed in fix_geometry is for calling nsamples()]
-            exit_info = self.geometry_step(knew, self.delta, number_of_samples, params)
+            exit_info = self.geometry_step(knew, self.delta, number_of_samples, params, throw_error_on_nans=throw_error_on_nans)
             if exit_info is not None:
                 return exit_info
 

dfols/model.py

@@ -413,7 +413,9 @@ def build_full_model(self):
         H = 2.0 * np.dot(J.T, J)
         return g, H
 
-    def lagrange_gradient(self, k=None, factorise_first=True):
+    def lagrange_gradient(self, k=None, factorise_first=True, throw_error_on_nans=False):
+        # throw_error_on_nans: throw an error if the *actual* rhs (i.e. objective values) have nans
+        # (needed for optclim with soft restarts)
         if factorise_first:
             self.factorise_geom_system()
 
@@ -423,6 +425,14 @@ def lagrange_gradient(self, k=None, factorise_first=True):
             rhs[k] = 1.0
         else:
             rhs = np.eye(self.npt())  # find all Lagrange polynomials
+
+        if throw_error_on_nans:
+            fval_row_idx = np.arange(self.npt())  # indices of all rows
+            if np.any(np.isnan(self.fval_v[fval_row_idx, :])):  # check objective values
+                if self.do_logging:
+                    module_logger.warning("model.lagrange_gradient: NaNs encountered in objective evaluations, raising error")
+                raise np.linalg.LinAlgError("NaN encountered in objective evaluations during Lagrange polynomial construction")
+
         soln = self.solve_geom_system(rhs)
 
         if k is not None:

dfols/params.py

@@ -77,6 +77,7 @@ def __init__(self, n, npt, maxfun, objfun_has_noise=False):
         self.params["regression.momentum_extra_steps"] = False  # use momentum (False) or geometry (True) to do steps
         # Restarts
         self.params["restarts.use_restarts"] = True if objfun_has_noise else False
+        self.params["restarts.throw_error_on_nans"] = False  # throw numpy.linalg.LinAlgError if building a Lagrange polynomial with nan objective values?
         self.params["restarts.max_unsuccessful_restarts"] = 10
         self.params["restarts.rhoend_scale"] = 1.0  # how much to decrease rhoend by after each restart
         self.params["restarts.use_soft_restarts"] = True
@@ -211,6 +212,8 @@ def param_type(self, key, npt):
             type_str, nonetype_ok, lower, upper = 'bool', False, None, None
         elif key == "restarts.use_restarts":
             type_str, nonetype_ok, lower, upper = 'bool', False, None, None
+        elif key == "restarts.throw_error_on_nans":
+            type_str, nonetype_ok, lower, upper = 'bool', False, None, None
         elif key == "restarts.max_unsuccessful_restarts":
             type_str, nonetype_ok, lower, upper = 'int', False, 0, None
         elif key == "restarts.rhoend_scale":

docs/advanced.rst

@@ -67,7 +67,8 @@ Regression Model Management
 
 Multiple Restarts
 -----------------
-* :code:`restarts.use_restarts` - Whether to do restarts when :math:`\rho_k` reaches :math:`\rho_{end}`, or (optionally) when all points are within noise level of :math:`f(x_k)`. Default is :code:`False` for smooth problems or :code:`True` for noisy problems. 
+* :code:`restarts.use_restarts` - Whether to do restarts when :math:`\rho_k` reaches :math:`\rho_{end}`, or (optionally) when all points are within noise level of :math:`f(x_k)`. Default is :code:`False` for smooth problems or :code:`True` for noisy problems.
+* :code:`restarts.throw_error_on_nans` - whether or not to throw :code:`numpy.linalg.LinAlgError` if trying to interpolate to NaN objective values. If :code:`False`, DFO-LS should terminate gracefully with an error flag. Default is :code:`False`.
 * :code:`restarts.max_unsuccessful_restarts` - Maximum number of consecutive unsuccessful restarts allowed (i.e.~restarts which did not reduce the objective further). Default is 10. 
 * :code:`restarts.rhoend_scale` - Factor to reduce :math:`\rho_{end}` by with each restart. Default is 1. 
 * :code:`restarts.use_soft_restarts` - Whether to use soft or hard restarts. Default is :code:`True`. 

docs/history.rst

@@ -102,3 +102,8 @@ Version 1.6.2 (21 Jan 2026)
 Version 1.6.3 (16 Mar 2026)
 -------------------------
 * Allow parameter :code:`init.run_in_parallel=True` when :code:`init.random_initial_directions=False`
+
+Version 1.6.4 (23 Mar 2026)
+-------------------------
+* Add new parameter :code:`restarts.throw_error_on_nans` to customize handling of NaN objective values during restarts
+