Adds Transformation class

examples/scripts/spm_CMAES.py

@@ -13,12 +13,14 @@
         prior=pybop.Gaussian(6e-06, 0.1e-6),
         bounds=[1e-6, 9e-6],
         true_value=parameter_set["Negative particle radius [m]"],
+        transformation=pybop.LogTransformation(),
     ),
     pybop.Parameter(
         "Positive particle radius [m]",
         prior=pybop.Gaussian(4.5e-06, 0.1e-6),
         bounds=[1e-6, 9e-6],
         true_value=parameter_set["Positive particle radius [m]"],
+        transformation=pybop.LogTransformation(),
     ),
 )
 

examples/standalone/cost.py

@@ -21,7 +21,7 @@ class StandaloneCost(pybop.BaseCost):
 
     Methods
     -------
-    __call__(x, grad=None)
+    __call__(x)
         Calculate the cost for a given parameter value.
     """
 
@@ -43,7 +43,7 @@ def __init__(self, problem=None):
         )
         self.x0 = self.parameters.initial_value()
 
-    def _evaluate(self, inputs, grad=None):
+    def _evaluate(self, inputs):
         """
         Calculate the cost for a given parameter value.
 

pybop/__init__.py

@@ -78,6 +78,17 @@
 from .problems.fitting_problem import FittingProblem
 from .problems.design_problem import DesignProblem
 
+#
+# Transformation classes
+#
+from .transformation import Transformation
+from .transformation._transformation import (
+    IdentityTransformation,
+    ScaledTransformation,
+    LogTransformation,
+    ComposedTransformation,
+)
+
 #
 # Cost function class
 #

pybop/costs/_likelihoods.py

@@ -40,7 +40,7 @@ def __init__(self, problem: BaseProblem, sigma0: Union[list[float], float]):
         self._multip = -1 / (2.0 * self.sigma2)
         self._dl = np.ones(self.n_parameters)
 
-    def _evaluate(self, inputs: Inputs, grad: Union[None, np.ndarray] = None) -> float:
+    def _evaluate(self, inputs: Inputs) -> float:
         """
         Evaluates the Gaussian log-likelihood for the given parameters with known sigma.
         """
@@ -173,7 +173,7 @@ def dsigma_scale(self, new_value):
             raise ValueError("dsigma_scale must be non-negative")
         self._dsigma_scale = new_value
 
-    def _evaluate(self, inputs: Inputs, grad: Union[None, np.ndarray] = None) -> float:
+    def _evaluate(self, inputs: Inputs) -> float:
         """
         Evaluates the Gaussian log-likelihood for the given parameters.
 
@@ -285,17 +285,14 @@ def __init__(self, problem, likelihood, sigma0=None, gradient_step=1e-3):
         ):
             raise ValueError(f"{self.likelihood} must be a subclass of BaseLikelihood")
 
-    def _evaluate(self, inputs: Inputs, grad=None) -> float:
+    def _evaluate(self, inputs: Inputs) -> float:
         """
         Calculate the maximum a posteriori cost for a given set of parameters.
 
         Parameters
         ----------
         inputs : Inputs
             The parameters for which to evaluate the cost.
-        grad : array-like, optional
-            An array to store the gradient of the cost function with respect
-            to the parameters.
 
         Returns
         -------

pybop/costs/base_cost.py

@@ -1,4 +1,4 @@
-from pybop import BaseProblem
+from pybop import BaseProblem, ComposedTransformation, IdentityTransformation
 from pybop.parameters.parameter import Inputs, Parameters
 
 
@@ -24,34 +24,46 @@ class BaseCost:
 
     def __init__(self, problem=None):
         self.parameters = Parameters()
+        self.transformation = None
         self.problem = problem
         if isinstance(self.problem, BaseProblem):
             self._target = self.problem._target
             self.parameters.join(self.problem.parameters)
             self.n_outputs = self.problem.n_outputs
             self.signal = self.problem.signal
+            self.transformation = self.construct_transformation()
 
