DFO-LS 1.5.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

{DFO_LS-1.5.0.dist-info → DFO_LS-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: DFO-LS
-Version: 1.5.0
+Version: 1.5.2
 Summary: A flexible derivative-free solver for (bound constrained) nonlinear least-squares minimization
 Author-email: Lindon Roberts <lindon.roberts@sydney.edu.au>
 Maintainer-email: Lindon Roberts <lindon.roberts@sydney.edu.au>

DFO_LS-1.5.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+dfols/__init__.py,sha256=EGaYvogmtsNfmB_MVMFwglCwZbhl8O18rsOldwjIr5Q,1605
+dfols/controller.py,sha256=Jffyao_z7wcQf1WEQtv2smnNew8HXGguWuUPLbgVuCc,52487
+dfols/diagnostic_info.py,sha256=kEcFCjD2rk39XRa90ocEaQvJWc0wj_ZPpQkOulVIM-k,6106
+dfols/hessian.py,sha256=sExx4J4KoGwHItbthX2odosB2ONbQFvLdlcod7PIh4k,4262
+dfols/model.py,sha256=1Npj3fJvMv66bKu_RIzLLI-2tyzPWOsKuyv-YUjcv2c,20711
+dfols/params.py,sha256=GzJGO0TByH1X3B0NbLOCOqmYG8dRiKPKjjX7or_fOqI,18342
+dfols/solver.py,sha256=tvDdZgQ3AtybIZCTJf2DvGo6YvbV1NNACrzT2RUF000,63910
+dfols/trust_region.py,sha256=JbHLBDw7H88a3cIMuialh7kpMNGjL3Lp9JsjrBNpDWQ,28231
+dfols/util.py,sha256=efGVAKPb7YrHya1IOgyzacwa_h0u2jHHs5FhuxUlYDg,10282
+DFO_LS-1.5.2.dist-info/LICENSE.txt,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+DFO_LS-1.5.2.dist-info/METADATA,sha256=eTT5r3VaND81vjaSdiW8AcUn6HsISxXAgV5UNXAHnBk,8069
+DFO_LS-1.5.2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+DFO_LS-1.5.2.dist-info/top_level.txt,sha256=UfxRhaDN8HQx2_l17KbrDrERJ90OCN7VKkDMpYYbRLU,6
+DFO_LS-1.5.2.dist-info/RECORD,,

{DFO_LS-1.5.0.dist-info → DFO_LS-1.5.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dfols/__init__.py

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

dfols/controller.py

@@ -240,12 +240,12 @@ class Controller(object):
                 # Handle exit conditions (f < min obj value or maxfun reached)
                 if exit_info is not None:
                     if num_samples_run > 0:
-                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
                                               x_in_abs_coords=True)
                     return exit_info  # return & quit
 
                 # Otherwise, add new results (increments model.npt_so_far)
-                self.model.change_point(k+1, x - self.model.xbase, rvec_list[0, :])  # expect step, not absolute x
+                self.model.change_point(k+1, x - self.model.xbase, rvec_list[0, :], self.nx)  # expect step, not absolute x
                 for i in range(1, num_samples_run):
                     self.model.add_new_sample(k+1, rvec_extra=rvec_list[i, :])
             
@@ -253,69 +253,101 @@ class Controller(object):
 
         at_lower_boundary = (self.model.sl > -0.01 * self.delta)  # sl = xl - x0, should be -ve, actually < -rhobeg
         at_upper_boundary = (self.model.su < 0.01 * self.delta)  # su = xu - x0, should be +ve, actually > rhobeg
-
-        xpts_added = np.zeros((num_directions + 1, self.n()))
-        for k in range(1, num_directions + 1):
-            # k = 0 --> base point (xpt = 0)  [ not here]
-            # k = 1, ..., 2n --> coordinate directions [1,...,n and n+1,...,2n]
-            # k = 2n+1, ..., (n+1)(n+2)/2 --> off-diagonal directions
-            if 1 <= k < self.n() + 1:  # first step along coord directions
+        
+        if params("init.run_in_parallel") and num_directions <= self.n():
+            # Can do all the evaluation in parallel if <= n+1 interpolation points, but if larger
+            # then the step depends on the function value at previous steps and does point swapping
+            xpts_added = np.zeros((num_directions + 1, self.n()))
+            eval_obj_results = []
+            for k in range(1, num_directions + 1):  # k = 1, ..., num_directions
+                # always have k = 1, ..., n since num_directions <= n
                 dirn = k - 1  # direction to move in (0,...,n-1)
                 stepa = self.delta if not at_upper_boundary[dirn] else -self.delta # take a +delta step if at lower, -delta if at upper
                 stepb = None
                 xpts_added[k, dirn] = stepa # set new (relative) point to the step since we haven't done any moving, so relative point is all zeros.
+                
+                # Evaluate objective at this new point
+                x = self.model.as_absolute_coordinates(xpts_added[k, :])
+                eval_obj_results.append(self.evaluate_objective(x, number_of_samples, params))
+            
+            # Evaluations done, now add to the model
+            for k in range(1, num_directions + 1):
+                x = self.model.as_absolute_coordinates(xpts_added[k, :])
+                rvec_list, obj_list, num_samples_run, exit_info = eval_obj_results[k-1]
+                # Handle exit conditions (f < min obj value or maxfun reached)
+                if exit_info is not None:
+                    if num_samples_run > 0:
+                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
+                                              x_in_abs_coords=True)
+                    return exit_info  # return & quit
 
