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

inference/mcmc/hmc/mass.py

@@ -44,14 +44,12 @@ class VectorMass(ScalarMass):
         )
 
         if not valid_variances:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ VectorMass error ]
                 \r>> The inverse-mass vector must be a 1D array and have size
                 \r>> equal to the given number of model parameters ({n_parameters})
                 \r>> and contain only positive values.
-                """
-            )
+                """)
 
 
 class MatrixMass(ParticleMass):
@@ -64,22 +62,18 @@ class MatrixMass(ParticleMass):
         )
 
         if not valid_covariance:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ MatrixMass error ]
                 \r>> The given inverse-mass matrix must be a valid covariance matrix,
                 \r>> i.e. 2 dimensional, square and symmetric.
-                """
-            )
+                """)
 
         if inv_mass.shape[0] != n_parameters:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ MatrixMass error ]
                 \r>> The dimensions of the given inverse-mass matrix {inv_mass.shape}
                 \r>> do not match the given number of model parameters ({n_parameters}).
-                """
-            )
+                """)
 
         self.inv_mass = inv_mass
         self.n_parameters = n_parameters
@@ -101,15 +95,13 @@ def get_particle_mass(
         return ScalarMass(inverse_mass, n_parameters)
 
     if not isinstance(inverse_mass, ndarray):
-        raise TypeError(
-            f"""\n
+        raise TypeError(f"""\n
             \r[ HamiltonianChain error ]
             \r>> The value given to the 'inverse_mass' keyword argument must be either
             \r>> a scalar type (e.g. int or float), or a numpy.ndarray.
             \r>> Instead, the given value has type:
             \r>> {type(inverse_mass)}
-            """
-        )
+            """)
 
     if inverse_mass.ndim == 1:
         return VectorMass(inverse_mass, n_parameters)

inference/mcmc/parallel.py

@@ -116,12 +116,10 @@ class ParallelTempering:
         self.successful_swaps = zeros([self.N_chains, self.N_chains])
 
         if sorted(self.temperatures) != self.temperatures:
-            warn(
-                """
+            warn("""
                 The list of Markov-chain objects passed to ParallelTempering
                 should be sorted in order of increasing chain temperature.
-                """
-            )
+                """)
 
         # Spawn a separate process for each chain object
         for chn in chains:

inference/mcmc/pca.py

@@ -278,22 +278,18 @@ class PcaChain(MetropolisChain):
         return chain
 
     def set_non_negative(self, *args, **kwargs):
-        warn(
-            """
+        warn("""
              The set_non_negative method is not available for PcaChain:
              Limits on parameters should instead be set using
              the parameter_boundaries keyword argument.
-             """
-        )
+             """)
 
     def set_boundaries(self, *args, **kwargs):
-        warn(
-            """
+        warn("""
              The set_boundaries method is not available for PcaChain:
              Limits on parameters should instead be set using
              the parameter_boundaries keyword argument.
-             """
-        )
+             """)
 
     def pass_through(self, prop):
         return prop

inference/mcmc/utilities.py

@@ -101,51 +101,41 @@ class Bounds:
         self.upper = upper if isinstance(upper, ndarray) else array(upper).squeeze()
 
         if self.lower.ndim > 1 or self.upper.ndim > 1:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {error_source} error ]
                 \r>> Lower and upper bounds must be one-dimensional arrays, but
                 \r>> instead have dimensions {self.lower.ndim} and {self.upper.ndim} respectively.
-                """
-            )
+                """)
 
         if self.lower.size != self.upper.size:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {error_source} error ]
                 \r>> Lower and upper bounds must be arrays of equal size, but
                 \r>> instead have sizes {self.lower.size} and {self.upper.size} respectively.
-                """
-            )
+                """)
 
         if (self.lower >= self.upper).any():
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {error_source} error ]
                 \r>> All given upper bounds must be larger than the corresponding lower bounds.
-                """
-            )
+                """)
 
         self.width = self.upper - self.lower
         self.n_bounds = self.width.size
 
     def validate_start_point(self, start: ndarray, error_source="Bounds"):
         if self.n_bounds != start.size:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {error_source} error ]
                 \r>> The number of parameters ({start.size}) does not
                 \r>> match the given number of bounds ({self.n_bounds}).
