InfluenceDiffusion 0.0.15__tar.gz → 0.0.17__tar.gz

{influencediffusion-0.0.15 → influencediffusion-0.0.17}/InfluenceDiffusion/Inference.py

@@ -4,9 +4,9 @@ import numpy as np
 from typing import Dict, Callable
 from functools import partial
 from scipy.stats import norm
+from scipy.stats._distn_infrastructure import rv_frozen
 
 from .estimation_models.OptimEstimation import GLTWeightEstimator
-from .utils import make_jax_cdf
 
 __all__ = ["GLTInferenceModule"]
 
@@ -15,7 +15,7 @@ class GLTInferenceModule:
     def __init__(self, estimator: GLTWeightEstimator, vertex_2_jax_cdf: Dict[int, Callable] = None):
         self.estimator = estimator
         if vertex_2_jax_cdf is None:
-            self.vertex_2_jax_cdf = {vertex: make_jax_cdf(distrib)
+            self.vertex_2_jax_cdf = {vertex: self._make_jax_cdf(distrib)
                                      for vertex, distrib in self.estimator.vertex_2_distrib.items()}
         else:
             self.vertex_2_jax_cdf = vertex_2_jax_cdf
@@ -41,6 +41,18 @@ class GLTInferenceModule:
         masks_tm1 = jnp.vstack([tm1_active_masks, tm1_failed_masks], dtype=jnp.float32)
         return ys, masks_t, masks_tm1
 
+    @staticmethod
+    def _make_jax_cdf(distrib: rv_frozen):
+        name = distrib.dist.name
+        args = distrib.args
+        kwargs = distrib.kwds
+        local_dic = {}
+        exec(f"jax_distrib=jax.scipy.stats.{name}", None, local_dic)
+        jax_distrib = local_dic["jax_distrib"]
+        if name == "expon":
+            return lambda x: 1. - jnp.exp(-x)
+        return lambda x: jax_distrib.cdf(x, *args, **kwargs)
+
     @staticmethod
     def _vertex_ll(parent_weights, cdf, ys, masks_t, masks_tm1, eps=1e-6):
         F_t = cdf(masks_t @ parent_weights)

influencediffusion-0.0.17/InfluenceDiffusion/estimation_models/CDFEstimation.py

@@ -0,0 +1,177 @@
+from typing import List, Tuple, Any
+from scipy.stats._distn_infrastructure import rv_continuous
+from scipy.interpolate import interp1d
+import numpy as np
+
+__all__ = ["CensoredCDFEstimator"]
+
+
+class CensoredCDFEstimator(rv_continuous):
+    """
+    This class implements the Turnbull estimator of the cumulative distribution function (CDF)
+    from a collection of censored intervals within which sample points are observed.
+    See: Turnbull, Bruce W. (1976).
+    “The Empirical Distribution Function with Arbitrarily Grouped, Censored and Truncated Data.”
+    Journal of the Royal Statistical Society. Series B (Methodological) 38(3), 290–295.
+
+    Parameters
+    ----------
+    support : tuple of float, optional
+        Explicit support (min, max) for the estimator. Default is (-np.inf, np.inf).
+    a : float, optional
+        Lower bound of the distribution. Default is None.
+    b : float, optional
+        Upper bound of the distribution. Default is None.
+    momtype : int, optional
+        Moment type used by `rv_continuous`. Default is 1.
+    xtol : float, optional
+        Tolerance for calculations in `rv_continuous`. Default is 1e-14.
+    badvalue : optional
+        Value to return for invalid inputs. Default is None.
+    name : str, optional
+        Name of the distribution. Default is None.
+    longname : str, optional
+        Long descriptive name of the distribution. Default is None.
+    shapes : str or None, optional
+        Shape parameters (if any) for the distribution. Default is None.
+    extradoc : str, optional
+        Additional documentation string. Default is None.
+    seed : int or np.random.Generator, optional
+        Random seed for reproducibility. Default is None.
+    """
+
+    def __init__(self, support: Tuple[float, float] = (-np.inf, np.inf),
+                 momtype=1,
+                 a=None,
+                 b=None,
+                 xtol=1e-14,
+                 badvalue=None,
+                 name=None,
+                 longname=None,
+                 shapes=None,
+                 extradoc=None,
+                 seed=None):
+
+        super().__init__(momtype=momtype, a=a, b=b, xtol=xtol, badvalue=badvalue,
+                         name=name, longname=longname, shapes=shapes, seed=seed)
+        self.support_ = support
+
+    def fit(self, intervals: List[Tuple[float, float]],
+            max_iter=50, tol=1e-4, verbose=False, verbose_interval=1):
+        """
+        Fit the CDF estimator to interval-censored data using an EM-like algorithm.
+
+        Parameters
+        ----------
+        intervals : list of tuple of float
+            List of observed intervals (left, right) for each sample.
+        max_iter : int, default 50
+            Maximum number of iterations for the EM procedure.
+        tol : float, default 1e-4
+            Convergence tolerance for the probability updates.
+        verbose : bool, default False
+            If True, prints iteration progress.
+        verbose_interval : int, default 1
+            Interval at which verbose output is printed.
+
+        Returns
+        -------
+        self : CensoredCDFEstimator
+            The fitted estimator with computed CDF probabilities and interpolator.
+        """
+        self.qp_ints_ = self._extract_disjoint_intervals(intervals)
+
+        alphas = np.fromfunction(
+            np.vectorize(lambda i, j: self._if_sub_interval(intervals[i], self.qp_ints_[j])),
+            shape=(len(intervals), len(self.qp_ints_)), dtype=int)
+
+        self.qp_probs_ = np.ones(len(self.qp_ints_)) / len(self.qp_ints_)
+
+        for iteration in range(max_iter):
+            cur_probs = self.qp_probs_.copy()
+            ms = (alphas * cur_probs) / (alphas @ cur_probs).reshape(-1, 1)
+            self.qp_probs_ = ms.sum(0) / ms.sum()
+            diff = np.linalg.norm(cur_probs - self.qp_probs_)
+            if verbose and iteration % verbose_interval == 0:
+                print(f"Iteration: {iteration}, Probs diff l2-norm: {round(diff, int(2 - np.log10(tol)))}")
+            if diff < tol:
+                break
+
+        if len(self.qp_ints_[:, 0]) >= 2:
+            self._cdf_interpolator = interp1d(self.qp_ints_[:, 0], np.cumsum(self.qp_probs_),
+                                              bounds_error=False, fill_value=(0.0, 1.0))
+        else:
+            self._cdf_interpolator = lambda x: np.clip(x, 0, 1)
+
+        return self
+
+    def _cdf(self, x: Any, *args, **kwargs):
+        """
+        Evaluate the CDF at given points.
+
+        Parameters
+        ----------
+        x : array-like or float
+            Points at which to evaluate the CDF.
+
+        Returns
+        -------
+        array-like or float
+            Evaluated CDF values at `x`.
+        """
+        return self._cdf_interpolator(x)
+
+    def support(self):
+        """
+        Get the support of the distribution.
+
+        Returns
+        -------
+        tuple of float
+            Lower and upper bounds of the support.
+        """
+        return self.support_
+
+    @staticmethod
+    def _if_sub_interval(interval1: Tuple[float, float], interval2: Tuple[float, float]):
+        """
+        Check if interval2 is fully contained within interval1.
+
+        Parameters
+        ----------
+        interval1 : tuple of float
+            Parent interval (left, right).
+        interval2 : tuple of float
+            Candidate sub-interval (left, right).
+
+        Returns
+        -------
+        bool
+            True if interval2 is contained within interval1, False otherwise.
+        """
+        return (interval1[0] <= interval2[0]) and (interval1[1] >= interval2[1])
+
+    @staticmethod
+    def _extract_disjoint_intervals(intervals: List[Tuple[float, float]]):
+        """
+        Convert overlapping intervals into a sorted array of disjoint intervals.
+
+        Parameters
+        ----------
+        intervals : list of tuple of float
+            List of input intervals (left, right).
+
+        Returns
+        -------
+        np.ndarray, shape (n_disjoint, 2)
+            Array of disjoint intervals covering the same range as the input.
+        """
+        assert len(intervals) > 0, "At least one interval should be provided"
+        assert all(interval[0] <= interval[1] for interval in intervals)
+        lefts, rights = zip(*intervals)
+        sort_endpoints = sorted([(left, "L") for left in lefts] + [(right, "R") for right in rights])
+        disjoint_intervals = []
+        for (ep, next_ep) in zip(sort_endpoints[:-1], sort_endpoints[1:]):
+            if ep[1] == "L" and next_ep[1] == "R":
+                disjoint_intervals.append((ep[0], next_ep[0]))
+        return np.array(disjoint_intervals)

{influencediffusion-0.0.15 → influencediffusion-0.0.17}/InfluenceDiffusion/estimation_models/OptimEstimation.py

@@ -1,4 +1,5 @@
 import numpy as np
+from warnings import warn
 from typing import List, Union, Dict, Tuple
 from scipy.optimize import LinearConstraint, minimize
 from scipy.stats._distn_infrastructure import rv_frozen
@@ -294,7 +295,13 @@ class GLTGridSearchEstimator(GLTWeightEstimator):
 
 class GLTWeightDistribEstimator(GLTWeightEstimator):
     """
-    Estimator of weights and vertex threshold distributions under the GLT diffusion model
+    Estimator of weights and vertex threshold distributions under the GLT diffusion model.
+    This estimator alternates estimation of the GLT weights and estimation of the vertex threshold CDF
+    using the Turnbull estimator. For the Turnbull estimator, see:
+
+    Turnbull, Bruce W. (1976).
+    “The Empirical Distribution Function with Arbitrarily Grouped, Censored and Truncated Data.”
+    Journal of the Royal Statistical Society. Series B (Methodological) 38(3), 290–295.
     """
 
     def __init__(self, graph: Graph,
@@ -303,17 +310,37 @@ class GLTWeightDistribEstimator(GLTWeightEstimator):
 
         """Initialize the GLTWeightDistribEstimator.
 
+
         Parameters
         ----------
         graph : Graph
             The graph structure.
+        threshold_support : Tuple[float, float]
+            Support for the vertex threshold distributions.
         n_jobs : int, optional
             Number of jobs for parallel processing.
         """
         super().__init__(graph=graph, vertex_2_distrib=None, n_jobs=n_jobs)
+        warn("This estimator is currently unstable and can only estimate CDF accurately for high indeg vertices!")
         self.threshold_support = threshold_support
 
     def _construct_vertex_threshold_observed_intervals(self, vertex: int, parent_weights: np.array):
+        """
+        Construct the observed intervals for a vertex's threshold based on parent activations.
+
+        Parameters
+        ----------
+        vertex : int
+            The vertex for which to construct threshold intervals.
+        parent_weights : np.ndarray
+            Current weights of the parent vertices.
+
+        Returns
+        -------
+        List[Tuple[float, float]]
+            List of intervals containing the lower and upper bounds for the vertex threshold
+            based on observed activations.
+        """
         intervals = []
         for mask_tm1, mask_t in zip(self._vertex_2_active_parent_mask_tm1[vertex],
                                     self._vertex_2_active_parent_mask_t[vertex]):

{influencediffusion-0.0.15 → influencediffusion-0.0.17}/InfluenceDiffusion/plot_utils.py

@@ -1,7 +1,6 @@
 import numpy as np
 import matplotlib.pyplot as plt
 
-
 __all__ = ["plot_with_conf_intervals", "plot_hist_with_normal_fit"]
 
 
@@ -13,22 +12,31 @@ def plot_with_conf_intervals(x_true, x_pred, conf_intervals=None,
     Plot a scatter plot of `x_true` vs `x_pred` with confidence intervals as a filled area
     and a diagonal line y=x.
 
-    :param x_true: Array-like, true values.
-    :param x_pred: Array-like, predicted values.
-    :param conf_intervals: 2D array of shape (2, len(x_pred)),
-                           containing the lower and upper bounds of the confidence intervals.
-                           If None, no confidence intervals are plotted.
-    :param fontsize: int, font size for axis labels. Default is 12.
-    :param figsize: tuple, size of the figure (width, height) in inches. Default is (10, 8).
-    :param color: str or tuple, color of the scatter points and confidence interval area. Default is "blue".
-    :param ax: matplotlib.axes.Axes, optional existing axes to plot on.
-               If None, a new figure and axes are created.
-    :param xlab: str, label for the x-axis. Default is "True activation probability".
-    :param ylab: str, label for the y-axis. Default is "Predicted activation probability".
+    Parameters
+    ----------
+    x_true : array-like
+        True values.
+    x_pred : array-like
+        Predicted values.
+    conf_intervals : array-like, shape (2, len(x_pred)), optional
+        Lower and upper bounds of the confidence intervals. If None, no intervals are plotted.
+    fontsize : int, default 12
+        Font size for axis labels.
+    figsize : tuple, default (10, 8)
+        Figure size in inches (width, height).
+    color : str or tuple, default "blue"
+        Color of the scatter points and confidence interval area.
+    ax : matplotlib.axes.Axes, optional
+        Existing axes to plot on. If None, a new figure and axes are created.
+    xlab : str, default "True activation probability"
+        Label for the x-axis.
+    ylab : str, default "Predicted activation probability"
+        Label for the y-axis.
     """
     assert len(x_pred) == len(x_true), "x_pred and x_true must have the same length"
-    assert conf_intervals.shape[1] == len(x_pred), "conf_intervals must have the same second dim as x_pred"
-    assert conf_intervals.shape[0] == 2, "conf_intervals must have two rows for lower and upper bounds"
+    if conf_intervals is not None:
+        assert conf_intervals.shape[1] == len(x_pred), "conf_intervals must have same second dim as x_pred"
+        assert conf_intervals.shape[0] == 2, "conf_intervals must have two rows for lower and upper bounds"
 
     # Sort by x_true so fill_between works correctly
     sort_idx = np.argsort(x_true)
@@ -62,10 +70,16 @@ def plot_hist_with_normal_fit(sample, true_value, true_std=None, n_bins=20):
     """
     Plot a histogram of a sample with a fitted normal curve and a vertical line at the true value.
 
-    :param sample: Array-like, sample data points
-    :param true_value: Float, the true value
-    :param true_std: Float, the true std
-    :param n_bins: Int, the number of histogram bins
+    Parameters
+    ----------
+    sample : array-like
+        Sample data points.
+    true_value : float
+        The true value.
+    true_std : float, optional
+        The true standard deviation, used to plot the theoretical normal curve.
+    n_bins : int, default 20
+        Number of bins for the histogram.
     """
     from scipy.stats import norm
 
@@ -80,15 +94,15 @@ def plot_hist_with_normal_fit(sample, true_value, true_std=None, n_bins=20):
     p_fit = norm.pdf(x, loc=mean, scale=std)
     plt.plot(x, p_fit, 'b', linewidth=2, label="Fitted Gaussian")
 
-    # Create the normal distribution's PDF
+    # Plot the theoretical normal curve
     if true_std is not None:
         p = norm.pdf(x, loc=true_value, scale=true_std)
         plt.plot(x, p, 'r', linewidth=2, label="Theoretical Gaussian")
 
-    # Plot the vertical line at the true value
+    # Plot vertical line at the true value
     plt.axvline(true_value, color='black', linestyle='--', linewidth=1.5, label="True value")
 
-    # Add labels and title
+    # Labels and legend
     plt.xlabel('Value')
     plt.ylabel('Density')
     plt.legend()

{influencediffusion-0.0.15 → influencediffusion-0.0.17}/InfluenceDiffusion/utils.py

@@ -1,7 +1,5 @@
 import numpy as np
 from typing import Iterable, Set
-from scipy.stats._distn_infrastructure import rv_frozen
-import jax.numpy as jnp
 
 
 def multiple_union(set_list: Iterable[Set]):
@@ -29,15 +27,3 @@ def random_vector_inside_simplex(dim: int, ub: float = 1.):
 def random_vector_on_simplex(dim: int, ub: float = 1.):
     X = random_vector_inside_simplex(dim=dim, ub=1)
     return X / np.sum(X) * ub
-
-
-def make_jax_cdf(distrib: rv_frozen):
-    name = distrib.dist.name
-    args = distrib.args
-    kwargs = distrib.kwds
-    local_dic = {}
-    exec(f"jax_distrib=jax.scipy.stats.{name}", None, local_dic)
-    jax_distrib = local_dic["jax_distrib"]
-    if name == "expon":
-        return lambda x: 1. - jnp.exp(-x)
-    return lambda x: jax_distrib.cdf(x, *args, **kwargs)

{influencediffusion-0.0.15 → influencediffusion-0.0.17}/InfluenceDiffusion.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: InfluenceDiffusion
-Version: 0.0.15
+Version: 0.0.17
 Summary: InfluenceDiffusion package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>

{influencediffusion-0.0.15 → influencediffusion-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: InfluenceDiffusion
-Version: 0.0.15
+Version: 0.0.17
 Summary: InfluenceDiffusion package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>

{influencediffusion-0.0.15 → influencediffusion-0.0.17}/setup.py

@@ -3,7 +3,7 @@ from pathlib import Path
 this_directory = Path(__file__).parent
 LONG_DESCRIPTION = (this_directory / "README.md").read_text()
 
-VERSION = '0.0.15'
+VERSION = '0.0.17'
 DESCRIPTION = 'InfluenceDiffusion package'
 
 setup(

influencediffusion-0.0.15/InfluenceDiffusion/estimation_models/CDFEstimation.py

@@ -1,73 +0,0 @@
-from typing import List, Tuple, Any
-from scipy.stats._distn_infrastructure import rv_continuous
-from scipy.interpolate import interp1d
-import numpy as np
-
-
-class CensoredCDFEstimator(rv_continuous):
-    def __init__(self, support: Tuple[float, float] = (-np.inf, np.inf),
-                 momtype=1,
-                 a=None,
-                 b=None,
-                 xtol=1e-14,
-                 badvalue=None,
-                 name=None,
-                 longname=None,
-                 shapes=None,
-                 extradoc=None,
-                 seed=None):
-
-        super().__init__(momtype=momtype, a=a, b=b, xtol=xtol, badvalue=badvalue,
-                         name=name, longname=longname, shapes=shapes, seed=seed)
-        self.support_ = support
-
-    def fit(self, intervals: List[Tuple[float, float]],
-            max_iter=50, tol=1e-4, verbose=False, verbose_interval=1):
-
-        self.qp_ints_ = self._extract_disjoint_intervals(intervals)
-
-        alphas = np.fromfunction(
-            np.vectorize(lambda i, j: self._if_sub_interval(intervals[i], self.qp_ints_[j])),
-            shape=(len(intervals), len(self.qp_ints_)), dtype=int)
-
-        self.qp_probs_ = np.ones(len(self.qp_ints_)) / len(self.qp_ints_)
-
-        for iteration in range(max_iter):
-            cur_probs = self.qp_probs_.copy()
-            ms = (alphas * cur_probs) / (alphas @ cur_probs).reshape(-1, 1)
-            self.qp_probs_ = ms.sum(0) / ms.sum()
-            diff = np.linalg.norm(cur_probs - self.qp_probs_)
-            if verbose and iteration % verbose_interval == 0:
-                print(f"Iteration: {iteration}, Probs diff l2-norm: {round(diff, int(2 - np.log10(tol)))}")
-            if diff < tol:
-                break
-
-        if len(self.qp_ints_[:, 0]) >= 2:
-            self._cdf_interpolator = interp1d(self.qp_ints_[:, 0], np.cumsum(self.qp_probs_),
-                                              bounds_error=False, fill_value=(0.0, 1.0))
-        else:
-            self._cdf_interpolator = lambda x: np.clip(x, 0, 1)
-
-        return self
-
-    def _cdf(self, x: Any, *args, **kwargs):
-        return self._cdf_interpolator(x)
-
-    def support(self):
-        return self.support_
-
-    @staticmethod
-    def _if_sub_interval(interval1: Tuple[float, float], interval2: Tuple[float, float]):
-        return (interval1[0] <= interval2[0]) and (interval1[1] >= interval2[1])
-
-    @staticmethod
-    def _extract_disjoint_intervals(intervals: List[Tuple[float, float]]):
-        assert len(intervals) > 0, "At least one interval should be provided"
-        assert all(interval[0] <= interval[1] for interval in intervals)
-        lefts, rights = zip(*intervals)
-        sort_endpoints = sorted([(left, "L") for left in lefts] + [(right, "R") for right in rights])
-        disjoint_intervals = []
-        for (ep, next_ep) in zip(sort_endpoints[:-1], sort_endpoints[1:]):
-            if ep[1] == "L" and next_ep[1] == "R":
-                disjoint_intervals.append((ep[0], next_ep[0]))
-        return np.array(disjoint_intervals)