-            elif self.n() + 1 <= k < 2 * self.n() + 1:  # second step along coord directions
-                dirn = k - self.n() - 1  # direction to move in (0,...,n-1)
-                stepa = xpts_added[k - self.n(), dirn] # previous step
-                stepb = -self.delta # new step
-                if at_lower_boundary[dirn]:
-                    # if at lower boundary, set the second step to be +ve
-                    stepb = min(2.0 * self.delta, self.model.su[dirn])  # su = xu - x0, should be +ve
-                if at_upper_boundary[dirn]:
-                    # if at upper boundary, set the second step to be -ve
-                    stepb = max(-2.0 * self.delta, self.model.sl[dirn])  # sl = xl - x0, should be -ve
-                xpts_added[k, dirn] = stepb
-
-            else:  # k = 2n+1, ..., (n+1)(n+2)/2
-                # p = (k - 1) % n + 1  # cycles through (1,...,n), starting at 2n+1 --> 1
-                # l = (k - 2 * n - 1) / n + 1  # (1,...,1, 2, ..., 2, etc.) where each number appears n times
-                # q = (p + l if p + l <= n else p + l - n)
-                stepa = None
-                stepb = None
-                itemp = (k - self.n() - 1) // self.n()
-                q = k - itemp * self.n() - self.n()
-                p = q + itemp
-                if p > self.n():
-                    p, q = q, p - self.n()  # does swap correctly in Python
-
-                xpts_added[k, p - 1] = xpts_added[p, p - 1]
-                xpts_added[k, q - 1] = xpts_added[q, q - 1]
+                # Otherwise, add new results (increments model.npt_so_far)
+                self.model.change_point(k, x - self.model.xbase, rvec_list[0, :], self.nx)  # expect step, not absolute x
+                for i in range(1, num_samples_run):
+                    self.model.add_new_sample(k, rvec_extra=rvec_list[i, :])
+        else:
+            xpts_added = np.zeros((num_directions + 1, self.n()))
+            for k in range(1, num_directions + 1):
+                # k = 0 --> base point (xpt = 0)  [ not here]
+                # k = 1, ..., 2n --> coordinate directions [1,...,n and n+1,...,2n]
+                # k = 2n+1, ..., (n+1)(n+2)/2 --> off-diagonal directions
+                if 1 <= k < self.n() + 1:  # first step along coord directions
+                    dirn = k - 1  # direction to move in (0,...,n-1)
+                    stepa = self.delta if not at_upper_boundary[dirn] else -self.delta # take a +delta step if at lower, -delta if at upper
+                    stepb = None
+                    xpts_added[k, dirn] = stepa # set new (relative) point to the step since we haven't done any moving, so relative point is all zeros.
+
+                elif self.n() + 1 <= k < 2 * self.n() + 1:  # second step along coord directions
+                    dirn = k - self.n() - 1  # direction to move in (0,...,n-1)
+                    stepa = xpts_added[k - self.n(), dirn] # previous step
+                    stepb = -self.delta # new step
+                    if at_lower_boundary[dirn]:
+                        # if at lower boundary, set the second step to be +ve
+                        stepb = min(2.0 * self.delta, self.model.su[dirn])  # su = xu - x0, should be +ve
+                    if at_upper_boundary[dirn]:
+                        # if at upper boundary, set the second step to be -ve
+                        stepb = max(-2.0 * self.delta, self.model.sl[dirn])  # sl = xl - x0, should be -ve
+                    xpts_added[k, dirn] = stepb
+
+                else:  # k = 2n+1, ..., (n+1)(n+2)/2
+                    # p = (k - 1) % n + 1  # cycles through (1,...,n), starting at 2n+1 --> 1
+                    # l = (k - 2 * n - 1) / n + 1  # (1,...,1, 2, ..., 2, etc.) where each number appears n times
+                    # q = (p + l if p + l <= n else p + l - n)
+                    stepa = None
+                    stepb = None
+                    itemp = (k - self.n() - 1) // self.n()
+                    q = k - itemp * self.n() - self.n()
+                    p = q + itemp
+                    if p > self.n():
+                        p, q = q, p - self.n()  # does swap correctly in Python
+
+                    xpts_added[k, p - 1] = xpts_added[p, p - 1]
+                    xpts_added[k, q - 1] = xpts_added[q, q - 1]
 
