Merge pull request #9 from cindeem/fix_newman

Fix newman_partion from creating empty partitions

Author: cindeem

brainx/modularity.py

@@ -1270,13 +1270,20 @@ def simulated_annealing(g, p0=None, temperature = 50, temp_scaling = 0.995, tmin
 
 def modularity_matrix(g):
     """Modularity matrix of the graph.
+    
+    Parameters
+    ----------
+    g : NetworkX graph
+        input graph
 
-    The eigenvector corresponding to the largest eigenvalue of the modularity
-    matrix is analyzed to assign clusters.
-
+    Returns
+    -------
+    B : numpy array
+        modularity matrix (graph laplacian)
+    
     """
     A = np.asarray(nx.adjacency_matrix(g))
-    k = np.sum(A, axis=0)
+    k = np.sum(A, axis=0) #vertex degree
     M = np.sum(k) # 2x number of edges
 
     return A - ((k * k[:, None]) / float(M))
@@ -1300,6 +1307,10 @@ def newman_partition(g, max_div=np.inf):
 
     """
     A = np.asarray(nx.adjacency_matrix(g))
+    if not A.sum() == A.astype(bool).sum():
+        raise ValueError('Adjacency matrix is weighted, need binary matrix')
+    ## add line to binarize adj_matrix if not binary
+    ## warning?
     k = np.sum(A, axis=0)
     M = np.sum(A) # 2x number of edges
     B = modularity_matrix(g)
@@ -1312,15 +1323,13 @@ def _divide_partition(p, max_div=np.inf):
         ----------
         p : array of ints
             Node labels.
-        B : ndarray
-            Modularity matrix.
+        max_div : int
+            maximum number of divisions (default np.inf)
 
         Returns
         -------
-        pp, qq : list of ints
-            Partitioning of node labels.  If the partition is indivisible, then
-            only `pp` is returned.
-
+        out : list of ints
+            Partitioning of node labels. 
         """
         p = np.asarray(p)
 
@@ -1329,13 +1338,11 @@ def _divide_partition(p, max_div=np.inf):
 
         # Construct the subgraph modularity matrix
         A_ = A[p, p[:, None]]
-        k_ = np.sum(A_, axis=0)
-        M_ = np.sum(k_)
-
-        B_ = B[p, p[:, None]]
-        B_ = B_ - np.diag(k_ - k[p] * M_ / float(M))
-
-#        w, v = nl.eigh(B_)
+        graph_A_ = nx.from_numpy_matrix(A_, nx.Graph())
+        # make sure partition has edges
+        if graph_A_.number_of_edges() <= 1:
+            return [p]
+        B_ = modularity_matrix(graph_A_)
         w, v = sl.eigh(B_, eigvals=(len(B_) - 2, len(B_) - 1))
 
         # Find the maximum eigenvalue of the modularity matrix
@@ -1349,6 +1356,11 @@ def _divide_partition(p, max_div=np.inf):
         # to nodes in the first partition and 1 for nodes in the second
         v_max = v[:, n]
         mask = (v_max < 0)
+        # if the mask is all True or all False, this will not split the partition
+        # and would create an empty partition
+        # catch by checking max vector contains pos and neg values
+        if np.abs(v_max.sum()) == np.abs(v_max).sum(): 
+            return [p]
         s = np.ones_like(v_max)
         s[mask] = -1
 

brainx/tests/test_modularity.py

@@ -795,6 +795,24 @@ def test_badindex_graphpartition():
                       {0:set(g.nodes()[:-1])})
     npt.assert_raises(TypeError, mod.GraphPartition, g, g.nodes())
 
+def test_newman_partition():
+    """ Test Newman Partition function """
+    tmpmat = np.random.random((10,10))
+    tmpmat[tmpmat < .5] = 0
+    graph = nx.from_numpy_matrix(tmpmat, nx.Graph(weighted = False))
+    npt.assert_raises(ValueError, mod.newman_partition, graph)
+    tmpmat[:] = 0
+    # test that no edges raises error (from GraphPartition)
+    graph = nx.from_numpy_matrix(tmpmat, nx.Graph(weighted = False))
+    npt.assert_raises(ValueError, mod.newman_partition, graph)
+    tmpmat[:] = 1
+    util.fill_diagonal(tmpmat, 0)
+    graph = nx.from_numpy_matrix(tmpmat, nx.Graph(weighted=False))
+    part = mod.newman_partition(graph)
+    ## if all edges are connected expect only one partition
+    expected_part = {0: set([0,1,2,3,4,5,6,7,8,9])}
+    nt.assert_equal(part.index, expected_part)
+
 
 if __name__ == "__main__":
     npt.run_module_suite()