chaged import on weighted_modularity, cleaned up nodal_roles

Author: mb3152

brainx/nodal_roles.py

@@ -4,14 +4,13 @@
 from random import choice
 import networkx as nx
 
-def within_module_degree(graph, partition, weighted = False):
+def within_community_degree(weighted_partition):
     '''
-    Computes the within-module degree for each node (Guimera et al. 2005)
+    Computes the "within-module degree" (z-score) for each node (Guimera et al. 2005)
 
     ------
     Inputs
     ------
-    graph = Networkx Graph, unweighted, undirected.
     partition = dictionary from modularity partition of graph using Louvain method
 
     ------
@@ -20,48 +19,33 @@ def within_module_degree(graph, partition, weighted = False):
     Dictionary of the within-module degree of each node.
 
     '''
-    new_part = {}
-    for m,n in zip(partition.values(),partition.keys()):
-        try:
-            new_part[m].append(n)
-        except KeyError:
-            new_part[m] = [n]
-    partition = new_part
-    wd_dict = {}
-
-    #loop through each module, look at nodes in modules
-    for m in partition.keys():
-        mod_list = partition[m]
-        mod_wd_dict = {}
-        #get within module degree of each node
-        for source in mod_list:
-            count = 0
-            for target in mod_list:
-                if (source,target) in graph.edges() or (target,source) in graph.edges():
-                    if weighted == True:
-                        count += graph.get_edge_data(source,target)['weight']
-                        count += graph.get_edge_data(target,source)['weight'] # i assume this will only get one weighted edge.
-                    else:
-                        count += 1
-            mod_wd_dict[source] = count
+    all_community_degrees = {}
+    wc_dict = {}
+    for node in weighted_partition.graph:
+        node_community = weighted_partition.get_node_community(node)
+        within_community_degree = weighted_partition.degree_within_community(node)
+        try: # to load average within module degree of community
+            all_community_degree = all_community_degrees[node_community]
+        except: # collect within module degree of community
+            all_community_degree = []
+            for node in node_community:
+                partition.degree_within_community(node)
+                all_community_degree.append()
+            all_community_degrees[node_community] = all_community_degree
+        std = np.std(all_community_degree) # std of community's degrees
+        mean = np.mean(all_community_degree) # mean of community's degrees
         # z-score
-        all_mod_wd = mod_wd_dict.values()
-        avg_mod_wd = float(sum(all_mod_wd) / len(all_mod_wd))
-        std = np.std(all_mod_wd)
-        #add to dictionary
-        for source in mod_list:
-            wd_dict[source] = (mod_wd_dict[source] - avg_mod_wd) / std
-    return wd_dict
+        wc_dict[node] = (within_community_degree - mean / std)
+    return wc_dict
 
 
-def participation_coefficient(graph, partition, weighted = False):
+def participation_coefficient(weighted_partition, catch_edgeless_node=True):
     '''
     Computes the participation coefficient for each node (Guimera et al. 2005).
 
     ------
     Inputs
     ------
-    graph = Networkx graph
     partition = modularity partition of graph
 
     ------
@@ -70,61 +54,22 @@ def participation_coefficient(graph, partition, weighted = False):
     Dictionary of the participation coefficient for each node.
 
     '''
-    #this is because the dictionary output of Louvain is "backwards"
-    new_part = {}
-    for m,n in zip(partition.values(),partition.keys()):
-        try:
-            new_part[m].append(n)
-        except KeyError:
-            new_part[m] = [n]
-    partition = new_part
     pc_dict = {}
-    all_nodes = set(graph.nodes())
-    # loop through modules
-    if weighted == False:
-        for m in partition.keys():
-            #set of nodes in modules
-            mod_list = set(partition[m])
-            #set of nodes outside that module
-            between_mod_list = list(set.difference(all_nodes, mod_list))
-            for source in mod_list:
-                #degree of node
-                degree = float(nx.degree(G=graph, nbunch=source))
-                count = 0
-                # between module degree
-                for target in between_mod_list:
-                    if (source,target) in graph.edges() or(source,target) in graph.edges():
-                        count += 1
-                bm_degree = float(count)
-                if bm_degree == 0.0:
-                    pc = 0.0
-                else:
-                    pc = 1 - ((float(bm_degree) / float(degree))**2)
-                pc_dict[source] = pc
-        return pc_dict
-        #this is because the dictionary output of Louvain is "backwards"
-    if weighted == True:
-        for m in partition.keys():
-            #set of nodes in modules
-            mod_list = set(partition[m])
-            #set of nodes outside that module
-            between_mod_list = list(set.difference(all_nodes, mod_list))
-            for source in mod_list:
-                #degree of node
-                degree = 0
-                edges = G.edges([source],data=True)
-                for edge in edges:
-                    degree += graph.get_edge_data(edge[0],edge[1])['weight']
-                count = 0
-                # between module degree
-                for target in between_mod_list:
-                    if (source,target) in graph.edges() or(source,target) in graph.edges():
-                        count += graph.get_edge_data(source,target)['weight']
-                        count += graph.get_edge_data(target,source)['weight'] # i assume this will only get one weighted edge.
-                bm_degree = float(count)
-                if bm_degree == 0.0:
-                    pc = 0.0
-                else:
-                    pc = 1 - ((float(bm_degree) / float(degree))**2)
-                pc_dict[source] = pc
-        return pc_dict
+    graph = weighted_partition.graph
+    for node in graph:
+        node_degree = weighted_partition.node_degree(node)
+        if node_degree == 0.0: 
+            if catch_edgeless_node:
+                raise ValueError("Node {} is edgeless".format(node))
+            pc_dict[node] = 0.0
+            continue    
+        deg_per_comm = weighted_partition.node_degree_by_community(node)
+        node_comm = weighted_partition.get_node_community(node)
+        deg_per_comm.pop(node_comm) 
+        bc_degree = sum(deg_per_comm) #between community degree
+        if bc_degree == 0.0:
+            pc_dict[node] = 0.0
+            continue
+        pc = 1 - ((float(bc_degree) / float(node_degree))**2)
+        pc_dict[node] = pc
+    return pc_dict