-    @property
-    def n_parameters(self):
-        return len(self.parameters)
+    def construct_transformation(self):
+        """
+        Create a ComposedTransformation object from the individual parameters transformations.
+        """
+        transformations = self.parameters.get_transformations()
+        if not transformations or all(t is None for t in transformations):
+            return None
 
-    def __call__(self, x, grad=None):
+        valid_transformations = [
+            t if t is not None else IdentityTransformation() for t in transformations
+        ]
+        return ComposedTransformation(valid_transformations)
+
+    def __call__(self, x):
         """
         Call the evaluate function for a given set of parameters.
         """
-        return self.evaluate(x, grad)
+        if self.transformation:
+            p = self.transformation.to_model(x)
+            return self.evaluate(p)
+        else:
+            return self.evaluate(x)
 
-    def evaluate(self, x, grad=None):
+    def evaluate(self, x):
         """
         Call the evaluate function for a given set of parameters.
 
         Parameters
         ----------
         x : array-like
             The parameters for which to evaluate the cost.
-        grad : array-like, optional
-            An array to store the gradient of the cost function with respect
-            to the parameters.
 
         Returns
         -------
@@ -66,15 +78,15 @@ def evaluate(self, x, grad=None):
         inputs = self.parameters.verify(x)
 
         try:
-            return self._evaluate(inputs, grad)
+            return self._evaluate(inputs)
 
         except NotImplementedError as e:
             raise e
 
         except Exception as e:
             raise ValueError(f"Error in cost calculation: {e}") from e
 
-    def _evaluate(self, inputs: Inputs, grad=None):
+    def _evaluate(self, inputs: Inputs):
         """
         Calculate the cost function value for a given set of parameters.
 
@@ -84,9 +96,6 @@ def _evaluate(self, inputs: Inputs, grad=None):
         ----------
         inputs : Inputs
             The parameters for which to evaluate the cost.
-        grad : array-like, optional
-            An array to store the gradient of the cost function with respect
-            to the parameters.
 
         Returns
         -------
@@ -123,7 +132,11 @@ def evaluateS1(self, x):
         inputs = self.parameters.verify(x)
 
         try:
-            return self._evaluateS1(inputs)
+            if self.transformation:
+                p = self.transformation.to_model(inputs)
+                return self._evaluateS1(p)
+            else:
+                return self._evaluateS1(inputs)
 
         except NotImplementedError as e:
             raise e
@@ -152,3 +165,7 @@ def _evaluateS1(self, inputs: Inputs):
             If the method has not been implemented by the subclass.
         """
         raise NotImplementedError
+
+    @property
+    def n_parameters(self):
+        return len(self.parameters)

pybop/costs/design_costs.py

@@ -65,7 +65,7 @@ def update_simulation_data(self, inputs: Inputs):
         self.problem._target = {key: solution[key] for key in self.problem.signal}
         self.dt = solution["Time [s]"][1] - solution["Time [s]"][0]
 
-    def _evaluate(self, inputs: Inputs, grad=None):
+    def _evaluate(self, inputs: Inputs):
         """
         Computes the value of the cost function.
 
@@ -75,8 +75,6 @@ def _evaluate(self, inputs: Inputs, grad=None):
         ----------
         inputs : Inputs
             The parameters for which to compute the cost.
-        grad : array, optional
-            Gradient information, not used in this method.
 
         Raises
         ------
@@ -99,16 +97,14 @@ class GravimetricEnergyDensity(DesignCost):
     def __init__(self, problem, update_capacity=False):
         super().__init__(problem, update_capacity)
 
-    def _evaluate(self, inputs: Inputs, grad=None):
+    def _evaluate(self, inputs: Inputs):
         """
         Computes the cost function for the energy density.
 
         Parameters
         ----------
         inputs : Inputs
             The parameters for which to compute the cost.
-        grad : array, optional
-            Gradient information, not used in this method.
 
         Returns
         -------
@@ -155,16 +151,14 @@ class VolumetricEnergyDensity(DesignCost):
     def __init__(self, problem, update_capacity=False):
         super().__init__(problem, update_capacity)
 
-    def _evaluate(self, inputs: Inputs, grad=None):
+    def _evaluate(self, inputs: Inputs):
         """
         Computes the cost function for the energy density.
 
         Parameters
         ----------
         inputs : Inputs
             The parameters for which to compute the cost.
