Streaming_graph_sampling/FeatureComputer2.py at master · feilong0309/Streaming_graph_sampling · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
'''
Created on May 17, 2013

@author: ecem
'''

import logging
import sampling as smp

log = logging.getLogger(__name__)

__all__=['execute_single_query','execute_all_frontend_queries','execute_all_backend_queries','compute_queries','execute_all_queries_for_a_feature']
from sampling.classes.query_types import *

def compute_single_query(feature, query):
    try:
        log.debug('Running '+query.name+' for '+feature.name)
        return query.run_query(feature)
    except TypeError:
        log.debug('Error in query execution:'+query.name)
        log.debug("Ignoring query.")

def compute_queries(query, feature_list):
    feature_dic={}
    log.info('Computing characteristics of population graph')
    for feature in feature_list:
        result=compute_single_query(feature, query)
        if result!=None:
            feature_dic[feature.name]=result
    return feature_dic

def compute_all_frontend_queries(G, feature_list):
    feature_dic={}
    for feature in feature_list:
        result=compute_single_query(feature, FrontendQuery(G))
        if result!=None:
            feature_dic[feature.name]=result
    return feature_dic

def compute_all_backend_queries(G, sample_graph, feature_list):
    feature_dic={}
    for feature in feature_list:
        result=compute_single_query(feature, BackendQuery(G, sample_graph))
        if result!=None:
            feature_dic[feature.name]=result
    return feature_dic

def compute_all_queries_for_a_feature(G, sample_graph, feature, query_list):
    query_dic={}
    for query in query_list:
        if type(query) == BackendQuery:
            query.set_population_graph(G)
            query.set_sample_graph(sample_graph)
        elif type(query) == FrontendQuery:
            query.set_graph(sample_graph)
        result=compute_single_query(feature,query)
        if result !=None:
            query_dic[query.name]=result
            #DataFramePlotter().plot_data(DataFrame.from_dict({'sample':result,'population':Globals.curr_graph_distributions[0][feature.name]['Backend Query']}),saveTo=Globals.curr_dir, cumulative=True, title=feature.name+'('+query.name+')',ylim=(0,1.01))
    #log.debug(feature.name+':'+str(query_dic))
    return query_dic

def compute_all_features(G, sample_graph, feature_list, query_list):
    feature_dic={}
    for feature in feature_list:
        result=compute_all_queries_for_a_feature(G, sample_graph, feature, query_list)
        if result !=None:
            feature_dic[feature.name]=result

    return feature_dic

if __name__ == "__main__":
    import networkx as nx
    import sampling as smp
    from sampling.sampling_algorithms import *
#
    G=nx.barabasi_albert_graph(10, 4, 3)

    nx.write_edgelist(G, 'G.edgelist')

    sample_graph=induced_random_edge_sampler(G, 5, stopping_condition='UNIQUE_NODES', with_replacement=True)
    print sample_graph.nodes()
    print sample_graph.edges()

    nx.write_edgelist(sample_graph, 'sample.edgelist',data=False)
    q_list=[BackendQuery(), FrontendQuery()]
    f_list=[smp.SimpleGraphDegree()]

    query_list=['BackendQuery','FrontendQuery']
    feature_list=['SimpleGraphDegree','SimpleGraphClusteringCoefficient','SimpleGraphPathLength']
    compute_all_features(G, sample_graph, feature_list, query_list)
#    ex=QueryExecuter()
#    print ex.compute_all_queries(G, sample_graph, f_list, q_list)
#    print compute_all_backend_queries(G, sample_graph, f_list, q_list)