Write inter_node_distances w/ test, update nodal metric functions.

Author: dabliss

brainx/metrics.py

@@ -12,6 +12,48 @@
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
+
+def inter_node_distances(G, n_nodes):
+    """Compute the shortest path lengths between all nodes in G.
+
+    This performs the same operation as NetworkX's
+    all_pairs_shortest_path_lengths with two exceptions: Here, self
+    paths are excluded from the dictionary returned, and the distance
+    between disconnected nodes is set to infinity.  The latter
+    difference is consistent with the Brain Connectivity Toolbox for
+    Matlab.
+
+    Parameters
+    ----------
+    G: 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)
+    for src in node_labels:
+        lengths[src].pop(src)
+        for targ in node_labels:
+            if src != targ:
+                try:
+                    lengths[src][targ]
+                except KeyError:
+                    lengths[src][targ] = np.inf
+    return lengths
+
+
 def compute_sigma(arr,clustarr,lparr):
     """ Function for computing sigma given a graph array arr and clust and lp
     arrays from a pseudorandom graph for a particular block b."""
@@ -50,27 +92,11 @@ def nodal_pathlengths(G, n_nodes):
     infinity.
 
     """
-    # float is the default dtype for np.zeros, but we'll choose it explicitly
-    # in case numpy ever changes the default to something else.
-    nodal_means = np.zeros(n_nodes, dtype=float)
-    lengths = nx.all_pairs_shortest_path_length(G)
-    # 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 assume we'd traverse the nodes in
-    # ascending order if we were to iterate through 'lengths'.
-    node_labels = range(n_nodes)
-    for src in node_labels:
-        source_lengths = []
-        for targ in node_labels:
-            if src != targ:
-                try:
-                    val = lengths[src][targ]
-                except KeyError:
-                    val = np.inf
-                source_lengths.append(val)
-        nodal_means[src] = np.mean(source_lengths)
-    return nodal_means
+    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)]
+    return np.array(nodal_means)
 
 
 def assert_no_selfloops(G):
@@ -185,17 +211,11 @@ def nodal_efficiency(G, n_nodes):
 
     """
     nodal_efficiencies = np.zeros(n_nodes, dtype=float)
-    lengths = nx.all_pairs_shortest_path_length(G)
-    node_labels = range(n_nodes)
-    for src in node_labels:
-        inverse_paths = []
-        for targ in node_labels:
-            if src != targ:
-                try:
-                    val = lengths[src][targ]
-                except KeyError:
-                    val = np.inf
-                inverse_paths.append(1.0 / val)
+    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):
+        inverse_paths = [1.0 / val for val in lengths[src].itervalues()]
         nodal_efficiencies[src] = np.mean(inverse_paths)
     return nodal_efficiencies
 
@@ -231,7 +251,6 @@ def local_efficiency(G):
     return np.array(nodepaths)
 
 
-#@profile
 def local_efficiency(G):
     """Compute array of local efficiency for the given graph.
 

brainx/tests/test_metrics.py

@@ -22,6 +22,11 @@
 class NodalMetricsTestCase(TestCase):
 
     def setUp(self):
+        # Distances for all node pairs:
+        # 0-1: 1    1-2: 1    2-3: 1    3-4: 1
+        # 0-2: 1    1-3: 2    2-4: 2
+        # 0-3: 2    1-4: 3
+        # 0-4: 3
         self.corr_mat = np.array([[0.0, 0.0, 0.0, 0.0, 0.0],
                                   [0.5, 0.0, 0.0, 0.0, 0.0],
                                   [0.3, 0.4, 0.0, 0.0, 0.0],
@@ -30,19 +35,40 @@ def setUp(self):
         self.n_nodes = self.corr_mat.shape[0]
         self.g = nx.from_numpy_matrix(self.corr_mat)
 
-    def test_nodal_pathlengths_conn(self):
-        path_lengths = metrics.nodal_pathlengths(self.g, self.n_nodes)
+    def test_inter_node_distances_conn(self):
+        distances = metrics.inter_node_distances(self.g, self.n_nodes)
+        desired = {0: {1: 1, 2: 1, 3: 2, 4: 3},
+                   1: {0: 1, 2: 1, 3: 2, 4: 3},
+                   2: {0: 1, 1: 1, 3: 1, 4: 2},
+                   3: {0: 2, 1: 2, 2: 1, 4: 1},
+                   4: {0: 3, 1: 3, 2: 2, 3: 1}}
+        self.assertEqual(distances, desired)
+
+    def test_inter_node_distances_disconn(self):
+        self.g.remove_edge(2, 3)
+        # Now all nodes still have at least one edge, but not all nodes are
+        # reachable from all others.
+        distances = metrics.inter_node_distances(self.g, self.n_nodes)
         # Distances for all node pairs:
-        # 0-1: 1    1-2: 1    2-3: 1    3-4: 1
-        # 0-2: 1    1-3: 2    2-4: 2
-        # 0-3: 2    1-4: 3
-        # 0-4: 3
+        # 0-1: 1    1-2: 1    2-3: Inf  3-4: 1
+        # 0-2: 1    1-3: Inf  2-4: Inf
+        # 0-3: Inf  1-4: Inf
+        # 0-4: Inf
+        desired = {0: {1: 1, 2: 1, 3: np.inf, 4: np.inf},
+                   1: {0: 1, 2: 1, 3: np.inf, 4: np.inf},
+                   2: {0: 1, 1: 1, 3: np.inf, 4: np.inf},
+                   3: {0: np.inf, 1: np.inf, 2: np.inf, 4: 1},
+                   4: {0: np.inf, 1: np.inf, 2: np.inf, 3: 1}}
+        self.assertEqual(distances, desired)
+
+    def test_nodal_pathlengths_conn(self):
+        mean_path_lengths = metrics.nodal_pathlengths(self.g, self.n_nodes)
         desired = 1.0 / (self.n_nodes - 1) * np.array([1 + 1 + 2 + 3,
                                                        1 + 1 + 2 + 3,
                                                        1 + 1 + 1 + 2,
                                                        2 + 2 + 1 + 1,
                                                        3 + 3 + 2 + 1])
-        npt.assert_array_almost_equal(path_lengths, desired)
+        npt.assert_array_almost_equal(mean_path_lengths, desired)
 
     def test_nodal_pathlengths_disconn(self):
         self.g.remove_edge(2, 3)
@@ -64,11 +90,6 @@ def test_nodal_pathlengths_disconn(self):
 
     def test_nodal_efficiency_conn(self):
         n_eff_array = metrics.nodal_efficiency(self.g, self.n_nodes)
-        # Distances for all node pairs:
-        # 0-1: 1    1-2: 1    2-3: 1    3-4: 1
-        # 0-2: 1    1-3: 2    2-4: 2
-        # 0-3: 2    1-4: 3
-        # 0-4: 3
         desired = (1.0 / (self.n_nodes - 1) *
                    np.array([1 + 1 + 1 / 2.0 + 1 / 3.0,
                              1 + 1 + 1 / 2.0 + 1 / 3.0,