def plot_intact_basic(num_it=10): print("Plotting intact") multilayer_network = multinet.multi_layer_network().load_network( "../datasets/intact02.gpickle", input_type="gpickle", directed=False).add_dummy_layers() network_colors, graph = multilayer_network.get_layers(style="hairball") partition = cw.louvain_communities(multilayer_network) # select top n communities by size top_n = 3 partition_counts = dict(Counter(partition.values())) top_n_communities = list(partition_counts.keys())[0:top_n] # assign node colors color_mappings = dict( zip(top_n_communities, [x for x in colors_default if x != "black"][0:top_n])) network_colors = [ color_mappings[partition[x]] if partition[x] in top_n_communities else "black" for x in multilayer_network.get_nodes() ] layout_parameters = {"iterations": num_it, "forceImport": True} f = plt.figure() hairball_plot(graph, network_colors, legend=False, layout_parameters=layout_parameters) f.savefig("../example_images/intact_" + str(num_it) + "_BH_basic.png", bbox_inches='tight', dpi=300)
def visualize_network(input_file, input_type, directed, top_n_communities): network = multinet.multi_layer_network().load_network( input_file=args.input_network, directed=directed, input_type=args.input_type) network.basic_stats() ## check core imports partition = cw.louvain_communities(network.core_network) ## select top n communities by size top_n = top_n_communities partition_counts = dict(Counter(partition.values())) top_n_communities = list(partition_counts.keys())[0:top_n] ## assign node colors color_mappings = dict( zip(top_n_communities, [x for x in colors_default if x != "black"][0:top_n])) network_colors = [ color_mappings[partition[x]] if partition[x] in top_n_communities else "black" for x in network.get_nodes() ] ## visualize the network's communities! hairball_plot(network.core_network, color_list=network_colors, layered=False, layout_parameters={"iterations": args.iterations}, scale_by_size=True, layout_algorithm="force", legend=False) plt.show()
from py3plex.core import random_generators from py3plex.algorithms.community_detection import community_wrapper as cw from py3plex.core import multinet ER_multilayer = random_generators.random_multilayer_ER(50, 8, 0.05, directed=False) partition = cw.louvain_communities(ER_multilayer) print(partition) comNet = multinet.multi_layer_network().load_network( '../datasets/simple_multiplex.edgelist', directed=False, input_type='multiplex_edges') comNet.load_layer_name_mapping('../datasets/simple_multiplex.txt') comNet.basic_stats() part = cw.louvain_communities(comNet) print(part)
"../datasets/test_embedding.emb", binary="../bin/node2vec", weighted=False) # preprocess and check embedding -- for speed, install parallel tsne from https://github.com/DmitryUlyanov/Multicore-TSNE, py3plex knows how to use it. multilayer_network.load_embedding("../datasets/test_embedding.emb") output_positions = embedding_tools.get_2d_coordinates_tsne( multilayer_network, output_format="pos_dict") # custom layouts are part of the custom coordinate option layout_parameters = {"iterations": 200} layout_parameters['pos'] = output_positions # assign parameters network_colors, graph = multilayer_network.get_layers(style="hairball") partition = cw.louvain_communities(multilayer_network) # select top n communities by size top_n = 10 partition_counts = dict(Counter(partition.values())) top_n_communities = list(partition_counts.keys())[0:top_n] # assign node colors color_mappings = dict( zip(top_n_communities, [x for x in colors_default if x != "black"][0:top_n])) network_colors = [ color_mappings[partition[x]] if partition[x] in top_n_communities else "black" for x in multilayer_network.get_nodes()
# community-based semantic subgroup discovery (skrlj 2017) API. Note this does not include the biomine calls # this works for UniProt identifiers TODO:generalize! from py3plex.core import multinet from py3plex.algorithms import hedwig from py3plex.algorithms.community_detection import community_wrapper as cw # load as undirected (simplified example) network = multinet.multi_layer_network().load_network( "../datasets/intact02.gpickle", directed=False, input_type="gpickle") network.basic_stats() partition = cw.louvain_communities(network) # convert examples to RDF mappings and check the validity, use gzipped gaf files.. dataset_name = "../datasets/example_partition_inputs.n3" print(partition) rdf_partitions = hedwig.convert_mapping_to_rdf( partition, annotation_mapping_file="../datasets/goa_human.gaf.gz", layer_type="uniprotkb") rdf_partitions.serialize(destination=dataset_name, format="n3") # convert obo file to n3 hedwig.obo2n3("../datasets/go.obo.gz", "../background_knowledge/bk.n3", "../datasets/goa_human.gaf.gz") # some default input parameters
def benchmark_on_dataset(graph, ground_truth, folder_path, network_tag, network_name): network = multinet.multi_layer_network() network.core_network = graph sparse_mat = nx.to_scipy_sparse_matrix(graph) node_set = network.core_network.nodes() NRC = SCD_obj(sparse_mat, node_names=node_set) num_important = 1000 param1 = { "verbose": False, "sparisfy": False, "parallel_step": 8, "prob_threshold": 0.0005, "community_range": [5, sparse_mat.shape[1], 10], "num_important": num_important, "clustering_measure": "silhouette", "stopping": 2, "improvement_step": 0.005, "node_feature_type": "ppr_embedding" } param2 = { "verbose": False, "sparisfy": False, "parallel_step": 8, "prob_threshold": 0.0005, "community_range": [5, sparse_mat.shape[1], 10], "num_important": num_important, "clustering_measure": "silhouette", "stopping": 5, "improvement_step": 0.005, "node_feature_type": "netmf_embedding" } with timeout(10000): print("LP...") # print(list(commod.label_propagation.(network.core_network.to_undirected()))) partition_lp = { enx: x for enx, x in enumerate( list( commod.label_propagation.asyn_lpa_communities( network.core_network))) } par_tmp = {} for k, v in partition_lp.items(): for x in v: par_tmp[x] = int(k) partition_lp = par_tmp with timeout(10000): print("EBC...") partition_EBC = NRC.detect_communities(**param2) with timeout(10000): print("INM...") partition_infomap = cw.infomap_communities(network, binary="../bin/Infomap", multiplex=False, verbose=False) with timeout(3600): print("NORC...") partition_norc = NRC.detect_communities(**param1) with timeout(10000): print("Louvain...") partition_louvain = cw.louvain_communities(network) results = [] ncl = cm.number_of_communities(partition_louvain) nci = cm.number_of_communities(partition_infomap) ncn = cm.number_of_communities(partition_norc) nce = cm.number_of_communities(partition_EBC) nclp = cm.number_of_communities(partition_lp) al, gl, com_l = get_community_assignments(partition_louvain, ground_truth) an, gn, com_norc = get_community_assignments(partition_norc, ground_truth) ai, gi, com_im = get_community_assignments(partition_infomap, ground_truth) aebc, gebc, com_EBC = get_community_assignments(partition_EBC, ground_truth) alp, glp, com_lp = get_community_assignments(partition_lp, ground_truth) if args.visualize_graphs == "True": partitions = [ ground_truth, partition_EBC, partition_lp, partition_norc, partition_louvain, partition_infomap ] ctx = 0 for partition in partitions: ctx += 1 visualize_a_partition(graph, partition, ctx) NMI_louvain = normalized_mutual_info_score(al, gl) NMI_infomap = normalized_mutual_info_score(ai, gi) NMI_EBC = normalized_mutual_info_score(aebc, gebc) NMI_norc = normalized_mutual_info_score(an, gn) NMI_lp = normalized_mutual_info_score(alp, glp) ARI_louvain = adjusted_rand_score(al, gl) ARI_EBC = adjusted_rand_score(aebc, gebc) ARI_infomap = adjusted_rand_score(ai, gi) ARI_norc = adjusted_rand_score(an, gn) ARI_lp = adjusted_rand_score(alp, glp) louvain_modularity = cm.modularity(graph, com_l) infomap_modularity = cm.modularity(graph, com_im) norc_modularity = cm.modularity(graph, com_norc) EBC_modularity = cm.modularity(graph, com_EBC) lp_modularity = cm.modularity(graph, com_lp) out_object_EBC = { "Network_name": network_name, "folder_path": folder_path, "Network_tag": network_tag, "algorithm": "EBC", "number_of_communities": nce, "modularity": EBC_modularity, "NMI": NMI_EBC, "ARI": ARI_EBC } out_object_lp = { "Network_name": network_name, "folder_path": folder_path, "Network_tag": network_tag, "algorithm": "LabelPropagation", "number_of_communities": nclp, "modularity": lp_modularity, "NMI": NMI_lp, "ARI": ARI_lp } #out_object_async = {"Network_name": network_name, "folder_path": folder_path, "Network_tag":network_tag,"algorithm":"AsyncLP","number_of_communities":ncalp,"modularity":async_modularity,"NMI":NMI_async,"ARI":ARI_async} out_object_nc = { "Network_name": network_name, "folder_path": folder_path, "Network_tag": network_tag, "algorithm": "NoRC", "number_of_communities": ncn, "modularity": norc_modularity, "NMI": NMI_norc, "ARI": ARI_norc } out_object_im = { "Network_name": network_name, "folder_path": folder_path, "Network_tag": network_tag, "algorithm": "Infomap", "number_of_communities": nci, "modularity": infomap_modularity, "NMI": NMI_infomap, "ARI": ARI_infomap } out_object_lv = { "Network_name": network_name, "folder_path": folder_path, "Network_tag": network_tag, "algorithm": "Louvain", "number_of_communities": ncl, "modularity": louvain_modularity, "NMI": NMI_louvain, "ARI": ARI_louvain } # results.append(out_object_async) results.append(out_object_EBC) results.append(out_object_lp) results.append(out_object_nc) results.append(out_object_im) results.append(out_object_lv) for obj in results: print("\t".join([ "RESULT_LINE", obj['Network_tag'], obj['algorithm'], str(obj['number_of_communities']), str(obj['modularity']), str(obj['NMI']), str(obj['ARI']) ])) return results
def plot_intact_embedding(num_it): # string layout for larger network ----------------------------------- multilayer_network = multinet.multi_layer_network().load_network( "../datasets/intact02.gpickle", input_type="gpickle", directed=False).add_dummy_layers() multilayer_network.basic_stats() # use embedding to first initialize the nodes.. # call a specific n2v compiled binary train_node2vec_embedding.call_node2vec_binary( "../datasets/IntactEdgelistedges.txt", "../datasets/test_embedding.emb", binary="../bin/node2vec", weighted=False) # preprocess and check embedding -- for speed, install parallel tsne from https://github.com/DmitryUlyanov/Multicore-TSNE, py3plex knows how to use it. multilayer_network.load_embedding("../datasets/test_embedding.emb") # load the positions and select the projection algorithm output_positions = embedding_tools.get_2d_coordinates_tsne( multilayer_network, output_format="pos_dict") # custom layouts are part of the custom coordinate option layout_parameters = {"iterations": num_it} layout_parameters['pos'] = output_positions # assign parameters network_colors, graph = multilayer_network.get_layers(style="hairball") partition = cw.louvain_communities(multilayer_network) # select top n communities by size top_n = 10 partition_counts = dict(Counter(partition.values())) top_n_communities = list(partition_counts.keys())[0:top_n] # assign node colors color_mappings = dict( zip(top_n_communities, [x for x in colors_default if x != "black"][0:top_n])) network_colors = [ color_mappings[partition[x]] if partition[x] in top_n_communities else "black" for x in multilayer_network.get_nodes() ] f = plt.figure() # gravity=0.2,strongGravityMode=False,barnesHutTheta=1.2,edgeWeightInfluence=1,scalingRatio=2.0 hairball_plot(graph, network_colors, layout_algorithm="custom_coordinates_initial_force", layout_parameters=layout_parameters, nodesize=0.02, alpha_channel=0.30, edge_width=0.001, scale_by_size=False) f.savefig("../datasets/" + str(num_it) + "intact.png", bbox_inches='tight', dpi=300)