def prepare_communities(community_file, n_nodes): i = 0 communities = { } # Dicionário com uma chave (id da community): e uma lista de ids dos membros da comunidade size = [] # Lista com os tamanhos das communidades size_norm = [ ] # Lista com os tamanhos das communidades normalizada pelo número de vértices da rede-ego n_singletons = 0 # Número de Singletons (comunidades formada por apenas um vértice) n_non_singletons = 0 # Número de Não Singletons for line in community_file: i += 1 key = "com" + str( i) # Chave para o dicionário comm - um identificador "comm1" comm = [] # Lista para armazenar as os membros da comunidade i a = line.split(' ') for item in a: if item != "\n": comm.append(long(item)) if len(comm) > 1: n_singletons += 1 else: n_non_singletons += 1 communities[ key] = comm # dicionário communities recebe a lista de ids dos membros das comunidades tendo como chave o valor key b = float(len(comm)) / float(n_nodes) size.append(len(comm)) size_norm.append(b) n_comm = len( communities) # Quantidade de comunidades para o ego em questão avg_size = calc.calcular( size) # Somar o vetor com o tamanho das comunidades... avg_size_norm = calc.calcular( size_norm ) # Somar o vetor com o tamanho das comunidades normalizado... overlap = float(avg_size['soma']) / float( n_nodes ) # The overlap: the average number of communities to which each vertex belongs. This is the sum of the sizes of all communities (including singletons) divided by the number of vertices, n. return communities, n_comm, size, avg_size[ 'media'], size_norm, avg_size_norm[ 'media'], overlap, n_singletons, n_non_singletons
def net_structure(dataset_dir, output_dir, net, IsDir, weight): print( "\n######################################################################\n" ) if os.path.isfile(str(output_dir) + str(net) + "_connected_comp.json"): print("Arquivo já existe: " + str(output_dir) + str(net) + "_connected_comp.json") else: print("Componentes conectados - " + str(dataset_dir)) cc = [] # Média do tamanho dos componentes conectados por rede-ego cc_normal = [ ] # Média (normalizada pelo número de vértices do grafo) do tamanho dos componentes conectados por rede-ego n_cc = [] # Média do número de componentes conectados por rede-ego n = [] # vetor com número de vértices para cada rede-ego e = [] # vetor com número de arestas para cada rede-ego i = 0 for file in os.listdir(dataset_dir): i += 1 print( str(output_dir) + str(net) + "/" + str(file) + " - Calculando propriedades para o ego " + str(i) + ": " + str(file)) if IsDir is True: G = snap.LoadEdgeList( snap.PNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') else: G = snap.LoadEdgeList( snap.PUNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') # G.Dump() # time.sleep(5) ##################################################################################### n.append(G.GetNodes()) # Numero de vertices e.append(G.GetEdges()) # Numero de arestas n_nodes = G.GetNodes() n_edges = G.GetEdges() ##################################################################################### if n_edges == 0: a = 0 cc.append(a) cc_normal.append(a) n_cc.append(a) print("Nenhuma aresta encontrada para a rede-ego " + str(i) + " - (" + str(file)) else: Components = snap.TCnComV() snap.GetWccs(G, Components) _cc = [] _cc_normal = [] _n_cc = 0 for CnCom in Components: _cc.append(CnCom.Len()) b = float(CnCom.Len()) / float(n_nodes) _cc_normal.append(b) _n_cc += 1 result = calc.calcular(_cc) cc.append(result['media']) result_normal = calc.calcular(_cc_normal) cc_normal.append(result_normal['media']) n_cc.append(_n_cc) print("Número de componentes conectados para o ego " + str(i) + " (" + str(file) + "): " + str(_n_cc)) print( "Média do tamanho dos componentes conectados para o ego " + str(i) + " (" + str(file) + "): " + str(result['media'])) print( "Média (normalizada) do tamanho dos componentes conectados para o ego " + str(i) + " (" + str(file) + "): " + str(result_normal['media'])) print N_CC = calc.calcular_full(n_cc) CC = calc.calcular_full(cc) CC_NORMAL = calc.calcular_full(cc_normal) overview = {} overview['Len_ConnectedComponents'] = CC overview['Len_ConnectedComponents_Normal'] = CC_NORMAL overview['N_ConnectedComponents'] = N_CC with open(str(output_dir) + str(net) + "_connected_comp.json", 'w') as f: f.write(json.dumps(overview)) with open(str(output_dir) + str(net) + "_connected_comp.txt", 'w') as f: f.write( "\n######################################################################\n" ) f.write( "Number_Connected_Comp: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (N_CC['media'], N_CC['variancia'], N_CC['desvio_padrao'])) f.write( "Length_Connected_Comp: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (CC['media'], CC['variancia'], CC['desvio_padrao'])) f.write( "Length_Connected_Comp_Normalized: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (CC_NORMAL['media'], CC_NORMAL['variancia'], CC_NORMAL['desvio_padrao'])) f.write( "\n######################################################################\n" ) print( "\n######################################################################\n" ) print( "Number_Connected_Comp: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (N_CC['media'], N_CC['variancia'], N_CC['desvio_padrao'])) print( "Length_Connected_Comp: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (CC['media'], CC['variancia'], CC['desvio_padrao'])) print( "Length_Connected_Comp_Normalized: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (CC_NORMAL['media'], CC_NORMAL['variancia'], CC_NORMAL['desvio_padrao'])) print( "\n######################################################################\n" )
def calculate_alg(singletons,net,uw,ud,g_type,alg): communities = "/home/amaury/communities_hashmap/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" graphs = "/home/amaury/graphs_hashmap_infomap_without_weight/"+str(net)+"/"+str(g_type)+"/" #Todos os grafos sem peso... out_ad = str(output_dir)+"average_degree/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_c = str(output_dir)+"conductance/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_cut_r = str(output_dir)+"cut_ratio/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_d = str(output_dir)+"density/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_e = str(output_dir)+"expansion/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_normal_cut = str(output_dir)+"normalized_cut/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_s = str(output_dir)+"separability/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" _avg_time = [] if not os.path.exists(communities): print ("Diretório com as comunidades não encontrado: "+str(communities)+"\n") else: print("\n######################################################################") for threshold in os.listdir(communities): if not os.path.isdir(str(communities)+str(threshold)+"/"): print ("Threshold para a rede "+str(net)+" não encontrado: "+str(threshold)) else: partial_start = time.time() create_dirs(out_ad,out_c,out_cut_r,out_d,out_e,out_normal_cut,out_s) if os.path.exists(str(out_ad)+str(threshold)+".json") and os.path.exists(str(out_c)+str(threshold)+".json") and os.path.exists(str(out_cut_r)+str(threshold)+".json") and os.path.exists(str(out_d)+str(threshold)+".json") and os.path.exists(str(out_e)+str(threshold)+".json") and os.path.exists(str(out_normal_cut)+str(threshold)+".json") and os.path.exists(str(out_s)+str(threshold)+".json"): print ("Arquivo de destino já existe: "+str(threshold)+".json") else: print("######################################################################") average_degree = {} conductance = {} cut_ratio = {} density = {} expansion = {} normalized_cut = {} separability = {} i=0 #Ponteiro para o ego for file in os.listdir(str(communities)+str(threshold)+"/"): if os.path.isfile(str(communities)+str(threshold)+"/"+file): ego_id = file.split(".txt") ego_id = long(ego_id[0]) i+=1 if not os.path.isfile(str(graphs)+str(ego_id)+".edge_list"): print ("ERROR - EGO: "+str(i)+" - Arquivo com lista de arestas não encontrado:" +str(graphs)+str(ego_id)+".edge_list") else: with open(str(communities)+str(threshold)+"/"+file, 'r') as community_file: if ud is False: G = snap.LoadEdgeList(snap.PNGraph, str(graphs)+str(ego_id)+".edge_list", 0, 1) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') else: G = snap.LoadEdgeList(snap.PUNGraph, str(graphs)+str(ego_id)+".edge_list", 0, 1) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') print(str(g_type)+" - "+str(alg)+" - "+str(singletons)+" - Rede: "+str(net)+" - THRESHOLD: "+str(threshold)+" - ego("+str(i)+"): "+str(file)) communities_dict = prepare_communities(community_file) #Função para devolver um dicionário com as comunidades avg_ad,avg_c,avg_cut_r,avg_d,avg_e,avg_normal_cut,avg_s = metrics_v2.calc_metrics(communities_dict,G,ud) # Calcular as métricas average_degree[ego_id] = avg_ad conductance[ego_id] = avg_c cut_ratio[ego_id] = avg_cut_r density[ego_id] = avg_d expansion[ego_id] = avg_e normalized_cut[ego_id] = avg_normal_cut separability[ego_id] = avg_s print ("Average Degree: "+str(avg_ad['media'])+" - Conductance: "+str(avg_c['media'])+" - Cut Ratio: "+str(avg_cut_r['media'])+" - Density: "+str(avg_d['media'])) print ("Expansion: "+str(avg_e['media'])+" - Normalized Cut: "+str(avg_normal_cut['media'])+" - Separability: "+str(avg_s['media'])) print print("######################################################################") with open(str(out_ad)+str(threshold)+".json", "w") as f: f.write(json.dumps(average_degree)) with open(str(out_c)+str(threshold)+".json", "w") as f: f.write(json.dumps(conductance)) with open(str(out_cut_r)+str(threshold)+".json", "w") as f: f.write(json.dumps(cut_ratio)) with open(str(out_d)+str(threshold)+".json", "w") as f: f.write(json.dumps(density)) with open(str(out_e)+str(threshold)+".json", "w") as f: f.write(json.dumps(expansion)) with open(str(out_normal_cut)+str(threshold)+".json", "w") as f: f.write(json.dumps(normalized_cut)) with open(str(out_s)+str(threshold)+".json", "w") as f: f.write(json.dumps(separability)) partial_end = time.time() partial_time_exec = partial_end - partial_start print ("\nTempo de execução para o threshold "+str(threshold)+": "+str(partial_time_exec)+"\n") _avg_time.append(partial_time_exec) avg_time = calc.calcular(_avg_time) print ("\nTempo de médio de execução em cada threshold: "+str(avg_time)+"\n") print("\n######################################################################\n")
def net_structure(dataset_dir, output_dir, graph_type, metric, net, alg): os.system('clear') print( "\n######################################################################\n" ) print( "\nScript para cálculo da modularidade das comunidades detectadas\n") graphs_dir = "/home/amaury/graphs_hashmap_infomap_without_weight/" + str( net) + "/" + str(graph_type) + "/" if not os.path.exists(graphs_dir): print("Diretório não encontrado: " + str(graphs_dir)) else: print( "\n######################################################################\n" ) print( "\nScript para cálculo da modularidade das comunidades detectadas - Rede " + str(net) + "\n") if not os.path.isdir(dataset_dir + str(net) + "/"): print("Diretório com avaliações da rede " + str(net) + " não encontrado: " + str(dataset_dir + str(net) + "/")) else: for threshold in os.listdir(dataset_dir + str(net) + "/"): if os.path.isfile(str(output_dir) + str(threshold) + ".json"): print("Arquivo de destino já existe. " + str(output_dir) + str(threshold) + ".json") else: modularity = [ ] # Vetor com a Média das modularidades de cada grafo modularity_data = { } # Dicionário com o ego e as modularidades para cada comunidade i = 0 for file in os.listdir(dataset_dir + str(net) + "/" + str(threshold) + "/"): i += 1 ego_id = file.split(".txt") ego_id = long(ego_id[0]) communities = [ ] # Armazenar as comunidades da rede-ego m_file = [ ] # vetor de modularidade das comunidades do ego i try: G = snap.LoadEdgeList( snap.PNGraph, str(graphs_dir) + str(ego_id) + ".edge_list", 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') n_edges = G.GetEdges( ) # Número de arestas do grafo if n_edges == 0: a = 0 m_file.append(a) else: try: with open( dataset_dir + str(net) + "/" + str(threshold) + "/" + str(file), 'r') as f: for line in f: comm = [ ] #Lista para armazenar as comunidades a = line.split(' ') for item in a: if item != "\n": comm.append(item) communities.append(comm) except Exception as e: print( "\nERRO - Impossível carregar as comunidades: " + dataset_dir + str(net) + "/" + str(threshold) + "/" + str(file) + "\n") print e for comm in communities: if comm is not None: Nodes = snap.TIntV() for nodeId in comm: if nodeId is not None: Nodes.Add(long(nodeId)) m_file.append( snap.GetModularity( G, Nodes, n_edges) ) #Passar o número de arestas do grafo como parâmetro para agilizar o processo except Exception as e: print( "\nERRO - Impossível carregar o grafo para o ego: " + str(ego_id) + " -- " + str(graphs_dir) + str(ego_id) + ".edge_list\n") print e _m_file = calc.calcular(m_file) modularity_data[ego_id] = m_file if _m_file is not None: modularity.append(_m_file['media']) print( str(graph_type) + " - Rede: " + str(net) + " - Threshold: " + str(threshold) + " - Modularidade para o ego " + str(i) + " (" + str(file) + "): %5.3f" % (_m_file['media'])) print( "######################################################################" ) M = calc.calcular_full(modularity) if M is not None: overview = { 'threshold': threshold, 'modularity': M, 'modularity_data': modularity_data } print( "\n######################################################################\n" ) print( "Rede: %s --- Threshold: %s --- Modularity: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f" % (net, threshold, M['media'], M['variancia'], M['desvio_padrao'])) print( "\n######################################################################\n" ) if overview is not None: with open( str(output_dir) + str(threshold) + ".json", 'a+') as f: f.write(json.dumps(overview) + "\n") print( "\n######################################################################\n" )
def calculate_alg(singletons, net, ud, g_type, alg): communities = "/home/amaury/communities_hashmap/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" graphs = "/home/amaury/graphs_hashmap_infomap_without_weight/" + str( net) + "/" + str( g_type ) + "/" #Pega só o grafo sem peso para realizar os cálculos out_Q = str(output_dir) + "modularity/" + str(g_type) + "/" + str( alg) + "/" + str(singletons) + "/" + str(net) + "/" out_Qds = str(output_dir) + "modularity_density/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" out_intra_edges = str(output_dir) + "intra_edges/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" out_intra_density = str(output_dir) + "intra_density/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" out_contraction = str(output_dir) + "contraction/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" out_inter_edges = str(output_dir) + "inter_edges/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" out_expansion = str(output_dir) + "expansion/" + str(g_type) + "/" + str( alg) + "/" + str(singletons) + "/" + str(net) + "/" out_conductance = str(output_dir) + "conductance/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" out_modularity_degree = str(output_dir) + "modularity_degree/" + str( g_type) + "/" + str(alg) + "/" + str(singletons) + "/" + str(net) + "/" _avg_time = [] if not os.path.exists(communities): print("Diretório com as comunidades não encontrado: " + str(communities) + "\n") else: print( "\n######################################################################" ) for threshold in os.listdir(communities): if not os.path.isdir(str(communities) + str(threshold) + "/"): print("Threshold para a rede " + str(net) + " não encontrado: " + str(threshold)) else: partial_start = time.time() paths = [ out_Q, out_Qds, out_intra_edges, out_intra_density, out_contraction, out_inter_edges, out_expansion, out_conductance, out_modularity_degree ] create_dirs(paths) if os.path.exists( str(out_Q) + str(threshold) + ".json") and os.path.exists( str(out_Qds) + str(threshold) + ".json" ) and os.path.exists( str(out_intra_edges) + str(threshold) + ".json" ) and os.path.exists( str(out_intra_density) + str(threshold) + ".json") and os.path.exists( str(out_contraction) + str(threshold) + ".json") and os.path.exists( str(out_inter_edges) + str(threshold) + ".json") and os.path.exists( str(out_expansion) + str(threshold) + ".json") and os.path.exists( str(out_conductance) + str(threshold) + ".json") and os.path.exists( str(out_modularity_degree) + str(threshold) + ".json"): print("Arquivo de destino já existe: " + str(out_Q) + str(threshold) + ".json") else: print( "######################################################################" ) Q = {} Qds = {} intra_edges = {} intra_density = {} contraction = {} inter_edges = {} expansion = {} conductance = {} modularity_degree = {} i = 0 #Ponteiro para o ego for file in os.listdir( str(communities) + str(threshold) + "/"): if os.path.isfile( str(communities) + str(threshold) + "/" + file): ego_id = file.split(".txt") ego_id = long(ego_id[0]) i += 1 if not os.path.isfile( str(graphs) + str(ego_id) + ".edge_list"): print( "ERROR - EGO: " + str(i) + " - Arquivo com lista de arestas não encontrado:" + str(graphs) + str(ego_id) + ".edge_list") else: community_file = str(communities) + str( threshold) + "/" + file graph_file = str(graphs) + str( ego_id) + ".edge_list" print("Ego: " + str(i) + " - " + communities + threshold + "/" + file) if ud is False: # Para grafo NÂO Ponderado e Direcionado execute = subprocess.Popen( [ "java", "CommunityQuality", str(graph_file), str(community_file), "isUnweighted" ], stdout=subprocess.PIPE) else: # Para grafo NÃO Ponderado e NÃO Direcionado execute = subprocess.Popen( [ "java", "CommunityQuality", str(graph_file), str(community_file), "isUnweighted", "isUndirected" ], stdout=subprocess.PIPE) resp = execute.communicate()[0] print resp value = resp.split(", ") for item in value: item = item.split(" = ") if item[0] == "Q": Q[ego_id] = float(item[1]) elif item[0] == "Qds": Qds[ego_id] = float(item[1]) elif item[0] == "intraEdges": intra_edges[ego_id] = float(item[1]) elif item[0] == "intraDensity": intra_density[ego_id] = float(item[1]) elif item[0] == "contraction": contraction[ego_id] = float(item[1]) elif item[0] == "interEdges": inter_edges[ego_id] = float(item[1]) elif item[0] == "expansion": expansion[ego_id] = float(item[1]) elif item[0] == "conductance": conductance[ego_id] = float(item[1]) elif item[0] == "modularity degree": modularity_degree[ego_id] = float( item[1]) print( "######################################################################" ) with open(str(out_Q) + str(threshold) + ".json", "w") as f: f.write(json.dumps(Q)) with open(str(out_Qds) + str(threshold) + ".json", "w") as f: f.write(json.dumps(Qds)) with open( str(out_intra_edges) + str(threshold) + ".json", "w") as f: f.write(json.dumps(intra_edges)) with open( str(out_intra_density) + str(threshold) + ".json", "w") as f: f.write(json.dumps(intra_density)) with open( str(out_contraction) + str(threshold) + ".json", "w") as f: f.write(json.dumps(contraction)) with open( str(out_inter_edges) + str(threshold) + ".json", "w") as f: f.write(json.dumps(inter_edges)) with open( str(out_expansion) + str(threshold) + ".json", "w") as f: f.write(json.dumps(expansion)) with open( str(out_conductance) + str(threshold) + ".json", "w") as f: f.write(json.dumps(conductance)) with open( str(out_modularity_degree) + str(threshold) + ".json", "w") as f: f.write(json.dumps(modularity_degree)) partial_end = time.time() partial_time_exec = partial_end - partial_start print("\nTempo de execução para o threshold " + str(threshold) + ": " + str(partial_time_exec) + "\n") _avg_time.append(partial_time_exec) avg_time = calc.calcular(_avg_time) print("\nTempo de médio de execução em cada threshold: " + str(avg_time) + "\n") print( "\n######################################################################\n" )
def calc_metrics(communities,G,uw,ud): ###################################################################################################################################################################### average_degree = [] conductance = [] cut_ratio = [] density = [] expansion = [] normal_cut_ratio = [] separability = [] clustering = [] if ud is False: #Para grafos direcionados... for k,community in communities.iteritems(): _average_degree = 0 _conductance = 0 _cut_ratio = 0 _density = 0 _expansion = 0 _normal_cut_ratio = 0 _separability = 0 average_degree.append(_average_degree) #Armazena os resultados para cada partição para depois fazer a média do ego. conductance.append(_conductance) #Armazena os resultados para cada partição para depois fazer a média do ego. cut_ratio.append(_cut_ratio) #Armazena os resultados para cada partição para depois fazer a média do ego. density.append(_density) #Armazena os resultados para cada partição para depois fazer a média do ego. expansion.append(_expansion) #Armazena os resultados para cada partição para depois fazer a média do ego. normal_cut_ratio.append(_normal_cut_ratio) #Armazena os resultados para cada partição para depois fazer a média do ego. separability.append(_separability) #Armazena os resultados para cada partição para depois fazer a média do ego. else: #Para grafos não direcionados... clustering_of_G = nx.average_clustering(G,weight='weight') #Calcula o coeficiente de Clustering para o Grafo. for k,community in communities.iteritems(): _average_degree = 0 _conductance = 0 _cut_ratio = 0 _density = 0 _expansion = 0 _normal_cut_ratio = 0 _separability = 0 ############################################################################################################ CLUSTERING COEFFICIENT _cc = [] #Anexar os coeficientes de clustering de cada Nó na comunidade for Node in community: try: _cc.append(clustering_of_G[Node]) except Exception as e: print ("Error - "+str(e)) if _cc is not None: _clustering = calc.calcular(_cc) #Trazer a média do coeficiente de clustering da comunidade clustering.append(_clustering['media']) #Armazena os resultados para cada partição para depois fazer a média do ego. else: _clustering = 0 clustering.append(_clustering) #Armazena os resultados para cada partição para depois fazer a média do ego. ############################################################################################################# average_degree.append(_average_degree) #Armazena os resultados para cada partição para depois fazer a média do ego. conductance.append(_conductance) #Armazena os resultados para cada partição para depois fazer a média do ego. cut_ratio.append(_cut_ratio) #Armazena os resultados para cada partição para depois fazer a média do ego. density.append(_density) #Armazena os resultados para cada partição para depois fazer a média do ego. expansion.append(_expansion) #Armazena os resultados para cada partição para depois fazer a média do ego. normal_cut_ratio.append(_normal_cut_ratio) #Armazena os resultados para cada partição para depois fazer a média do ego. separability.append(_separability) avg_ad = calc.calcular_full(average_degree) avg_c = calc.calcular_full(conductance) avg_cut_r = calc.calcular_full(cut_ratio) avg_d = calc.calcular_full(density) avg_e = calc.calcular_full(expansion) avg_normal_cut = calc.calcular_full(normal_cut_ratio) avg_s = calc.calcular_full(separability) avg_cc = calc.calcular_full(clustering) print avg_ad, avg_c, avg_cut_r, avg_d, avg_e, avg_normal_cut, avg_s, avg_cc time.sleep(5) return avg_ad, avg_c, avg_cut_r, avg_d, avg_e, avg_normal_cut, avg_s, avg_cc
def net_structure(dataset_dir, output_dir, net, IsDir, weight): print( "\n######################################################################\n" ) if os.path.isfile(str(output_dir) + str(net) + "_net_struct.json"): print("Arquivo já existe: " + str(output_dir) + str(net) + "_net_struct.json") else: print("Dataset network structure - " + str(dataset_dir)) n = [] # Média dos nós por rede-ego e = [] # Média das arestas por rede-ego bc_n = [] # média de betweenness centrality dos nós bc_e = [] # média de betweenness centrality das arestas i = 0 for file in os.listdir(dataset_dir): i += 1 print( str(output_dir) + str(net) + " - Calculando propriedades para o ego " + str(i) + ": " + str(file)) if IsDir is True: G = snap.LoadEdgeList( snap.PNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') else: G = snap.LoadEdgeList( snap.PUNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') ##################################################################################### n.append(G.GetNodes()) # Numero de vertices e.append(G.GetEdges()) # Numero de arestas n_nodes = G.GetNodes() n_edges = G.GetEdges() ##################################################################################### if n_edges == 0 or n_nodes < 3: bc_n.append(n_edges) bc_e.append(n_edges) else: Nodes = snap.TIntFltH() Edges = snap.TIntPrFltH() snap.GetBetweennessCentr( G, Nodes, Edges, 1.0, IsDir) #Betweenness centrality Nodes and Edges _bc_n = [] _bc_e = [] if IsDir is True: max_betweenneess = (n_nodes - 1) * (n_nodes - 2) else: max_betweenneess = ((n_nodes - 1) * (n_nodes - 2)) / 2 for node in Nodes: bc_n_normalized = float( Nodes[node]) / float(max_betweenneess) _bc_n.append(bc_n_normalized) for edge in Edges: bc_e_normalized = float( Edges[edge]) / float(max_betweenneess) _bc_e.append(bc_e_normalized) result = calc.calcular(_bc_n) bc_n.append(result['media']) result = calc.calcular(_bc_e) bc_e.append(result['media']) ##################################################################################### BC_N = calc.calcular_full(bc_n) BC_E = calc.calcular_full(bc_e) overview = {} overview['BetweennessCentrNodes'] = BC_N overview['BetweennessCentrEdges'] = BC_E with open(str(output_dir) + str(net) + "_net_struct.json", 'w') as f: f.write(json.dumps(overview)) with open(str(output_dir) + str(net) + "_net_struct.txt", 'w') as f: f.write( "\n######################################################################\n" ) f.write( "Betweenness Centr Nodes: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (BC_N['media'], BC_N['variancia'], BC_N['desvio_padrao'])) f.write( "Betweenness Centr Edges: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (BC_E['media'], BC_E['variancia'], BC_E['desvio_padrao'])) f.write( "\n######################################################################\n" )
def prepare_communities(community_file, n_nodes): i = 0 communities = { } # Dicionário com uma chave (id da community): e uma lista de ids dos membros da comunidade alters_set = set() size = [] # Lista com os tamanhos das communidades size_norm = [ ] # Lista com os tamanhos das communidades normalizada pelo número de vértices da rede-ego greater_comm_norm = 0 # Tamanho da maior comunidade normalizado pelo conjunto de vértices do grafo n_singletons = 0 # Número de Singletons (comunidades formada por apenas um vértice) n_non_singletons = 0 # Número de Não Singletons greater_comm = 0 # Tamanho da maior comunidade smaller_comm = "inf" # Tamanho da menor comunidade for line in community_file: i += 1 key = "com" + str( i) # Chave para o dicionário comm - um identificador "comm1" comm = [] # Lista para armazenar as os membros da comunidade i a = line.split(' ') for item in a: if item != "\n": comm.append(long(item)) alters_set.add(long(item)) if len(comm) > 1: n_non_singletons += 1 elif len(comm) == 1: n_singletons += 1 if len(comm) > greater_comm: # Tamanho da maior comunidade greater_comm = len(comm) if len(comm) < smaller_comm: # Tamanho da menor comunidade smaller_comm = len(comm) communities[ key] = comm # dicionário communities recebe a lista de ids dos membros das comunidades tendo como chave o valor key b = float(len(comm)) / float(n_nodes) size.append(len(comm)) size_norm.append(b) n_comm = len( communities) # Quantidade de comunidades para o ego em questão greater_comm_norm = float(greater_comm) / float(n_nodes) if n_nodes > alters_set: alters_ignored = n_nodes - len( alters_set ) # Número de alters que foram ignorados no processo de detecção e não receberam rótulos. alters_ignored_norm = float(alters_ignored) / float(n_nodes) else: alters_ignored = 0 alters_ignored_norm = 0 avg_size = calc.calcular_full( size) # Somar o vetor com o tamanho das comunidades... avg_size_norm = calc.calcular( size_norm ) # Somar o vetor com o tamanho das comunidades normalizado... overlap = float(avg_size['soma']) / float( n_nodes ) # The overlap: the average number of communities to which each vertex belongs. This is the sum of the sizes of all communities (including singletons) divided by the number of vertices, n. return communities, n_comm, size, avg_size['media'], avg_size[ 'desvio_padrao'], size_norm, avg_size_norm[ 'media'], overlap, n_singletons, n_non_singletons, alters_ignored, alters_ignored_norm, greater_comm, greater_comm_norm, smaller_comm
def calc_metric(G, metric): IsDir = True # Todas as redes são direcionadas n_nodes = G.GetNodes() n_edges = G.GetEdges() if metric == "nodes": result = n_nodes elif metric == "edges": result = n_edges elif metric == "size": result = n_nodes + n_edges elif metric == "avg_degree": result = float(2 * n_edges) / float(n_nodes) elif metric == "diameter": result = snap.GetBfsFullDiam(G, 100, IsDir) elif metric == "density": result = float(n_edges) / (float(n_nodes) * (float(n_nodes - 1))) elif metric == "closeness_centr": Normalized = True cc = [] for NI in G.Nodes(): cc.append(snap.GetClosenessCentr( G, NI.GetId(), Normalized, IsDir)) #get a closeness centrality _cc = calc.calcular(cc) result = _cc['media'] elif metric == "betweenness_centr_nodes": bc_n = [] if n_edges == 0 or n_nodes < 3: bc_n.append(int(0)) else: Nodes = snap.TIntFltH() Edges = snap.TIntPrFltH() snap.GetBetweennessCentr(G, Nodes, Edges, 1.0, IsDir) #Betweenness centrality Nodes if IsDir is True: max_betweenneess = (n_nodes - 1) * (n_nodes - 2) else: max_betweenneess = ((n_nodes - 1) * (n_nodes - 2)) / 2 for node in Nodes: bc_n_normalized = float(Nodes[node]) / float(max_betweenneess) bc_n.append(bc_n_normalized) _bc_n = calc.calcular(bc_n) result = _bc_n['media'] elif metric == "betweenness_centr_edges": bc_e = [] if n_edges == 0 or n_nodes < 3: bc_e.append(int(0)) else: Nodes = snap.TIntFltH() Edges = snap.TIntPrFltH() snap.GetBetweennessCentr(G, Nodes, Edges, 1.0, IsDir) #Betweenness centrality Edges if IsDir is True: max_betweenneess = (n_nodes - 1) * (n_nodes - 2) else: max_betweenneess = ((n_nodes - 1) * (n_nodes - 2)) / 2 for edge in Edges: bc_e_normalized = float(Edges[edge]) / float(max_betweenneess) bc_e.append(bc_e_normalized) _bc_e = calc.calcular(bc_e) result = _bc_e['media'] elif metric == "clust_coef": result = snap.GetClustCf(G, -1) else: result = None print("\nImpossível calcular " + str(metric)) print("\n") sys.exit() return result
def net_structure(dataset_dir, output_dir, net, IsDir, weight): print( "\n######################################################################\n" ) if os.path.isfile(str(output_dir) + str(net) + "_clustering_coef.json"): print("Arquivo já existe: " + str(output_dir) + str(net) + "_clustering_coef.json") else: print("Dataset clustering coefficient - " + str(dataset_dir)) cf = [] # Média dos coeficientes de clusterings por rede-ego gcf = [] # Média usando opção global n = [] # vetor com número de vértices para cada rede-ego e = [] # vetor com número de arestas para cada rede-ego i = 0 for file in os.listdir(dataset_dir): i += 1 print( str(output_dir) + str(net) + "/" + str(file) + " - Calculando propriedades para o ego " + str(i) + ": " + str(file)) if IsDir is True: G = snap.LoadEdgeList( snap.PNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') else: G = snap.LoadEdgeList( snap.PUNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') # G.Dump() # time.sleep(5) ##################################################################################### n.append(G.GetNodes()) # Numero de vertices e.append(G.GetEdges()) # Numero de arestas n_nodes = G.GetNodes() n_edges = G.GetEdges() ##################################################################################### #Usando opção local - Retorna o mesmo resultado do global if n_edges == 0: a = 0 cf.append(a) print("Nenhuma aresta encontrada para a rede-ego " + str(i) + " - (" + str(file)) else: NIdCCfH = snap.TIntFltH() snap.GetNodeClustCf(G, NIdCCfH) _cf = [] for item in NIdCCfH: _cf.append(NIdCCfH[item]) # Clusterinf Coefficient result = calc.calcular(_cf) cf.append(result['media']) print("Clustering Coef para o ego " + str(i) + " (" + str(file) + "): " + str(result['media'])) print ##################################################################################### #Usando opção global - Retorna o mesmo resultado do local # # if n_edges == 0: # a = 0 # gcf.append(a) # else: # GraphClustCoeff = snap.GetClustCf (G) # gcf.append(GraphClustCoeff) # print "Clustering coefficient: %f" % GraphClustCoeff # print ##################################################################################### CF = calc.calcular_full(cf) overview = {} overview['ClusteringCoefficient'] = CF with open(str(output_dir) + str(net) + "_clustering_coef.json", 'w') as f: f.write(json.dumps(overview)) with open(str(output_dir) + str(net) + "_clustering_coef.txt", 'w') as f: f.write( "\n######################################################################\n" ) f.write( "Clustering Coef: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (CF['media'], CF['variancia'], CF['desvio_padrao'])) f.write( "\n######################################################################\n" ) print( "\n######################################################################\n" ) print( "Clustering Coef: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (CF['media'], CF['variancia'], CF['desvio_padrao'])) print( "\n######################################################################\n" )
def calculate_alg(singletons,net,uw,ud,g_type,alg): communities = "/home/amaury/communities_hashmap/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" graphs = "/home/amaury/graphs_hashmap_infomap_without_weight/"+str(net)+"/"+str(g_type)+"/" # Todos os grafos serão considerados sem peso... out_ad = str(output_dir)+"average_degree/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_c = str(output_dir)+"conductance/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_cut_r = str(output_dir)+"cut_ratio/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_d = str(output_dir)+"density/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_e = str(output_dir)+"expansion/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_normal_cut = str(output_dir)+"normalized_cut/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_s = str(output_dir)+"separability/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" out_s = str(output_dir)+"clustering/"+str(g_type)+"/"+str(alg)+"/"+str(singletons)+"/"+str(net)+"/" _avg_time = [] if not os.path.exists(communities): print ("Diretório com as comunidades não encontrado: "+str(communities)+"\n") else: print("\n######################################################################") for threshold in os.listdir(communities): if not os.path.isdir(str(communities)+str(threshold)+"/"): print ("Threshold para a rede "+str(net)+" não encontrado: "+str(threshold)) else: partial_start = time.time() create_dirs(out_ad,out_c,out_cut_r,out_d,out_e,out_normal_cut,out_s) if os.path.exists(str(out_ad)+str(threshold)+".json") and os.path.exists(str(out_c)+str(threshold)+".json") and os.path.exists(str(out_cut_r)+str(threshold)+".json") and os.path.exists(str(out_d)+str(threshold)+".json") and os.path.exists(str(out_e)+str(threshold)+".json") and os.path.exists(str(out_normal_cut)+str(threshold)+".json") and os.path.exists(str(out_s)+str(threshold)+".json"): print ("Arquivo de destino já existe: "+str(threshold)+".json") else: print("######################################################################") average_degree = {} conductance = {} cut_ratio = {} density = {} expansion = {} normalized_cut = {} separability = {} clustering = {} i=0 #Ponteiro para o ego for file in os.listdir(str(communities)+str(threshold)+"/"): if os.path.isfile(str(communities)+str(threshold)+"/"+file): ego_id = file.split(".txt") ego_id = long(ego_id[0]) i+=1 if not os.path.isfile(str(graphs)+str(ego_id)+".edge_list"): print ("ERROR - EGO: "+str(i)+" - Arquivo com lista de arestas não encontrado:" +str(graphs)+str(ego_id)+".edge_list") else: with open(str(communities)+str(threshold)+"/"+file, 'r') as community_file: if ud is True and uw is False: # Se o grafo é UNDirected e Weighted (n5,n6,n7,n8,n10) G = nx.read_weighted_edgelist(str(graphs)+str(ego_id)+".edge_list") elif ud is False and uw is False: # Se o grafo é Directed e Weighted (n2,n3,n4) G = nx.read_weighted_edgelist(str(graphs)+str(ego_id)+".edge_list",create_using=nx.DiGraph()) elif ud is False and uw is True: # Se o grafo é Directed e UNWeighted (n1,n9) G = nx.read_edgelist(str(graphs)+str(ego_id)+".edge_list") else: ("\ERROR - Impossível criar grafo com as configurações de ud e uw: "+str(uw),str(ud)) G = 0 sys.exit() print(str(g_type)+" - "+str(alg)+" - "+str(singletons)+" - Rede: "+str(net)+" - THRESHOLD: "+str(threshold)+" - ego("+str(i)+"): "+str(file)) communities_dict = prepare_communities(community_file) #Função para devolver um dicionário com as comunidades avg_ad,avg_c,avg_cut_r,avg_d,avg_e,avg_normal_cut,avg_s, avg_cc = metrics_networkx.calc_metrics(communities_dict,G,uw,ud) # Calcular as métricas average_degree[ego_id] = avg_ad conductance[ego_id] = avg_c cut_ratio[ego_id] = avg_cut_r density[ego_id] = avg_d expansion[ego_id] = avg_e normalized_cut[ego_id] = avg_normal_cut separability[ego_id] = avg_s clustering[ego_id] = avg_cc print("######################################################################") with open(str(out_ad)+str(threshold)+".json", "w") as f: f.write(json.dumps(average_degree)) with open(str(out_c)+str(threshold)+".json", "w") as f: f.write(json.dumps(conductance)) with open(str(out_cut_r)+str(threshold)+".json", "w") as f: f.write(json.dumps(cut_ratio)) with open(str(out_d)+str(threshold)+".json", "w") as f: f.write(json.dumps(density)) with open(str(out_e)+str(threshold)+".json", "w") as f: f.write(json.dumps(expansion)) with open(str(out_normal_cut)+str(threshold)+".json", "w") as f: f.write(json.dumps(normalized_cut)) with open(str(out_s)+str(threshold)+".json", "w") as f: f.write(json.dumps(separability)) with open(str(out_s)+str(threshold)+".json", "w") as f: f.write(json.dumps(clustering)) partial_end = time.time() partial_time_exec = partial_end - partial_start print ("\nTempo de execução para o threshold "+str(threshold)+": "+str(partial_time_exec)+"\n") _avg_time.append(partial_time_exec) avg_time = calc.calcular(_avg_time) print ("\nTempo de médio de execução em cada threshold: "+str(avg_time)+"\n") print("\n######################################################################\n")
def statistics(dataset_dir, output_dir, net, isdir): print( "\n######################################################################\n" ) print("Dataset statistics - " + str(dataset_dir)) IsDir = isdir n = [] # Média dos nós por rede-ego e = [] # Média das arestas por rede-ego d = [] # Média dos diametros por rede-ego cc = [] # Média dos coeficientes de clusterings por rede-ego bc_n = [] # média de betweenness centrality dos nós bc_e = [] # média de betweenness centrality das arestas i = 0 for file in os.listdir(dataset_dir): i += 1 print("Calculando propriedades para o ego %d..." % (i)) G = snap.LoadEdgeList(snap.PNGraph, dataset_dir + file, 0, 1) # load from a text file n.append(G.GetNodes()) # Numero de vertices e.append(G.GetEdges()) # Numero de arestas d.append(snap.GetBfsFullDiam(G, 100, IsDir)) # get diameter of G # cc.append(snap.GetClustCf(G)) # clustering coefficient of G Nodes = snap.TIntFltH() Edges = snap.TIntPrFltH() snap.GetBetweennessCentr(G, Nodes, Edges, 1.0, IsDir) _bc_n = [] _bc_e = [] for node in Nodes: _bc_n.append(Nodes[node]) for edge in Edges: _bc_e.append(Edges[edge]) result = calc.calcular(_bc_n) bc_n.append(result['media']) result = calc.calcular(_bc_e) bc_e.append(result['media']) ##################################################################################### N = calc.calcular_full(n) E = calc.calcular_full(e) D = calc.calcular_full(d) BC_N = calc.calcular_full(bc_n) BC_E = calc.calcular_full(bc_e) print( "\n######################################################################\n" ) print("NET: %s -- Egos-net: %d" % (net, len(n))) print("Nodes: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f" % (N['media'], N['variancia'], N['desvio_padrao'])) print("Edges: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f" % (E['media'], E['variancia'], E['desvio_padrao'])) print("Diameter: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f" % (D['media'], D['variancia'], D['desvio_padrao'])) print( "Betweenness Centr Nodes: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f" % (BC_N['media'], BC_N['variancia'], BC_N['desvio_padrao'])) print( "Betweenness Centr Edges: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f" % (BC_E['media'], BC_E['variancia'], BC_E['desvio_padrao'])) print( "\n######################################################################\n" )
def net_structure(dataset_dir, output_dir, net, IsDir, weight): print( "\n######################################################################\n" ) if os.path.isfile(str(output_dir) + str(net) + "_net_struct.json"): print("Arquivo já existe: " + str(output_dir) + str(net) + "_net_struct.json") else: print("Dataset network structure - " + str(dataset_dir)) n = [] # Média dos nós por rede-ego e = [] # Média das arestas por rede-ego nodes = {} # chave_valor para ego_id e numero de vertices edges = {} # chave_valor para ego_id e numero de arestas d = [] # Média dos diametros por rede-ego cc = [] # Média dos Close Centrality bc_n = [] # média de betweenness centrality dos nós bc_e = [] # média de betweenness centrality das arestas degree = { } # chave-valor para armazenar "grau dos nós - numero de nós com este grau" i = 0 for file in os.listdir(dataset_dir): ego_id = file.split(".edge_list") ego_id = long(ego_id[0]) i += 1 print( str(output_dir) + str(net) + " - Calculando propriedades para o ego " + str(i) + ": " + str(file)) if IsDir is True: G = snap.LoadEdgeList( snap.PNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') else: G = snap.LoadEdgeList( snap.PUNGraph, dataset_dir + file, 0, 1 ) # load from a text file - pode exigir um separador.: snap.LoadEdgeList(snap.PNGraph, file, 0, 1, '\t') ##################################################################################### n_nodes = G.GetNodes() n_edges = G.GetEdges() nodes[ego_id] = n_nodes #Dicionário ego_id = vertices edges[ego_id] = n_edges n.append(n_nodes) # Numero de vértices e.append(n_edges) # Número de Arestas ##################################################################################### if n_edges == 0: a = 0 d.append(a) cc.append(a) bc_n.append(a) bc_e.append(a) else: d.append(snap.GetBfsFullDiam(G, 100, IsDir)) # get diameter of G ##################################################################################### _cc = [] Normalized = True for NI in G.Nodes(): _cc.append( snap.GetClosenessCentr( G, NI.GetId(), Normalized, IsDir)) #get a closeness centrality result = calc.calcular(_cc) cc.append(result['media']) ##################################################################################### if n_edges == 0 or n_nodes < 3: bc_n.append(n_edges) bc_e.append(n_edges) else: Nodes = snap.TIntFltH() Edges = snap.TIntPrFltH() snap.GetBetweennessCentr( G, Nodes, Edges, 1.0, IsDir) #Betweenness centrality Nodes and Edges _bc_n = [] _bc_e = [] if IsDir is True: max_betweenneess = (n_nodes - 1) * (n_nodes - 2) else: max_betweenneess = ((n_nodes - 1) * (n_nodes - 2)) / 2 for node in Nodes: bc_n_normalized = float( Nodes[node]) / float(max_betweenneess) _bc_n.append(bc_n_normalized) for edge in Edges: bc_e_normalized = float( Edges[edge]) / float(max_betweenneess) _bc_e.append(bc_e_normalized) result = calc.calcular(_bc_n) bc_n.append(result['media']) result = calc.calcular(_bc_e) bc_e.append(result['media']) ##################################################################################### DegToCntV = snap.TIntPrV() snap.GetDegCnt(G, DegToCntV) #Grau de cada nó em cada rede-ego for item in DegToCntV: k = item.GetVal1() v = item.GetVal2() if degree.has_key(k): degree[k] = degree[k] + v else: degree[k] = v ##################################################################################### print n[i - 1], e[i - 1], d[i - 1], cc[i - 1], bc_n[i - 1], bc_e[i - 1] print ##################################################################################### N = calc.calcular_full(n) E = calc.calcular_full(e) histogram.histogram(degree, output_dir + "histogram" + "/", N['soma'], net) D = calc.calcular_full(d) CC = calc.calcular_full(cc) BC_N = calc.calcular_full(bc_n) BC_E = calc.calcular_full(bc_e) overview = {} overview['Nodes'] = N overview['Edges'] = E overview['Diameter'] = D overview['CloseCentr'] = CC overview['BetweennessCentrNodes'] = BC_N overview['BetweennessCentrEdges'] = BC_E nodes_stats = calc.calcular_full(n) edges_stats = calc.calcular_full(e) overview_basics = { 'nodes': n, 'nodes_stats': nodes_stats, 'edges': e, 'edges_stats': edges_stats } output_basics = output_dir + "/" + str(net) + "/" if not os.path.exists(output_basics): os.makedirs(output_basics) with open(str(output_basics) + str(net) + "_nodes.json", 'w') as f: f.write(json.dumps(nodes)) with open(str(output_basics) + str(net) + "_edges.json", 'w') as f: f.write(json.dumps(edges)) with open(str(output_basics) + str(net) + "_overview.json", 'w') as f: f.write(json.dumps(overview_basics)) with open(str(output_dir) + str(net) + "_net_struct.json", 'w') as f: f.write(json.dumps(overview)) with open(str(output_dir) + str(net) + "_net_struct.txt", 'w') as f: f.write( "\n######################################################################\n" ) f.write("NET: %s -- Ego-nets: %d \n" % (net, len(n))) f.write( "Nodes: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (N['media'], N['variancia'], N['desvio_padrao'])) f.write( "Edges: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (E['media'], E['variancia'], E['desvio_padrao'])) f.write( "Diameter: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (D['media'], D['variancia'], D['desvio_padrao'])) f.write( "CloseCentr: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (CC['media'], CC['variancia'], CC['desvio_padrao'])) f.write( "Betweenness Centr Nodes: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (BC_N['media'], BC_N['variancia'], BC_N['desvio_padrao'])) f.write( "Betweenness Centr Edges: Média: %5.3f -- Var:%5.3f -- Des. Padrão: %5.3f \n" % (BC_E['media'], BC_E['variancia'], BC_E['desvio_padrao'])) f.write( "\n######################################################################\n" )