-            # Evaluate objective at this new point
-            x = self.model.as_absolute_coordinates(xpts_added[k, :])
-            rvec_list, obj_list, num_samples_run, exit_info = self.evaluate_objective(x, number_of_samples, params)
+                # Evaluate objective at this new point
+                x = self.model.as_absolute_coordinates(xpts_added[k, :])
+                rvec_list, obj_list, num_samples_run, exit_info = self.evaluate_objective(x, number_of_samples, params)
 
-            # Handle exit conditions (f < min obj value or maxfun reached)
-            if exit_info is not None:
-                if num_samples_run > 0:
-                    self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
-                                          x_in_abs_coords=True)
-                return exit_info  # return & quit
+                # Handle exit conditions (f < min obj value or maxfun reached)
+                if exit_info is not None:
+                    if num_samples_run > 0:
+                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
+                                              x_in_abs_coords=True)
+                    return exit_info  # return & quit
 
-            # Otherwise, add new results (increments model.npt_so_far)
-            self.model.change_point(k, x - self.model.xbase, rvec_list[0, :])  # expect step, not absolute x
-            for i in range(1, num_samples_run):
-                self.model.add_new_sample(k, rvec_extra=rvec_list[i, :])
+                # Otherwise, add new results (increments model.npt_so_far)
+                self.model.change_point(k, x - self.model.xbase, rvec_list[0, :], self.nx)  # expect step, not absolute x
+                for i in range(1, num_samples_run):
+                    self.model.add_new_sample(k, rvec_extra=rvec_list[i, :])
 
-            # If k exceeds N+1, then the positions of the k-th and (k-N)-th interpolation
-            # points may be switched, in order that the function value at the first of them
-            # contributes to the off-diagonal second derivative terms of the initial quadratic model.
-            # Note: this works because the steps for (k) and (k-n) points were in the same coordinate direction
-            if self.n() + 1 <= k < 2 * self.n() + 1:
-                # Only swap if steps were in different directions AND new pt has lower objective
-                if stepa * stepb < 0.0 and self.model.objval[k] < self.model.objval[k - self.n()]:
-                    xpts_added[[k, k-self.n()]] = xpts_added[[k-self.n(), k]]
+                # If k exceeds N+1, then the positions of the k-th and (k-N)-th interpolation
+                # points may be switched, in order that the function value at the first of them
+                # contributes to the off-diagonal second derivative terms of the initial quadratic model.
+                # Note: this works because the steps for (k) and (k-n) points were in the same coordinate direction
+                if self.n() + 1 <= k < 2 * self.n() + 1:
+                    # Only swap if steps were in different directions AND new pt has lower objective
+                    if stepa * stepb < 0.0 and self.model.objval[k] < self.model.objval[k - self.n()]:
+                        xpts_added[[k, k-self.n()]] = xpts_added[[k-self.n(), k]]
 
         return None   # return & continue
 
@@ -351,13 +383,13 @@ class Controller(object):
                 # Handle exit conditions (f < min obj value or maxfun reached)
                 if exit_info is not None:
                     if num_samples_run > 0:
-                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
                                               x_in_abs_coords=True)
                     return exit_info  # return & quit
 
                 # Otherwise, add new results (increments model.npt_so_far)
                 self.model.change_point(1 + ndirns, x - self.model.xbase,
-                                        rvec_list[0, :])  # expect step, not absolute x
+                                        rvec_list[0, :], self.nx)  # expect step, not absolute x
                 for i in range(1, num_samples_run):
                     self.model.add_new_sample(1 + ndirns, rvec_extra=rvec_list[i, :])
         else:
