InfluenceDiffusion 0.0.12__tar.gz → 0.0.14__tar.gz

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion/Graph.py

@@ -1,4 +1,3 @@
-import pandas as pd
 import numpy as np
 from typing import List, Tuple, Union, Dict
 import networkx as nx
@@ -7,67 +6,41 @@ __all__ = ["Graph"]
 
 
 class Graph(nx.DiGraph):
-    def __init__(self, edge_list: List[Tuple[int, int]],
-                 directed: bool = True,
-                 weights: Union[np.array, List[float]] = None):
-        """
-        Initialize a directed or undirected graph from an edge list.
-
-        Parameters
-        ----------
-        edge_list : List[Tuple[int, int]]
-            List of tuples (source, sink) representing edges of the graph.
-        directed : bool, optional
-            Flag to indicate whether the graph is directed (default is True).
-        weights : Union[None, List[float]], optional
-            Optional weights for each edge. If None, all edges are assigned a weight of 1.
-        """
-        self.directed = directed
-        self.edge_array = np.array(edge_list, dtype=int)
-
-        if not self.directed:
-            reverse_edge_array = self.edge_array[:, [1, 0]]
-            self.edge_array = np.concatenate([self.edge_array, reverse_edge_array])
-
-        super().__init__(self.edge_array.tolist())
-
-        if weights is not None:
-            assert len(weights) == len(edge_list), "number of edges is different from number of weights"
+    def __init__(self, incoming_graph_data=None, weights: Union[List, np.array] = None, **attr):
+        super().__init__(incoming_graph_data, **attr)
+        self.edge_array = np.array(self.edges)
+        if weights is None:
+            self.weights = np.ones(len(self.edges))
         else:
-            weights = np.ones(len(edge_list))
-        self.weights = np.array(weights) if directed else np.hstack([weights] * 2)
-        self.edge_2_index = {tuple(edge): idx for idx, edge in enumerate(self.edge_array)}
+            assert len(weights) == self.count_edges(), "number of weights different from the number of edges"
+            self.weights = np.array(weights)
+        nx.set_edge_attributes(self, dict(zip(self.edges, self.weights)), "weight")
 
-    def rename_graph_vertices(self, old_2_new_vertex_name_dict: Union[None, Dict] = None) -> "Graph":
-        """
-        Rename graph vertices according to the provided mapping or re-index them.
+    def add_edge(self, u_of_edge, v_of_edge, **attr):
+        super().add_edge(u_of_edge, v_of_edge, **attr)
+        self.edge_array = np.array(self.edges)
+        self.weights = self._get_edge_weight_attributes()
 
-        Parameters
-        ----------
-        old_2_new_vertex_name_dict : Union[None, Dict], optional
-            Mapping of old vertex names to new names. 
-            If None, re-indexes vertices to [0, 1, ..., |V|-1].
+    def add_edges_from(self, ebunch_to_add, **attr):
+        super().add_edges_from(ebunch_to_add, **attr)
+        self.edge_array = np.array(self.edges)
+        self.weights = self._get_edge_weight_attributes()
 
-        Returns
-        -------
-        Graph
-            The updated graph instance with renamed vertices.
-        """
-        if old_2_new_vertex_name_dict is None:
-            old_vertex_names = sorted(list(self.get_vertices()))
-            old_2_new_vertex_name_dict = {name: idx for idx, name in enumerate(old_vertex_names)}
+    def add_weighted_edges_from(self, ebunch_to_add, weight='weight', **attr):
+        super().add_weighted_edges_from(ebunch_to_add, weight=weight, **attr)
+        self.edge_array = np.array(self.edges)
+        self.weights = self._get_edge_weight_attributes()
 
-        self.edge_array[:, 0] = list(map(lambda v: old_2_new_vertex_name_dict[v], self.edge_array[:, 0]))
-        self.edge_array[:, 1] = list(map(lambda v: old_2_new_vertex_name_dict[v], self.edge_array[:, 1]))
-        return self
+    def _get_edge_weight_attributes(self):
+        return np.array([edge[2] for edge in self.edges.data("weight", default=1)])
 
-    def set_weights(self, weights: Union[str, np.array]) -> "Graph":
+    def set_weights(self, weights: Union[List, np.array]) -> "Graph":
         """
         Set weights for the edges in the graph.
 
         Parameters
         ----------
-        weights : Union[str, np.array]
+        weights : Union[list, np.array]
             Array of weights for the edges.
 
         Returns
@@ -81,7 +54,8 @@ class Graph(nx.DiGraph):
             If the number of weights does not match the number of edges.
         """
         assert len(weights) == self.count_edges(), "number of weights different from the number of edges"
-        self.weights = np.array(weights)
+        nx.set_edge_attributes(self, dict(zip(self.edges, weights)), 'weight')
+        self.weights = self._get_edge_weight_attributes()
         return self
 
     def get_edges(self, as_array: bool = False) -> Union[np.array, List[Tuple[int, int]]]:
@@ -100,7 +74,7 @@ class Graph(nx.DiGraph):
         """
         if as_array:
             return self.edge_array
-        return [tuple(edge) for edge in self.edge_array]
+        return list(self.edges)
 
     def get_vertices(self) -> set:
         """
@@ -144,7 +118,7 @@ class Graph(nx.DiGraph):
         int
             The total number of edges.
         """
-        return len(self.edge_array)
+        return len(self.edges)
 
     def count_vertices(self) -> int:
         """
@@ -155,7 +129,7 @@ class Graph(nx.DiGraph):
         int
             The total number of vertices.
         """
-        return len(self.get_vertices())
+        return len(self.nodes)
 
     def get_children_mask(self, vertex: int) -> np.array:
         """
