inference-tools 0.14.2__py3-none-any.whl → 0.14.3__py3-none-any.whl

inference/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.14.2'
-__version_tuple__ = version_tuple = (0, 14, 2)
+__version__ = version = '0.14.3'
+__version_tuple__ = version_tuple = (0, 14, 3)
+
+__commit_id__ = commit_id = 'gc06533b'

inference/approx/conditional.py

@@ -109,20 +109,16 @@ def piecewise_linear_sample(
     """
     dx = x[1:] - x[:-1]
     if (dx <= 0.0).any():
-        raise ValueError(
-            """\n
+        raise ValueError("""\n
             \r[ piecewise_linear_sample error ]
             \r>> The 'x' argument must be given in strictly ascending order.
-            """
-        )
+            """)
 
     if (probability_density < 0).any():
-        raise ValueError(
-            """\n
+        raise ValueError("""\n
             \r[ piecewise_linear_sample error ]
             \r>> All values in the given 'probability_density' array must be non-negative.
-            """
-        )
+            """)
 
     means = 0.5 * (probability_density[1:] + probability_density[:-1])
     delta = 0.5 * (probability_density[1:] - probability_density[:-1]) / means

inference/gp/covariance.py

@@ -36,12 +36,10 @@ class CovarianceFunction(ABC):
         return CompositeCovariance([*K1, *K2])
 
     def gradient_terms(self, v, x, theta):
-        raise NotImplementedError(
-            f"""
+        raise NotImplementedError(f"""
             Gradient calculations are not yet available for the
             {type(self)} covariance function.
-            """
-        )
+            """)
 
 
 class CompositeCovariance(CovarianceFunction):
@@ -436,37 +434,31 @@ class ChangePoint(CovarianceFunction):
         ]
         for K in self.cov:
             if not isinstance(K, CovarianceFunction):
-                raise TypeError(
-                    """\n
+                raise TypeError("""\n
                     \r[ ChangePoint error ]
                     \r>> Each of the specified covariance kernels must be an instance of
                     \r>> a class which inherits from the 'CovarianceFunction' abstract
                     \r>> base-class.
-                    """
-                )
+                    """)
 
         self.n_kernels = len(kernels)
 
         if location_bounds is not None:
             if len(location_bounds) != self.n_kernels - 1:
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     \r[ ChangePoint error ]
                     \r>> The length of 'location_bounds' must be one less than the number of kernels
-                    """
-                )
+                    """)
             self.location_bounds = [check_bounds(lb) for lb in location_bounds]
         else:
             self.location_bounds = None
 
         if width_bounds is not None:
             if len(width_bounds) != self.n_kernels - 1:
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     \r[ ChangePoint error ]
                     \r>> The length of 'width_bounds' must be one less than the number of kernels
-                    """
-                )
+                    """)
             self.width_bounds = [check_bounds(wb) for wb in width_bounds]
         else:
             self.width_bounds = None

inference/gp/inversion.py

@@ -61,55 +61,45 @@ class GpLinearInverter:
         prior_mean_function: MeanFunction = ConstantMean,
     ):
         if model_matrix.ndim != 2:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 [ GpLinearInverter error ]
                 >> 'model_matrix' argument must be a 2D numpy.ndarray
-                """
-            )
+                """)
 
         if y.ndim != y_err.ndim != 1 or y.size != y_err.size:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 [ GpLinearInverter error ]
                 >> 'y' and 'y_err' arguments must be 1D numpy.ndarray
                 >> of equal size.
-                """
-            )
+                """)
 
         if model_matrix.shape[0] != y.size:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 [ GpLinearInverter error ]
                 >> The size of the first dimension of 'model_matrix' must
                 >> equal the size of 'y', however they have shapes
                 >> {model_matrix.shape}, {y.shape}
                 >> respectively.
-                """
-            )
+                """)
 
         if parameter_spatial_positions.ndim != 2:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 [ GpLinearInverter error ]
                 >> 'parameter_spatial_positions' must be a 2D numpy.ndarray, with the
                 >> size of first dimension being equal to the number of model parameters
                 >> and the size of the second dimension being equal to the number of
                 >> spatial dimensions.
-                """
-            )
+                """)
 
         if model_matrix.shape[1] != parameter_spatial_positions.shape[0]:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 [ GpLinearInverter error ]
                 >> The size of the second dimension of 'model_matrix' must be equal
                 >> to the size of the first dimension of 'parameter_spatial_positions',
                 >> however they have shapes
                 >> {model_matrix.shape}, {parameter_spatial_positions.shape}
                 >> respectively.
-                """
-            )
+                """)
 
         self.A = model_matrix
         self.y = y
@@ -230,13 +220,11 @@ class GpLinearInverter:
             as a 1D ``numpy.ndarray``.
         """
         if initial_guess.size != self.n_hyperpars:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 [ GpLinearInverter error ]
                 >> There are a total of {self.n_hyperpars} hyper-parameters,
                 >> but {initial_guess.size} values were given in 'initial_guess'.