@@ -371,12 +403,12 @@ class Controller(object):
                 # Handle exit conditions (f < min obj value or maxfun reached)
                 if exit_info is not None:
                     if num_samples_run > 0:
-                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
                                               x_in_abs_coords=True)
                     return exit_info  # return & quit
 
                 # Otherwise, add new results (increments model.npt_so_far)
-                self.model.change_point(1 + ndirns, x - self.model.xbase, rvec_list[0, :])  # expect step, not absolute x
+                self.model.change_point(1 + ndirns, x - self.model.xbase, rvec_list[0, :], self.nx)  # expect step, not absolute x
                 for i in range(1, num_samples_run):
                     self.model.add_new_sample(1 + ndirns, rvec_extra=rvec_list[i, :])
 
@@ -408,7 +440,7 @@ class Controller(object):
             # Handle exit conditions (f < min obj value or maxfun reached)
             if exit_info is not None:
                 if num_samples_run > 0:
-                    self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                    self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
                                           x_in_abs_coords=True)
                 return exit_info  # return & quit
 
@@ -422,7 +454,7 @@ class Controller(object):
                     return exit_info  # return & quit
 
             # Otherwise, add new results
-            self.model.change_point(kmin, xnew, rvec_list[0, :])  # expect step, not absolute x
+            self.model.change_point(kmin, xnew, rvec_list[0, :], self.nx)  # expect step, not absolute x
             for i in range(1, num_samples_run):
                 self.model.add_new_sample(kmin, rvec_extra=rvec_list[i, :])
 
@@ -548,12 +580,12 @@ class Controller(object):
         # Handle exit conditions (f < min obj value or maxfun reached)
         if exit_info is not None:
             if num_samples_run > 0:
-                self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
                                       x_in_abs_coords=True)
             return exit_info  # didn't fix geometry - return & quit
 
         # Otherwise, add new results
-        self.model.change_point(knew, xnew, rvec_list[0, :])  # expect step, not absolute x
+        self.model.change_point(knew, xnew, rvec_list[0, :], self.nx)  # expect step, not absolute x
         for i in range(1, num_samples_run):
             self.model.add_new_sample(knew, rvec_extra=rvec_list[i, :])
 
@@ -768,8 +800,8 @@ class Controller(object):
         if x_in_abs_coords_to_save is not None:
             assert rvec_to_save is not None, "Soft restart: specified x_to_save but not rvec_to_save"
             assert nsamples_to_save is not None, "Soft restart: specified x_to_save but not nsamples_to_save"
-            self.model.save_point(x_in_abs_coords_to_save, rvec_to_save, nsamples_to_save, x_in_abs_coords=True)
-        self.model.save_point(self.model.xopt(abs_coordinates=True), self.model.ropt(),
+            self.model.save_point(x_in_abs_coords_to_save, rvec_to_save, nsamples_to_save, self.nx, x_in_abs_coords=True)
+        self.model.save_point(self.model.xopt(abs_coordinates=True), self.model.ropt(), self.nx,
                               self.model.nsamples[self.model.kopt], x_in_abs_coords=True)
 
         if self.do_logging:
@@ -820,12 +852,12 @@ class Controller(object):
                 # Handle exit conditions (f < min obj value or maxfun reached)
                 if exit_info is not None:
                     if num_samples_run > 0:
-                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                        self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
                                               x_in_abs_coords=True)
                     return exit_info  # return & quit
 
                 # Otherwise, add new results
-                self.model.add_new_point(xnew, rvec_list[0, :])  # expect step, not absolute x
+                self.model.add_new_point(xnew, rvec_list[0, :], self.nx)  # expect step, not absolute x
                 for i in range(1, num_samples_run):
                     self.model.add_new_sample(self.model.npt() - 1, rvec_extra=rvec_list[i, :])
 
@@ -900,12 +932,12 @@ class Controller(object):
             # Handle exit conditions (f < min obj value or maxfun reached)
             if exit_info is not None:
                 if num_samples_run > 0:
-                    self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                    self.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, self.nx,
                                           x_in_abs_coords=True)
                 return exit_info  # return & quit
 
             # Otherwise, add new results
-            self.model.change_point(knew, xnew, rvec_list[0, :])  # expect step, not absolute x
+            self.model.change_point(knew, xnew, rvec_list[0, :], self.nx)  # expect step, not absolute x
             for i in range(1, num_samples_run):
                 self.model.add_new_sample(knew, rvec_extra=rvec_list[i, :])
         return None

dfols/diagnostic_info.py

