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")
