def __init__(self, graph_file, model): self.graph_file = graph_file self.model = model self.graph = XGraph() self.graph.load_graph_from_file(graph_file) self.graph.threshold_generator() self.graph.weight_generator() self.graph.mutation_factor_generator() self.cost = self.pricing_graph()
class XBudgetedCIMext(object):
def __init__(self, graph_file, model):
self.graph_file = graph_file
self.model = model
self.graph = XGraph()
self.graph.load_graph_from_file(graph_file)
self.graph.threshold_generator()
self.graph.weight_generator()
self.graph.mutation_factor_generator()
self.cost = self.pricing_graph()
def pricing_graph(self):
gp = XGraphPricing()
return gp.pricing_graph(self.graph_file)
def random_max_degree_neighbor(self, S, budget, epsilon):
bsum = 0
T = []
vertices = self.graph.get_all_vertices()
i = 0
ft = time.time()
while i < k:
v = random.choice(vertices)
es = list(set(T) | set(S))
max_v = self.graph.max_degree_neighbor(v, es)
if max_v not in self.cost.keys():
continue
if bsum + self.cost[max_v] <= budget + epsilon:
T.append(max_v)
bsum += self.cost[max_v]
i += 1
if bsum >= budget - epsilon:
break
time_elapsed = time.time() - ft
print '#RMDN Time consumed: %.2f secs' % (time_elapsed)
return T, time_elapsed
def greedy(self, k, budget, epsilon):
S = []
i = 0
bsum = 0
vertices = self.graph.get_all_vertices()
ft = time.time()
while i < k:
target, maxinf = -1, -1
for v in vertices:
if v in S:
continue
Ss = copy.deepcopy(S)
Ss.append(v)
g = copy.deepcopy(self.graph)
curS, _ = self.model.calc_influence(g, Ss, [])
g = copy.deepcopy(self.graph)
prevS, _ = self.model.calc_influence(g, S, [])
if curS - prevS > maxinf and bsum + self.cost[v] <= budget + epsilon:
maxinf = curS - prevS
target = v
if target != -1:
S.append(target)
bsum += self.cost[target]
i += 1
if bsum >= budget - epsilon:
break
time_elapsed = time.time() - ft
print '#Greedy Time consumed: %.2f secs' % (time_elapsed)
return S, time_elapsed
def degree_heuristic(self, S, budget, epsilon):
ft = time.time()
out_degree = []
vertices = self.graph.get_all_vertices()
for vid in vertices:
out_degree.append((vid, len(self.graph.get_edges_by_vertice(vid))))
out_degree_sorted = sorted(out_degree, key=lambda x: x[1], reverse=True)
T = []
bsum = 0
i = 0
while True:
vid = out_degree_sorted[i][0]
i += 1
if vid in T or vid in S:
continue
if bsum + self.cost[vid] <= budget + epsilon:
bsum += self.cost[vid]
T.append(vid)
if bsum >= budget - epsilon or len(T) >= len(S):
break
time_elapsed = time.time() - ft
print '#Degree Heuristic Time consumed: %.2f secs' % (time_elapsed)
return T, time_elapsed
def comparable_heuristic(self, S, budget, epsilon):
ft = time.time()
T = []
bsum = 0
for v in S:
edges = self.graph.get_edges_by_vertice(v)
maxinf = -1
target = -1
for e in edges:
to = e.get_dest()
# if to in T or to in S or self.cost[to] <= 0:
if to in T or to in S:
continue
if target == -1:
target = to
g = copy.deepcopy(self.graph)
maxinf, _ = self.model.calc_influence(g, [target], S)
continue
g = copy.deepcopy(self.graph)
prevT, _ = self.model.calc_influence(g, T, S)
Ts = copy.deepcopy(T)
Ts.append(to)
g = copy.deepcopy(self.graph)
curT, _ = self.model.calc_influence(g, Ts, S)
# fc = float(curT - prevT)/self.cost[to]
fc = curT - prevT
if maxinf < fc and bsum + self.cost[to] <= budget + epsilon:
maxinf = fc
target = to
if target != -1:
T.append(target)
bsum += self.cost[target]
if bsum >= budget - epsilon or len(T) >= len(S):
break
time_elapsed = time.time() - ft
print '#Comparable Heuristic Time consumed: %.2f secs' % (time_elapsed)
return T, time_elapsed
def local_degree_heuristic(self, S, budget, epsilon):
ft = time.time()
vertices = self.graph.get_all_vertices()
T = []
bsum = 0
for v in S:
r = random.choice(vertices)
target = r
x = self.graph.max_degree_neighbor(r, list(set(T) | set(S)))
if x != -1:
target = x
maxd = len(self.graph.get_edges_by_vertice(target))
edges = self.graph.get_edges_by_vertice(v)
for e in edges:
to = e.get_dest()
d = len(self.graph.get_edges_by_vertice(to))
if maxd < d and bsum + self.cost[to] <= budget + epsilon:
maxd = d
target = to
if target != -1 and bsum + self.cost[target] <= budget + epsilon:
T.append(target)
bsum += self.cost[target]
if bsum >= budget - epsilon or len(T) >= len(S):
break
time_elapsed = time.time() - ft
print '#Local Degree Heuristic Time consumed: %.2f secs' % (time_elapsed)
return T, time_elapsed
def local_greedy_heuristic(self, S, budget, epsilon):
ft = time.time()
vertices = self.graph.get_all_vertices()
T = []
bsum = 0
for v in S:
r = random.choice(vertices)
target = r
r = self.graph.max_degree_neighbor(r, list(set(T) | set(S)))
if r != -1:
target = r
maxinf = -(1 << 20)
# if self.cost[target] <= 0 or bsum + self.cost[target] > budget + epsilon:
if bsum + self.cost[target] > budget + epsilon:
target = -1
else:
Ttmp = copy.deepcopy(T)
Ttmp.append(target)
g = copy.deepcopy(self.graph)
prevT, _ = self.model.calc_influence(g, T, S)
g = copy.deepcopy(self.graph)
curT, _ = self.model.calc_influence(g, Ttmp, S)
# maxinf = float(curS - prevS)/self.cost[target]
maxinf = curT - prevT
edges = self.graph.get_edges_by_vertice(v)
for e in edges:
to = e.get_dest()
# if to in T or to in S or self.cost[to] <= 0:
if to in T or to in S:
continue
if target == -1:
target = to
g = copy.deepcopy(self.graph)
maxinf, _ = self.model.calc_influence(g, [target], S)
continue
g = copy.deepcopy(self.graph)
prevT, _ = self.model.calc_influence(g, T, S)
Ts = copy.deepcopy(T)
Ts.append(to)
g = copy.deepcopy(self.graph)
curT, _ = self.model.calc_influence(g, Ts, S)
# fc = float(curS - prevS)/self.cost[to]
fc = curT - prevT
if maxinf < fc and bsum + self.cost[to] <= budget + epsilon:
maxinf = fc
target = to
if target != -1:
T.append(target)
bsum += self.cost[target]
if bsum >= budget - epsilon or len(T) >= len(S):
break
time_elapsed = time.time() - ft
print '#Local Greedy Heuristic Time consumed: %.2f secs' % (time_elapsed)
return T, time_elapsed
def infmax(self, k, R, budget, epsilon, result_file):
ts = []
res = []
S, gtimes = self.greedy(k, budget, epsilon)
T, dtimes = self.degree_heuristic(S, budget, epsilon)
ts.append(T)
res.append(('DHeu', 0, 0, dtimes))
T, ctimes = self.comparable_heuristic(S, budget, epsilon)
ts.append(T)
res.append(('CHeu', 0, 0, ctimes))
T, rtimes = self.random_max_degree_neighbor(S, budget, epsilon)
ts.append(T)
res.append(('RMDN', 0, 0, rtimes))
T, ldtimes = self.local_degree_heuristic(S, budget, epsilon)
ts.append(T)
res.append(('LDeg', 0, 0, ldtimes))
T, lgtimes = self.local_greedy_heuristic(S, budget, epsilon)
ts.append(T)
res.append(('LGdy', 0, 0, lgtimes))
for i in xrange(R):
print 'Round %d starts...' % (i + 1)
for j in xrange(len(ts)):
g = copy.deepcopy(self.graph)
s, t = self.model.calc_influence(g, S, ts[j])
print 'Round %d: %s-> #s = %d, #t = %d' % (i+1, res[j][0], s, t)
print 'len(S) = %d, len(T) = %d' % (len(S), len(T))
lres = list(res[j])
lres[1] += s
lres[2] += t
res[j] = tuple(lres)
fp = open(result_file, 'wb')
if not fp:
print 'Failed to open file %s !' % result_file
return
line = 'Greedy time consumed: ' + str(gtimes) + '\n'
line += 'Budget: ' + str(budget) + '\n'
fp.write(line)
line = 'ALGORITHM\tLEN(S)\tLEN(T)\tINFLUENCE(S)\tINFLUENCE(T)\tTIME\n'
fp.write(line)
for i in xrange(len(res)):
rs = float(res[i][1]) / R
rs = round(rs, 2)
rt = float(res[i][2]) / R
rt = round(rt, 2)
line = '{0: >9}'.format(res[i][0]) + '\t' + '{0: >6}'.format(str(len(S))) + '\t'
line += '{0: >6}'.format(str(len(ts[i]))) + '\t' + '{0: >12}'.format(str(rs)) + '\t'
line += '{0: >12}'.format(str(rt)) + '\t' + '{0: >4}'.format(str(res[i][3])) + '\n'
fp.write(line)
fp.close()
class XBudgetedCIM(object):
def __init__(self, graph_file, model):
self.graph_file = graph_file
self.model = model
self.graph = XGraph()
self.graph.load_graph_from_file(graph_file)
self.graph.threshold_generator()
self.graph.weight_generator()
self.graph.mutation_factor_generator()
self.cost = self.pricing_graph()
def pricing_graph(self):
gp = XGraphPricing()
return gp.pricing_graph(self.graph_file)
def get_sample(self, k, budget, epsilon):
bsum = 0
T = []
vertices = self.graph.get_all_vertices()
i = 0
while i < k:
v = random.choice(vertices)
max_v = self.graph.max_degree_neighbor(v, T)
if max_v not in self.cost.keys() or max_v in T:
continue
if bsum + self.cost[max_v] <= budget + epsilon:
T.append(max_v)
bsum += self.cost[max_v]
if bsum >= budget - epsilon:
break
i += 1
return T
def greedy(self, T, budget, epsilon):
pass
def degree_heuristic(self, T, budget, epsilon):
ft = time.time()
out_degree = []
vertices = self.graph.get_all_vertices()
for vid in vertices:
out_degree.append((vid, len(self.graph.get_edges_by_vertice(vid))))
out_degree_sorted = sorted(out_degree, key=lambda x: x[1], reverse=True)
S = []
bsum = 0
i = 0
while True:
vid = out_degree_sorted[i][0]
i += 1
if vid in T or vid in S:
continue
if bsum + self.cost[vid] <= budget + epsilon:
bsum += self.cost[vid]
S.append(vid)
if bsum >= budget - epsilon:
break
print '#Degree Heuristic Time consumed: %.2f secs' % (time.time() - ft)
return S
def comparable_heuristic(self, T, budget, epsilon):
ft = time.time()
S = []
bsum = 0
for v in T:
edges = self.graph.get_edges_by_vertice(v)
maxinf = -1
target = -1
for e in edges:
to = e.get_dest()
if to in T or to in S or self.cost[to] == 0:
continue
if target == -1:
target = to
g = copy.deepcopy(self.graph)
maxinf, _ = self.model.calc_influence(g, [target], T)
continue
g = copy.deepcopy(self.graph)
Ss = copy.deepcopy(S)
prevS, _ = self.model.calc_influence(g, S, T)
Ss.append(to)
g = copy.deepcopy(self.graph)
curS, _ = self.model.calc_influence(g, Ss, T)
fc = float(curS - prevS)/self.cost[to]
if maxinf < fc and bsum + self.cost[to] <= budget + epsilon:
maxinf = fc
target = to
if target != -1:
S.append(target)
bsum += self.cost[to]
if bsum >= budget - epsilon:
break
print '#Comparable Heuristic Time consumed: %.2f secs' % (time.time() - ft)
return S
def infmax(self, k, budget, epsilon):
T = self.get_sample(k, budget, epsilon)
S = self.degree_heuristic(T, budget, epsilon)
g = copy.deepcopy(self.graph)
t, s = self.model.calc_influence(g, T, S)
print 'DegreeHeuristic k = %d, budget = %d, t = %d, s = %d' % (k, budget, t, s)
S = self.comparable_heuristic(T, budget, epsilon)
g = copy.deepcopy(self.graph)
t, s = self.model.calc_influence(g, T, S)
print 'ComparableHeuristic k = %d, budget = %d, t = %d, s = %d' % (k, budget, t, s)