@@ -102,7 +102,7 @@ class DiagnosticInfo(object):
         self.data["rho"].append(control.rho)
         # And from a model?
         self.data["npt"].append(control.model.npt())
-        x, rvec, f, jac, nsamples = control.model.get_final_results()
+        x, rvec, f, jac, nsamples, eval_num, jac_eval_nums = control.model.get_final_results()
         self.data["xk"].append(remove_scaling(x, control.scaling_changes))
         self.data["rk"].append(rvec)
         self.data["fk"].append(f)

dfols/model.py

@@ -85,6 +85,8 @@ class Model(object):
         self.nsamples = np.zeros((npt,), dtype=int)  # number of samples used to evaluate objective at each point
         self.nsamples[0] = r0_nsamples
         self.objbeg = self.objval[0]  # f(x0), saved to check for sufficient reduction
+        self.eval_num = np.zeros((npt,), dtype=int)  # which evaluation number (1-indexed, nx not nf) is currently stored self.points[k,:]
+        self.eval_num[0] = 1
 
         # Termination criteria
         self.abs_tol = abs_tol
@@ -93,6 +95,7 @@ class Model(object):
         # Model information
         self.model_const = np.zeros((m, ))  # constant term for model m(s) = c + J*s
         self.model_jac = np.zeros((m, n))  # Jacobian term for model m(s) = c + J*s
+        self.model_jac_eval_nums = None  # which evaluation numbers (1-indexed, nx not nf) were used to build model_jac
 
         # Saved point (in absolute coordinates) - always check this value before quitting solver
         self.xsave = None
@@ -100,6 +103,8 @@ class Model(object):
         self.objsave = None
         self.jacsave = None
         self.nsamples_save = None
+        self.eval_num_save = None
+        self.jacsave_eval_nums = None
 
         # Factorisation of interpolation matrix
         self.factorisation_current = False
@@ -174,7 +179,7 @@ class Model(object):
             sq_distances[k] = sumsq(self.points[k, :] - xopt)
         return sq_distances
 
-    def change_point(self, k, x, rvec, allow_kopt_update=True):
+    def change_point(self, k, x, rvec, eval_num, allow_kopt_update=True):
         # Update point k to x (w.r.t. xbase), with residual values fvec
         if k >= self.npt_so_far and self.npt_so_far < self.num_pts:
             assert k == self.npt_so_far, "Growing: updating wrong point"
@@ -188,6 +193,7 @@ class Model(object):
         if self.h is not None:
             self.objval[k] += self.h(remove_scaling(self.xbase + x, self.scaling_changes), *self.argsh)
         self.nsamples[k] = 1
+        self.eval_num[k] = eval_num
         self.factorisation_current = False
 
         if allow_kopt_update and self.objval[k] < self.objopt():
@@ -198,6 +204,7 @@ class Model(object):
         self.points[[k1, k2], :] = self.points[[k2, k1], :]
         self.fval_v[[k1, k2], :] = self.fval_v[[k2, k1], :]
         self.objval[[k1, k2]] = self.objval[[k2, k1]]
+        self.eval_num[[k1, k2]] = self.eval_num[[k2, k1]]
         if self.kopt == k1:
             self.kopt = k2
         elif self.kopt == k2:
@@ -219,7 +226,7 @@ class Model(object):
         self.kopt = np.argmin(self.objval[:self.npt()])  # make sure kopt is always the best value we have
         return
 
-    def add_new_point(self, x, rvec):
+    def add_new_point(self, x, rvec, eval_num):
         self.points = np.append(self.points, x.reshape((1, self.n())), axis=0)  # append row to xpt
         self.fval_v = np.append(self.fval_v, rvec.reshape((1, self.m())), axis=0)  # append row to fval_v
         obj = sumsq(rvec)
@@ -227,6 +234,7 @@ class Model(object):
             obj += self.h(remove_scaling(self.xbase + x, self.scaling_changes), *self.argsh)
         self.objval = np.append(self.objval, obj)  # append entry to fval
         self.nsamples = np.append(self.nsamples, 1)  # add new sample number
+        self.eval_num = np.append(self.eval_num, eval_num)  # add new evaluation number
         self.num_pts += 1  # make sure npt is updated
         self.npt_so_far += 1
 
@@ -249,7 +257,7 @@ class Model(object):
         self.model_const += np.dot(self.model_jac, xbase_shift)
         return
 
