Merge pull request #90 from serralba/master

Support for networkx==2.4

Author: palash1992

gem/embedding/gf.py

@@ -125,7 +125,7 @@ def learn_embedding(self, graph=None, edge_f=None,
                 try:
                     self._X = graph_util.loadEmbedding(embFileName)
                 except FileNotFoundError:
-                    self._X = np.random.randn(graph.number_of_nodes(), self._d)
+                    self._X = np.random.randn(len(graph.nodes), self._d)
                 t2 = time()
                 try:
                     call(["rm", embFileName])
@@ -135,7 +135,7 @@ def learn_embedding(self, graph=None, edge_f=None,
         if not graph:
             graph = graph_util.loadGraphFromEdgeListTxt(edge_f)
         t1 = time()
-        self._node_num = graph.number_of_nodes()
+        self._node_num = len(graph.nodes)
         self._X = 0.01 * np.random.randn(self._node_num, self._d)
         for iter_id in range(self._max_iter):
             if not iter_id % self._print_step:

gem/embedding/hope.py

@@ -61,7 +61,7 @@ def learn_embedding(self, graph=None, edge_f=None,
         # M_g = I - self._beta*A
         # M_l = self._beta*A
         A = nx.to_numpy_matrix(graph)
-        M_g = np.eye(graph.number_of_nodes()) - self._beta * A
+        M_g = np.eye(len(graph.nodes)) - self._beta * A
         M_l = self._beta * A
         S = np.dot(np.linalg.inv(M_g), M_l)
 

gem/embedding/lle.py

@@ -59,7 +59,7 @@ def learn_embedding(self, graph=None, edge_f=None,
         t1 = time()
         A = nx.to_scipy_sparse_matrix(graph)
         normalize(A, norm='l1', axis=1, copy=False)
-        I_n = sp.eye(graph.number_of_nodes())
+        I_n = sp.eye(len(graph.nodes))
         I_min_A = I_n - A
         u, s, vt = lg.svds(I_min_A, k=self._d + 1, which='SM')
         t2 = time()

gem/embedding/sdne.py

@@ -80,7 +80,7 @@ def learn_embedding(self, graph=None, edge_f=None,
         S = nx.to_scipy_sparse_matrix(graph)
         t1 = time()
         S = (S + S.T) / 2
-        self._node_num = graph.number_of_nodes()
+        self._node_num = len(graph.nodes)
 
         # Generate encoder, decoder and autoencoder
         self._num_iter = self._n_iter

gem/evaluation/evaluate_graph_reconstruction.py

@@ -10,7 +10,7 @@ def evaluateStaticGraphReconstruction(digraph, graph_embedding,
                                       X_stat, node_l=None, file_suffix=None,
                                       sample_ratio_e=None, is_undirected=True,
                                       is_weighted=False):
-    node_num = digraph.number_of_nodes()
+    node_num = len(digraph.nodes)
     # evaluation
     if sample_ratio_e:
         eval_edge_pairs = evaluation_util.getRandomEdgePairs(
@@ -54,7 +54,7 @@ def expGR(digraph, graph_embedding,
     print('\tGraph Reconstruction')
     summ_file = open('%s_%s.grsumm' % (res_pre, m_summ), 'w')
     summ_file.write('Method\t%s\n' % metrics.getMetricsHeader())
-    if digraph.number_of_nodes() <= n_sampled_nodes:
+    if len(digraph.nodes) <= n_sampled_nodes:
         rounds = 1
     MAP = [None] * rounds
     prec_curv = [None] * rounds
@@ -67,8 +67,8 @@ def expGR(digraph, graph_embedding,
             digraph,
             n_sampled_nodes=n_sampled_nodes
         )
-        n_nodes[round_id] = sampled_digraph.number_of_nodes()
-        n_edges[round_id] = sampled_digraph.number_of_edges()
+        n_nodes[round_id] = len(sampled_digraph.nodes)
+        n_edges[round_id] = len(sampled_digraph.edges)
         print('\t\tRound: %d, n_nodes: %d, n_edges:%d\n' % (round_id,
                                                             n_nodes[round_id],
                                                             n_edges[round_id]))

gem/evaluation/evaluate_link_prediction.py

@@ -16,7 +16,7 @@ def evaluateStaticLinkPrediction(digraph, graph_embedding,
                                  sample_ratio_e=None,
                                  no_python=False,
                                  is_undirected=True):
-    node_num = digraph.number_of_nodes()
+    node_num = len(digraph.nodes)
     # seperate train and test graph
     train_digraph, test_digraph = evaluation_util.splitDiGraphToTrainTest(
         digraph,
@@ -28,7 +28,7 @@ def evaluateStaticLinkPrediction(digraph, graph_embedding,
             nx.weakly_connected_component_subgraphs(train_digraph),
             key=len
         )
-        tdl_nodes = train_digraph.nodes()
+        tdl_nodes = list(train_digraph.nodes())
         nodeListMap = dict(zip(tdl_nodes, range(len(tdl_nodes))))
         nx.relabel_nodes(train_digraph, nodeListMap, copy=False)
         test_digraph = test_digraph.subgraph(tdl_nodes)
@@ -63,7 +63,7 @@ def evaluateStaticLinkPrediction(digraph, graph_embedding,
         edge_pairs=eval_edge_pairs
     )
     if node_l is None:
-        node_l = list(range(train_digraph.number_of_nodes()))
+        node_l = list(range(len(train_digraph.nodes)))
     filtered_edge_list = [e for e in predicted_edge_list if not train_digraph.has_edge(node_l(e[0]), node_l(e[1]))]
 
     MAP = metrics.computeMAP(filtered_edge_list, test_digraph)

gem/evaluation/metrics.py

@@ -23,7 +23,7 @@ def computePrecisionCurve(predicted_edge_list, true_digraph, max_k=-1):
     return precision_scores, delta_factors
 
 def computeMAP(predicted_edge_list, true_digraph, max_k=-1):
-    node_num = true_digraph.number_of_nodes()
+    node_num = len(true_digraph.nodes)
     node_edges = []
     for i in range(node_num):
         node_edges.append([])

gem/utils/evaluation_util.py

@@ -36,7 +36,7 @@ def getEdgeListFromAdjMtx(adj, threshold=0.0, is_undirected=True, edge_pairs=Non
 def splitDiGraphToTrainTest(di_graph, train_ratio, is_undirected=True):
     train_digraph = di_graph.copy()
     test_digraph = di_graph.copy()
-    node_num = di_graph.number_of_nodes()
+    node_num = len(di_graph.nodes)
     for (st, ed, w) in di_graph.edges_iter(data='weight', default=1):
         if(is_undirected and st >= ed):
             continue

gem/utils/graph_util.py

@@ -9,7 +9,7 @@
 
 
 def transform_DiGraph_to_adj(di_graph):
-    n = di_graph.number_of_nodes()
+    n = len(di_graph.nodes)
     adj = np.zeros((n, n))
     for st, ed, w in di_graph.edges(data='weight', default=1):
         adj[st, ed] = w
@@ -30,19 +30,19 @@ def transform_adj_to_DiGraph(adj):
 
 def get_lcc(di_graph):
     di_graph = max(nx.weakly_connected_component_subgraphs(di_graph), key=len)
-    tdl_nodes = di_graph.nodes()
+    tdl_nodes = list(di_graph.nodes())
     nodeListMap = dict(zip(tdl_nodes, range(len(tdl_nodes))))
     nx.relabel_nodes(di_graph, nodeListMap, copy=False)
     return di_graph, nodeListMap
 
 
 def print_graph_stats(G):
-    print('# of nodes: %d, # of edges: %d' % (G.number_of_nodes(),
-                                              G.number_of_edges()))
+    print('# of nodes: %d, # of edges: %d' % (len(G.nodes),
+                                              len(G.edges)))
 
 
 def sample_graph(di_graph, n_sampled_nodes=None):
-    node_num = di_graph.number_of_nodes()
+    node_num = len(di_graph.nodes)
     if n_sampled_nodes and node_num > n_sampled_nodes:
         node_l = np.random.choice(node_num, n_sampled_nodes, replace=False)
         node_l_inv = {v: k for k, v in enumerate(node_l)}
@@ -57,13 +57,13 @@ def sample_graph(di_graph, n_sampled_nodes=None):
                 continue
         return sampled_graph, node_l
     else:
-        return di_graph, np.arange(di_graph.number_of_nodes())
+        return di_graph, np.arange(len(di_graph.nodes))
 
 
 def randwalk_DiGraph_to_adj(di_graph, node_frac=0.1,
                             n_walks_per_node=5, len_rw=2):
     t0 = time.time()
-    n = di_graph.number_of_nodes()
+    n = len(di_graph.nodes)
     adj = np.zeros((n, n))
     rw_node_num = int(node_frac * n)
     rw_node_list = np.random.choice(n, size=[rw_node_num],
@@ -97,8 +97,8 @@ def randwalk_DiGraph_to_adj(di_graph, node_frac=0.1,
 def addChaos(di_graphs, k):
     anomaly_time_steps = sorted(random.sample(range(len(di_graphs)), k))
     for t in anomaly_time_steps:
-        n = di_graphs[t].number_of_nodes()
-        e = di_graphs[t].number_of_edges()
+        n = len(di_graphs[t].nodes)
+        e = len(di_graphs[t].edges)
         di_graphs[t] = nx.fast_gnp_random_graph(n, e / float(n * (n - 1)),
                                                 seed=None, directed=False)
         di_graphs[t] = di_graphs[t].to_directed()
@@ -108,11 +108,11 @@ def addChaos(di_graphs, k):
 def addNodeAnomalies(di_graphs, p, k):
     anomaly_time_steps = sorted(random.sample(range(len(di_graphs)), k))
     for t in anomaly_time_steps:
-        n_nodes = di_graphs[t].number_of_nodes()
+        n_nodes = len(di_graphs[t].nodes)
         anomalous_nodes_idx = np.random.choice([0, 1],
                                                size=(n_nodes, 1),
                                                p=(1 - p, p))
-        node_list = np.array(di_graphs[t].nodes())
+        node_list = np.array(list(di_graphs[t].nodes()))
         node_list = node_list.reshape((n_nodes, 1))
         anomalous_nodes = np.multiply(anomalous_nodes_idx, node_list)
         anomalous_nodes = anomalous_nodes[anomalous_nodes > 0]
@@ -123,15 +123,15 @@ def addNodeAnomalies(di_graphs, p, k):
         di_graphs[t].add_edges_from(
             itertools.product(range(n_nodes), list(anomalous_nodes))
         )
-        print('Nodes: %d, Edges: %d' % (di_graphs[t].number_of_nodes(),
-                                        di_graphs[t].number_of_edges()))
+        print('Nodes: %d, Edges: %d' % (len(di_graphs[t].nodes),
+                                        len(di_graphs[t].edges)))
     return anomaly_time_steps
 
 
 def saveGraphToEdgeListTxt(graph, file_name):
     with open(file_name, 'w') as f:
-        f.write('%d\n' % graph.number_of_nodes())
-        f.write('%d\n' % graph.number_of_edges())
+        f.write('%d\n' % len(graph.nodes))
+        f.write('%d\n' % len(graph.edges))
         for i, j, w in graph.edges(data='weight', default=1):
             f.write('%d %d %f\n' % (i, j, w))