Rename G graph, iterate through sorted dicts of node metrics.

Author: dabliss

brainx/metrics.py

@@ -13,8 +13,8 @@
 # Functions
 #-----------------------------------------------------------------------------
 
-def inter_node_distances(G, n_nodes):
-    """Compute the shortest path lengths between all nodes in G.
+def inter_node_distances(graph):
+    """Compute the shortest path lengths between all nodes in graph.
 
     This performs the same operation as NetworkX's
     all_pairs_shortest_path_lengths with two exceptions: Here, self
@@ -25,24 +25,17 @@ def inter_node_distances(G, n_nodes):
 
     Parameters
     ----------
-    G: networkx Graph
+    graph: networkx Graph
         An undirected graph.
 
-    n_nodes: integer
-        Number of nodes in G.
-
     Returns
     -------
     lengths: dictionary
         Dictionary of shortest path lengths keyed by source and target.
 
-    Notes
-    -----
-    This function assumes the nodes are labeled 0 to n_nodes - 1.
-
     """
-    lengths = nx.all_pairs_shortest_path_length(G)
-    node_labels = range(n_nodes)
+    lengths = nx.all_pairs_shortest_path_length(graph)
+    node_labels = sorted(lengths)
     for src in node_labels:
         lengths[src].pop(src)
         for targ in node_labels:
@@ -66,17 +59,14 @@ def compute_sigma(arr,clustarr,lparr):
     return out
 
 
-def nodal_pathlengths(G, n_nodes):
+def nodal_pathlengths(graph):
     """Compute mean path length for each node.
 
     Parameters
     ----------
-    G: networkx Graph
+    graph: networkx Graph
         An undirected graph.
 
-    n_nodes: integer
-        Number of nodes in G.
-
     Returns
     -------
     nodal_means: numpy array
@@ -85,28 +75,24 @@ def nodal_pathlengths(G, n_nodes):
 
     Notes
     -----
-    This function assumes the nodes are labeled 0 to n_nodes - 1.
-
     Per the Brain Connectivity Toolbox for Matlab, the distance between
     one node and another that cannot be reached from it is set to
     infinity.
 
     """
-    lengths = inter_node_distances(G, n_nodes)
-    # It's important we iterate through range(n_nodes) rather than the keys
-    # of lengths, as the keys are not guaranteed to be in ascending order.
-    nodal_means = [np.mean(lengths[src].values()) for src in range(n_nodes)]
+    lengths = inter_node_distances(graph)
+    nodal_means = [np.mean(lengths[src].values()) for src in sorted(lengths)]
     return np.array(nodal_means)
 
 
-def assert_no_selfloops(G):
-    """Raise an error if the graph G has any selfloops.
+def assert_no_selfloops(graph):
+    """Raise an error if the graph graph has any selfloops.
     """
-    if G.nodes_with_selfloops():
+    if graph.nodes_with_selfloops():
         raise ValueError("input graph can not have selfloops")
 
 
-def path_lengths(G):
+def path_lengths(graph):
     """Compute array of all shortest path lengths for the given graph.
 
     The length of the output array is the number of unique pairs of nodes that
@@ -118,12 +104,12 @@ def path_lengths(G):
     
     Parameters
     ----------
-    G : an undirected graph object.
+    graph : an undirected graph object.
     """
 
-    assert_no_selfloops(G)
+    assert_no_selfloops(graph)
 
-    length = nx.all_pairs_shortest_path_length(G)
+    length = nx.all_pairs_shortest_path_length(graph)
     paths = []
     seen = set()
     for src,targets in length.iteritems():
@@ -136,7 +122,7 @@ def path_lengths(G):
 
 
 #@profile
-def path_lengthsSPARSE(G):
+def path_lengthsSPARSE(graph):
     """Compute array of all shortest path lengths for the given graph.
 
     XXX - implementation using scipy.sparse.  This might be faster for very
@@ -153,14 +139,14 @@ def path_lengthsSPARSE(G):
     
     Parameters
     ----------
-    G : an undirected graph object.
+    graph : an undirected graph object.
     """
 
-    assert_no_selfloops(G)
+    assert_no_selfloops(graph)
 
-    length = nx.all_pairs_shortest_path_length(G)
+    length = nx.all_pairs_shortest_path_length(graph)
 