@@ -392,38 +366,6 @@ class Graph(nx.DiGraph):
         """
         return np.mean(self.get_all_indegrees(weighted))
 
-    def get_edge_index(self, edge: Tuple[int, int]) -> int:
-        """
-        Get the index of a specified edge.
-
-        Parameters
-        ----------
-        edge : Tuple[int, int]
-            The edge for which to find the index.
-
-        Returns
-        -------
-        int
-            The index of the edge in the graph.
-        """
-        return self.edge_2_index[tuple(edge)]
-
-    def get_edge_weight(self, edge: Tuple[int, int]) -> float:
-        """
-        Get the weight of a specified edge.
-
-        Parameters
-        ----------
-        edge : Tuple[int, int]
-            The edge for which to retrieve the weight.
-
-        Returns
-        -------
-        float
-            The weight of the edge.
-        """
-        return self.weights[self.get_edge_index(edge)]
-
     def get_edges_mask_from_set_to_vertex(self, vertex_set: set, vertex: int) -> np.array:
         """
         Create a mask for edges leading from a set of vertices to a specified vertex.
@@ -445,23 +387,6 @@ class Graph(nx.DiGraph):
         parent_edges_mask[parent_edges_mask] = [(parent in vertex_set) for parent in parent_vertices]
         return parent_edges_mask
 