-                """
-            )
+                """)
 
         if not self.inside(start):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {error_source} error ]
                 \r>> Starting location for the chain is outside specified bounds.
-                """
-            )
+                """)
 
     def reflect(self, theta: ndarray) -> ndarray:
         q, rem = np_divmod(theta - self.lower, self.width)

inference/pdf/base.py

@@ -39,13 +39,11 @@ class DensityEstimator(ABC):
             in the form ``(lower_limit, upper_limit)``.
         """
         if not 0.0 < fraction < 1.0:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {self.__class__.__name__} error ]
                 \r>> The 'fraction' argument must have a value greater than
                 \r>> zero and less than one, but the value given was {fraction}.
-                """
-            )
+                """)
         # use the sample to estimate the HDI
         lwr, upr = sample_hdi(self.sample, fraction=fraction)
         # switch variables to the centre and width of the interval

inference/pdf/hdi.py

@@ -25,37 +25,31 @@ def sample_hdi(sample: ndarray, fraction: float) -> ndarray:
 
     # verify inputs are valid
     if not 0.0 < fraction < 1.0:
-        raise ValueError(
-            f"""\n
+        raise ValueError(f"""\n
             \r[ sample_hdi error ]
             \r>> The 'fraction' argument must be a float between 0 and 1,
             \r>> but the value given was {fraction}.
-            """
-        )
+            """)
 
     if isinstance(sample, ndarray):
         s = sample.copy()
     elif isinstance(sample, Sequence):
         s = array(sample)
     else:
-        raise ValueError(
-            f"""\n
+        raise ValueError(f"""\n
             \r[ sample_hdi error ]
             \r>> The 'sample' argument should be a numpy.ndarray or a
             \r>> Sequence which can be converted to an array, but
             \r>> instead has type {type(sample)}.
-            """
-        )
+            """)
 
     if s.ndim > 2 or s.ndim == 0:
-        raise ValueError(
-            f"""\n
+        raise ValueError(f"""\n
             \r[ sample_hdi error ]
             \r>> The 'sample' argument should be a numpy.ndarray
             \r>> with either one or two dimensions, but the given
             \r>> array has dimensionality {s.ndim}.
-            """
-        )
+            """)
 
     if s.ndim == 1:
         s.resize([s.size, 1])
@@ -64,31 +58,25 @@ def sample_hdi(sample: ndarray, fraction: float) -> ndarray:
     L = int(fraction * n_samples)
 
     if n_samples < 2:
-        raise ValueError(
-            f"""\n
+        raise ValueError(f"""\n
             \r[ sample_hdi error ]
             \r>> The first dimension of the given 'sample' array must 
             \r>> have have a length of at least 2.
-            """
-        )
+            """)
 
     # check that we have enough samples to estimate the HDI for the chosen fraction
     if n_samples <= L:
-        warn(
-            f"""\n
+        warn(f"""\n
             \r[ sample_hdi warning ]
             \r>> The given number of samples is insufficient to estimate the interval
             \r>> for the given fraction.
-            """
-        )
+            """)
 
     elif n_samples - L < 20:
-        warn(
-            f"""\n
+        warn(f"""\n
             \r[ sample_hdi warning ]
             \r>> n_samples * (1 - fraction) is small - calculated interval may be inaccurate.
-            """
-        )
+            """)
 
     # check that we have enough samples to estimate the HDI for the chosen fraction
     s.sort(axis=0)

inference/pdf/kde.py

@@ -51,13 +51,11 @@ class GaussianKDE(DensityEstimator):
         self.max_cvs = max_cv_samples
 
         if self.sample.size < 3:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ GaussianKDE error ]
                 \r>> Not enough samples were given to estimate the PDF.
                 \r>> At least 3 samples are required.
-                """
-            )
+                """)
 
         if bandwidth is None:
             self.h = self.simple_bandwidth_estimator()  # very simple bandwidth estimate

inference/plotting.py

@@ -89,23 +89,19 @@ def matrix_plot(
             labels = [f"param {i}" for i in range(N_par)]
     else:
         if len(labels) != N_par:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ matrix_plot error ]
                 \r>> The number of labels given does not match
                 \r>> the number of plotted parameters.
-                """
-            )
+                """)
 
     if reference is not None:
         if len(reference) != N_par:
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ matrix_plot error ]
                 \r>> The number of reference values given does not match
                 \r>> the number of plotted parameters.
-                """
-            )
+                """)
     # check that given plot style is valid, else default to a histogram
     if plot_style not in ["contour", "hdi", "histogram", "scatter"]:
         plot_style = "contour"
@@ -115,13 +111,11 @@ def matrix_plot(
 
     iterable = hasattr(hdi_fractions, "__iter__")
     if not iterable or not all(0 < f < 1 for f in hdi_fractions):
-        raise ValueError(
-            """\n
+        raise ValueError("""\n
             \r[ matrix_plot error ]
             \r>> The 'hdi_fractions' argument must be given as an
             \r>> iterable of floats, each in the range [0, 1].
-            """
-        )
+            """)
 
     # by default, we suppress axis ticks if there are 6 parameters or more to keep things tidy
     if show_ticks is None:
@@ -373,10 +367,11 @@ def hdi_plot(
     x: ndarray,
     sample: ndarray,
     intervals: Sequence[float] = (0.65, 0.95),
-    colormap: str = "Blues",
+    color: str = "C0",
     axis=None,
-    label_intervals=True,
-    color_levels=None,
+    plot_mean=True,
+    labels=True,
+    interval_alpha: Sequence[float] = None,
 ):
     """
     Plot highest-density intervals for a given sample of model realisations.
