def run(self, data, seed=None): if data.is_directed(): raise UnsupportedException("only undirected graph is supported") if seed is not None: self.logger.info("seed ignored") UGraph = convert.to_snap(data) CmtyV = snap.TCnComV() timecost, modularity = utils.timeit( lambda: snap.CommunityCNM(UGraph, CmtyV)) clusters = {} i = 0 for Cmty in CmtyV: clusters[i] = [] for NI in Cmty: clusters[i].append(NI) i += 1 self.logger.info( "Made %d clusters in %f seconds. modularity of the graph is %f" % (len(clusters), timecost, modularity)) result = {} result['timecost'] = timecost result['runname'] = self.name result['dataname'] = data.name result['meta'] = self.get_meta() result['modularity'] = modularity result['clusters'] = clusters save_result(result) self.result = result return self
def analizzaClausetNewmanMoore(pfPaj, pfAINN, pfMod): # prende un grafo in formato Pajek # restituisce le comunita come ID Nome Comunita g = snap.LoadPajek(snap.PUNGraph, pfPaj) comunita = snap.TCnComV() modularity = snap.CommunityCNM(g, comunita) dMod = {} # {numero : classe} classe = 0 for com in comunita: # print('comunita {} = '.format(classe), end='' ) for nodo in com: # print('{} '.format(nodo), end='') dMod.update({nodo: classe}) classe += 1 # print('') print('Numero di comunita analizzaClausetNewmanMoore: {} modularity: {}'. format(classe, modularity)) dNum = {} with open(pfAINN, 'rb') as fAINN: for line in fAINN: autID, autNum, autNome = line.rstrip().split('\t') autNum = int(autNum) dNum.update({autNum: [autID, autNome]}) # print(dNum) with open(pfMod, 'wb') as fMod: for autNum in dNum: fMod.write('{}\t{}\t{}\r\n'.format(dNum[autNum][0], dNum[autNum][1], dMod[autNum])) return classe # numero di comunita trovate
def community_partition(G): CommuV = snap.TCnComV() modularity = snap.CommunityCNM(G, CommuV) ComutyH = snap.TIntIntH() partition = 0 for community in CommuV: for NI in community: ComutyH[NI] = partition partition = partition + 1 return ComutyH
def comDetect(algorithm, clusterCommands, Graph, conn, cur): CmtyV = snap.TCnComV() before_time = time.time() if algorithm == "gn": modularity = snap.CommunityGirvanNewman(Graph, CmtyV) if algorithm == 'cnm': modularity = snap.CommunityCNM(Graph, CmtyV) print "Total handling time is: ", (time.time() - before_time) createTable(clusterCommands, CmtyV, conn, cur) print "The modularity of the network is %f" % modularity
def getCnn(): G1, id2, synset2, _, _, _ = generate_word_graph(True, False, False) print(G1.GetNodes()) CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(G1, CmtyV) for Cmty in CmtyV: print "Community: " for NI in Cmty: print NI print "The modularity of the network is %f" % modularity
def run(self): snap.DelSelfEdges(self.graph) community_list = snap.TCnComV() snap.CommunityCNM(self.graph, community_list) self.community_list = list() for community in community_list: cmty = list() for node in community: cmty.append(node) self.community_list.append(cmty)
def split_communities(C_Net): CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(C_Net, CmtyV) print(len(CmtyV)) # number of communities Cs = [] for Cmty in CmtyV: NIdV = snap.TIntV() for NI in Cmty: NIdV.add(NI) Cs.append(NIdV) return Cs
def community_cnm(G): CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(G,CmtyV) #print modularity ret_list = [] for Cmty in CmtyV: temp = [] for NI in Cmty: temp.append(NI) ret_list.append(temp) return ret_list
def getComms(graph): comms = snap.TCnComV() modularity = snap.CommunityCNM(graph, comms) print 'Modularity', modularity commDict = {} for i in xrange(len(comms)): for id in comms[i]: if id in commDict: 'node in more than one comm?' else: commDict[id] = i return comms, commDict
def get_community_CNM(file_path, output_path): Graph, H = load_graph(file_path) Graph = convert_to_undirected(Graph) CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(Graph, CmtyV) output_str = 'Modularity: ' + str( modularity) + '\nNum of communities: ' + str( len(CmtyV)) + '\nCommunities:\n' for Cmty in CmtyV: output_str += str(len(Cmty)) + '\n' with open(output_path, 'w') as f: f.write(output_str)
def get_communities(G_Undir, chords_dict): print("************") print("Communities") snap.DelSelfEdges(G_Undir) CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(G_Undir, CmtyV) for Cmty in CmtyV: print "Community: size", Cmty.Len() for NI in Cmty: print chords_dict[NI] print "" print "" print "The modularity of the network is %f" % modularity
def detectCommunities(self, algo="CNM", snapgraph=None, H=None, nxGraph=None, write=True, printout=True): ''' Detect communities using Clauset-Newman-Moore modularity-based greedy algorithm or Girvan-Neman betweeness-centrality based algorithm. Returns results as a dictionary and saves a text-file version. ''' # Creates a SNAP Graph Object if none is provided if snapgraph == None: snapgraph, H = self.buildSnapGraph(networkxGraph=nxGraph) # G = snapgraph # Detect community and calculate modularity networkxGraph = H.Graph start = time.time() CmtyV = snap.TCnComV() if algo == "CNM": modularity = snap.CommunityCNM(snapgraph, CmtyV) else: modularity = snap.CommunityGirvanNewman(snapgraph, CmtyV) if printout == True: i = 1 for Cmty in CmtyV: print(f"Community {i}: ") print(list(Cmty)) # communities.append(list(Cmty)) print("\n") i += 1 print("The modularity of the network is %f" % modularity) print(f"Time : {time.time()-start} seconds") # Save to text file at savepath if write = True if write == True: self.writeTxt(CmtyV, modularity) # Create a dataframe of community assignments communities = [] for i, cmty in enumerate(CmtyV): for c in cmty: communities.append((c, i + 1)) community_df = pd.DataFrame(communities, columns=['hashtag_id', 'CNM_Label']) # Export labeleed graph as a JSON file. nx.set_node_attributes( networkxGraph, community_df.set_index('hashtag_id').to_dict('index')) print("Community labelled graph exported as ", self.name_arg, ".json") H.exportGraph("JSON")
def comunityDetect(graph): CmtyV = snap.TCnComV() # modularity = snap.CommunityGirvanNewman(graph, CmtyV) modularity = snap.CommunityCNM(graph, CmtyV) list_comunity = [] for Cmty in CmtyV: comunity = [] for NI in Cmty: comunity.append(NI) list_comunity.append(comunity) return list_comunity, modularity
def CNM_Graph(G1): CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(G1, CmtyV) count = 0 sizes = [] communities = [] for Cmty in CmtyV: listcmty = [] for NI in Cmty: listcmty.append(NI) communities.append(listcmty) count += 1 sizes.append(len(listcmty)) return sizes, communities, modularity, count
def community_detection(input, output): print("Loading graph...") FIn = snap.TFIn(input) graph = snap.TNGraph.Load(FIn) ugraph = snap.ConvertGraph(snap.PUNGraph, graph) print("Performing community detection...") CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(ugraph, CmtyV) print("Modularity:", modularity) with open(output, "w") as file: for Cmty in CmtyV: file.write(repr([NI for NI in Cmty])) file.write("\n")
def out_modularity_cnm(g): """将cnm方法检测到的社区写入文件""" community_vector = snap.TCnComV() modularity = snap.CommunityCNM(g, community_vector) i = 0 s = 'The modularity of the network is ' + str(modularity) com_set = [] for community in community_vector: tmp_com = [i] # print "Community: " for j in community: # print(i) # print type(i) # int tmp_com.append(j) com_set.append(tmp_com) i += 1 file_op.write_file_li(com_set, 'H:/social_network_analysis/Email-Enron-result.txt', s)
def labelCNMCommunity(graph): communities = {} CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(graph, CmtyV) # print "The modularity of the network is %f" % modularity communityIndex = 1 for Cmty in CmtyV: for nid in Cmty: if Cmty.Len() == 1: communities[nid] = 0.0 else: communities[nid] = communityIndex communityIndex += 1 return communities
def same_community(G, n1, n2, method="CNM"): deleted = False if G.IsEdge(n1, n2): G.DelEdge(n1, n2) deleted = True CmtyV = snap.TCnComV() if method == "CNM": modularity = snap.CommunityCNM(G, CmtyV) elif method == "GN": modularity = snap.CommunityGirvanNewman(G, CmtyV) for cmty in CmtyV: cmty_set = set(cmty) if n1 in cmty and n2 in cmty: if deleted: G.AddEdge(n1, n2) return 1 if deleted: G.AddEdge(n1, n2) return 0
def build_graph_analytics(self): """ Put the structures together for the graph analytics """ for (idx, node) in enumerate(self.nodes): self.node_to_id[node] = idx self.id_to_node[idx] = node self.g_article_posts = snap.TUNGraph.New(len(self.node_to_id), len(self.up_likes_articles)) for node in self.nodes: self.g_article_posts.AddNode(self.node_to_id[node]) for (a, b) in self.up_likes_articles: self.g_article_posts.AddEdge(self.node_to_id[a], self.node_to_id[b]) for (a, b) in self.up_posts_to_articles: self.g_article_posts.AddEdge(self.node_to_id[a], self.node_to_id[b]) self.cmtyv = snap.TCnComV() self.modularity = snap.CommunityCNM(self.g_article_posts, self.cmtyv) self.sig_communities = [[node for node in cc] for cc in self.cmtyv if cc.Len() > 2] self.sig_communities_by_id = [[self.id_to_node[id] for id in l] for l in self.sig_communities] self.user_post_graph_cnm = nx.Graph() self.user_post_graph_cnm.add_nodes_from(self.nodes)
def community_cnm_with_limit(G,limit_nodes): finished_list = [] unfinished_list = [] graph_nodes = [] for i in G.Nodes(): graph_nodes.append(i.GetId()) unfinished_list.append(graph_nodes) print "detection starts" sys.stdout.flush() CmtyV = snap.TCnComV() while len(unfinished_list) > 0: result_nodes = [] list_nodes = unfinished_list.pop() #create Graph for CNM if len(list_nodes) != G.GetNodes(): TG = generate_graph(G,list_nodes) else: TG = G #community detection with CNM modularity = snap.CommunityCNM(TG,CmtyV) #judge the number of the nodes in the community detected by the CNM for Cmty in CmtyV: result_nodes = [] for NI in Cmty: result_nodes.append(NI) if(len(result_nodes) > limit_nodes): unfinished_list.append(result_nodes) else: finished_list.append(result_nodes) print "the size of finished_list : %d " % len(finished_list) sys.stdout.flush() print "the size of unfinished_list : %d " % len(unfinished_list) sys.stdout.flush() if TG != G: TG.Clr() print "detection end" sys.stdout.flush() return finished_list
def generate_graph(n_nodes=50, out_degree=None, seed=1): """ This method generates a Graph based on the Barabasi Algorithm and computes several metrics: 1) It finds the Node with the maximum Degree. 2) It finds the Node with the maximum PageRank Score. 3) Calculates communities within the graph by using two different algorithms: a) Girvan - Newman community Detection b) Clauset-Newman-Moore community Detection. :param n_nodes: int. Specifies the number of nodes for the graph to be created. :param out_degree: int. Specifies the outer degree for each node. If None, then a random integer is generated between 5 and 20. :param seed: Int. An integer that is used to generate the same 'random' integer for the out degree. :return: Boolean. Whether the execution time of the specific community detection algorithms is over 10 minutes. """ if out_degree is None: random.seed(seed) out_degree = random.randint(5, 20) print print "Generating Graph with %s Nodes of Out Degree: %s " % (n_nodes, out_degree) # Generating a random graph based on the Barabasi Algorithm. barabasi_graph = snap.GenPrefAttach(n_nodes, out_degree) # Finding the node ID with the maximoun Degree. maximum_degree_node = snap.GetMxDegNId(barabasi_graph) # Iterating in the graph nodes in order to find the Maximum degree for this particular node. for NI in barabasi_graph.Nodes(): if NI.GetId() == maximum_degree_node: print "Node: %d, Maximum Degree %d" % (NI.GetId(), NI.GetDeg()) # Computing the PageRank score of every node in Graph # Setting the ID and the PageRank score to -1. (minimum of both of these is 0) page_rank_id, page_rank_score = -1, -1 # Creating the iterator for the PageRank algorithm. PRankH = snap.TIntFltH() # Calculating the PageRank for every Node. snap.GetPageRank(barabasi_graph, PRankH) # By iterating on each node we find the Node with the maximum PageRank Score. for node in PRankH: if PRankH[node] > page_rank_score: page_rank_score = PRankH[node] page_rank_id = node print print "Node with the Highest PageRank value: " print "Node: %s, PageRank value %s " % (page_rank_id, page_rank_score) print try: start_Girvan_Newman = time.time( ) # setting the timer for the first community detection algorithm. # Calculating Girvan - Newman community Detection Algorithm CmtyV = snap.TCnComV() snap.CommunityGirvanNewman(barabasi_graph, CmtyV) print 'Girvan-Newman community Detection Algorithm: Execution Time: ', time.time( ) - start_Girvan_Newman # Calculating Girvan-Newman community Detection Algorithm start_Clauset_Newman_Moore = time.time( ) # setting the timer for the second community detection algorithm. CmtyV = snap.TCnComV() snap.CommunityCNM(barabasi_graph, CmtyV) print 'Clauset-Newman-Moore community Detection Algorithm: Execution Time: ', time.time( ) - start_Clauset_Newman_Moore print '-' * 100 print '-' * 100 if time.time( ) - start_Girvan_Newman > 10 * 60: # if the total execution time for both algorithms is over 10 # minutes then return False in order to quit the loop that this method will be used in. return False return True except MemoryError: # if we get a memory error during the Community Detection algorithms we set to False in order # to avoid adding more Nodes when running this method in a while loop. return False
H = HashtagGraph(name="ClausetNewmanMoore", ret_maximal_subgraph=True) H.load_raw_csv("data/Hashtag_Raw_Data/COVID19_hashtags7.csv") networkxGraph = H.Graph G = snap.TUNGraph.New() for n in list(networkxGraph.nodes): G.AddNode(n) for src, trgt in list(networkxGraph.edges): G.AddEdge(src, trgt) start = time.time() CommunityVec = snap.TCnComV() modularity = snap.CommunityCNM(G, CommunityVec) print("The modularity of the network is %f" % modularity) print(f"Time : {time.time()-start} seconds") communities = [] for i, cmty in enumerate(CommunityVec): for c in cmty: communities.append((c, i+1, networkxGraph.degree[c])) community_df = pd.DataFrame(communities, columns=['hashtag_id', 'CNM_Label', 'Degree']) nx.set_node_attributes(networkxGraph, community_df.set_index('hashtag_id').to_dict('index')) for i, j in networkxGraph.edges: if networkxGraph.nodes[i]['CNM_Label'] == networkxGraph.nodes[j]['CNM_Label']:
f_in = snap.TFIn(FOLDED_POSTID_GRAPH_PATH) post_graph = snap.TUNGraph.Load(f_in) print "nodes", post_graph.GetNodes() print "edges", post_graph.GetEdges() COMMUNITIES_PATH = path.join(BASE_PATH, 'postid-communities-with-postbodies.txt') COMMUNITIES_VEC_PATH = path.join(BASE_PATH, 'postid-communities.vector') # remove degree-1 nodes assert snap.CntSelfEdges(post_graph) == 0 snap.DelDegKNodes(post_graph, 1, 1) comm_vec = snap.TCnComV() modularity = snap.CommunityCNM(post_graph, comm_vec) f_out = snap.TFOut(COMMUNITIES_VEC_PATH) comm_vec.Save(f_out) f_out.Flush() f_in = snap.TFIn(COMMUNITIES_VEC_PATH) comm_vec = snap.TCnComV() comm_vec.Load(f_in) print "communities", len(comm_vec) pickle_file = open(POSTID_PICKLE, 'rb') postid_dict = pickle.load(pickle_file) community_dict = collections.defaultdict(int)
nodes_file = open(sys.argv[1]) graph = snap.TUNGraph.New() for line in nodes_file: graph.AddNode(int(line.strip())) nodes_file.close() edges_file = open(sys.argv[2]) comment_symbol = "#" edges = 0 for line in edges_file: if line.startswith(comment_symbol): continue else: nodes = line.split() graph.AddEdge(int(nodes[0].strip()), int(nodes[1].strip())) edges += 1 communities = snap.TCnComV() modularity = snap.CommunityCNM(graph, communities) string = "" for com in communities: print " ".join([str(node) for node in com])
def get_communities(G): CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(G, CmtyV) return [[IId for IId in Community] for Community in CmtyV], modularity
def main(): tag_posts_dict = {} graph = snap.PUNGraph.New() tree = et.parse(current_dir + '/dataset/Posts.xml') doc = tree.getroot() # tree = et.parse(current_dir + '/dataset/Posts.xml') # doc = tree.getroot() for row in doc.findall('row'): if row.get('PostTypeId') == '1' and row.get('OwnerUserId') is not None: graph.AddNode(int(row.get('Id'))) tags = row.get('Tags') if tags is not None: tags_list = tags.split('><') for tag in tags_list: # if tags is not None: # tags_list = tags.split('><') # for tag in tags_list: tag = re.sub('[<>]', '', tag) if tag not in tag_posts_dict: tag_posts_dict[tag] = [row.get('Id')] else: tag_posts_dict[tag].append(row.get('Id')) for tag, posts in tag_posts_dict.iteritems(): for src_post in posts: for dest_post in posts: # for src_post in posts: # for dest_post in posts: if src_post != dest_post and not graph.IsEdge( int(src_post), int(dest_post)): graph.AddEdge(int(src_post), int(dest_post)) communities_list_list = [] # communities of questions CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(graph, CmtyV) for Cmty in CmtyV: community_list = [] for NI in Cmty: community_list.append(str(NI)) communities_list_list.append(community_list) questions_list = get_questionsid_list() users_questions_dict = {} tree = et.parse(current_dir + '/dataset/Users.xml') doc = tree.getroot() for row in doc.findall('row'): users_questions_dict[row.get('Id')] = [] tree = et.parse(current_dir + '/dataset/Posts.xml') doc = tree.getroot() for row in doc.findall('row'): if row.get('CreationDate').split('-')[0] < '2016' and row.get( 'PostTypeId') == '2' and row.get('OwnerUserId') is not None: users_questions_dict[row.get('OwnerUserId')].append( row.get('ParentId')) # for row in doc.findall('row'): # if row.get('CreationDate').split('-')[0] < '2016' and row.get('PostTypeId') == '2' and row.get('OwnerUserId') is not None: # users_questions_dict[row.get('OwnerUserId')].append(row.get('ParentId')) randomusersid_list_list = get_randomusersid_list_list() user_probability_list_dict = [] for idx in range(100): user_probability_list_dict.append({}) for user in randomusersid_list_list[idx]: user_probability_list_dict[idx][user] = 0 for idx in range(100): question = questions_list[idx] users = randomusersid_list_list[idx] for user in users: questions = users_questions_dict[user] if questions is not None: for user_question in questions: for community in communities_list_list: if question in community and user_question in community: user_probability_list_dict[idx][user] += float(1) check_answer_range(user_probability_list_dict)
def main(): # Load data nodes = pd.read_csv("../data/nodes.csv", sep='\t', index_col=0) # Data in nice form headers = list(nodes.columns) nodes = np.asarray(nodes) # Load social network accordingly if path.exists("../data/youtube.graph"): FIn = snap.TFIn("../data/youtube.graph") social_network = snap.TNGraph.Load(FIn) else: edges = pd.read_csv("../data/edges.csv", sep='\t', index_col=0) edges = np.asarray(edges).astype(int) social_network = data2dag(edges, nodes.shape[0]) # Check for self edges for e in social_network.Edges(): if e.GetSrcNId() == e.GetDstNId(): print("Self Loop Found:", e.GetSrcNId()) # CNM Algorithm from snap.py print("Computing CNM") start = timeit.default_timer() CmtyV = snap.TCnComV() undirected = snap.ConvertGraph(snap.PUNGraph, social_network) snap.DelSelfEdges(undirected) the_modularity = snap.CommunityCNM(undirected, CmtyV) stop = timeit.default_timer() node_to_cmty = np.zeros(nodes.shape[0]) cmty_sizes = np.zeros(len(CmtyV)) for i in range(len(CmtyV)): for node in CmtyV[i]: node_to_cmty[node] = i cmty_sizes[i] = len(CmtyV[i]) cmtys = [[node for node in cmty] for cmty in CmtyV] ''' edges = pd.read_csv("../data/edges.csv", sep='\t', index_col=0) edges = np.asarray(edges).astype(int) G = nx.Graph() G.add_nodes_from(range(nodes.shape[0])) G.add_edges_from(list(map(tuple, edges))) ''' #assert(is_partition(G, cmtys)) #print("Calculating Modularity") #modul = modularity(G, cmtys) print("Results from Clauset-Newman-Moore:") #print("Modularity:",modul) print("Number of clusters:", len(CmtyV)) print("Time elapsed:", stop - start) # Fun category stuff to do upload_col = headers.index('category') categories = set() for i in range(nodes.shape[0]): categories.add(nodes[i][upload_col]) idx_to_categories = list(categories) print("Number of categories:", len(idx_to_categories)) categories_to_idx = dict() for i in range(len(idx_to_categories)): categories_to_idx[idx_to_categories[i]] = i # Communities and categories cmty_category_count = np.zeros((len(CmtyV), len(idx_to_categories))) for i in range(nodes.shape[0]): cmty_category_count[int(node_to_cmty[i]), categories_to_idx[nodes[i][upload_col]]] += 1 cmty_category_count = cmty_category_count / cmty_sizes[:, np.newaxis] # Create graphs per category plt.figure() plt.plot(sorted(np.max(cmty_category_count, axis=1), reverse=True), label="Top proportion") plt.plot(0.5 * np.ones(cmty_category_count.shape[0]), label="Majority Threshold", linestyle='dashed') plt.title("Category Proportions in Clusters") plt.xlabel("Cluster") plt.ylabel("Proportion") plt.legend() plt.savefig("../figures/category_top_clusters.png") ''' for i in range(cmty_category_count.shape[0]): top_category = np.argmax(cmty_category_count[i]) print("Community "+str(i)+": "+str(idx_to_categories[top_category])+",",cmty_category_count[i][top_category]) ''' '''
print "SD> INFO: Creating Networkx Graph..." G = snap.LoadEdgeList(snap.PUNGraph, filepath, 0, 1, edgedelimiter) print "SD> INFO: Run community detection algorithm" # Compute the required connected components CmtyV = snap.TCnComV() for iter in range(10): print iter algo_start = time.clock() # Clauset-Newman-Moore # At every step of the algorithm two communities that contribute maximum positive value to global modularity are merged C = snap.CommunityCNM(G, CmtyV) algo_stop = time.clock() algo_delta = algo_delta + algo_stop - algo_start #f.close() proc_stop = time.clock() proc_delta = proc_stop - proc_start #nc = np.max([C[com] for com in C]) + 1 print "SD> INFO: Completed" print "SD> ===========================" print "SD> INFO: Results" print "SD> INFO: Number of nodes: %i" % G.GetNodes()
import snap as snap import numpy as np count = 0 file_number = 8 #r = 65608366 r = 65608366 c = 3 node_list = np.zeros((r, c), dtype=np.int64) print(node_list.shape) # "file"+"i"+".txt" for i in range(file_number): f_i = i + 1 G = snap.LoadEdgeList(snap.PUNGraph, "file" + str(f_i) + ".txt", 0, 1) # snap.PrintInfo(G, "QA Stats", "qa-info.txt", False) CmtyV = snap.TCnComV() modularity = snap.CommunityCNM(G, CmtyV) # myfile = open('community'+'i'+'.txt', 'w') for Cmty in CmtyV: count += 1 print("Community: ") # myfile.write("Community" + " "+ str(count)+"\n") for NI in Cmty: print(NI) if node_list[NI][2] == 0: node_list[NI][2] = 1 node_list[NI][1] = count node_list[NI][0] = NI # myfile.write(str(NI)) # myfile.write("\n") mat = np.matrix(node_list) with open('outfile.txt', 'wb') as f:
def community_cnm(graph): cc_vector = sp.TCnComV() sp.CommunityCNM(graph, cc_vector) return [list(nodes) for nodes in cc_vector]