-    def get_adj_matrix(self) -> np.array:
-        """
-        Generate the adjacency matrix of the graph.
-
-        Returns
-        -------
-        np.array
-            The adjacency matrix as a numpy array.
-        """
-        vertices = list(self.get_vertices())
-        n_vertex = len(vertices)
-        adj_matrix = pd.DataFrame(np.zeros((n_vertex, n_vertex)), columns=vertices, index=vertices)
-        for (v1, v2), weight in zip(self.edge_array, self.weights):
-            adj_matrix.at[v1, v2] = weight
-
-        return adj_matrix
-
     def is_edge_in_graph(self, edge: Tuple[int, int]) -> bool:
         """
         Check if a specified edge exists in the graph.

influencediffusion-0.0.14/InfluenceDiffusion/Inference.py

@@ -0,0 +1,114 @@
+import jax
+import jax.numpy as jnp
+import numpy as np
+from typing import Dict, Callable
+from functools import partial
+from scipy.stats import norm
+
+from .estimation_models.OptimEstimation import GLTWeightEstimator
+from .utils import make_jax_cdf
+
+
+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)
+                                     for vertex, distrib in self.estimator.vertex_2_distrib.items()}
+        else:
+            self.vertex_2_jax_cdf = vertex_2_jax_cdf
+        self.vertex_2_parent_weight_cov = {}
+
+    def _get_vertex_activ_status_and_masks(self, vertex: int):
+        n_parents = self.estimator.graph.get_indegree(vertex)
+        if vertex in self.estimator._vertex_2_active_parent_mask_t:
+            t_active_masks = self.estimator._vertex_2_active_parent_mask_t[vertex]
+            tm1_active_masks = self.estimator._vertex_2_active_parent_mask_tm1[vertex]
+        else:
+            t_active_masks = jnp.empty(shape=(0, n_parents))
+            tm1_active_masks = jnp.empty(shape=(0, n_parents))
+
+        if vertex in self.estimator._failed_vertices_masks:
+            t_failed_masks = self.estimator._failed_vertices_masks[vertex]
+            tm1_failed_masks = jnp.zeros_like(t_failed_masks)
+        else:
+            t_failed_masks = jnp.empty(shape=(0, n_parents))
+            tm1_failed_masks = jnp.empty(shape=(0, n_parents))
+        ys = jnp.array([True] * len(t_active_masks) + [False] * len(t_failed_masks), dtype=bool)
+        masks_t = jnp.vstack([t_active_masks, t_failed_masks], dtype=jnp.float32)
+        masks_tm1 = jnp.vstack([tm1_active_masks, tm1_failed_masks], dtype=jnp.float32)
+        return ys, masks_t, masks_tm1
+
+    @staticmethod
+    def _vertex_ll(parent_weights, cdf, ys, masks_t, masks_tm1, eps=1e-6):
+        F_t = cdf(masks_t @ parent_weights)
+        F_tm1 = cdf(masks_tm1 @ parent_weights)
+        F_tm1 = jnp.where(F_tm1 < eps, 0, F_tm1)
+        F_t = jnp.where(F_t > 1. - eps, 1., F_t)
+        prob = jnp.clip(F_t - F_tm1, eps, 1. - eps)
+        return jnp.sum(jnp.log(jnp.where(ys, prob, 1. - prob)))
+
+    @staticmethod
+    def _vertex_conditional_activ_prob(weights, cdf, mask_t, mask_tm1, eps=1e-6):
+        F_t = cdf(mask_t @ weights)
+        F_tm1 = cdf(mask_tm1 @ weights)
+        F_t = jnp.clip(F_t, eps, 1. - eps)
+        F_tm1 = jnp.clip(F_tm1, eps, 1. - eps)
+        return 1. - (1. - F_t) / (1. - F_tm1)
+
+    def compute_vertex_conditional_activ_probs(self, vertex: int, masks_t, masks_tm1):
+        cdf = self.vertex_2_jax_cdf[vertex]
+        parent_mask = self.estimator.graph.get_parents_mask(vertex)
+        weights = jnp.array(self.estimator.weights_[parent_mask], dtype=jnp.float32)
+        return self._vertex_conditional_activ_prob(weights=weights, cdf=cdf, mask_t=masks_t, mask_tm1=masks_tm1)
+
+    def compute_vertex_parent_weight_cov(self, vertex, fisher_eps=1e-6):
+        if vertex in self.vertex_2_parent_weight_cov:
+            return self.vertex_2_parent_weight_cov[vertex]
+        cdf = self.vertex_2_jax_cdf[vertex]
+        parent_mask = self.estimator.graph.get_parents_mask(vertex)
+        weights = jnp.array(self.estimator.weights_[parent_mask], dtype=jnp.float32)
+        ys, masks_t, masks_tm1 = self._get_vertex_activ_status_and_masks(vertex=vertex)
+        hessian_fun = jax.hessian(partial(self._vertex_ll, cdf=cdf, ys=ys,
+                                          masks_t=masks_t, masks_tm1=masks_tm1))
+        fisher_info = -hessian_fun(weights)
+        cov = jnp.linalg.inv(fisher_info + fisher_eps * jnp.eye(len(fisher_info)))
+        self.vertex_2_parent_weight_cov[vertex] = cov
+        return cov
+
+    def compute_vertex_2_parent_weight_cov_dict(self):
+        return {vertex: self.compute_vertex_parent_weight_cov(vertex)
+                for vertex in self.estimator.informative_vertices}
+
+    def compute_parent_weight_conf_ints(self, vertex: int, alpha: float = 0.05):
+        weights = self.estimator.weights_[self.estimator.graph.get_parents_mask(vertex)]
+        lb, ub = self.estimator.vertex_2_distrib[vertex].support()
+        cov = self.compute_vertex_parent_weight_cov(vertex=vertex)
+        stds = jnp.sqrt(jnp.diag(cov))
+        quantile = norm.ppf(1 - alpha / 2)
+        return jnp.stack([jnp.clip(weights - quantile * stds, lb, None),
+                          jnp.clip(weights + quantile * stds, None, ub)]).T
+
+    def compute_all_weight_conf_ints(self, alpha=0.05):
+        conf_ints = np.empty(shape=(self.estimator.graph.count_edges(), 2), dtype=np.float32)
+        for vertex in self.estimator.informative_vertices:
+            parent_conf_ints = self.compute_parent_weight_conf_ints(vertex=vertex, alpha=alpha)
+            mask = self.estimator.graph.get_parents_mask(vertex)
+            conf_ints[mask] = parent_conf_ints
+        return conf_ints
+
+    def compute_vertex_activation_prob_conf_ints(self, vertex: int, masks_t, masks_tm1, alpha=0.05):
+        cdf = self.vertex_2_jax_cdf[vertex]
+        weights = self.estimator.weights_[self.estimator.graph.get_parents_mask(vertex)]
+        cov = self.compute_vertex_parent_weight_cov(vertex=vertex)
+        quantile = norm.ppf(1 - alpha / 2)
+        conf_ints = []
+        for mask_t, mask_tm1 in zip(masks_t, masks_tm1):
+            prob, prob_grad = jax.value_and_grad(partial(self._vertex_conditional_activ_prob,
+                                                 cdf=cdf, mask_t=mask_t, mask_tm1=mask_tm1))(weights)
+            prob_grad = prob_grad.reshape((-1, 1))
+            std = jnp.sqrt(prob_grad.T @ cov @ prob_grad)
+            conf_ints.append([jnp.clip(prob - quantile * std, 0., None).item(),
+                              jnp.clip(prob + quantile * std, None, 1.).item()])
+
+        return np.stack(conf_ints)

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion/Trace.py

@@ -78,10 +78,10 @@ class Trace(tuple):
         if check_feasibility:
             self.make_feasibility_check()
 
-        self.__cumulative_trace: Tuple[Set] = None
-        self.__failed_vertices: Set = None
-        self.__activated_vertices: Set = None
-        self.__activation_time_dict: Dict[int, int] = None
+        self.__cumulative_trace = None
+        self.__failed_vertices = None
+        self.__activated_vertices = None
+        self.__activation_time_dict = None
 
     def make_feasibility_check(self) -> None:
         """Check if each vertex has at least one active parent at each time step."""

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion/__init__.py

@@ -1,6 +1,8 @@
 from .Graph import Graph
 from .influence_models import InfluenceModel, ICM, LTM, GLTM
 from .Trace import Trace, Traces, PseudoTraces
+from .Inference import GLTInferenceModule
 from .utils import invert_non_zeros, multiple_union, random_vector_inside_simplex, random_vector_on_simplex
+from plot_utils import plot_with_conf_intervals, plot_hist_with_normal_fit
 from .weight_samplers import make_weighted_cascade_weights, make_random_weights_with_fixed_indeg, \
     make_random_weights_with_indeg_constraint

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion/estimation_models/BaseWeightEstimator.py

@@ -2,14 +2,13 @@ from typing import List, Union, Dict
 import os
 import pickle
 import numpy as np
-from tqdm import tqdm
 from joblib import Parallel, delayed
 from scipy.stats import uniform
 from scipy.stats._distn_infrastructure import rv_frozen
 
 from ..Trace import Traces, PseudoTraces
 from ..Graph import Graph
-from ..utils import multiple_union
+from ..utils import multiple_union, random_vector_inside_simplex
 
 __all__ = ["BaseWeightEstimator", "BaseGLTWEightEstimator", "BaseICWEightEstimator"]
 
@@ -144,13 +143,13 @@ class BaseWeightEstimator:
         vertex_2_active_parent_mask_t = {vertex: [] for vertex in self.informative_vertices}
         failed_vertices_masks = {vertex: [] for vertex in self.informative_vertices}
 
-        for vertex, vertex_pseudo_traces in tqdm(traces.items()):
+        for vertex, vertex_pseudo_traces in traces.items():
             for vertices_tm1, new_vertices_t in vertex_pseudo_traces:
                 parents = self.graph.get_parents(vertex, out_type=np.array)
-                active_parents_mask_tm1 = np.in1d(parents, np.array(list(vertices_tm1)))
+                active_parents_mask_tm1 = np.isin(parents, np.array(list(vertices_tm1)))
                 if new_vertices_t:
                     vertices_t = vertices_tm1 | new_vertices_t
-                    active_parents_mask_t = np.in1d(parents, np.array(list(vertices_t)))
+                    active_parents_mask_t = np.isin(parents, np.array(list(vertices_t)))
                     vertex_2_active_parent_mask_tm1[vertex].append(active_parents_mask_tm1)
                     vertex_2_active_parent_mask_t[vertex].append(active_parents_mask_t)
                 else:
@@ -362,10 +361,12 @@ class BaseGLTWEightEstimator(BaseWeightEstimator):
     """
 
     def __init__(self, graph: Graph, n_jobs: int = None,
-                 vertex_2_distrib: Dict[int, rv_frozen] = None):
+                 vertex_2_distrib: Union[Dict[int, rv_frozen], rv_frozen] = None):
         super().__init__(graph, n_jobs)
         if vertex_2_distrib is None:
             vertex_2_distrib = {v: uniform(0, 1) for v in graph.get_vertices()}