@@ -389,27 +384,33 @@ def hdi_plot(
         where ``n`` is the number of samples.
 
     :param intervals: \
-        A tuple containing the fractions of the total probability for each interval.
+        The fractions of the total probability contained in each interval which is to be
+        plotted as a Sequence of floats. All given values must be in the range [0, 1].
 
-    :param str colormap: \
-        The colormap to be used for plotting the intervals. Must be the name of
-        a valid colormap present in ``matplotlib.colormaps``.
+    :param str color: \
+        The color to be used for plotting the intervals. Must be the name of
+        a valid ``matplotlib`` color.
 
     :param axis: \
         A ``matplotlib.pyplot`` axis object which will be used to plot the intervals.
 
-    :param bool label_intervals: \
-        If ``True``, then labels will be assigned to each interval plot such that they appear
-        in the legend when using ``matplotlib.pyplot.legend``.
+    :param bool plot_mean: \
+        If ``True``, the mean of the samples is also plotted on top of the
+        highest-density intervals.
 
-    :param color_levels: \
-        A list of integers in the range [0,255] which specify the color value within the chosen
-        color map to be used for each of the intervals.
+    :param bool labels: \
+        If ``True``, then labels will be assigned to each plot element such that they
+        appear in the legend when using ``matplotlib.pyplot.legend``.
+
+    :param interval_alpha: \
+        A sequence of floats in the range [0, 1] specifying the 'alpha' value (which sets
+        the color transparency) which is used when coloring the intervals for each given
+        probability fraction.
     """
     # order the intervals from highest to lowest
     intervals = array(intervals)
-    intervals.sort()
-    intervals = intervals[::-1]
+    sorter = intervals.argsort()
+    intervals = intervals[sorter]
 
     # check that all the intervals are valid:
     if not all((intervals > 0.0) & (intervals < 1.0)):
@@ -425,32 +426,56 @@ def hdi_plot(
 
     # sort the sample data
     s.sort(axis=0)
-    n = s.shape[0]
-
-    if colormap in colormaps:
-        cmap = colormaps[colormap]
-    else:
-        cmap = colormaps["Blues"]
-        warn(f"'{colormap}' is not a valid colormap from matplotlib.colormaps")
 
-    if color_levels is None:
+    if interval_alpha is None:
         # construct the colors for each interval
-        lwr = 0.20
-        upr = 1.0
-        color_levels = 255 * ((upr - lwr) * (1 - intervals) + lwr)
+        lwr = 0.15
+        upr = 0.9
+        interval_alpha = (upr - lwr) * (1 - intervals) + lwr
+    else:
+        interval_alpha = array(interval_alpha)
+        assert interval_alpha.ndim == 1
+        assert interval_alpha.size == interval_alpha.size
+        interval_alpha = interval_alpha[sorter]
 
-    colors = [cmap(int(c)) for c in color_levels]
+        valid_alpha = (interval_alpha >= 0.0) & (interval_alpha <= 1.0)
+        if not valid_alpha:
+            raise ValueError("Given 'alpha' values must be in the range [0, 1]")
 
     # if not plotting axis is given, then use default pyplot
     if axis is None:
         _, axis = plt.subplots()
 
-    # iterate over the intervals and plot each
-    for frac, col in zip(intervals, colors):
+    if plot_mean:
+        lab = "mean" if labels else None
+        axis.plot(x, s.mean(axis=0), color=color, lw=2, label=lab)
+
+    # Calculate HDI for each interval fraction
+    lower = []
+    upper = []
+    for frac in intervals:
         lwr, upr = sample_hdi(s, fraction=frac)
-        lab = f"{int(100 * frac)}% HDI" if label_intervals else None
-        axis.fill_between(x, lwr, upr, color=col, label=lab)
+        lower.append(lwr)
+        upper.append(upr)
+
+    lab = f"{int(100 * intervals[0])}% HDI" if labels else None
+    axis.fill_between(
+        x, lower[0], upper[0], color=color, label=lab, alpha=interval_alpha[0]
+    )
 
+    for i in range(len(intervals) - 1):
+        lab = f"{int(100 * intervals[i + 1])}% HDI" if labels else None
+        axis.fill_between(
+            x,
+            lower[i + 1],
+            lower[i],
+            color=color,
+            label=lab,
+            alpha=interval_alpha[i + 1],
+        )
+        axis.fill_between(
+            x, upper[i], upper[i + 1], color=color, alpha=interval_alpha[i + 1]
+        )
     return axis
 
 

inference/priors.py

@@ -20,13 +20,11 @@ class BasePrior(ABC):
         n_parameters: int,
         class_name="BasePrior",
     ) -> list[int]:
-        indices_type_error = TypeError(
-            f"""\n
+        indices_type_error = TypeError(f"""\n
             \r[ {class_name} error ]
             \r>> 'variable_inds' argument of {class_name} must be
             \r>> given as an integer or list of integers
-            """
-        )
+            """)
 
         if not isinstance(variable_inds, (int, Iterable)):
             raise indices_type_error
@@ -41,22 +39,18 @@ class BasePrior(ABC):
             variable_inds = list(variable_inds)
 
         if n_parameters != len(variable_inds):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {class_name} error ]
                 \r>> The total number of variables specified via the 'variable_indices' argument
                 \r>> is inconsistent with the number specified by the other arguments.
-                """
-            )
+                """)
 
         if len(variable_inds) != len(set(variable_inds)):
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {class_name} error ]
                 \r>> All integers given via the 'variable_indices' must be unique.
                 \r>> Two or more of the given integers are duplicates.
-                """
-            )
+                """)
 
         return variable_inds
 
@@ -101,13 +95,11 @@ class BasePrior(ABC):
         :returns: \
             A single sample from the prior distribution as a 1D ``numpy.ndarray``.
         """