-    def save_point(self, x, rvec, nsamples, x_in_abs_coords=True):
+    def save_point(self, x, rvec, nsamples, eval_num, x_in_abs_coords=True):
         xabs = x.copy() if x_in_abs_coords else self.as_absolute_coordinates(x)
         obj = sumsq(rvec)
         if self.h is not None:
@@ -258,8 +266,10 @@ class Model(object):
             self.xsave = xabs
             self.rsave = rvec.copy()
             self.objsave = obj
-            self.jacsave = self.model_jac.copy()
+            self.jacsave = self.model_jac.copy() if self.model_jac is not None else None
             self.nsamples_save = nsamples
+            self.eval_num_save = eval_num
+            self.jacsave_eval_nums = self.model_jac_eval_nums.copy() if self.model_jac_eval_nums is not None else None
             return True
         else:
             return False  # this value is worse than what we have already - didn't save
@@ -267,9 +277,9 @@ class Model(object):
     def get_final_results(self):
         # Return x and objval for optimal point (either from xsave+objsave or kopt)
         if self.objsave is None or self.objopt() <= self.objsave:  # optimal has changed since xsave+objsave were last set
-            return self.xopt(abs_coordinates=True).copy(), self.ropt().copy(), self.objopt(), self.model_jac.copy(), self.nsamples[self.kopt]
+            return self.xopt(abs_coordinates=True).copy(), self.ropt().copy(), self.objopt(), self.model_jac.copy(), self.nsamples[self.kopt], self.eval_num[self.kopt], self.model_jac_eval_nums
         else:
-            return self.xsave.copy(), self.rsave.copy(), self.objsave, self.jacsave, self.nsamples_save
+            return self.xsave.copy(), self.rsave.copy(), self.objsave, self.jacsave, self.nsamples_save, self.eval_num_save, self.jacsave_eval_nums
 
     def min_objective_value(self):
         # Get termination criterion for f small: f <= abs_tol or f <= rel_tol * f0
@@ -367,6 +377,7 @@ class Model(object):
         J_old = self.model_jac.copy()
         self.model_jac = dg[1:,:].T
         self.model_const = dg[0,:] - np.dot(self.model_jac, xopt)  # shift base to xbase
+        self.model_jac_eval_nums = self.eval_num.copy()
         if verbose or get_chg_J:
             norm_J_error = np.linalg.norm(self.model_jac - J_old, ord='fro')**2
             linalg_resid = np.linalg.norm(W.dot(dg) - rhs)**2

dfols/solver.py

@@ -48,7 +48,7 @@ module_logger = logging.getLogger(__name__)
 
 # A container for the results of the optimization routine
 class OptimResults(object):
-    def __init__(self, xmin, rmin, objmin, jacmin, nf, nx, nruns, exit_flag, exit_msg):
+    def __init__(self, xmin, rmin, objmin, jacmin, nf, nx, nruns, exit_flag, exit_msg, xmin_eval_num, jacmin_eval_nums):
         self.x = xmin
         self.resid = rmin
         self.obj = objmin
@@ -59,6 +59,8 @@ class OptimResults(object):
         self.flag = exit_flag
         self.msg = exit_msg
         self.diagnostic_info = None
+        self.xmin_eval_num = xmin_eval_num
+        self.jacmin_eval_nums = jacmin_eval_nums
         # Set standard names for exit flags
         self.EXIT_SLOW_WARNING = EXIT_SLOW_WARNING
         self.EXIT_MAXFUN_WARNING = EXIT_MAXFUN_WARNING
@@ -89,6 +91,9 @@ class OptimResults(object):
                 output += "Not showing approximate Jacobian because it is too long; check self.jacobian\n"
             if self.diagnostic_info is not None:
                 output += "Diagnostic information available; check self.diagnostic_info\n"
+            output += "Solution xmin was evaluation point %g\n" % self.xmin_eval_num
+            if len(self.jacmin_eval_nums) < 100:
+                output += "Approximate Jacobian formed using evaluation points %s\n" % str(self.jacmin_eval_nums)
         output += "Exit flag = %g\n" % self.flag
         output += "%s\n" % self.msg
         output += "****************************\n"