+        elif isinstance(vertex_2_distrib, rv_frozen):
+            vertex_2_distrib = {v: vertex_2_distrib for v in graph.get_vertices()}
         self.vertex_2_distrib = vertex_2_distrib
 
     def _generate_random_weights(self) -> np.ndarray:
@@ -381,10 +382,8 @@ class BaseGLTWEightEstimator(BaseWeightEstimator):
             parent_mask = self.graph.get_parents_mask(vertex)
             num_parents = self.graph.get_indegree(vertex, weighted=False)
             support_ub = self.vertex_2_distrib[vertex].support()[1]
-            if support_ub == np.inf:
-                weights[parent_mask] = np.random.exponential(num_parents)
-            else:
-                weights[parent_mask] = np.random.rand(num_parents) * support_ub / num_parents
+            support_ub = 1 if support_ub == np.inf else support_ub
+            weights[parent_mask] = random_vector_inside_simplex(num_parents, ub=support_ub)
         return weights
 
     def _check_init_weight_correctness(self, init_weights: Union[List, np.ndarray], eps: float = 1e-6) -> None:

influencediffusion-0.0.14/InfluenceDiffusion/estimation_models/CDFEstimation.py

@@ -0,0 +1,73 @@
+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)

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion/estimation_models/OptimEstimation.py

@@ -2,22 +2,17 @@ import numpy as np
 from typing import List, Union, Dict, Tuple
 from scipy.optimize import LinearConstraint, minimize
 from scipy.stats._distn_infrastructure import rv_frozen
+from copy import copy
 
 from ..Graph import Graph
 from ..Trace import Traces, PseudoTraces
 from .BaseWeightEstimator import BaseGLTWEightEstimator
+from .CDFEstimation import CensoredCDFEstimator
 
-__all__ = ["GLTGridSearchEstimator", "GLTWeightEstimator"]
+__all__ = ["GLTGridSearchEstimator", "GLTWeightEstimator", "GLTWeightDistribEstimator"]
 
 
 class GLTWeightEstimator(BaseGLTWEightEstimator):
-    """GLTW Weight Estimator for modeling influence in networks.
-
-    Attributes
-    ----------
-    vertex_2_distrib : Dict[int, rv_frozen]
-        Distribution mapping for vertices.
-    """
 
     def _compute_failed_vertex_ll(self, weights: np.ndarray, vertex: int) -> float:
         """Compute the log-likelihood for failed vertices.
@@ -99,8 +94,8 @@ class GLTWeightEstimator(BaseGLTWEightEstimator):
         """
         return np.sum([
             self._compute_vertex_nll(weights[self.graph.get_parents_mask(vertex)], vertex)
-            for vertex in self.informative_vertices
-        ])
+            for vertex in self.informative_vertices]
+        )
 
     def _compute_normalized_vertex_nll(self, weights: np.ndarray, vertex: int) -> float:
         """Compute the normalized negative log-likelihood for a vertex.
@@ -149,7 +144,8 @@ class GLTWeightEstimator(BaseGLTWEightEstimator):
             for vertex in self.informative_vertices
         }
 
-    def _optimize_vertex_parent_params(self, vertex: int, optimization_kwargs: Dict = None) -> Tuple[np.ndarray, rv_frozen]:
+    def _optimize_vertex_parent_params(self, vertex: int, optimization_kwargs: Dict = None) -> \
+            Tuple[np.ndarray, rv_frozen]:
         """Optimize parameters for a specific vertex.
 
         Parameters
@@ -173,7 +169,8 @@ class GLTWeightEstimator(BaseGLTWEightEstimator):
         )
         return optimizer_output.x, self.vertex_2_distrib[vertex]
 
