def py3plex_visualization(network): start = time.time() multilayer_network = multinet.multi_layer_network( verbose=False).load_network(network, directed=False, input_type="multiedge_tuple_list") network_labels, graphs, multilinks = multilayer_network.get_layers( ) # get layers for visualization draw_multilayer_default(graphs, display=False, background_shape="circle", labels=network_labels, layout_algorithm="force", verbose=False) enum = 1 color_mappings = {idx: col for idx, col in enumerate(colors_default)} for edge_type, edges in multilinks.items(): draw_multiedges(graphs, edges, alphachannel=0.2, linepoints="-.", linecolor="black", curve_height=5, linmod="upper", linewidth=0.4) enum += 1 end = time.time() plt.show() plt.clf() return (end - start)
def test_basic_visualizatio3(): multilayer_network = multinet.multi_layer_network().load_network( "./datasets/multinet_k100.txt", directed=True, input_type="multiedgelist") multilayer_network.basic_stats() multilayer_network.visualize_network()
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) NRC = NoRC(sparse_mat) node_set = network.core_network.nodes() num_important = 1000 param2 = { "verbose": False, "sparisfy": False, "parallel_step": 8, "prob_threshold": 0.0005, "community_range": [5, sparse_mat.shape[1], 10], "num_important": num_important, "node_names": node_set, "clustering_measure": "silhouette", "stopping": 3, "improvement_step": 0.005, "node_feature_type": "embedding" } print("EBC...") partition_EBC = NRC.detect_communities(**param2) try: cluster_quality = NRC.cluster_quality with open('traces/traces_{}.json'.format(network_name), 'w') as outfile: json.dump(cluster_quality, outfile) except Exception as es: print(es) pass
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 test_basic_visualizatio3(): logging.info("Import viz test 3") multilayer_network = multinet.multi_layer_network().load_network( "datasets/multinet_k100.txt", directed=True, input_type="multiedgelist") multilayer_network.basic_stats() multilayer_network.visualize_network()
def test_basic_visualizatio6(): ## string layout for larger network ----------------------------------- multilayer_network = multinet.multi_layer_network().load_network( "./datasets/soc-Epinions1.edgelist", label_delimiter="---", input_type="edgelist", directed=True) hairball_plot(multilayer_network.core_network, layout_parameters={"iterations": 300})
def test_basic_visualizatio5(): ## basic string layout ---------------------------------- multilayer_network = multinet.multi_layer_network().load_network( "./datasets/epigenetics.gpickle", directed=False, label_delimiter="---", input_type="gpickle_biomine") network_colors, graph = multilayer_network.get_layers(style="hairball") hairball_plot(graph, network_colors, legend=True)
def test_imports(): logging.info("Import tests") multilayer_network = multinet.multi_layer_network().load_network( "datasets/epigenetics.gpickle", directed=True, input_type="gpickle_biomine") multilayer_network = multinet.multi_layer_network().load_network( "datasets/ecommerce_0.gml", directed=True, input_type="gml") multilayer_network = multinet.multi_layer_network().load_network( "datasets/ions.mat", directed=False, input_type="sparse") multilayer_network = multinet.multi_layer_network().load_network( "datasets/test.edgelist", directed=False, input_type="edgelist") multilayer_network = multinet.multi_layer_network().load_network( "datasets/multiedgelist.txt", directed=False, input_type="multiedgelist") # multilayer_network = multinet.multi_layer_network().load_network("datasets/erdos_detangler.json",directed=False, input_type="detangler_json") ## TOD multilayer_network = multinet.multi_layer_network().load_network( "datasets/edgeList.txt", directed=False, input_type="multiedgelist") # save the network as a gpickle object multilayer_network.save_network( output_file="datasets/stored_network.gpickle", output_type="gpickle")
def test_basic_visualizatio5(): logging.info("Import viz test 6") # basic string layout ---------------------------------- multilayer_network = multinet.multi_layer_network().load_network( "datasets/epigenetics.gpickle", directed=False, label_delimiter="---", input_type="gpickle_biomine") network_colors, graph = multilayer_network.get_layers(style="hairball") hairball_plot(graph, network_colors, legend=True, layout_parameters={"iterations": 30})
def load_detangler_json(file_path): import json network = multinet.multi_layer_network() with open(file_path) as f: graph = json.load(f) id2n = {} for n in graph[u'nodes']: id2n[n[u'id']] = n layers = n[u'descriptors'].split(';') node = n[u'label'] for l in layers: node_dict = {'source': node, 'type': l} network.add_nodes(node_dict) for c in itertools.combinations(layers, 2): network.add_edges( { 'source': node, 'target': node, 'source_type': c[0], 'target_type': c[1] }, input_type='dict') for e in graph[u'links']: s = id2n[e[u'source']][u'label'] t = id2n[e[u'target']][u'label'] layers = e[u'descriptors'].split(';') for l in layers: network.add_edges( { 'source': s, 'target': t, 'type': l, 'source_type': l, 'target_type': l }, input_type='dict') return network
def test_basic_visualizati4(): ## multilayer ----------------------------------- logging.info("Import viz test 4") multilayer_network = multinet.multi_layer_network().load_network("datasets/epigenetics.gpickle",directed=True, input_type="gpickle_biomine") multilayer_network.basic_stats() ## check core imports #multilayer_network.visualize_network() ## visualize # ## You can also access individual graphical elements separately! network_labels, graphs, multilinks = multilayer_network.get_layers() ## get layers for visualizat# ion draw_multilayer_default(graphs,display=False,background_shape="circle",labels=network_labels) enum = 1 color_mappings = {idx : col for idx, col in enumerate(colors_default)} for edge_type,edges in multilinks.items(): # network_list,multi_edge_tuple,input_type="nodes",linepoints="-.",alphachannel=0.3,linecolor="black",curve_height=1,style="curve2_bezier",linewidth=1,invert=False,linmod="both",resolution=0.1 logging.info(edge_type) if edge_type == "refers_to": draw_multiedges(graphs,edges,alphachannel=0.05,linepoints="--",linecolor="lightblue",curve_height=5,linmod="upper",linewidth=0.4) elif edge_type == "refers_to": draw_multiedges(graphs,edges,alphachannel=0.2,linepoints=":",linecolor="green",curve_height=5,linmod="upper",linewidth=0.3) elif edge_type == "belongs_to": draw_multiedges(graphs,edges,alphachannel=0.2,linepoints=":",linecolor="red",curve_height=5,linmod="upper",linewidth=0.4) elif edge_type == "codes_for": draw_multiedges(graphs,edges,alphachannel=0.2,linepoints=":",linecolor="orange",curve_height=5,linmod="upper",linewidth=0.4) else: draw_multiedges(graphs,edges,alphachannel=0.2,linepoints="-.",linecolor="black",curve_height=5,linmod="both",linewidth=0.4) enum+=1 plt.clf() ## monotone coloring draw_multilayer_default(graphs,display=False,background_shape="rectangle",labels=network_labels,networks_color="black",rectanglex=2,rectangley=2,background_color="default") enum = 1 for edge_type,edges in multilinks.items(): draw_multiedges(graphs,edges,alphachannel=0.2,linepoints="--",linecolor="black",curve_height=2,linmod="upper",linewidth=0.4) enum+=1
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()
## simple embedding visualization example from py3plex.core import multinet from py3plex.visualization.embedding_visualization import embedding_visualization ## visualization steps multilayer_network = multinet.multi_layer_network().load_embedding("../datasets/test_embedding.emb") embedding_visualization.visualize_embedding(multilayer_network)
# simple plot of a larger file from collections import Counter from py3plex.algorithms.community_detection import community_wrapper as cw from py3plex.visualization.embedding_visualization import embedding_tools from py3plex.wrappers import train_node2vec_embedding from py3plex.visualization.multilayer import hairball_plot, plt from py3plex.visualization.colors import colors_default from py3plex.core import multinet # 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") output_positions = embedding_tools.get_2d_coordinates_tsne( multilayer_network, output_format="pos_dict") # custom layouts are part of the custom coordinate option
### simple supra adjacency matrix manipulation ## tensor-based operations examples from py3plex.core import multinet from py3plex.core import random_generators ## initiate an instance of a random graph ER_multilayer = random_generators.random_multilayer_ER(500, 8, 0.05, directed=False) mtx = ER_multilayer.get_supra_adjacency_matrix() comNet = multinet.multi_layer_network( network_type="multiplex", coupling_weight=1).load_network('../datasets/simple_multiplex.edgelist', directed=False, input_type='multiplex_edges') comNet.basic_stats() comNet.load_layer_name_mapping('../datasets/simple_multiplex.txt') mat = comNet.get_supra_adjacency_matrix() print(mat.shape) kwargs = {"display": True} comNet.visualize_matrix(kwargs) ## how are nodes ordered? for edge in comNet.get_edges(data=True): print(edge) print(comNet.node_order_in_matrix)
# simple example for saving to multiedgelists from py3plex.core import multinet multilayer_network = multinet.multi_layer_network().load_network( "../datasets/goslim_mirna.gpickle", directed=False, input_type="gpickle_biomine") # save to string-based representation multilayer_network.save_network("../datasets/mirna_multiedgelist.list", output_type="multiedgelist") # encode each node-layer pair with an int multilayer_network.save_network("../datasets/mirna_edgelist.list", output_type="edgelist") # save to string-based representation multilayer_network.save_network("../datasets/mirna_multiedgelist_encoded.list", output_type="multiedgelist_encoded") # mappings are saved into the main object! # print(multilayer_network.node_map) # print(multilayer_network.layer_map)
## visualization of a simple heterogeneous network from py3plex.visualization.multilayer import * from py3plex.visualization.colors import all_color_names, colors_default from py3plex.core import multinet ## visualization from a simple file multilayer_network = multinet.multi_layer_network().load_network( "../datasets/edgeList.txt", directed=False, input_type="multiedgelist") multilayer_network.basic_stats() multilayer_network.visualize_network() plt.show() multilayer_network = multinet.multi_layer_network().load_network( "../datasets/multiL.txt", directed=True, input_type="multiedgelist") multilayer_network.basic_stats() multilayer_network.visualize_network(style="diagonal") plt.show() multilayer_network = multinet.multi_layer_network().load_network( "../datasets/multinet_k100.txt", directed=True, input_type="multiedgelist") multilayer_network.basic_stats() multilayer_network.visualize_network() plt.show() ## multilayer ----------------------------------- multilayer_network = multinet.multi_layer_network().load_network( "../datasets/epigenetics.gpickle", directed=True, input_type="gpickle_biomine") multilayer_network.basic_stats() ## check core imports #multilayer_network.visualize_network() ## visualize
from py3plex.core import multinet ## a multilayer object A = multinet.multi_layer_network().load_network( "../datasets/multiedgelist.txt", input_type="multiedgelist", directed=False) A.basic_stats() ## this is nicer printing. A.monitor("Edge looping:") ## looping through edges: for edge in A.get_edges(data=True): print(edge) A.monitor("Node looping:") ## what about nodes? for node in A.get_nodes(data=True): print(node) C1 = A.subnetwork(['1'], subset_by="layers") A.monitor(list(C1.get_nodes())) C2 = A.subnetwork(['1'], subset_by="node_names") A.monitor(list(C2.get_nodes())) C3 = A.subnetwork([('1', '1'), ('2', '1')], subset_by="node_layer_names") A.monitor(list(C3.get_nodes()))
from py3plex.core import multinet from py3plex.wrappers import train_node2vec_embedding from py3plex.visualization.embedding_visualization import embedding_visualization from py3plex.visualization.embedding_visualization import embedding_tools import json ## load network in GML multilayer_network = multinet.multi_layer_network().load_network("../datasets/imdb_gml.gml",directed=True,input_type="gml") save this network as edgelist for node2vec multilayer_network.save_network("../datasets/test.edgelist") ## call a specific embedding binary --- this is not limited to n2v train_node2vec_embedding.call_node2vec_binary("../datasets/test.edgelist","../datasets/test_embedding.emb",binary="../bin/node2vec",weighted=False) ## preprocess and check embedding multilayer_network.load_embedding("../datasets/test_embedding.emb") ## visualize embedding embedding_visualization.visualize_embedding(multilayer_network) ## output embedded coordinates as JSON output_json = embedding_tools.get_2d_coordinates_tsne(multilayer_network,output_format="json") with open('../datasets/embedding_coordinates.json', 'w') as outfile: json.dump(output_json, outfile)
from collections import Counter from py3plex.visualization.colors import colors_default from py3plex.visualization.multilayer import draw_multiedges, draw_multilayer_default, hairball_plot, plt from py3plex.core import multinet ## Load the relevan layer names for later layer_map = {} with open("../datasets/twitterlayers.txt") as twl: for line in twl: line = line.strip() idx, lname = line.split() layer_map[idx] = lname ## Loade the network first! multilayer_network = multinet.multi_layer_network( network_type="multiplex").load_network("../datasets/test13.edges", directed=False, input_type="multiplex_edges") ## Let's customize it a bit. network_labels, graphs, multilinks = multilayer_network.get_layers() print(network_labels) network_labels = [layer_map[k] for k in network_labels] draw_multilayer_default(graphs, display=False, background_shape="circle", labels=network_labels, node_size=1) plt.show()
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
# entanglement: By. Benjamin Renoust and Blaz Skrlj, 2019 # load an example multilayer network from py3plex.core import multinet from py3plex.algorithms.multilayer_algorithms.entanglement import compute_entanglement_analysis # visualization from a simple file multilayer_network = multinet.multi_layer_network().load_network( "../datasets/multiL.txt", directed=True, input_type="multiedgelist") multilayer_network.basic_stats() analysis = compute_entanglement_analysis(multilayer_network) print("%d connected components of layers" % len(analysis)) for i, b in enumerate(analysis): print('--- block %d' % i) layer_labels = b['Layer entanglement'].keys() print('Covering layers: %s' % layer_labels) print('Entanglement intensity: %f' % b['Entanglement intensity']) print('Layer entanglement: %s' % b['Layer entanglement']) print('Entanglement homogeneity: %f' % b['Entanglement homogeneity']) print('Normalized homogeneity: %f' % b['Normalized homogeneity'])
from py3plex.core import multinet from py3plex.visualization.multilayer import * from py3plex.visualization.colors import colors_default from collections import Counter import argparse parser = argparse.ArgumentParser() parser.add_argument("--input_network", default="../datasets/cora.mat") parser.add_argument("--input_type", default="sparse") parser.add_argument("--iterations", default=200, type=int) args = parser.parse_args() # network and group objects must be present within the .mat object network = multinet.multi_layer_network().load_network(input_file=args.input_network, directed=False, input_type=args.input_type) # convert to generic px format (n,l,n2,l2)---dummy layers are added if args.input_type == 'sparse': network.sparse_to_px() network.basic_stats() # check core imports ################################## # THE LOUVAIN ALGORITHM ################################## partition = cw.louvain_communities(network) #print(partition) # select top n communities by size
# visualize multiplex network dynamics from py3plex.visualization.multilayer import draw_multilayer_default from py3plex.core import multinet from collections import defaultdict import matplotlib.pyplot as plt import seaborn as sns # first parse the layer n1 n2 w edgelist multilayer_network = multinet.multi_layer_network().load_network( "../multilayer_datasets/MLKing/MLKing2013_multiplex.edges", directed=True, input_type="multiplex_edges") # map layer ids to names multilayer_network.load_layer_name_mapping( "../multilayer_datasets/MLKing/MLKing2013_layers.txt") # Finally, load termporal edge information multilayer_network.load_network_activity( "../multilayer_datasets/MLKing/MLKing2013_activity.txt") # read correctly? multilayer_network.basic_stats() layout_parameters = {"iterations": 1} # internally split to layers multilayer_network.split_to_layers(style="diagonal", compute_layouts="force", layout_parameters=layout_parameters,
# enrichment modules from py3plex.algorithms.statistics import enrichment_modules # community detection from py3plex.algorithms.community_detection import community_wrapper as cw # core data structure from py3plex.core import multinet # store communities from collections import defaultdict # load the network network = multinet.multi_layer_network().load_network( input_file="../datasets/epigenetics.gpickle", directed=False, input_type="gpickle_biomine") # identify partitions partition = cw.louvain_communities(network.core_network) # uniprot : node pairs are used as input! Generic example TBA community_object = defaultdict(set) for node, community in partition.items(): if len(node[0].split(":")) == 2: db, name = node[0].split(":") if db == "UniProt": community_object[community].add(node) # p<0.05 and fdr_bh correction for GO function -- this can take some time! enrichment_table = enrichment_modules.fet_enrichment_uniprot(
# personalized pagerank for node classification from py3plex.core import multinet from py3plex.algorithms.network_classification.PPR import * from py3plex.visualization.benchmark_visualizations import * from sklearn.svm import SVC # load a sparse network multilayer_network = multinet.multi_layer_network().load_network( "../datasets/cora.mat", directed=False, input_type="sparse") # this can take some time! model = SVC(kernel='linear', C=1, probability=True) # This setting works for multiclass classifiers, and NOT MULTILABEL. # validate PPR embeddings validation_results = validate_ppr(multilayer_network.core_network, multilayer_network.labels, multiclass_classifier=model, repetitions=2) # plot the results plot_core_macro(validation_results)
## simple example of how a network can be easily saved! from py3plex.core import multinet dataset = "../datasets/imdb_gml.gml" ## load as GML multilayer_network = multinet.multi_layer_network().load_network(input_file=dataset,directed=True,input_type=dataset.split(".")[-1]) ## save to gpickle multilayer_network.save_network("../datasets/imdb.gpickle",output_type="gpickle") multilayer_network_new = multinet.multi_layer_network() multilayer_network_new.load_network("../datasets/imdb.gpickle",input_type="gpickle") ## show some very basic stats multilayer_network_new.basic_stats() triplet_set = list(set(multilayer_network.get_decomposition_cycles())) print(triplet_set)
def compare_motifs(struct_mat, func_mat, name, bins=50, N=4): from pynets.stats.netmotifs import adaptivethresh from pynets.core.thresholding import standardize from scipy import spatial import pandas as pd from py3plex.core import multinet # Structural graph threshold window struct_mat = standardize(struct_mat) dims_struct = struct_mat.shape[0] struct_mat[range(dims_struct), range(dims_struct)] = 0 tmin_struct = struct_mat.min() tmax_struct = struct_mat.max() threshes_struct = np.linspace(tmin_struct, tmax_struct, bins) # Functional graph threshold window func_mat = standardize(func_mat) dims_func = func_mat.shape[0] func_mat[range(dims_func), range(dims_func)] = 0 tmin_func = func_mat.min() tmax_func = func_mat.max() threshes_func = np.linspace(tmin_func, tmax_func, bins) assert np.all( struct_mat == struct_mat.T), "Structural Matrix must be symmetric" assert np.all( func_mat == func_mat.T), "Functional Matrix must be symmetric" # list of mlib = ['1113', '1122', '1223', '2222', '2233', '3333'] # Count motifs print("%s%s%s%s" % ('Mining ', N, '-node motifs: ', mlib)) motif_dict = {} for thr_struct, thr_func in list( itertools.product(threshes_struct, threshes_func)): # Count at_struct = adaptivethresh(struct_mat, float(thr_struct), mlib, N) at_func = adaptivethresh(func_mat, float(thr_func), mlib, N) motif_dict["%s%s%s%s" % ('struct_', np.round( thr_struct, 4), '_func_', np.round(thr_func, 4))] = {} motif_dict["%s%s%s%s" % ('struct_', np.round(thr_struct, 4), '_func_', np.round(thr_func, 4))]['struct'] = at_struct motif_dict["%s%s%s%s" % ('struct_', np.round( thr_struct, 4), '_func_', np.round(thr_func, 4))]['func'] = at_func print("%s%s%s%s%s" % ('Layer 1 (structural) with absolute threshold of : ', thr_struct, ' yields ', np.sum(at_struct), ' total motifs')) print("%s%s%s%s%s" % ('Layer 2 (functional) with absolute threshold of : ', thr_func, ' yields ', np.sum(at_func), ' total motifs')) for k, v in list(motif_dict.items()): if np.sum(v['struct']) == 0 or np.sum(v['func']) == 0: del motif_dict[k] for k, v in list(motif_dict.items()): motif_dict[k]['dist'] = spatial.distance.cosine(v['struct'], v['func']) df = pd.DataFrame(motif_dict).T df['struct_func_3333'] = np.zeros(len(df)) df['struct_func_2233'] = np.zeros(len(df)) df['struct_func_2222'] = np.zeros(len(df)) df['struct_func_1223'] = np.zeros(len(df)) df['struct_func_1122'] = np.zeros(len(df)) df['struct_func_1113'] = np.zeros(len(df)) df['struct_3333'] = np.zeros(len(df)) df['func_3333'] = np.zeros(len(df)) df['struct_2233'] = np.zeros(len(df)) df['func_2233'] = np.zeros(len(df)) df['struct_2222'] = np.zeros(len(df)) df['func_2222'] = np.zeros(len(df)) df['struct_1223'] = np.zeros(len(df)) df['func_1223'] = np.zeros(len(df)) df['struct_1122'] = np.zeros(len(df)) df['func_1122'] = np.zeros(len(df)) df['struct_1113'] = np.zeros(len(df)) df['func_1113'] = np.zeros(len(df)) for idx in range(len(df)): df.set_value(df.index[idx], 'struct_3333', df['struct'][idx][-1]) df.set_value(df.index[idx], 'func_3333', df['func'][idx][-1]) df.set_value(df.index[idx], 'struct_2233', df['struct'][idx][-2]) df.set_value(df.index[idx], 'func_2233', df['func'][idx][-2]) df.set_value(df.index[idx], 'struct_2222', df['struct'][idx][-3]) df.set_value(df.index[idx], 'func_2222', df['func'][idx][-3]) df.set_value(df.index[idx], 'struct_1223', df['struct'][idx][-4]) df.set_value(df.index[idx], 'func_1223', df['func'][idx][-4]) df.set_value(df.index[idx], 'struct_1122', df['struct'][idx][-5]) df.set_value(df.index[idx], 'func_1122', df['func'][idx][-5]) df.set_value(df.index[idx], 'struct_1113', df['struct'][idx][-6]) df.set_value(df.index[idx], 'func_1113', df['func'][idx][-6]) df['struct_func_3333'] = np.abs(df['struct_3333'] - df['func_3333']) df['struct_func_2233'] = np.abs(df['struct_2233'] - df['func_2233']) df['struct_func_2222'] = np.abs(df['struct_2222'] - df['func_2222']) df['struct_func_1223'] = np.abs(df['struct_1223'] - df['func_1223']) df['struct_func_1122'] = np.abs(df['struct_1122'] - df['func_1122']) df['struct_func_1113'] = np.abs(df['struct_1113'] - df['func_1113']) df = df[(df.struct_3333 != 0) & (df.func_3333 != 0) & (df.struct_2233 != 0) & (df.func_2233 != 0) & (df.struct_2222 != 0) & (df.func_2222 != 0) & (df.struct_1223 != 0) & (df.func_1223 != 0) & (df.struct_1122 != 0) & (df.func_1122 != 0) & (df.struct_1113 != 0) & (df.func_1113 != 0)] df = df.sort_values(by=[ 'dist', 'struct_func_3333', 'struct_func_2233', 'struct_func_2222', 'struct_func_1223', 'struct_func_1122', 'struct_func_1113', 'struct_3333', 'func_3333', 'struct_2233', 'func_2233', 'struct_2222', 'func_2222', 'struct_1223', 'func_1223', 'struct_1122', 'func_1122', 'struct_1113', 'func_1113' ], ascending=[ True, True, True, True, True, True, True, False, False, False, False, False, False, False, False, False, False, False, False ]) # Take the top 25th percentile df = df[df['dist'] < df['dist'].quantile(0.25)] best_threshes = [] best_mats = [] #best_graphs = [] best_multigraphs = [] for str in list(df.index): func_mat_tmp = func_mat.copy() struct_mat_tmp = struct_mat.copy() struct_thr = float(str.split('_')[1]) func_thr = float(str.split('_')[3]) best_threshes.append((struct_thr, func_thr)) func_mat_tmp[func_mat_tmp < func_thr] = 0 struct_mat_tmp[struct_mat_tmp < struct_thr] = 0 best_mats.append((func_mat_tmp, struct_mat_tmp)) G = build_nx_multigraph(func_mat, struct_mat, str) #best_graphs.append(G) B = multinet.multi_layer_network(network_type="multiplex", directed=False) B.add_edges([[x, 1, y, 2, z] for x, y, z in list(G.edges)], input_type="list") best_multigraphs.append(B) mg_dict = dict(zip(best_threshes, best_multigraphs)) return mg_dict
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)
## reading different inputs from py3plex.core import multinet multilayer_network = multinet.multi_layer_network().load_network("../datasets/epigenetics.gpickle",directed=True, input_type="gpickle_biomine") multilayer_network = multinet.multi_layer_network().load_network("../datasets/ecommerce_0.gml",directed=True, input_type="gml") multilayer_network = multinet.multi_layer_network().load_network("../datasets/ions.mat",directed=False, input_type="sparse") multilayer_network = multinet.multi_layer_network().load_network("../datasets/test.edgelist",directed=False, input_type="edgelist") multilayer_network = multinet.multi_layer_network().load_network("../datasets/multiedgelist.txt",directed=False, input_type="multiedgelist") #multilayer_network = multinet.multi_layer_network().load_network("../datasets/erdos_detangler.json",directed=False, input_type="detangler_json") ## TOD multilayer_network = multinet.multi_layer_network().load_network("../datasets/edgeList.txt",directed=False, input_type="multiedgelist") ## save the network as a gpickle object multilayer_network.save_network(output_file="../datasets/stored_network.gpickle",output_type="gpickle")