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)
Пример #4
0
    "../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()
Пример #5
0
# 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
Пример #6
0
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)