-    def _set_informative_vertices_parent_params(self, informative_vertices_params: List[Tuple[np.ndarray, rv_frozen]]) -> None:
+    def _set_informative_vertices_parent_params(self, informative_vertices_params: List[Tuple[np.ndarray, rv_frozen]]) \
+            -> None:
         """Set the optimized parameters for informative vertices.
 
         Parameters
@@ -257,7 +254,8 @@ class GLTGridSearchEstimator(GLTWeightEstimator):
             for vertex_distribs in self.vertex_2_distrib_grid.values()
         ]), "All elements of the grid should be `rv_frozen`."
 
-    def _optimize_vertex_parent_params(self, vertex: int, optimization_kwargs: Dict = None) -> Tuple[np.ndarray, rv_frozen]:
+    def _optimize_vertex_parent_params(self, vertex: int, optimization_kwargs: Dict = None) -> \
+            Tuple[np.ndarray, rv_frozen]:
         """Optimize parameters for a specific vertex using grid search.
 
         Parameters
@@ -292,3 +290,81 @@ class GLTGridSearchEstimator(GLTWeightEstimator):
                 best_nll = nll
 
         return best_weights, best_distrib
+
+
+class GLTWeightDistribEstimator(GLTWeightEstimator):
+    """
+    Estimator of weights and vertex threshold distributions under the GLT diffusion model
+    """
+
+    def __init__(self, graph: Graph,
+                 threshold_support: Tuple[float, float] = (0, np.inf),
+                 n_jobs: int = 1) -> None:
+
+        """Initialize the GLTWeightDistribEstimator.
+
+        Parameters
+        ----------
+        graph : Graph
+            The graph structure.
+        n_jobs : int, optional
+            Number of jobs for parallel processing.
+        """
+        super().__init__(graph=graph, vertex_2_distrib=None, n_jobs=n_jobs)
+        self.threshold_support = threshold_support
+
+    def _construct_vertex_threshold_observed_intervals(self, vertex: int, parent_weights: np.array):
+        intervals = []
+        for mask_tm1, mask_t in zip(self._vertex_2_active_parent_mask_tm1[vertex],
+                                    self._vertex_2_active_parent_mask_t[vertex]):
+            lb = parent_weights[mask_tm1].sum()
+            ub = parent_weights[mask_t].sum()
+            intervals.append((lb, ub))
+
+        for failed_mask in self._failed_vertices_masks[vertex]:
+            lb = parent_weights[failed_mask].sum()
+            intervals.append((lb, np.inf))
+        return intervals
+
+    def _optimize_vertex_parent_params(self, vertex: int,
+                                       max_alternate_iter=2, tol=1e-5,
+                                       verbose=False,
+                                       optimization_kwargs: Dict = None) -> Tuple[np.ndarray, rv_frozen]:
+        """Optimize parameters for a specific vertex by iteratively estimating the weights and vertex threshold CDF.
+
+        Parameters
+        ----------
+        vertex : int
+            The vertex to optimize.
+        max_alternate_iter: int
+            Max number of weight & CDF estimation steps
+        verbose: bool
+            If verbose the NLL after iteration.
+        optimization_kwargs : Dict, optional
+            Additional optimization parameters.
+
+        Returns
+        -------
+        Tuple[np.ndarray, rv_frozen]
+            Weights and vertex threshold empirical CDF.
+        """
+        parent_weights = self.weights_[self.graph.get_parents_mask(vertex)].copy()
+        for iteration in range(max_alternate_iter):
+
+            cdf_fit_intervals = self._construct_vertex_threshold_observed_intervals(vertex, parent_weights)
+            distrib = CensoredCDFEstimator(support=self.threshold_support)
+            self.vertex_2_distrib[vertex] = copy(distrib.fit(intervals=cdf_fit_intervals))
+            optimizer_output = minimize(
+                lambda weights: self._compute_normalized_vertex_nll(weights, vertex=vertex),
+                x0=parent_weights,
+                method='SLSQP',
+                constraints=self._weight_constraints[vertex],
+                options=optimization_kwargs)
+            diff = np.linalg.norm(optimizer_output.x - parent_weights)
+            parent_weights = optimizer_output.x.copy()
+            if verbose:
+                print(f"Alternating Iteration: {iteration}, l2-norm wights diff: {diff}")
+            if diff < tol:
+                break
+
+        return parent_weights, self.vertex_2_distrib[vertex]

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion/influence_models.py

@@ -48,6 +48,7 @@ class InfluenceModel:
         self.vertices = list(self.g.get_vertices())
         self.random_state = random_state
         self.n_jobs = n_jobs
+        self._edge_2_index = {edge: idx for idx, edge in enumerate(g.edges)}
         if check_init:
             self.check_param_init_correctness()
 
@@ -179,7 +180,7 @@ class InfluenceModel:
         self._pre_simulation_init(seed_set, simulation_rvs=simulation_rvs)
         return self._simulate_trace(out_trace_type=out_trace_type)
 
-    def make_simulation(self, seed_set: Set[int], simulation_rvs=None) -> np.ndarray:
+    def make_simulation(self, seed_set: Set[int], simulation_rvs=None) -> Union[Trace, List[Set[int]]]:
         """Run a simulation and return the propagation trace.
 
         Parameters
@@ -219,7 +220,8 @@ class InfluenceModel:
         seed_sets = self._sample_seeds(n_seeds=n_traces, seed_size_range=seed_size_range)
         return self.sample_traces_from_seeds(seed_sets, out_trace_type=out_trace_type)
 
-    def sample_traces_from_seeds(self, seed_sets: List[Set[int]], out_trace_type: bool = True) -> Union[Traces, List[List[Set[int]]]]:
+    def sample_traces_from_seeds(self, seed_sets: List[Set[int]],
+                                 out_trace_type: bool = True) -> Union[Traces, List[List[Set[int]]]]:
         """Sample traces from a list of seed sets.
 
         Parameters