-                """
-            )
+                """)
 
         hp_bounds = [*self.mean.bounds, *self.cov.bounds]
 

inference/gp/optimisation.py

@@ -164,14 +164,12 @@ class GpOptimiser:
             if new_y_err is not None:
                 self.y_err = append(self.y_err, new_y_err)
             else:
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     \r[ GpOptimiser error ]
                     \r>> 'new_y_err' argument of the 'add_evaluation' method must be
                     \r>> specified if the 'y_err' argument was specified when the
                     \r>> instance of GpOptimiser was initialised.
-                    """
-                )
+                    """)
 
         # re-train the GP
         self.gp = GpRegressor(

inference/gp/regression.py

@@ -96,12 +96,10 @@ class GpRegressor:
         self.y = self.y.squeeze()
 
         if self.y.ndim != 1:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ GpRegressor error ]
                 \r>> 'y' argument must be a 1D array, but instead has shape {self.y.shape}
-                """
-            )
+                """)
 
         # determine the number of data points and spatial dimensions
         self.n_points = self.y.size
@@ -111,23 +109,19 @@ class GpRegressor:
             self.n_dimensions = 1
             self.x = self.x.reshape([self.x.size, self.n_dimensions])
         else:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ GpRegressor Error ]
                 \r>> 'x' argument must be a 2D array, but instead has
                 \r>> {self.x.ndim} dimensions and shape {self.x.shape}.
-                """
-            )
+                """)
 
         if self.x.shape[0] != self.n_points:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ GpRegressor Error ]
                 \r>> The first dimension of the 'x' array must be equal in size
                 \r>> to the 'y' array.
                 \r>> 'x' has shape {self.x.shape}, but 'y' has size {self.y.size}.
-                """
-            )
+                """)
 
         # build data errors covariance matrix
         self.sig = self.check_error_data(y_err, y_cov)
@@ -167,13 +161,11 @@ class GpRegressor:
         if hyperpars is None:
             if optimizer not in ["bfgs", "diffev"]:
                 optimizer = "bfgs"
-                warn(
-                    """
+                warn("""
                     An invalid option was passed to the 'optimizer' keyword argument.
                     The default option 'bfgs' was used instead.
                     Valid options are 'bfgs' and 'diffev'.
-                    """
-                )
+                    """)
 
             if optimizer == "diffev":
                 hyperpars = self.differential_evo()
