Updt grad descent hypers for likelihood tests, add tol arg to scipy o…

…ptimisers, pass optimiser final cost as is

pybop/_optimisation.py

@@ -156,8 +156,6 @@ def run(self):
             x, final_cost = self._run_pints()
         elif not self.pints:
             x, final_cost = self._run_pybop()
-            if not self._minimising:
-                final_cost = -final_cost
 
         # Store the optimised parameters
         if self.cost.problem is not None:
@@ -374,8 +372,10 @@ def _run_pints(self):
         # Store the optimised parameters
         self.store_optimised_parameters(x)
 
-        # Return best position and score
-        return x, f if self._minimising else -f
+        # Return best position and the score used internally,
+        # i.e the negative log-likelihood in the case of
+        # self._minimising = False
+        return x, f
 
     def f_guessed_tracking(self):
         """

pybop/costs/_likelihoods.py

@@ -95,9 +95,9 @@
         y, dy = self.problem.evaluateS1(x)
         for key in self.signal:
             if len(y.get(key, [])) != len(self._target.get(key, [])):
                 likelihood = np.float64(np.inf)
-                dl = self._de * np.ones(self.n_parameters)
+                dl = self._dl * np.ones(self.n_parameters)
                 return -likelihood, -dl
 
         r = np.array([self._target[signal] - y[signal] for signal in self.signal])
 
@@ -150,7 +150,7 @@
 
         for key in self.signal:
             if len(prediction.get(key, [])) != len(self._target.get(key, [])):
                 return -np.float64(np.inf)  # prediction doesn't match target
 
         e = np.array(
             [
@@ -167,7 +167,7 @@
         if self.n_outputs == 1:
             return e.item()
         else:
             return np.sum(e)
 
     def _evaluateS1(self, x, grad=None):
         """
@@ -176,14 +176,14 @@
         """
         sigma = np.asarray(x[-self.n_outputs :])
         if np.any(sigma <= 0):
             return -np.float64(np.inf), self._de * np.ones(self.n_parameters)
 
         y, dy = self.problem.evaluateS1(x[: -self.n_outputs])
         for key in self.signal:
             if len(y.get(key, [])) != len(self._target.get(key, [])):
                 likelihood = np.float64(np.inf)
                 dl = self._de * np.ones(self.n_parameters)
                 return -likelihood, -dl
 
         r = np.array([self._target[signal] - y[signal] for signal in self.signal])
 
@@ -196,9 +196,9 @@
             dl = np.concatenate((dl, dsigma))
             return likelihood, dl
         else:
             r = r.reshape(self.n_outputs, self.problem.n_time_data)
             likelihood = self._evaluate(x)
             dl = sigma ** (-2.0) * np.sum((r[:, :, np.newaxis] * dy), axis=1)
             dsigma = -self._n_times / sigma + sigma**-(3.0) * np.sum(r**2, axis=0)
             dl = np.concatenate((dl, dsigma))
             return likelihood, np.sum(dl, axis=1)

pybop/optimisers/scipy_optimisers.py

@@ -20,10 +20,11 @@ class SciPyMinimize(BaseOptimiser):
         Maximum number of iterations to perform.
     """
 
-    def __init__(self, method=None, bounds=None, maxiter=None):
+    def __init__(self, method=None, bounds=None, maxiter=None, tol=1e-5):
         super().__init__()
         self.method = method
         self.bounds = bounds
+        self.tol = tol
         self.options = {}
         self._max_iterations = maxiter
 
@@ -79,6 +80,7 @@ def cost_wrapper(x):
             x0,
             method=self.method,
             bounds=bounds,
+            tol=self.tol,
             options=self.options,
             callback=callback,
         )
@@ -126,8 +128,11 @@ class SciPyDifferentialEvolution(BaseOptimiser):
         The number of individuals in the population. Defaults to 15.
     """
 
-    def __init__(self, bounds=None, strategy="best1bin", maxiter=1000, popsize=15):
+    def __init__(
+        self, bounds=None, strategy="best1bin", maxiter=1000, popsize=15, tol=1e-5
+    ):
         super().__init__()
+        self.tol = tol
         self.strategy = strategy
         self._max_iterations = maxiter
         self._population_size = popsize
@@ -178,6 +183,7 @@ def callback(x, convergence):
             strategy=self.strategy,
             maxiter=self._max_iterations,
             popsize=self._population_size,
+            tol=self.tol,
             callback=callback,
         )
 

tests/integration/test_parameterisations.py

@@ -70,7 +70,7 @@ def spm_costs(self, model, parameters, cost_class, init_soc):
             model, parameters, dataset, signal=signal, init_soc=init_soc
         )
         if cost_class in [pybop.GaussianLogLikelihoodKnownSigma]:
-            return cost_class(problem, sigma=[0.05, 0.05])
+            return cost_class(problem, sigma=[0.03, 0.03])
         else:
             return cost_class(problem)
 
@@ -123,7 +123,11 @@ def test_spm_optimisers(self, optimiser, spm_costs):
             assert parameterisation._max_iterations == 125
 
         elif optimiser in [pybop.GradientDescent]:
-            parameterisation.optimiser.set_learning_rate(0.02)
+            if isinstance(spm_costs, pybop.GaussianLogLikelihoodKnownSigma):
+                parameterisation.optimiser.set_learning_rate(1.8e-5)
+                parameterisation.set_min_iterations(150)
+            else:
+                parameterisation.optimiser.set_learning_rate(0.02)
             parameterisation.set_max_iterations(150)
             x, final_cost = parameterisation.run()
 
@@ -196,9 +200,9 @@ def test_multiple_signals(self, multi_optimiser, spm_two_signal_cost):
 
         # Test each optimiser
         parameterisation = pybop.Optimisation(
-            cost=spm_two_signal_cost, optimiser=multi_optimiser, sigma0=0.05
+            cost=spm_two_signal_cost, optimiser=multi_optimiser, sigma0=0.03
         )
-        parameterisation.set_max_unchanged_iterations(iterations=15, threshold=5e-4)
+        parameterisation.set_max_unchanged_iterations(iterations=35, threshold=5e-4)
         parameterisation.set_max_iterations(125)
         initial_cost = parameterisation.cost(spm_two_signal_cost.x0)