-        raise NotImplementedError(
-            f"""\n
+        raise NotImplementedError(f"""\n
             \r[ {self.__class__.__name__} error ]
             \r>> 'sample' is an optional method for classes inheriting from
             \r>> 'BasePrior', and has not been implemented for '{self.__class__.__name__}'.
-            """
-        )
+            """)
 
 
 class JointPrior(BasePrior):
@@ -125,13 +117,11 @@ class JointPrior(BasePrior):
 
     def __init__(self, components: list[BasePrior], n_variables: int):
         if not all(isinstance(c, BasePrior) for c in components):
-            raise TypeError(
-                """\n
+            raise TypeError("""\n
                 \r[ JointPrior error ]
                 \r>> The sequence of prior objects passed to the 'components' argument 
                 \r>> of 'JointPrior' must be instances of a subclass of 'BasePrior'.
-                """
-            )
+                """)
 
         # Combine any prior components which are of the same type
         self.components = []
@@ -146,34 +136,28 @@ class JointPrior(BasePrior):
         self.prior_variables = []
         for var in chain(*[c.variables for c in self.components]):
             if var in self.prior_variables:
-                raise ValueError(
-                    f"""\n
+                raise ValueError(f"""\n
                     \r[ JointPrior error ]
                     \r>> Variable index '{var}' appears more than once in the prior
                     \r>> objects passed to the 'components' argument of 'JointPrior'.
-                    """
-                )
+                    """)
             self.prior_variables.append(var)
 
         if len(self.prior_variables) != n_variables:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ JointPrior error ]
                 \r>> The total number of variables specified across the various prior
                 \r>> components ({len(self.prior_variables)}) does not match the number
                 \r>> specified in the 'n_variables' argument ({n_variables}).
