Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

import networkx as nx

from remove_cycle_edges_by_hierarchy_greedy import scc_based_to_remove_cycle_edges_iterately

from remove_cycle_edges_by_hierarchy_BF import remove_cycle_edges_BF_iterately

from remove_cycle_edges_by_hierarchy_voting import remove_cycle_edges_heuristic

from measures import F1

from file_io import read_dict_from_file

from file_io import write_pairs_to_file

def get_edges_voting_scores(set_edges_list):

        total_edges = set()

        for edges in set_edges_list:

                total_edges = total_edges | edges

        edges_score = {}

        for e in total_edges:

                edges_score[e] = len(filter(lambda x: e in x, set_edges_list))

        return edges_score

def remove_cycle_edges_strategies(graph_file,nodes_score_dict,score_name = "socialagony", nodetype = int):

        g = nx.read_edgelist(graph_file,create_using = nx.DiGraph(),nodetype = nodetype)

        # greedy

        e1 = scc_based_to_remove_cycle_edges_iterately(g,nodes_score_dict)

        g = nx.read_edgelist(graph_file,create_using = nx.DiGraph(),nodetype = nodetype)

        # forward

        e2 = remove_cycle_edges_BF_iterately(g,nodes_score_dict,is_Forward = True,score_name = score_name)

        # backward

        g = nx.read_edgelist(graph_file,create_using = nx.DiGraph(),nodetype = nodetype)

        e3 = remove_cycle_edges_BF_iterately(g,nodes_score_dict,is_Forward = False,score_name = score_name)

        return e1,e2,e3

def remove_cycle_edges_by_voting(graph_file,set_edges_list,nodetype = int):

        edges_score = get_edges_voting_scores(set_edges_list)

        e = remove_cycle_edges_heuristic(graph_file,edges_score,nodetype = nodetype)

        return e

def remove_cycle_edges_by_hierarchy(graph_file,nodes_score_dict,score_name = "socialagony",nodetype = int):

        e1,e2,e3 = remove_cycle_edges_strategies(graph_file,nodes_score_dict,score_name = score_name,nodetype = nodetype)

        e4 = remove_cycle_edges_by_voting(graph_file,[set(e1),set(e2),set(e3)],nodetype = nodetype)

        return e1,e2,e3,e4

def computing_hierarchy(graph_file,players_score_func_name, nodetype = int):

        import os.path

        if players_score_func_name == "socialagony":

                from helper_funs import dir_tail_name

                dir_name,tail = dir_tail_name(graph_file)

                agony_file = os.path.join(dir_name,tail.split(".")[0] + "_socialagony.txt")

                #agony_file = graph_file[:len(graph_file)-6] + "_socialagony.txt"

                #from compute_social_agony import compute_social_agony

                #players = compute_social_agony(graph_file,agony_path = "agony/agony ")         

                if False:

                #if os.path.isfile(agony_file):

                        print("load pre-computed socialagony from: %s" % agony_file)

                        players = read_dict_from_file(agony_file)

                else:

                        print("start computing socialagony...")

                        from compute_social_agony import compute_social_agony

                        players = compute_social_agony(graph_file,agony_path = "agony/agony ")

                        print("write socialagony to file: %s" % agony_file)

                return players

        g = nx.read_edgelist(graph_file,create_using = nx.DiGraph(),nodetype = nodetype)

        if players_score_func_name == "pagerank":

                #print("computing pagerank...")

                players = nx.pagerank(g, alpha = 0.85)

                return players

        elif players_score_func_name == "trueskill":

                output_file = graph_file[:len(graph_file)-6] + "_trueskill.txt"

                output_file_2 = graph_file[:len(graph_file)-6] + "_trueskill.pkl"

                #from true_skill import graphbased_trueskill

                #players = graphbased_trueskill(g)

                #from file_io import write_dict_to_file

                #write_dict_to_file(players,output_file)

                '''

                if os.path.isfile(output_file):

                        print("load pre-computed trueskill from: %s" % output_file)

                        players = read_dict_from_file(output_file,key_type = int, value_type = float)

                elif os.path.isfile(output_file_2):

                        print("load pre-computed trueskill from: %s" % output_file_2)

                        players = read_from_pickle(output_file_2)

                '''

                if True:

                        print("start computing trueskill...")

                        from true_skill import graphbased_trueskill

                        players = graphbased_trueskill(g)

                        from file_io import write_dict_to_file

                        print("write trueskill to file: %s" % output_file)

                        write_dict_to_file(players,output_file)

                return players