@@ -441,7 +443,7 @@ class LTM(InfluenceModel):
         bool
             True if the adjacent vertex is influenced, otherwise False.
         """
-        self.vertex_2_influence_counter[v_adj] += self.g.get_edge_weight((v, v_adj))
+        self.vertex_2_influence_counter[v_adj] += self.g.get_edge_data(v, v_adj)["weight"]
         return self.vertex_2_threshold[v_adj] <= self.vertex_2_influence_counter[v_adj]
 
     def check_param_init_correctness(self, eps: float = 1e-6) -> None:
@@ -574,7 +576,7 @@ class ICM(InfluenceModel):
         bool
             True if the adjacent vertex is influenced, otherwise False.
         """
-        return self.edge_activations[self.g.get_edge_index((v, v_adj))]
+        return self.edge_activations[self._edge_2_index[(v, v_adj)]]
 
     def _generate_simulation_rvs(self, n_runs: int = 1) -> List:
         """Generate random activations for edges.

influencediffusion-0.0.14/InfluenceDiffusion/plot_utils.py

@@ -0,0 +1,91 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def plot_with_conf_intervals(x_true, x_pred, conf_intervals=None,
+                             fontsize=12, figsize=(10, 8), color="blue", ax=None,
+                             xlab="True activation probability",
+                             ylab="Predicted activation probability"):
+    """
+    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".
+    """
+    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"
+
+    # Sort by x_true so fill_between works correctly
+    sort_idx = np.argsort(x_true)
+    x_true_sorted = x_true[sort_idx]
+    x_pred_sorted = x_pred[sort_idx]
+
+    if ax is None:
+        fig, ax = plt.subplots(figsize=figsize)
+
+    # Scatter plot
+    ax.scatter(x_true_sorted, x_pred_sorted, color=color)
+
+    # Filled confidence intervals
+    if conf_intervals is not None:
+        conf_lower_sorted = conf_intervals[0, sort_idx]
+        conf_upper_sorted = conf_intervals[1, sort_idx]
+        ax.fill_between(x_true_sorted, conf_lower_sorted, conf_upper_sorted,
+                        color=color, alpha=0.2)
+
+    # Diagonal line y=x
+    min_x, max_x = np.min(x_true), np.max(x_true)
+    min_y, max_y = np.min(x_pred), np.max(x_pred)
+    ax.plot([min_x, max_x], [min_y, max_y], linestyle='--', color="black")
+
+    # Labels
+    ax.set_xlabel(xlab, fontsize=fontsize)
+    ax.set_ylabel(ylab, fontsize=fontsize)
+
+
+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
+    """
+    from scipy.stats import norm
+
+    # Plot the histogram
+    plt.hist(sample, bins=n_bins, density=True, alpha=0.6, color='g', edgecolor='black')
+
+    xmin, xmax = plt.xlim()
+    x = np.linspace(xmin, xmax, 100)
+    mean, std = norm.fit(sample)
+
+    # Plot the fitted normal curve
+    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
+    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
+    plt.axvline(true_value, color='black', linestyle='--', linewidth=1.5, label="True value")
+
+    # Add labels and title
+    plt.xlabel('Value')
+    plt.ylabel('Density')
+    plt.legend()

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion/utils.py

@@ -1,5 +1,7 @@
 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]):
@@ -16,7 +18,7 @@ def invert_non_zeros(array):
     return out
 
 
-def random_vector_inside_simplex(dim, ub=1):
+def random_vector_inside_simplex(dim: int, ub: float = 1.):
     U = np.random.uniform(low=0, high=ub, size=dim)
     U_sorted = np.sort(U)
     U_sorted = np.concatenate(([0], U_sorted))
@@ -24,7 +26,18 @@ def random_vector_inside_simplex(dim, ub=1):
     return x
 
 
-def random_vector_on_simplex(dim, ub=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.12 → influencediffusion-0.0.14}/InfluenceDiffusion.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: InfluenceDiffusion
-Version: 0.0.12
+Version: 0.0.14
 Summary: InfluenceDiffusion package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>
@@ -13,18 +13,27 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
+Requires-Dist: numpy<2
 Requires-Dist: scipy
 Requires-Dist: networkx
 Requires-Dist: typing
 Requires-Dist: joblib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 
 # InfluenceDiffusion
 
 InfluenceDiffusion is a Python library that provides instruments for working with influence diffusion models on graphs. In particular, it contains implementations of
-- Popular diffusion models such as Independent Cascade, (General) Linear Threshold, etc. 
-- Methods for estimating parameters of these models
+- Popular diffusion models such as Independent Cascade, (General) Linear Threshold, etc.
+- Methods for estimating parameters of these models and constructing the corresponding confidence intervals.
 
 
 ## Installation