-    nnod = G.number_of_nodes()
+    nnod = graph.number_of_nodes()
     paths_mat = sparse.dok_matrix((nnod,nnod))
 
     for src,targets in length.iteritems():
@@ -170,66 +156,59 @@ def path_lengthsSPARSE(G):
     return sparse.triu(paths_mat,1).data
 
 
-def glob_efficiency(G):
+def glob_efficiency(graph):
     """Compute array of global efficiency for the given graph.
 
     Global efficiency: returns a list of the inverse path length matrix
     across all nodes The mean of this value is equal to the global efficiency
     of the network."""
 
-    return 1.0/path_lengths(G)
+    return 1.0/path_lengths(graph)
 
 
-def nodal_efficiency(G, n_nodes):
-    """Return array with nodal efficiency for each node in G.
+def nodal_efficiency(graph):
+    """Return array with nodal efficiency for each node in graph.
 
     See Achard and Bullmore (2007, PLoS Comput Biol) for the definition
     of nodal efficiency.
 
     Parameters
     ----------
-    G: networkx Graph
+    graph: networkx Graph
         An undirected graph.
 
-    n_nodes: integer
-        Number of nodes in G.
-
     Returns
     -------
     nodal_efficiencies: numpy array
-        An array with the nodal efficiency for each node in G, in
+        An array with the nodal efficiency for each node in graph, in
         the order specified by node_labels.  The array is in ascending
         order of node labels.
 
     Notes
     -----
-    This function assumes the nodes are labeled 0 to n_nodes - 1.
-
     Per the Brain Connectivity Toolbox for Matlab, the distance between
     one node and another that cannot be reached from it is set to
     infinity.
 
     """
-    nodal_efficiencies = np.zeros(n_nodes, dtype=float)
-    lengths = inter_node_distances(G, n_nodes)
-    # It's important we iterate through range(n_nodes) rather than the keys
-    # of lengths, as the keys are not guaranteed to be in ascending order.
-    for src in range(n_nodes):
+    lengths = inter_node_distances(graph)
+    nodal_efficiencies = np.zeros(len(lengths), dtype=float)
+    for src in sorted(lengths):
         inverse_paths = [1.0 / val for val in lengths[src].itervalues()]
         nodal_efficiencies[src] = np.mean(inverse_paths)
     return nodal_efficiencies
 
 
-def local_efficiency(G):
+def local_efficiency(graph):
     """Compute array of global efficiency for the given grap.h
 
     Local efficiency: returns a list of paths that represent the nodal
     efficiencies across all nodes with their direct neighbors"""
 
     nodepaths=[]
-    length=nx.all_pairs_shortest_path_length(G)
-    for n in G.nodes():
-        nneighb= nx.neighbors(G,n)
+    length=nx.all_pairs_shortest_path_length(graph)
+    for n in graph.nodes():
+        nneighb= nx.neighbors(graph,n)
 
         paths=[]
         for src,targets in length.iteritems():
@@ -251,18 +230,18 @@ def local_efficiency(G):
     return np.array(nodepaths)
 
 
-def local_efficiency(G):
+def local_efficiency(graph):
     """Compute array of local efficiency for the given graph.
 
     Local efficiency: returns a list of paths that represent the nodal
     efficiencies across all nodes with their direct neighbors"""
 
-    assert_no_selfloops(G)
+    assert_no_selfloops(graph)
 
     nodepaths = []
-    length = nx.all_pairs_shortest_path_length(G)
-    for n in G:
-        nneighb = set(nx.neighbors(G,n))
+    length = nx.all_pairs_shortest_path_length(graph)
+    for n in graph:
+        nneighb = set(nx.neighbors(graph,n))
 
         paths = []
         for nei in nneighb:
@@ -279,20 +258,20 @@ def local_efficiency(G):
     return np.array(nodepaths)
 
 
-def dynamical_importance(G):
-    """Compute dynamical importance for G.
+def dynamical_importance(graph):
+    """Compute dynamical importance for graph.
 
     Ref: Restrepo, Ott, Hunt. Phys. Rev. Lett. 97, 094102 (2006)
     """
     # spectrum of the original graph
-    eigvals = nx.adjacency_spectrum(G)
+    eigvals = nx.adjacency_spectrum(graph)
     lambda0 = eigvals[0]