def breaking_cycles_by_hierarchy_performance(graph_file,gt_file,players_score_name,nodetype = int):

        from measures import report_performance

        if players_score_name != "ensembling":

                players_score_dict  = computing_hierarchy(graph_file,players_score_name,nodetype = nodetype)

                e1,e2,e3,e4 = remove_cycle_edges_by_hierarchy(graph_file,players_score_dict,players_score_name,nodetype = nodetype)

                if players_score_name == "pagerank":

                        report_performance(gt_file,e1,"PR")

                        return

                if players_score_name == "socialagony":

                        note = "SA_"

                elif players_score_name == "trueskill":

                        note = "TS_"

                report_performance(gt_file,e1, note+"G")

                report_performance(gt_file,e2, note+"F")

                report_performance(gt_file,e3, note+"B")

                report_performance(gt_file,e4, note+"Voting")

        else:

                players_score_dict  = computing_hierarchy(graph_file,"socialagony",nodetype = nodetype)

                e1,e2,e3,e4 = remove_cycle_edges_by_hierarchy(graph_file,players_score_dict,"socialagony",nodetype = nodetype)

                report_performance(gt_file,e1,  "SA_G")

                write_pairs_to_file(e1,graph_file[:len(graph_file)-6] + "_removed_by_SA-G.edges")

                report_performance(gt_file,e2,  "SA_F")

                write_pairs_to_file(e2,graph_file[:len(graph_file)-6] + "_removed_by_SA-F.edges")

                report_performance(gt_file,e3,  "SA_B")

                write_pairs_to_file(e3,graph_file[:len(graph_file)-6] + "_removed_by_SA-B.edges")

                report_performance(gt_file,e4,  "SA_Voting")

                write_pairs_to_file(e4,graph_file[:len(graph_file)-6] + "_removed_by_SA-Voting.edges")

                players_score_dict  = computing_hierarchy(graph_file,"trueskill",nodetype = nodetype)

                e5,e6,e7,e8 = remove_cycle_edges_by_hierarchy(graph_file,players_score_dict,"trueskill",nodetype = nodetype)

                report_performance(gt_file,e5,  "TS_G")

                write_pairs_to_file(e5,graph_file[:len(graph_file)-6] + "_removed_by_TS-G.edges")

                report_performance(gt_file,e6,  "TS_F")

                write_pairs_to_file(e6,graph_file[:len(graph_file)-6] + "_removed_by_TS-F.edges")

                report_performance(gt_file,e7,  "TS_B")

                write_pairs_to_file(e7,graph_file[:len(graph_file)-6] + "_removed_by_TS-B.edges")

                report_performance(gt_file,e8,  "TS_Voting")

                write_pairs_to_file(e7,graph_file[:len(graph_file)-6] + "_removed_by_TS-Voting.edges")

                e9 = remove_cycle_edges_by_voting(graph_file,[set(e1),set(e2),set(e3),set(e5),set(e6),set(e7)],nodetype = nodetype)

                report_performance(gt_file,e9,"H_Voting")

                write_pairs_to_file(e9,graph_file[:len(graph_file)-6] + "_removed_by_H-Voting.edges")

import argparse

if __name__ == "__main__":

        parser = argparse.ArgumentParser()

        parser.add_argument("-g","--graph_file",default= " ", help = "input graph file name (edges list)")

        parser.add_argument("-s","--score_name",default = "pagerank",help = "nodes score function: trueskill, socialagony, ensembling, pagerank...")

        parser.add_argument("-t","--gt_edges_file",default = None, help = "ground truth edges file")

        args = parser.parse_args()

        graph_file = args.graph_file

        players_score_name = args.score_name

        gt_file = args.gt_edges_file

        breaking_cycles_by_hierarchy_performance(graph_file,gt_file,players_score_name)