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

inference/mcmc/gibbs.py

@@ -253,7 +253,7 @@ class MetropolisChain(MarkovChain):
 
         if posterior is not None:
             self.posterior = posterior
-
+            self._validate_posterior(posterior=posterior, start=start)
             # if widths are not specified, take 5% of the starting values (unless they're zero)
             if widths is None:
                 widths = [v * 0.05 if v != 0 else 1.0 for v in start]
@@ -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

@@ -87,7 +87,7 @@ class HamiltonianChain(MarkovChain):
             start = start if isinstance(start, ndarray) else array(start)
             start = start if start.dtype is float64 else start.astype(float64)
             assert start.ndim == 1
-
+            self._validate_posterior(posterior=posterior, start=start)
             self.theta = [start]
             self.probs = [self.posterior(start) * self.inv_temp]
             self.leapfrog_steps = [0]
@@ -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)

inference/mcmc/hmc/mass.py

@@ -3,7 +3,7 @@ from typing import Union
 from numpy import ndarray, sqrt, eye, isscalar
 from numpy.random import Generator
 from numpy.linalg import cholesky
-from scipy.linalg import solve_triangular
+from scipy.linalg import solve_triangular, issymmetric
 
 
 class ParticleMass(ABC):
@@ -37,12 +37,43 @@ class VectorMass(ScalarMass):
         assert inv_mass.ndim == 1
         assert inv_mass.size == n_parameters
 
+        valid_variances = (
+            inv_mass.ndim == 1
+            and inv_mass.size == n_parameters
+            and (inv_mass > 0.0).all()
+        )
+
+        if not valid_variances:
+            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):
     def __init__(self, inv_mass: ndarray, n_parameters: int):
-        assert inv_mass.ndim == 2
-        assert inv_mass.shape[0] == inv_mass.shape[1] == n_parameters
-        assert (inv_mass == inv_mass.T).all()
+
+        valid_covariance = (
+            inv_mass.ndim == 2
+            and inv_mass.shape[0] == inv_mass.shape[1]
+            and issymmetric(inv_mass)
+        )
+
+        if not valid_covariance:
+            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
+                \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
@@ -64,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