InfluenceDiffusion 0.0.11__tar.gz → 0.0.13__tar.gz

{influencediffusion-0.0.11 → influencediffusion-0.0.13}/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.11 → influencediffusion-0.0.13}/InfluenceDiffusion/estimation_models/BaseWeightEstimator.py

@@ -2,7 +2,6 @@ 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
@@ -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:

{influencediffusion-0.0.11 → influencediffusion-0.0.13}/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.13/InfluenceDiffusion.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: InfluenceDiffusion
+Version: 0.0.13
+Summary: InfluenceDiffusion package
+Author: Alexander Kagan
+Author-email: <amkagan@umich.edu>
+Keywords: python,Influence Maximization,Network diffusion models,General Linear Threshold model,Social Networks,Independent Cascade model
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: networkx
+Requires-Dist: typing
+Requires-Dist: joblib
+
+
+# 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
+
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install InfluenceDiffusion.
+
+```bash
+pip install InfluenceDiffusion
+```
+
+## Usage
+
+```python
+# Imports
+import matplotlib.pyplot as plt
+from networkx import erdos_renyi_graph
+
+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.weight_samplers import make_random_weights_with_indeg_constraint
+
+# 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)
+g.set_weights(weights)
+
+# Sample traces from an LT model on this graph
+ltm = LTM(g)
+traces = ltm.sample_traces(1000)
+
+# Estimate the weights using the traces
+ltm_estimator = LTWeightEstimatorEM(g)
+pred_weights = ltm_estimator.fit(traces)
+
+# 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()
+```
+
+## License
+
+MIT License
+
+Copyright (c) 2024 Alexander Kagan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

influencediffusion-0.0.13/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: InfluenceDiffusion
+Version: 0.0.13
+Summary: InfluenceDiffusion package
+Author: Alexander Kagan
+Author-email: <amkagan@umich.edu>
+Keywords: python,Influence Maximization,Network diffusion models,General Linear Threshold model,Social Networks,Independent Cascade model
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: networkx
+Requires-Dist: typing
+Requires-Dist: joblib
+
+
+# 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
+
+
+## Installation
+
+Use the package manager [pip](https://pip.pypa.io/en/stable/) to install InfluenceDiffusion.
+
+```bash
+pip install InfluenceDiffusion
+```
+
+## Usage
+
+```python
+# Imports
+import matplotlib.pyplot as plt
+from networkx import erdos_renyi_graph
+
+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.weight_samplers import make_random_weights_with_indeg_constraint
+
+# 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)
+g.set_weights(weights)
+
+# Sample traces from an LT model on this graph
+ltm = LTM(g)
+traces = ltm.sample_traces(1000)
+
+# Estimate the weights using the traces
+ltm_estimator = LTWeightEstimatorEM(g)
+pred_weights = ltm_estimator.fit(traces)
+
+# 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()
+```
+
+## License
+
+MIT License
+
+Copyright (c) 2024 Alexander Kagan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{influencediffusion-0.0.11 → influencediffusion-0.0.13}/setup.py

@@ -1,8 +1,10 @@
 from setuptools import setup, find_packages
+from pathlib import Path
+this_directory = Path(__file__).parent
+LONG_DESCRIPTION = (this_directory / "README.md").read_text()
 
-VERSION = '0.0.11'
+VERSION = '0.0.13'
 DESCRIPTION = 'InfluenceDiffusion package'
-LONG_DESCRIPTION = 'In this package, we implement popular network diffusion models and methods for their estimation.'
 
 setup(
     name="InfluenceDiffusion",

influencediffusion-0.0.11/InfluenceDiffusion.egg-info/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.1
-Name: InfluenceDiffusion
-Version: 0.0.11
-Summary: InfluenceDiffusion package
-Author: Alexander Kagan
-Author-email: <amkagan@umich.edu>
-Keywords: python,Influence Maximization,Network diffusion models,General Linear Threshold model,Social Networks,Independent Cascade model
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Education
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Microsoft :: Windows
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: networkx
-Requires-Dist: typing
-Requires-Dist: joblib
-
-In this package, we implement popular network diffusion models and methods for their estimation.

influencediffusion-0.0.11/PKG-INFO

@@ -1,22 +0,0 @@
-Metadata-Version: 2.1
-Name: InfluenceDiffusion
-Version: 0.0.11
-Summary: InfluenceDiffusion package
-Author: Alexander Kagan
-Author-email: <amkagan@umich.edu>
-Keywords: python,Influence Maximization,Network diffusion models,General Linear Threshold model,Social Networks,Independent Cascade model
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Education
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Microsoft :: Windows
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: scipy
-Requires-Dist: networkx
-Requires-Dist: typing
-Requires-Dist: joblib
-
-In this package, we implement popular network diffusion models and methods for their estimation.