InfluenceDiffusion 0.0.12__tar.gz → 0.0.13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: InfluenceDiffusion
-Version: 0.0.12
+Version: 0.0.13
 Summary: InfluenceDiffusion package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: InfluenceDiffusion
-Version: 0.0.12
+Version: 0.0.13
 Summary: InfluenceDiffusion package
 Author: Alexander Kagan
 Author-email: <amkagan@umich.edu>

{influencediffusion-0.0.12 → influencediffusion-0.0.13}/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.13'
 DESCRIPTION = 'InfluenceDiffusion package'
 
 setup(