Adding TransformedLogLikelihood class

Author: MichaelClerx

docs/source/transformations.rst

@@ -31,6 +31,24 @@ Example::
     transform = pints.LogTransformation(n_parameters)
     mcmc = pints.MCMCController(log_posterior, n_chains, x0, transform=transform)
 
+Transformation types:
+
+ - :class:`ComposedTransformation`
+ - :class:`IdentityTransformation`
+ - :class:`LogitTransformation`
+ - :class:`LogTransformation`
+ - :class:`RectangularBoundariesTransformation`
+ - :class:`ScalingTransformation`
+ - :class:`UnitCubeTransformation`
+
+Transformed classes:
+
+ - :class:`Transformation`
+ - :class:`TransformedBoundaries`
+ - :class:`TransformedErrorMeasure`
+ - :class:`TransformedLogPDF`
+ - :class:`TransformedLogPrior`
+
 
 Transformation types
 ********************

pints/_transformation.py

@@ -32,25 +32,46 @@ class Transformation():
     """
     def convert_log_pdf(self, log_pdf):
         """
-        Returns a transformed log-PDF class.
+        Returns a transformed :class:`pints.LogPDF`.
+
+        If `log_pdf` is a :class:`LogPrior`, a :class:`TransformedLogPrior`
+        will be returned, which also transforms the output of the
+        :meth:`sample` method.
+
+        If `log_pdf` is a :class:`LogLikelihood`, a
+        :class:`TransformedLogLikelihood` is returned, which is assumed to be
+        invariant with respect to the transform (because it is a probability of
+        the data, not the parameters). For all other types (including
+        ``LogPrior``) a non-invariant transform is used, see
+        :class:`TransformedLogPDF` for details.
         """
+        if isinstance(log_pdf, pints.LogLikelihood):
+            return TransformedLogLikelihood(log_pdf, self)
+        if isinstance(log_pdf, pints.LogPrior):
+            return TransformedLogPrior(log_pdf, self)
         return TransformedLogPDF(log_pdf, self)
 
     def convert_log_prior(self, log_prior):
         """
-        Returns a transformed log-prior class.
+        Deprecated function: Use :meth:`convert_log_pdf` instead.
         """
+        # Deprecated on 2026-02-06
+        import warnings
+        warnings.warn(
+            'The method `convert_log_prior` is deprecated. Please use'
+            ' `convert_log_pdf` instead (which will automatically detect'
+            ' detect LogPDF subtypes).')
         return TransformedLogPrior(log_prior, self)
 
     def convert_error_measure(self, error_measure):
         """
-        Returns a transformed error measure class.
+        Returns a transformed :class:`pints.ErrorMeasure`.
         """
         return TransformedErrorMeasure(error_measure, self)
 
     def convert_boundaries(self, boundaries):
         """
-        Returns a transformed boundaries class.
+        Returns a transformed :class:`pints.Boundaries` object.
         """
         if isinstance(boundaries, pints.RectangularBoundaries):
             if self.elementwise():
@@ -1212,6 +1233,62 @@ def sample(self, n):
         return qs
 
 
+class TransformedLogLikelihood(pints.LogLikelihood):
+    r"""
+    A :class:`pints.LogLikelihood` that accepts parameters in a transformed
+    search space.
+
+    Unlike a :class:`TransformedLogPDF`, a likelihood (a probability of the
+    data, given fixed parameters) is invariant to a parameter transform (but
+    not to a data transform), and so no Jacobian term appears. Instead
+
+    .. math::
+        ???
+
+
+    For the first order sensitivity, the transformation is done using
+
+    .. math::
+        ???
+
+    Extends :class:`pints.LogLikelihood`.
+
+    Parameters
+    ----------
+    log_likelihood
+        A :class:`pints.LogLikelihood`.
+    transformation
+        A :class:`pints.Transformation`.
+    """
+    def __init__(self, log_likelihood, transformation):
+        self._log_likelihood = log_likelihood
+        self._transform = transformation
+        self._n_parameters = self._log_pdf.n_parameters()
+        if self._transform.n_parameters() != self._n_parameters:
+            raise ValueError('Number of parameters for log_likelihood and '
+                             'transformation must match.')
+
+    def __call__(self, q):
+        # Compute LogLikelihood in the model space
+        return self._log_likelihood(self._transform.to_model(q))
+
+    def evaluateS1(self, q):
+        """ See :meth:`LogPDF.evaluateS1()`. """
+
+        # Call evaluateS1 of LogLikelihood in the model space
+        logl, dlogl_nojac = self._error.evaluateS1(self._transform.to_model(q))
+
+        # Calculate the S1 using change of variable (see ErrorMeasure above)
+        jacobian = self._transform.jacobian(q)
+        dlogl = np.matmul(dlogl_nojac, jacobian)  # Jacobian must be 2nd term
+
+        return logl, dlogl
+
+    def n_parameters(self):
+        """ See :meth:`LogPDF.n_parameters()`. """
+        return self._n_parameters
+
+
 class UnitCubeTransformation(ScalingTransformation):
     """
     Maps a parameter space onto the unit (hyper)cube.

pints/tests/test_transformation.py

@@ -954,7 +954,8 @@ def test_transformed_log_prior(self):
         d = 2
         t = pints.LogTransformation(2)
         r = pints.UniformLogPrior([0.1, 0.1], [0.9, 0.9])
-        tr = t.convert_log_prior(r)
+        tr = t.convert_log_pdf(r)
+        self.assertIsInstance(tr, pints.TransformedLogPrior)
 
         # Test sample
         n = 1
@@ -966,6 +967,13 @@ def test_transformed_log_prior(self):
         self.assertEqual(x.shape, (n, d))
         self.assertTrue(np.all(x < 0.))
 
+        # Test deprecated alias
+        with warnings.catch_warnings(record=True) as w:
+            tr = t.convert_log_prior(r)
+        self.assertEqual(len(w), 1)
+        self.assertIn('deprecated', str(w[0].message))
+        self.assertIsInstance(tr, pints.TransformedLogPrior)
+
 
 if __name__ == '__main__':
     unittest.main()