@@ -40,36 +49,43 @@ pip install InfluenceDiffusion
 ```python
 # Imports
 import matplotlib.pyplot as plt
-from networkx import erdos_renyi_graph
+from networkx import connected_watts_strogatz_graph
+from scipy.stats import beta
 
 from InfluenceDiffusion.Graph import Graph # class inheriting from nx.DiGraph
-from InfluenceDiffusion.influence_models import LTM 
-from InfluenceDiffusion.estimation_models.EMEstimation import LTWeightEstimatorEM 
+from InfluenceDiffusion.Inference import GLTInferenceModule
+from InfluenceDiffusion.influence_models import LTM
+from InfluenceDiffusion.estimation_models.OptimEstimation import GLTWeightEstimator
 from InfluenceDiffusion.weight_samplers import make_random_weights_with_indeg_constraint
+from InfluenceDiffusion.plot_utils import plot_with_conf_intervals
 
-# Sample an Erdos-Renyi graph 
-g_nx = erdos_renyi_graph(50, p=0.1, directed=True)
-g = Graph(edge_list=g_nx.edges)
 
-# Set ground-truth LT model edge weights (in-degree of each node is at most 1)
-weights = make_random_weights_with_indeg_constraint(g, indeg_ub=1)
+# Sample a connected Watts-Strogatz graph
+random_state = 1
+g = Graph(connected_watts_strogatz_graph(n=100, k=5, p=0.2, seed=random_state))
+
+# Set ground-truth GLT model edge weights (in-degree of each node is at most 1)
+weights = make_random_weights_with_indeg_constraint(g, indeg_ub=1, random_state=random_state)
 g.set_weights(weights)
 
-# Sample traces from an LT model on this graph
-ltm = LTM(g)
-traces = ltm.sample_traces(1000)
+# Sample traces from the Beta(2, 1)-GLT model on this graph
+threhsold_distrib = beta(2, 1)
+gltm = LTM(g, threshold_generator=threhsold_distrib, random_state=random_state)
+traces = gltm.sample_traces(1000)
 
 # Estimate the weights using the traces
-ltm_estimator = LTWeightEstimatorEM(g)
-pred_weights = ltm_estimator.fit(traces)
+gltm_estimator = GLTWeightEstimator(g, threhsold_distrib)
+pred_weights = gltm_estimator.fit(traces)
+
+# Compute 95% confidence intervals
+glt_inferencer = GLTInferenceModule(gltm_estimator)
+conf_ints = glt_inferencer.compute_all_weight_conf_ints(alpha=0.05)
 
 # Compare with the ground-truth weights
-plt.scatter(weights, pred_weights)
-plt.plot([0, 1], [0, 1], linestyle='--', c='black')
-plt.xlabel("True weights")
-plt.ylabel("Predicted weights")
-plt.show()
+plot_with_conf_intervals(weights, pred_weights, conf_ints,
+                         xlab="True weights", ylab="Predicted weights")
 ```
+![](images/weight_estimation.jpg)
 
 ## License
 

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion.egg-info/SOURCES.txt

@@ -3,9 +3,11 @@ README.md
 setup.cfg
 setup.py
 InfluenceDiffusion/Graph.py
+InfluenceDiffusion/Inference.py
 InfluenceDiffusion/Trace.py
 InfluenceDiffusion/__init__.py
 InfluenceDiffusion/influence_models.py
+InfluenceDiffusion/plot_utils.py
 InfluenceDiffusion/utils.py
 InfluenceDiffusion/weight_samplers.py
 InfluenceDiffusion.egg-info/PKG-INFO
@@ -14,6 +16,7 @@ InfluenceDiffusion.egg-info/dependency_links.txt
 InfluenceDiffusion.egg-info/requires.txt
 InfluenceDiffusion.egg-info/top_level.txt
 InfluenceDiffusion/estimation_models/BaseWeightEstimator.py
+InfluenceDiffusion/estimation_models/CDFEstimation.py
 InfluenceDiffusion/estimation_models/EMEstimation.py
 InfluenceDiffusion/estimation_models/OptimEstimation.py
 InfluenceDiffusion/estimation_models/__init__.py

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/InfluenceDiffusion.egg-info/requires.txt

@@ -1,4 +1,4 @@
-numpy
+numpy<2
 scipy
 networkx
 typing

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: InfluenceDiffusion
-Version: 0.0.12
+Version: 0.0.14
 Summary: InfluenceDiffusion package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>
@@ -13,18 +13,27 @@ Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
+Requires-Dist: numpy<2
 Requires-Dist: scipy
 Requires-Dist: networkx
 Requires-Dist: typing
 Requires-Dist: joblib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 
 # InfluenceDiffusion
 
 InfluenceDiffusion is a Python library that provides instruments for working with influence diffusion models on graphs. In particular, it contains implementations of
-- Popular diffusion models such as Independent Cascade, (General) Linear Threshold, etc. 
-- Methods for estimating parameters of these models
+- Popular diffusion models such as Independent Cascade, (General) Linear Threshold, etc.
+- Methods for estimating parameters of these models and constructing the corresponding confidence intervals.
 
 
 ## Installation