-        grad : array, optional
-            Gradient information, not used in this method.
 
         Returns
         -------

pybop/costs/fitting_costs.py

@@ -23,7 +23,7 @@ def __init__(self, problem):
         # Default fail gradient
         self._de = 1.0
 
-    def _evaluate(self, inputs: Inputs, grad=None):
+    def _evaluate(self, inputs: Inputs):
         """
         Calculate the root mean square error for a given set of parameters.
 
@@ -136,17 +136,14 @@ def __init__(self, problem):
         # Default fail gradient
         self._de = 1.0
 
-    def _evaluate(self, inputs: Inputs, grad=None):
+    def _evaluate(self, inputs: Inputs):
         """
         Calculate the sum of squared errors for a given set of parameters.
 
         Parameters
         ----------
         inputs : Inputs
             The parameters for which to evaluate the cost.
-        grad : array-like, optional
-            An array to store the gradient of the cost function with respect
-            to the parameters.
 
         Returns
         -------
@@ -234,7 +231,7 @@ def __init__(self, observer: Observer):
         super().__init__(problem=observer)
         self._observer = observer
 
-    def _evaluate(self, inputs: Inputs, grad=None):
+    def _evaluate(self, inputs: Inputs):
         """
         Calculate the observer cost for a given set of parameters.
 

pybop/optimisers/base_optimiser.py

@@ -58,13 +58,15 @@ def __init__(
         self.verbose = False
         self.log = dict(x=[], x_best=[], cost=[])
         self.minimising = True
+        self.transformation = None
         self.physical_viability = False
         self.allow_infeasible_solutions = False
         self.default_max_iterations = 1000
         self.result = None
 
         if isinstance(cost, BaseCost):
             self.cost = cost
+            self.transformation = self.cost.transformation
             self.parameters.join(cost.parameters)
             self.set_allow_infeasible_solutions()
             if isinstance(cost, (BaseLikelihood, DesignCost)):
@@ -131,6 +133,9 @@ def set_base_options(self):
         # Set other options
         self.verbose = self.unset_options.pop("verbose", self.verbose)
         self.minimising = self.unset_options.pop("minimising", self.minimising)
+        self.transformation = self.unset_options.pop(
+            "transformation", self.transformation
+        )
         if "allow_infeasible_solutions" in self.unset_options.keys():
             self.set_allow_infeasible_solutions(
                 self.unset_options.pop("allow_infeasible_solutions")

pybop/optimisers/base_pints_optimiser.py

@@ -48,9 +48,6 @@
         self._evaluations = None
         self._iterations = None
 
-        # PyBOP doesn't currently support the PINTS transformation class
-        self._transformation = None
-
         self.pints_optimiser = pints_optimiser
         super().__init__(cost, **optimiser_kwargs)
 
@@ -200,8 +197,8 @@
                 return (L, dl) if self.minimising else (-L, -dl)
         else:
 
-            def f(x, grad=None):
-                return self.cost(x, grad) if self.minimising else -self.cost(x, grad)
+            def f(x):
+                return self.cost(x) if self.minimising else -self.cost(x)
 
         # Create evaluator object
         if self._parallel:
@@ -325,8 +322,8 @@
 
             # Show current parameters
             x_user = self.pints_optimiser.x_guessed()
-            if self._transformation is not None:
-                x_user = self._transformation.to_model(x_user)
+            if self.transformation is not None:
+                x_user = self.transformation.to_model(x_user)
             for p in x_user:
                 print(PintsStrFloat(p))
             print("-" * 40)
@@ -348,8 +345,8 @@
             f = self.pints_optimiser.f_best()
 
         # Inverse transform search parameters
-        if self._transformation is not None:
-            x = self._transformation.to_model(x)
+        if self.transformation is not None:
+            x = self.transformation.to_model(x)
 
         return Result(
             x=x, final_cost=f if self.minimising else -f, n_iterations=self._iterations