Merge pull request #3 from fperez/empty-modules

Remove old parametric testing from test suite, add functionality for dealing with empty partitions in modularity.py

Author: cindeem

brainx/modularity.py

@@ -29,12 +29,27 @@
 # Our own modules
 import util
 
+#-----------------------------------------------------------------------------
+# Functions
+#-----------------------------------------------------------------------------
+def empty_module(msg='Empty module'):
+    """Raise an exception if an empty module is found"""
+
+    raise ValueError(msg)
+
+
 #-----------------------------------------------------------------------------
 # Class declarations
 #-----------------------------------------------------------------------------
 
 class GraphPartition(object):
-    """Represent a graph partition."""
+    """Represent a graph partition.
+
+    The main object keeping track of the data is the .index attribute, a dict
+    that maps integer module labels to node sets.  This dict's labels are
+    always assumed to start at 0 and not to point ever to empty modules.  If
+    empty modules are created during any module manipulations, they will be
+    removed from the index and the remaining modules will be relabeled."""
 
     def __init__(self, graph, index):
         """New partition, given a graph and a dict of module->nodes.
@@ -337,20 +352,16 @@ def apply_module_split(self, m, n1, n2, split_modules, e_new, a_new):
         #Otherwise need to create a new function to update/recompute mod_e and
         #mod_a.
 
-        # This checks whether there is an empty module. If so, renames the keys.
-        #if len(self.index[m1])<1:
-        #    self.index.pop(m1)
-        #    rename_keys(self.index,m1)
-        # This checks whether there is an empty module. If so, renames the keys.
-        #if len(self.index[m2])<1:
-        #    self.index.pop(m2)
-        #    rename_keys(self.index,m2)
-
-        # For now, rather than renumbering, just check if this ever happens
+        # If there are empty modules after the operation, remove them from the
+        # index and rename the partition labels
         if len(self.index[m1])<1:
-            raise ValueError('Empty module after module split, old mod')
+            self.index.pop(m1)
+            rename_keys(self.index, m1)
+            return
         if len(self.index[m2])<1:
-            raise ValueError('Empty module after module split, new mod')
+            self.index.pop(m2)
+            rename_keys(self.index, m2)
+            return
 
     def node_update(self, n, m1, m2):
         """Moves a single node within or between modules
@@ -439,6 +450,12 @@ def apply_node_update(self, n, m1, m2, node_moved_mods, e_new, a_new):
           The module that n used to belong to.
         m2 : module identifier
           The module that n will now belong to.
+        node_moved_mods : tuple
+          The two sets of modules for modules m1 and m2.
+        e_new : 2-tuple of arrays
+          The E arrays for m1 and m2
+        a_new : 2-tuple of arrays
+          The A arrays for m1 and m2
 
         Returns
         -------
@@ -450,18 +467,27 @@ def apply_node_update(self, n, m1, m2, node_moved_mods, e_new, a_new):
         self.index[m1] = node_moved_mods[0]
         self.index[m2] = node_moved_mods[1]
 
+        # If we end up with an empty module, we need to remove it from the
+        # partition, and store the information only for the new one.
+
         # This checks whether there is an empty module. If so, renames the keys.
-        if len(self.index[m1])<1:
-            raise ValueError('Empty module after node move')
-            #self.index.pop(m1)
-            #rename_keys(self.index,m1)
+        if len(self.index[m1]) < 1:
+            #empty_module('Empty module after node move')
+            self.index.pop(m1)
+            rename_keys(self.index, m1)
+            # Once the index structure changes, the labeling of E and A arrays
+            # will need to be recomputed (we could propagate the changes
+            # throughout, but it's extremely brittle and easy to make a very
+            # hard to debug error. Safer to just recompute the arrays in this
+            # case).
+            self.mod_e, self.mod_a = self._edge_info()
             #if m1 < m2:
             #    m2 = m2 - 1 #only need to rename this index if m1 is before m2
-
-        self.mod_e[m1] = e_new[0]
-        self.mod_a[m1] = a_new[0]
-        self.mod_e[m2] = e_new[1]
-        self.mod_a[m2] = a_new[1]
+        else:
+            self.mod_e[m1] = e_new[0]
+            self.mod_a[m1] = a_new[0]
+            self.mod_e[m2] = e_new[1]
+            self.mod_a[m2] = a_new[1]
 
         return m2
 