@@ -40,36 +49,43 @@ pip install InfluenceDiffusion
 ```python
 # Imports
 import matplotlib.pyplot as plt
-from networkx import erdos_renyi_graph
+from networkx import connected_watts_strogatz_graph
+from scipy.stats import beta
 
 from InfluenceDiffusion.Graph import Graph # class inheriting from nx.DiGraph
-from InfluenceDiffusion.influence_models import LTM 
-from InfluenceDiffusion.estimation_models.EMEstimation import LTWeightEstimatorEM 
+from InfluenceDiffusion.Inference import GLTInferenceModule
+from InfluenceDiffusion.influence_models import LTM
+from InfluenceDiffusion.estimation_models.OptimEstimation import GLTWeightEstimator
 from InfluenceDiffusion.weight_samplers import make_random_weights_with_indeg_constraint
+from InfluenceDiffusion.plot_utils import plot_with_conf_intervals
 
-# Sample an Erdos-Renyi graph 
-g_nx = erdos_renyi_graph(50, p=0.1, directed=True)
-g = Graph(edge_list=g_nx.edges)
 
-# Set ground-truth LT model edge weights (in-degree of each node is at most 1)
-weights = make_random_weights_with_indeg_constraint(g, indeg_ub=1)
+# Sample a connected Watts-Strogatz graph
+random_state = 1
+g = Graph(connected_watts_strogatz_graph(n=100, k=5, p=0.2, seed=random_state))
+
+# Set ground-truth GLT model edge weights (in-degree of each node is at most 1)
+weights = make_random_weights_with_indeg_constraint(g, indeg_ub=1, random_state=random_state)
 g.set_weights(weights)
 
-# Sample traces from an LT model on this graph
-ltm = LTM(g)
-traces = ltm.sample_traces(1000)
+# Sample traces from the Beta(2, 1)-GLT model on this graph
+threhsold_distrib = beta(2, 1)
+gltm = LTM(g, threshold_generator=threhsold_distrib, random_state=random_state)
+traces = gltm.sample_traces(1000)
 
 # Estimate the weights using the traces
-ltm_estimator = LTWeightEstimatorEM(g)
-pred_weights = ltm_estimator.fit(traces)
+gltm_estimator = GLTWeightEstimator(g, threhsold_distrib)
+pred_weights = gltm_estimator.fit(traces)
+
+# Compute 95% confidence intervals
+glt_inferencer = GLTInferenceModule(gltm_estimator)
+conf_ints = glt_inferencer.compute_all_weight_conf_ints(alpha=0.05)
 
 # Compare with the ground-truth weights
-plt.scatter(weights, pred_weights)
-plt.plot([0, 1], [0, 1], linestyle='--', c='black')
-plt.xlabel("True weights")
-plt.ylabel("Predicted weights")
-plt.show()
+plot_with_conf_intervals(weights, pred_weights, conf_ints,
+                         xlab="True weights", ylab="Predicted weights")
 ```
+![](images/weight_estimation.jpg)
 
 ## License
 

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/README.md

@@ -2,8 +2,8 @@
 # InfluenceDiffusion
 
 InfluenceDiffusion is a Python library that provides instruments for working with influence diffusion models on graphs. In particular, it contains implementations of
-- Popular diffusion models such as Independent Cascade, (General) Linear Threshold, etc. 
-- Methods for estimating parameters of these models
+- Popular diffusion models such as Independent Cascade, (General) Linear Threshold, etc.
+- Methods for estimating parameters of these models and constructing the corresponding confidence intervals.
 
 
 ## Installation
@@ -19,36 +19,43 @@ pip install InfluenceDiffusion
 ```python
 # Imports
 import matplotlib.pyplot as plt
-from networkx import erdos_renyi_graph
+from networkx import connected_watts_strogatz_graph
+from scipy.stats import beta
 
 from InfluenceDiffusion.Graph import Graph # class inheriting from nx.DiGraph
-from InfluenceDiffusion.influence_models import LTM 
-from InfluenceDiffusion.estimation_models.EMEstimation import LTWeightEstimatorEM 
+from InfluenceDiffusion.Inference import GLTInferenceModule
+from InfluenceDiffusion.influence_models import LTM
+from InfluenceDiffusion.estimation_models.OptimEstimation import GLTWeightEstimator
 from InfluenceDiffusion.weight_samplers import make_random_weights_with_indeg_constraint
+from InfluenceDiffusion.plot_utils import plot_with_conf_intervals
 
-# Sample an Erdos-Renyi graph 
-g_nx = erdos_renyi_graph(50, p=0.1, directed=True)
-g = Graph(edge_list=g_nx.edges)
 
-# Set ground-truth LT model edge weights (in-degree of each node is at most 1)
-weights = make_random_weights_with_indeg_constraint(g, indeg_ub=1)
+# Sample a connected Watts-Strogatz graph
+random_state = 1
+g = Graph(connected_watts_strogatz_graph(n=100, k=5, p=0.2, seed=random_state))
+
+# Set ground-truth GLT model edge weights (in-degree of each node is at most 1)
+weights = make_random_weights_with_indeg_constraint(g, indeg_ub=1, random_state=random_state)
 g.set_weights(weights)
 
-# Sample traces from an LT model on this graph
-ltm = LTM(g)
-traces = ltm.sample_traces(1000)
+# Sample traces from the Beta(2, 1)-GLT model on this graph
+threhsold_distrib = beta(2, 1)
+gltm = LTM(g, threshold_generator=threhsold_distrib, random_state=random_state)
+traces = gltm.sample_traces(1000)
 
 # Estimate the weights using the traces
-ltm_estimator = LTWeightEstimatorEM(g)
-pred_weights = ltm_estimator.fit(traces)
+gltm_estimator = GLTWeightEstimator(g, threhsold_distrib)
+pred_weights = gltm_estimator.fit(traces)
+
+# Compute 95% confidence intervals
+glt_inferencer = GLTInferenceModule(gltm_estimator)
+conf_ints = glt_inferencer.compute_all_weight_conf_ints(alpha=0.05)
 
 # Compare with the ground-truth weights
-plt.scatter(weights, pred_weights)
-plt.plot([0, 1], [0, 1], linestyle='--', c='black')
-plt.xlabel("True weights")
-plt.ylabel("Predicted weights")
-plt.show()
+plot_with_conf_intervals(weights, pred_weights, conf_ints,
+                         xlab="True weights", ylab="Predicted weights")
 ```
+![](images/weight_estimation.jpg)
 
 ## License
 

{influencediffusion-0.0.12 → influencediffusion-0.0.14}/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.12'
+VERSION = '0.0.14'
 DESCRIPTION = 'InfluenceDiffusion package'
 
 setup(
@@ -15,7 +15,7 @@ setup(
     long_description_content_type="text/markdown",
     long_description=LONG_DESCRIPTION,
     packages=find_packages(),
-    install_requires=["numpy",
+    install_requires=["numpy<2",
                       "scipy",
                       "networkx",
                       "typing",