Merge pull request #8 from cindeem/graphpart_fixnodes

RF: Fix GraphPartition Class

Change GraphPartition from using node_names to using integers representing nodes since it is used in indexing into adjacency_matrix

Author: cindeem

brainx/modularity.py

@@ -75,9 +75,7 @@ def __init__(self, graph, index):
         ## add quick check to make sure the passed index is
         ## a dict of sets
         self._check_index_contains_sets()
-        ## raise useful error if index is missing nodes in graph
-        self._check_allnodes_in_index(graph)
-        
+       
         # We'll need the graph's adjacency matrix often, so store it once
         self.graph_adj_matrix = nx.adj_matrix(graph)
 
@@ -91,11 +89,16 @@ def __init__(self, graph, index):
         self.num_edges = graph.number_of_edges()
 
         if self.num_edges == 0:
-            raise ValueError("TODO: Cannot create a graph partition of only one node.")
-
-        # Store the nodes as a set, needed for many operations
-        self._node_set = set(graph.nodes())
+            raise ValueError("Cannot create a graph partition "\
+                    "if graph has no edges")
 
+        # Store the nodes as a set of contiguous integers (indices into
+        #the adjacency_matrix), needed for many operations
+        self._node_set = set(range(self.num_nodes))
+        self._node_names = graph.nodes()
+        ## raise useful error if index is missing nodes in graph
+        self._check_allnodes_in_index()
+ 
         # Now, build the edge information used in modularity computations
         self.mod_e, self.mod_a = self._edge_info()
 
@@ -114,16 +117,13 @@ def _check_index_contains_sets(self):
         if not all([ x== type(set()) for x in index_types]):
             raise TypeError('index values should be of type set():: %s'%(index_types))
 
-    def _check_allnodes_in_index(self, graph):
+    def _check_allnodes_in_index(self):
         """Check that index contains all nodes in graph"""
         sets = self.index.values()
-        all = []
-        for item in sets:
-            all += list(item)
-        if not sorted(all) == sorted(graph.nodes()):
-            missing = [x for x in all if not x in graph.nodes()]
-            raise ValueError('index does not contain all nodes: missing %s'%missing)
-
+        indexnodes = set.union(*sets)
+        missing = self._node_set.difference(indexnodes)
+        if missing:
+            raise ValueError('index does not contain all graph nodes: missing %s'%missing)
 
     def _edge_info(self, mod_e=None, mod_a=None, index=None):
         """Create the vectors of edge information.
@@ -508,8 +508,9 @@ def random_mod(self):
         num_mods=len(self)
 
 
-        # Make a random choice bounded between 0 and 1, less than 0.5 means we will split the modules
-        # greater than 0.5 means we will merge the modules.
+        # Make a random choice bounded between 0 and 1, 
+        #   less than 0.5 means we will split the modules
+        #   greater than 0.5 means we will merge the modules.
 
         if num_mods >= self.num_nodes-1: ### CG: why are we subtracting 1 here?
             coin_flip = 1 #always merge if each node is in a separate module
@@ -609,6 +610,15 @@ def store_best(self):
         #Store references to the original graph and label dict
         self.bestindex = copy.deepcopy(self.index)
 
+    def index_as_node_names(self):
+        """ index by default contains references to integers represented the
+        nodes as indexed in the adjacency matrix defined in the original graph. 
+        This will return the index (partition) using the graph node names"""
+        named_part = []
+        for nmod, part in self.index.iteritems():
+            named_part.append( [self._node_names[x] for x in part] )
+        return named_part
+            
     def check_integrity(self, partition):
         """ Raises error if partition structure contains
         empty partitions or Nan values"""

brainx/tests/test_modularity.py

@@ -47,6 +47,26 @@ def betweenness_to_modularity(g,ppart):
 #-----------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------
+def test_graphpartition():
+    """ test GraphPartition correctly handles graph whose
+    nodes are strings"""
+    graph = nx.Graph()
+    graph.add_edge('a','b')
+    graph.add_edge('c','d')
+    index = {0:set([0,1]), 1:set([2,3])}
+    gpart = mod.GraphPartition(graph, index)
+    assert gpart._node_set == set([0,1,2,3])
+
+def test_index_as_node_names():
+    graph = nx.Graph()
+    graph.add_edge('a','b')
+    graph.add_edge('c','d')
+    ## NOTE network x does not store names as added
+    ## for this graph ['a', 'c', 'b', 'd']
+    index = {0:set([0,2]), 1:set([1,3])}
+    gpart = mod.GraphPartition(graph, index)
+    named_index = gpart.index_as_node_names()
+    assert ['a','b'] in named_index
 
 def test_random_modular_graph_between_fraction():
     """Test for graphs with non-zero between_fraction"""
@@ -428,16 +448,20 @@ def test_mutual_information():
                 n1 = set(list(graph_partition3.index[0])[::2])
                 n2 = set(list(graph_partition3.index[0])[1::2])
 
-                split_modules,e_new,a_new,d,t,m,n1,n2 = graph_partition3.compute_module_split(0,n1,n2)
-                graph_partition3.apply_module_split(m,n1,n2,split_modules,e_new,a_new)
-                mi3 = mod.mutual_information(ppart,graph_partition3.index)
+                (split_modules, e_new,
+                 a_new, d, t, m,
+                 n1,n2) = graph_partition3.compute_module_split(0,n1,n2)
+                graph_partition3.apply_module_split(m, n1, n2, 
+                                                    split_modules,
+                                                    e_new, a_new)
+                mi3 = mod.mutual_information(ppart, graph_partition3.index)
                 npt.assert_array_less(mi3,mi_orig)
                 ## NOTE: CORRECTNESS NOT TESTED YET
 
 
 def test_random_mod():
-    """ Test the GraphPartition operation that selects random modules to merge
-    and split
+    """ Test the GraphPartition operation that selects random modules 
+    to merge and split
     XXX not working yet"""
 
     #nnod_mod, av_degrees, nmods
@@ -767,7 +791,8 @@ def test_badindex_graphpartition():
     gp = mod.GraphPartition(g, index)
     nt.assert_true(gp.index == index)
     npt.assert_raises(TypeError, mod.GraphPartition, g, {0: g.nodes()})
-    npt.assert_raises(ValueError, mod.GraphPartition, g, {0:set(g.nodes()[:-1])})
+    npt.assert_raises(ValueError, mod.GraphPartition, g, 
+                      {0:set(g.nodes()[:-1])})
     npt.assert_raises(TypeError, mod.GraphPartition, g, g.nodes())
 
 

brainx/util.py

@@ -27,7 +27,7 @@ def format_matrix(data,s,b,lk,co,idc = [],costlist=[],nouptri = False):
 """
 
     cmat = data[b,s]
-    th = cost2thresh(co,s,b,lk,[],idc,costlist) #get the right threshold
+    th = cost2thresh(co,s,b,lk,idc,costlist) #get the right threshold
 
     #cmat = replace_diag(cmat) #replace diagonals with zero
     cmat = thresholded_arr(cmat,th,fill_val=0)