Refactors BaseCost.evaluate/S1 into BaseCost.compute

CHANGELOG.md

@@ -22,6 +22,7 @@
 
 ## Breaking Changes
 
+- [#436](https://github.com/pybop-team/PyBOP/pull/436) - **API Change:** The functionality from `BaseCost.evaluate/S1` & `BaseCost._evaluate/S1` is represented in `BaseCost.__call__` & `BaseCost.compute`. `BaseCost.compute` directly acts on the predictions, while `BaseCost.__call__` calls `BaseProblem.evaluate/S1` before `BaseCost.compute`. `compute` has optional args for gradient cost calculations.
 - [#424](https://github.com/pybop-team/PyBOP/issues/424) - Replaces the `init_soc` input to `FittingProblem` with the option to pass an initial OCV value, updates `BaseModel` and fixes `multi_model_identification.ipynb` and `spm_electrode_design.ipynb`.
 
 # [v24.6.1](https://github.com/pybop-team/PyBOP/tree/v24.6.1) - 2024-07-31

examples/scripts/spm_MLE.py

@@ -2,8 +2,14 @@
 
 import pybop
 
-# Define model
+# Define model and set initial parameter values
 parameter_set = pybop.ParameterSet.pybamm("Chen2020")
+parameter_set.update(
+    {
+        "Negative electrode active material volume fraction": 0.63,
+        "Positive electrode active material volume fraction": 0.51,
+    }
+)
 model = pybop.lithium_ion.SPM(parameter_set=parameter_set)
 
 # Fitting parameters
@@ -19,31 +25,39 @@
     ),
 )
 
-# Set initial parameter values
-parameter_set.update(
-    {
-        "Negative electrode active material volume fraction": 0.63,
-        "Positive electrode active material volume fraction": 0.51,
-    }
-)
 # Generate data
-sigma = 0.005
-t_eval = np.arange(0, 900, 3)
-values = model.predict(t_eval=t_eval)
-corrupt_values = values["Voltage [V]"].data + np.random.normal(0, sigma, len(t_eval))
+sigma = 0.002
+experiment = pybop.Experiment(
+    [
+        (
+            "Discharge at 0.5C for 3 minutes (3 second period)",
+            "Charge at 0.5C for 3 minutes (3 second period)",
+        ),
+    ]
+)
+values = model.predict(initial_state={"Initial SoC": 0.5}, experiment=experiment)
+
+
+def noise(sigma):
+    return np.random.normal(0, sigma, len(values["Voltage [V]"].data))
+
 
 # Form dataset
 dataset = pybop.Dataset(
     {
-        "Time [s]": t_eval,
+        "Time [s]": values["Time [s]"].data,
         "Current function [A]": values["Current [A]"].data,
-        "Voltage [V]": corrupt_values,
+        "Voltage [V]": values["Voltage [V]"].data + noise(sigma),
+        "Bulk open-circuit voltage [V]": values["Bulk open-circuit voltage [V]"].data
+        + noise(sigma),
     }
 )
 
+
+signal = ["Voltage [V]", "Bulk open-circuit voltage [V]"]
 # Generate problem, cost function, and optimisation class
-problem = pybop.FittingProblem(model, parameters, dataset)
-likelihood = pybop.GaussianLogLikelihoodKnownSigma(problem, sigma0=sigma)
+problem = pybop.FittingProblem(model, parameters, dataset, signal=signal)
+likelihood = pybop.GaussianLogLikelihood(problem, sigma0=sigma * 4)
 optim = pybop.IRPropMin(
     likelihood,
     max_unchanged_iterations=20,

examples/standalone/cost.py

@@ -1,3 +1,5 @@
+import numpy as np
+
 import pybop
 
 
@@ -43,22 +45,18 @@ def __init__(self, problem=None):
         )
         self.x0 = self.parameters.initial_value()
 
-    def compute(self, inputs):
+    def compute(
+        self, y: dict = None, dy: np.ndarray = None, calculate_grad: bool = False
+    ):
         """
         Compute the cost for a given parameter value.
 
         The cost function is defined as cost(x) = x^2 + 42, where x is the
         parameter value.
 
-        Parameters
-        ----------
-        inputs : Dict
-            The parameters for which to evaluate the cost.
-
         Returns
         -------
         float
             The calculated cost value for the given parameter.
         """
-
-        return inputs["x"] ** 2 + 42
+        return self.parameters["x"].value ** 2 + 42