-    # Now, loop over all nodes in G, and for each, make a copy of G, remove
+    # Now, loop over all nodes in graph, and for each, make a copy of graph, remove
     # that node, and compute the change in lambda.
-    nnod = G.number_of_nodes()
+    nnod = graph.number_of_nodes()
     dyimp = np.empty(nnod,float)
     for n in range(nnod):
-        gn = G.copy()
+        gn = graph.copy()
         gn.remove_node(n)
         lambda_n = nx.adjacency_spectrum(gn)[0]
         dyimp[n] = lambda0 - lambda_n
@@ -301,22 +280,22 @@ def dynamical_importance(G):
     return dyimp
 
 
-def weighted_degree(G):
+def weighted_degree(graph):
     """Return an array of degrees that takes weights into account.
 
     For unweighted graphs, this is the same as the normal degree() method
     (though we return an array instead of a list).
     """
-    amat = nx.adj_matrix(G).A  # get a normal array out of it
+    amat = nx.adj_matrix(graph).A  # get a normal array out of it
     return abs(amat).sum(0)  # weights are sums across rows
 
 
-def graph_summary(G):
+def graph_summary(graph):
     """Compute a set of statistics summarizing the structure of a graph.
     
     Parameters
     ----------
-    G : a graph object.
+    graph : a graph object.
 
     threshold : float, optional
 
@@ -326,26 +305,23 @@ def graph_summary(G):
     """
 
     # Average path length
-    lp = path_lengths(G)
-    clust = np.array(nx.clustering(G).values())
-    glob_eff = glob_efficiency(G)
-    loc_eff = local_efficiency(G)
+    lp = path_lengths(graph)
+    clust = np.array(nx.clustering(graph).values())
+    glob_eff = glob_efficiency(graph)
+    loc_eff = local_efficiency(graph)
 
     return dict( lp=lp.mean(), clust=clust.mean(), glob_eff=glob_eff.mean(),
                  loc_eff=loc_eff.mean() )
 
 
-def nodal_summaryOut(G, n_nodes):
+def nodal_summaryOut(graph):
     """Compute statistics for individual nodes.
 
     Parameters
     ----------
-    G: networkx graph
+    graph: networkx graph
         An undirected graph.
         
-    n_nodes: integer
-        Number of nodes in G.
-
     Returns
     -------
     dictionary
@@ -357,22 +333,16 @@ def nodal_summaryOut(G, n_nodes):
         ascending order of node labels.
 
     """
-    lp = nodal_pathlengths(G, n_nodes)
-    # As stated in the Python documentation, "Keys and values are listed in an
-    # arbitrary order which is non-random, varies across Python
-    # implementations, and depends on the dictionary's history of insertions
-    # and deletions."  Thus, we cannot expect, e.g., nx.clustering(G)
-    # to have the nodes listed in ascending order, as we desire.
-    node_labels = range(n_nodes)
-    clust_dict = nx.clustering(G)
-    clust = np.array([clust_dict[n] for n in node_labels])
-    b_cen_dict = nx.betweenness_centrality(G)
-    b_cen = np.array([b_cen_dict[n] for n in node_labels])
-    c_cen_dict = nx.closeness_centrality(G)
-    c_cen = np.array([c_cen_dict[n] for n in node_labels])
-    nod_eff = nodal_efficiency(G, n_nodes)
-    loc_eff = local_efficiency(G)
-    deg_dict = G.degree()
-    deg = [deg_dict[n] for n in node_labels]
+    lp = nodal_pathlengths(graph)
+    clust_dict = nx.clustering(graph)
+    clust = np.array([clust_dict[n] for n in sorted(clust_dict)])
+    b_cen_dict = nx.betweenness_centrality(graph)
+    b_cen = np.array([b_cen_dict[n] for n in sorted(b_cen_dict)])
+    c_cen_dict = nx.closeness_centrality(graph)
+    c_cen = np.array([c_cen_dict[n] for n in sorted(c_cen_dict)])
+    nod_eff = nodal_efficiency(graph)
+    loc_eff = local_efficiency(graph)
+    deg_dict = graph.degree()
+    deg = [deg_dict[n] for n in sorted(deg_dict)]
     return dict(lp=lp, clust=clust, b_cen=b_cen, c_cen=c_cen, nod_eff=nod_eff,
                 loc_eff=loc_eff, deg=deg)