@@ -182,8 +187,8 @@ def solve_main(objfun, x0, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxf
             module_logger.info("Initialising (coordinate directions)")
         exit_info = control.initialise_coordinate_directions(number_of_samples, num_directions, params)
     if exit_info is not None:
-        x, rvec, obj, jacmin, nsamples = control.model.get_final_results()
-        return x, rvec, obj, None, nsamples, control.nf, control.nx, nruns_so_far + 1, exit_info, diagnostic_info
+        x, rvec, obj, jacmin, nsamples, x_eval_num, jac_eval_nums = control.model.get_final_results()
+        return x, rvec, obj, None, nsamples, control.nf, control.nx, nruns_so_far + 1, exit_info, diagnostic_info, x_eval_num, jac_eval_nums
 
     finished_growing = (control.model.npt() >= control.model.num_pts)  # have we finished growing the initial set yet?
 
@@ -464,7 +469,7 @@ def solve_main(objfun, x0, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxf
                     
                     if num_samples_run > 0:
                             control.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0),
-                                                     num_samples_run, x_in_abs_coords=True)
+                                                     num_samples_run, control.nx, x_in_abs_coords=True)
                     
                     if exit_info is not None:
                         nruns_so_far += 1
@@ -549,7 +554,7 @@ def solve_main(objfun, x0, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxf
                 break  # quit
             if exit_info is not None:
                 if num_samples_run > 0:
-                    control.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run,
+                    control.model.save_point(x, np.mean(rvec_list[:num_samples_run, :], axis=0), num_samples_run, control.nx,
                                              x_in_abs_coords=True)
                 nruns_so_far += 1
                 break  # quit
@@ -638,7 +643,7 @@ def solve_main(objfun, x0, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxf
 
             if do_logging:
                 module_logger.debug("Updating with knew = %i" % knew)
-            control.model.change_point(knew, xnew, rvec_list[0, :])  # expect step, not absolute x
+            control.model.change_point(knew, xnew, rvec_list[0, :], control.nx)  # expect step, not absolute x
             for i in range(1, num_samples_run):
                 control.model.add_new_sample(knew, rvec_extra=rvec_list[i, :])
 
@@ -877,11 +882,11 @@ def solve_main(objfun, x0, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxf
     # (end main loop)
 
     # Quit & return the important information
-    x, rvec, obj, jacmin, nsamples = control.model.get_final_results()
+    x, rvec, obj, jacmin, nsamples, x_eval_num, jac_eval_nums = control.model.get_final_results()
     if do_logging:
         module_logger.debug("At return from DFO-LS, number of function evals = %i" % nf)
         module_logger.debug("Smallest objective value = %.15g at x = " % obj + str(x))
-    return x, rvec, obj, jacmin, nsamples, control.nf, control.nx, nruns_so_far, exit_info, diagnostic_info
+    return x, rvec, obj, jacmin, nsamples, control.nf, control.nx, nruns_so_far, exit_info, diagnostic_info, x_eval_num, jac_eval_nums
 
 
 def solve(objfun, x0, h=None, lh=None, prox_uh=None, argsf=(), argsh=(), argsprox=(), bounds=None, projections=[], npt=None, rhobeg=None, rhoend=1e-8, maxfun=None, nsamples=None, user_params=None,
@@ -1056,7 +1061,7 @@ def solve(objfun, x0, h=None, lh=None, prox_uh=None, argsf=(), argsh=(), argspro
     nruns = 0
     nf = 0
     nx = 0
-    xmin, rmin, objmin, jacmin, nsamples_min, nf, nx, nruns, exit_info, diagnostic_info = \
+    xmin, rmin, objmin, jacmin, nsamples_min, nf, nx, nruns, exit_info, diagnostic_info, xmin_eval_num, jacmin_eval_nums = \
         solve_main(objfun, x0, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
                     diagnostic_info, scaling_changes, h, lh, argsh, prox_uh, argsprox, default_growing_method_set_by_user=default_growing_method_set_by_user,
                    do_logging=do_logging, print_progress=print_progress)
@@ -1075,12 +1080,12 @@ def solve(objfun, x0, h=None, lh=None, prox_uh=None, argsf=(), argsh=(), argspro
             module_logger.info("Restarting from finish point (f = %g) after %g function evals; using rhobeg = %g and rhoend = %g"
                      % (objmin, nf, rhobeg, rhoend))
         if params("restarts.hard.use_old_rk"):
-            xmin2, rmin2, objmin2, jacmin2, nsamples2, nf, nx, nruns, exit_info, diagnostic_info = \
+            xmin2, rmin2, objmin2, jacmin2, nsamples2, nf, nx, nruns, exit_info, diagnostic_info, xmin_eval_num2, jacmin_eval_nums2 = \
                 solve_main(objfun, xmin, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
                             diagnostic_info, scaling_changes, h, lh, argsh, prox_uh, argsprox, r0_avg_old=rmin, r0_nsamples_old=nsamples_min,
                            do_logging=do_logging, print_progress=print_progress)
         else:
-            xmin2, rmin2, objmin2, jacmin2, nsamples2, nf, nx, nruns, exit_info, diagnostic_info = \
+            xmin2, rmin2, objmin2, jacmin2, nsamples2, nf, nx, nruns, exit_info, diagnostic_info, xmin_eval_num2, jacmin_eval_nums2 = \
                 solve_main(objfun, xmin, argsf, xl, xu, projections, npt, rhobeg, rhoend, maxfun, nruns, nf, nx, nsamples, params,
                            diagnostic_info, scaling_changes, h, lh, argsh, prox_uh, argsprox, do_logging=do_logging, print_progress=print_progress)
 
@@ -1088,9 +1093,10 @@ def solve(objfun, x0, h=None, lh=None, prox_uh=None, argsf=(), argsh=(), argspro
             if do_logging:
                 module_logger.info("Successful run with new f = %s compared to old f = %s" % (objmin2, objmin))
             last_successful_run = nruns
-            (xmin, rmin, objmin, nsamples_min) = (xmin2, rmin2, objmin2, nsamples2)
+            (xmin, rmin, objmin, nsamples_min, xmin_eval_num) = (xmin2, rmin2, objmin2, nsamples2, xmin_eval_num2)
             if jacmin2 is not None:  # may be None if finished during setup phase, in which case just use old Jacobian
                 jacmin = jacmin2
+                jacmin_eval_nums = jacmin_eval_nums2
         else:
             if do_logging:
                 module_logger.info("Unsuccessful run with new f = %s compared to old f = %s" % (objmin2, objmin))
@@ -1105,7 +1111,7 @@ def solve(objfun, x0, h=None, lh=None, prox_uh=None, argsf=(), argsh=(), argspro
     if scaling_changes is not None and jacmin is not None:
         for i in range(n):
             jacmin[:, i] = jacmin[:, i] / scaling_changes[1][i]
-    results = OptimResults(remove_scaling(xmin, scaling_changes), rmin, objmin, jacmin, nf, nx, nruns, exit_flag, exit_msg)
+    results = OptimResults(remove_scaling(xmin, scaling_changes), rmin, objmin, jacmin, nf, nx, nruns, exit_flag, exit_msg, xmin_eval_num, jacmin_eval_nums)
     if params("logging.save_diagnostic_info"):
         df = diagnostic_info.to_dataframe(with_xk=params("logging.save_xk"), with_rk=params("logging.save_rk"))
         results.diagnostic_info = df

DFO_LS-1.5.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-dfols/__init__.py,sha256=nMJ4G3JcmjQ82lYXV2ywxjHWQqd9nq7Ak6GIlrN70Tw,1605
-dfols/controller.py,sha256=gz4yGpk8KyfsWxrAkI8y69K5ckSHZ3Xdq0fEVFtIcPk,49925
-dfols/diagnostic_info.py,sha256=2kEUkL-MS4eDENUf1r2hOWsntP8OxMDKi_kyHmrC9V4,6081
-dfols/hessian.py,sha256=sExx4J4KoGwHItbthX2odosB2ONbQFvLdlcod7PIh4k,4262
-dfols/model.py,sha256=i-TcGNFAeYt4uu3R_-THTk2rOCDvgU_mcZQQXfE1ODA,19786
-dfols/params.py,sha256=GzJGO0TByH1X3B0NbLOCOqmYG8dRiKPKjjX7or_fOqI,18342
-dfols/solver.py,sha256=QUF84UYnSitvlpVssKLdcMF9e_zdA9qlZlg5e8IegeQ,63173
-dfols/trust_region.py,sha256=JbHLBDw7H88a3cIMuialh7kpMNGjL3Lp9JsjrBNpDWQ,28231
-dfols/util.py,sha256=efGVAKPb7YrHya1IOgyzacwa_h0u2jHHs5FhuxUlYDg,10282
-DFO_LS-1.5.0.dist-info/LICENSE.txt,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-DFO_LS-1.5.0.dist-info/METADATA,sha256=JIQNs15kBtVr5_cA7JnXDbT-uQ06pqTd3RD_MRYmB7w,8069
-DFO_LS-1.5.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-DFO_LS-1.5.0.dist-info/top_level.txt,sha256=UfxRhaDN8HQx2_l17KbrDrERJ90OCN7VKkDMpYYbRLU,6
-DFO_LS-1.5.0.dist-info/RECORD,,