@@ -1005,9 +1031,9 @@ def mutual_information(d1, d2):
     # the entire partitions, we look for this problem at this stage, and bail
     # if there was an empty module.
 ##     if (nsum_row==0).any():
-##         raise ValueError("Empty module in second partition.")
+##         empty_module("Empty module in second partition.")
 ##     if (nsum_col==0).any():
-##         raise ValueError("Empty module in first partition.")
+##         empty_module("Empty module in first partition.")
 
     # nn is the total number of nodes
     nn = nsum_row.sum()
@@ -1136,7 +1162,7 @@ def simulated_annealing(g, p0=None, temperature = 50, temp_scaling = 0.995, tmin
                                             graph_partition.modularity(), 11)
                     for mod in graph_partition.index:
                         if len(graph_partition.index[mod]) < 1:
-                            raise ValueError('Empty module after module %s,SA' % (movetype))
+                            empty_module('Empty module after module %s,SA' % (movetype))
 
 
                 #maybe store the best one here too?
@@ -1206,7 +1232,7 @@ def simulated_annealing(g, p0=None, temperature = 50, temp_scaling = 0.995, tmin
 
                         for mod in graph_partition.index:
                             if len(graph_partition.index[mod]) < 1:
-                                raise ValueError('Empty module after ndoe move,SA')
+                                empty_module('Empty module after ndoe move,SA')
 
 
                 #else:
@@ -1264,7 +1290,7 @@ def simulated_annealing(g, p0=None, temperature = 50, temp_scaling = 0.995, tmin
 
         for mod in graph_part_final.index:
             if len(graph_part_final.index[mod]) < 1:
-                raise ValueError('LAST CHECK: Empty module after module %s,SA' % (movetype))
+                empty_module('LAST CHECK: Empty module after module %s,SA' % (movetype))
 
     if extra_info:
         extra_dict = dict(energy = energy_array, temp = temp_array)
@@ -1416,9 +1442,13 @@ def adjust_partition(g, partition, max_iter=None):
         Partition with higher modularity.
 
     """
+    # Static copy of the entire list of nodes in the graph
     nodes = g.nodes()
+    # Set of module labels in the initial partition
     P = set(range(len(partition)))
 
+    # Create a dict that maps nodes to the partition label they belong to.
+    # This is effectively a reverse of the partition.index.
     node_map = {}
     for p in P:
         for node in partition.index[p]:

brainx/recarrutil.py

@@ -131,7 +131,8 @@ def op(a1, a2, out=None):
 # For methods in the array interface that take an axis argument, the pattern is
 # always the same: extrude, operate, intrude.  So we just auto-generate these
 # functions here.
-binops = [('add',np.add), ('subtract',np.subtract), ('multiply',np.multiply), ('divide',np.divide) ]
+binops = [('add', np.add), ('subtract', np.subtract),
+          ('multiply', np.multiply), ('divide', np.divide) ]
 #binops = [('add',np.add), np.subtract, np.multiply, np.divide ]
 for name, func in binops:
     exec "%s = binop_factory(func)" % name
@@ -176,18 +177,19 @@ def test_reductions():
         ymeth = getattr(y, fname)
         for axis in [None,0,1,-1,-2]:
             zred = reduction(z,axis)
-            yield(nt.assert_equal, zred.x, xmeth(axis))
-            yield(nt.assert_equal, zred.y, ymeth(axis))
+            nt.assert_equal(zred.x, xmeth(axis))
+            nt.assert_equal(zred.y, ymeth(axis))
 
 
 def test_binops():
     x, y, z, w = mk_xyzw()
+    binop_names = [n for (n, op) in binops]
     for fname in binop_names:
         op = eval(fname)
         npop = getattr(np, fname)
         opres = op(z,w)
-        yield(nt.assert_equal, opres.x, npop(z.x, w.x) )
-        yield(nt.assert_equal, opres.y, npop(z.y, w.y) )
+        nt.assert_equal(opres.x, npop(z.x, w.x))
+        nt.assert_equal(opres.y, npop(z.y, w.y))
 
 # Test support utilities