-
Notifications
You must be signed in to change notification settings - Fork 0
/
CmdTool.py
157 lines (136 loc) · 4.91 KB
/
CmdTool.py
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
import cmd
from synthetic import SyntheticDataConverter, Evaluation
from dblp import dblp_parser, dblp_loader
from plot import PlotGraphs
from tensor import TensorFact
from ged import GedLoad, GedWrite
from muturank import Muturank, Muturank_new
from metrics import NMI
import pprint
class CmdTool(cmd.Cmd):
def __init__(self):
cmd.Cmd.__init__(self)
self.graphs = {}
self.comms = {}
self.timeFrames = 0
self.timeline = {}
self.type = ""
print("Hi, choose one of the following options:")
def do_print_data_info(self, e):
print("timeframes :", [key for key in self.graphs])
print("# of communities per timeframe", [len(comms) for tf, comms in self.comms.iteritems()])
print(self.type)
def do_clear_memory(self, e):
CmdTool().cmdloop()
def do_load_ged_data(self, filename):
"""Give a GED compatible json file as input
:param give the filePath as parameter
"""
if not filename:
filename = "/home/lias/PycharmProjects/GED/test_input_community_edges.json"
ged = GedLoad(filename)
self.graphs = ged.graphs
self.comms = ged.comms
self.timeFrames = len(self.graphs)
self.type = "GED"
print("GED data have been loaded successfully!")
def do_write_ged(self, filename):
"""Output a json file as needed for GED evaluation
:param filename: the name of the file to be written
:return:
"""
GedWrite(self, filename)
print("Data have been exported successfully!")
def do_load_synthetic_data(self, filePath, evaluate=False):
"""
Load synthetic data
:param filePath: the path of the folder where
:param evaluate: boolean operator whether to evaluate data or not
:return:
"""
if not filePath:
filePath = "/home/lias/Dropbox/Msc/thesis/src/NEW/synthetic-data-generator/src/expand/"
# filePath = "data/synthetic/expand"
sd = SyntheticDataConverter(filePath)
self.graphs = sd.graphs
self.ground_comms = sd.comms
self.timeFrames = sd.timeFrames
self.timeline = sd.get_timeline()
self.type = sd.type
print("Synthetic data have been successfully loaded!")
if evaluate:
Evaluation(sd)
return
def do_load_dblp(self, filename, start_year=2000, end_year=2004, conf_file='data/dblp/confs.txt',
coms='components'):
"""
Load dblp dataset between years given
:param filename:
:param start_year:
:param end_year:
:param coms: ground truth communities or conferences 'confs' or 'components'
:return:
"""
if not filename:
filename = "data/dblp/my_dblp_data.json"
dblp = dblp_loader(filename, start_year=start_year, end_year=end_year, conf_file=conf_file, coms=coms)
self.graphs = dblp.graphs
self.comms = dblp.communities
self.timeFrames = dblp.timeFrames
print("DBLP data have been successfully loaded!")
return
def do_nntfact(self, params):
"""
:param params:
:return:
"""
k, seeds = params.split()
# num_of_coms = len(set([c for _,comms in self.comms.iteritems() for c in comms ]))
# set number of factors to the max number of communities in all timeframes
if not k:
k = max([len(comms) for tf, comms in self.comms.iteritems()])
TensorFact(self.graphs, num_of_coms=int(k), threshold=1e-4, seeds=int(seeds))
return
def do_create_muturank_tensor(self, connections):
"""
:param connections:
:return:
"""
Muturank(self.graphs)
print("Tensor for use with Muturank")
return
def do_run_Muturank(self, k, connection='one'):
"""
:param connections:
:return:
"""
threshold = 1e-6
alpha = 0.85
beta = 0.85
if not k:
k = len(self.ground_comms[0])
mutu = Muturank_new(self.graphs, threshold, alpha, beta, connection, clusters=int(k))
self.comms = mutu.dynamic_com
return
def do_evaluate(self, e):
ground_truth = {i: [] for i in range(len(self.ground_comms.itervalues().next()))}
for tf, coms in self.ground_comms.iteritems():
for i, com in coms.iteritems():
for node in com:
ground_truth[i].append(str(node) + "-t" + str(tf))
nmi = NMI(ground_truth, self.comms, evaluation_type="dynamic").results
print(nmi)
def do_plot_graphs(self, node_size):
"""
:param e:
:return:
"""
PlotGraphs(self.graphs, self.timeFrames, self.type, node_size)
return
def do_exit(self, e):
"""
exit the program
"""
return True
if __name__ == '__main__':
CmdTool().cmdloop()