-                """
-            )
+                """)
 
         if not all(0 <= i < n_variables for i in self.prior_variables):
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ JointPrior error ]
                 \r>> All variable indices specified across the various prior
                 \r>> objects passed to the 'components' argument of 'JointPrior'
                 \r>> must have values in the range [0, n_variables - 1].
-                """
-            )
+                """)
 
         self.n_variables = n_variables
 
@@ -419,12 +403,10 @@ class UniformPrior(BasePrior):
         self.grad = zeros(self.n_params)
 
         if (self.upper <= self.lower).any():
-            raise ValueError(
-                """\n
+            raise ValueError("""\n
                 \r[ UniformPrior error ]
                 \r>> All values in 'lower' must be less than the corresponding values in 'upper'
-                """
-            )
+                """)
 
         self.variables = self.validate_variable_indices(
             variable_inds=variable_indices,
@@ -498,55 +480,45 @@ def validate_prior_parameters(
             param = atleast_1d(param).astype(float)
 
         if not isinstance(param, ndarray):
-            raise TypeError(
-                f"""\n
+            raise TypeError(f"""\n
                 \r[ {class_name} error ]
                 \r>> Argument '{param_name}' should be an instance of a numpy.ndarray,
                 \r>> but instead has type:
                 \r>> {type(param)}
-                """
-            )
+                """)
 
         if param.ndim != 1:
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {class_name} error ]
                 \r>> Argument '{param_name}' should be a 1D numpy.ndarray, 
                 \r>> but has {param.ndim} dimensions and shape {param.shape}.
-                """
-            )
+                """)
 
         if not isfinite(param).all():
-            raise ValueError(
-                f"""\n
+            raise ValueError(f"""\n
                 \r[ {class_name} error ]
                 \r>> Argument '{param_name}' contains non-finite values.
-                """
-            )
+                """)
 
         if param_name in require_positive:
             if not (param > 0.0).all():
-                raise ValueError(
-                    f"""\n
+                raise ValueError(f"""\n
                     \r[ {class_name} error ]
                     \r>> All values given in '{param_name}' must be greater than zero.
-                    """
-                )
+                    """)
 
         validated_params.append(param)
 
     # check all inputs are the same size by collecting their sizes in a set
     if len({param.size for param in validated_params}) != 1:
-        raise ValueError(
-            f"""\n
+        raise ValueError(f"""\n
             \r[ {class_name} error ]
             \r>> Arguments
             \r>> {[param_name for param_name, _ in params]}
             \r>> must all be arrays of equal size, but instead have sizes
             \r>> {[param.size for param in validated_params]}
             \r>> respectively.
-            """
-        )
+            """)
 
     return validated_params
 

{inference_tools-0.14.2.dist-info → inference_tools-0.14.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inference-tools
-Version: 0.14.2
+Version: 0.14.3
 Summary: A collection of python tools for Bayesian data analysis
 Author-email: Chris Bowman <chris.bowman.physics@gmail.com>
 License: MIT License