@@ -224,14 +216,12 @@ class GpRegressor:
         """
         # check to make sure the right number of hyper-parameters were given
         if len(hyperpars) != self.n_hyperpars:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 [ GpRegressor error ]
                 >> An incorrect number of hyper-parameter values were passed via the 
                 >> 'hyperpars' keyword argument:
                 >> There are {self.n_hyperpars} hyper-parameters but {len(hyperpars)} values were given.
-                """
-            )
+                """)
 
         self.hyperpars = hyperpars
         self.mean_hyperpars = self.hyperpars[self.mean_slice]
@@ -250,45 +240,37 @@ class GpRegressor:
                 y_err = array(y_cov).squeeze()
             elif type(y_cov) is not ndarray:
                 # else if it isn't already an array raise an error
-                raise TypeError(
-                    f"""\n
+                raise TypeError(f"""\n
                     [ GpRegressor error ]
                     >> The 'y_cov' keyword argument should be given as a numpy array:
                     >> Expected type {ndarray} but type {type(y_cov)} was given.
-                    """
-                )
+                    """)
 
             # now check to make sure the given error array is a valid size
             if y_cov.shape != (self.n_points, self.n_points):
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     [ GpRegressor error ]
                     >> The 'y_cov' keyword argument was passed an array with an incorrect
                     >> shape. 'y_cov' must be a 2D array of shape (N,N), where 'N' is the
                     >> number of given y-data values.
-                    """
-                )
+                    """)
 
             # check to make sure the given matrix is symmetric
             if not (y_cov == y_cov.T).all():
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     [ GpRegressor error ]
                     >> The covariance matrix passed to the 'y_cov' keyword argument
                     >> is not symmetric.
-                    """
-                )
+                    """)
 
             # raise a warning if both keywords have been specified
             if y_err is not None:
-                warn(
-                    """\n
+                warn("""\n
                     [ GpRegressor warning ]
                     >> Only one of the 'y_err' and 'y_cov' keyword arguments should 
                     >> be specified. Only the input to 'y_cov' will be used - the
                     >> input to 'y_err' will be ignored.
-                    """
-                )
+                    """)
 
             return y_cov
 
@@ -298,24 +280,20 @@ class GpRegressor:
                 y_err = array(y_err).squeeze()
             elif type(y_err) is not ndarray:
                 # else if it isn't already an array raise an error
-                raise TypeError(
-                    f"""\n
+                raise TypeError(f"""\n
                     [ GpRegressor error ]
                     >> The 'y_err' keyword argument should be given as a numpy array:
                     >> Expected type {ndarray} but type {type(y_err)} was given.
-                    """
-                )
+                    """)
 
             # now check to make sure the given error array is a valid size
             if y_err.shape != (self.n_points,):
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     [ GpRegressor error ]
                     >> The 'y_err' keyword argument was passed an array with an
                     >> incorrect shape. 'y_err' must be a 1D array of length 'N',
                     >> where 'N' is the number of given y-data values.
-                    """
-                )
+                    """)
 
             return diag(y_err**2)
         else:
@@ -329,23 +307,19 @@ class GpRegressor:
         elif x.ndim == 1 and x.size == self.n_dimensions:
             x = x.reshape([1, x.size])
         elif x.ndim > 2:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 [ GpRegressor error ]
                 >> 'points' argument must be a 2D array, but given array
                 >> has {x.ndim} dimensions and shape {x.shape}.
-                """
-            )
+                """)
 
         if x.shape[1] != self.n_dimensions:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 [ GpRegressor error ]
                 >> The second dimension of the 'points' array must have size
                 >> equal to the number of dimensions of the input data.
                 >> The input data have {self.n_dimensions} dimensions but 'points' has shape {x.shape}.
-                """
-            )
+                """)
         return x
 
     def gradient(self, points: ndarray):

inference/likelihoods.py

@@ -265,10 +265,8 @@ class LogisticLikelihood(Likelihood):
 
 
 def jacobian_not_given(*args):
-    raise ValueError(
-        """
+    raise ValueError("""
         The gradient() method of a likelihood class instance was called, however
         the forward_model_jacobian keyword argument was not specified when instance 
         was created.
-        """
-    )
+        """)

inference/mcmc/base.py

@@ -217,24 +217,20 @@ class MarkovChain(ABC):
 
     def __plot_checks(self, burn: int, thin: int, plot_type: str):
         if self.chain_length < 2:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {self.__class__.__name__} error ]
                 \r>> Cannot generate the {plot_type} plot as no samples have
                 \r>> been produced - current chain length is {self.chain_length}.
-                """
-            )
+                """)
 
         reduced_length = max(self.chain_length - burn - 1, 0) // thin + 1
         if reduced_length < 2:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {self.__class__.__name__} error ]
                 \r>> The given values of 'burn' and 'thin' leave insufficient
                 \r>> samples to generate the {plot_type} plot.
                 \r>> Number of samples after burn / thin is {reduced_length}.
-                """
-            )
+                """)
 
     @property
     def burn(self):
@@ -253,44 +249,36 @@ class MarkovChain(ABC):
         self.__burn_thin_error()
 
     def __burn_thin_error(self):
-        raise AttributeError(
-            f"""\n
+        raise AttributeError(f"""\n
             \r[ {self.__class__.__name__} error ]
             \r>> The 'burn' and 'thin' instance attributes of inference-tools
             \r>> mcmc samplers were removed in version 0.13.0. Burn and thin
             \r>> values should now be passed explicitly to any methods with
             \r>> 'burn' and 'thin' keyword arguments.
-            """
-        )
+            """)
 
     def _validate_posterior(self, posterior: callable, start: ndarray):
         if not callable(posterior):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {self.__class__.__name__} error ]
                 \r>> The given 'posterior' is not a callable object.
-                """
-            )
+                """)
 
         prob = posterior(start)
 
         if not isinstance(prob, float):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {self.__class__.__name__} error ]
                 \r>> The given 'posterior' must return a float or a type which
                 \r>> derives from float (e.g. numpy.float64), however the returned
                 \r>> value has type:
                 \r>> {type(prob)}
-                """
-            )
+                """)
 
         if not isfinite(prob):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {self.__class__.__name__} error ]
                 \r>> The given 'posterior' must return a finite value for the given
                 \r>> 'start' parameter values, but instead returns a value of:
                 \r>> {prob}
-                """
-            )
+                """)

inference/mcmc/ensemble.py

@@ -91,12 +91,10 @@ class EnsembleSampler(MarkovChain):
 
         # proposal settings
         if not alpha > 1.0:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ EnsembleSampler error ]
                 \r>> The given value of the 'alpha' parameter must be greater than 1.
-                """
-            )
+                """)
         self.alpha = alpha
         # uniform sampling in 'x' where z = 0.5*x**2 yields the correct PDF for z
         self.x_lwr = sqrt(2.0 / self.alpha)
@@ -113,70 +111,58 @@ class EnsembleSampler(MarkovChain):
     @staticmethod
     def __validate_starting_positions(positions: ndarray):
         if not isinstance(positions, ndarray):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ EnsembleSampler error ]
                 \r>> 'starting_positions' should be a numpy.ndarray, but instead has type:
                 \r>> {type(positions)}
-                """
-            )
+                """)
 
         theta = (
             positions.reshape([positions.size, 1]) if positions.ndim == 1 else positions
         )
 
         if theta.ndim != 2 or theta.shape[0] < (theta.shape[1] + 1):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ EnsembleSampler error ]
                 \r>> 'starting_positions' should be a numpy.ndarray with shape
                 \r>> (n_walkers, n_parameters), where n_walkers >= n_parameters + 1.
                 \r>> Instead, the given array has shape {positions.shape}.
-                """
-            )
+                """)
 
         if not isfinite(theta).all():
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ EnsembleSampler error ]
                 \r>> The given 'starting_positions' array contains at least one
                 \r>> value which is non-finite.
-                """
-            )
+                """)
 
         if theta.shape[1] == 1:
             # only need to check the variance for the one-parameter case
             if var(theta) == 0:
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     \r[ EnsembleSampler error ]
                     \r>> The values given in 'starting_positions' have zero variance,
                     \r>> and therefore the walkers are unable to move.
-                    """
-                )
+                    """)
         else:
             covar = cov(theta.T)
             std_dev = sqrt(diag(covar))  # get the standard devs
             if (std_dev == 0).any():
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     \r[ EnsembleSampler error ]
                     \r>> For one or more variables, The values given in 'starting_positions' 
                     \r>> have zero variance, and therefore the walkers are unable to move
                     \r>> in those variables.
-                    """
-                )
+                    """)
             # now check if any pairs of variables are approximately co-linear
             correlation = covar / (std_dev[:, None] * std_dev[None, :])
             if (abs(triu(correlation, k=1)) > 0.999).any():
-                raise ValueError(
-                    """\n
+                raise ValueError("""\n
                     \r[ EnsembleSampler error ]
                     \r>> The values given in 'starting_positions' are approximately
                     \r>> co-linear for one or more pair of variables. This will
                     \r>> prevent the walkers from moving properly in those variables.
-                    """
-                )
+                    """)
         return theta
 
     def __proposal(self, i: int):

inference/mcmc/gibbs.py

@@ -272,13 +272,11 @@ class MetropolisChain(MarkovChain):
 
                 # check posterior value of chain starting point is finite
                 if not isfinite(self.probs[0]):
-                    ValueError(
-                        """\n
+                    ValueError("""\n
                         \r[ MetropolisChain error ]
                         \r>> 'posterior' argument callable returns a non-finite value
                         \r>> for the starting position given to the 'start' argument.
-                        """
-                    )
+                        """)
 
             self.display_progress = display_progress
             self.ProgressPrinter = ChainProgressPrinter(

inference/mcmc/hmc/__init__.py

@@ -149,12 +149,10 @@ class HamiltonianChain(MarkovChain):
             if (accept_prob >= 1) or (self.rng.random() <= accept_prob):
                 break
         else:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ HamiltonianChain error ]
                 \r>> Failed to take step within maximum allowed attempts of {self.max_attempts}
-                """
-            )
+                """)
 
         self.theta.append(t)
         self.probs.append(p)