def generateCelfHeap(self, data_name):
# -- calculate expected profit for all combinations of nodes and products --
### celf_item: (list) (mg, k_prod, i_node, flag)
Billboard_set, Handbill_set = SpiltHeuristicsSet(data_name)
Billboard_celf_heap, Handbill_celf_heap = [], []
diff = Diffusion(self.graph_dict, self.product_list, self.product_weight_list)
for i in Billboard_set:
s_set = [set() for _ in range(self.num_product)]
s_set[0].add(i)
ep = diff.getSeedSetProfitBCS(s_set)
if ep > 0:
for k in range(self.num_product):
mg = safe_div(ep * self.product_list[k][0] * self.product_weight_list[k], self.product_list[0][0] * self.product_weight_list[0])
celf_item = (mg, k, i, 0)
heap.heappush_max(Billboard_celf_heap, celf_item)
for i in Handbill_set:
s_set = [set() for _ in range(self.num_product)]
s_set[0].add(i)
ep = diff.getSeedSetProfitBCS(s_set)
if ep > 0:
for k in range(self.num_product):
mg = safe_div(ep * self.product_list[k][0], self.product_list[0][0] * self.product_weight_list[0])
mg = safe_div(mg, self.seed_cost_dict[k][i])
celf_item = (mg, k, i, 0)
heap.heappush_max(Handbill_celf_heap, celf_item)
return Billboard_celf_heap, Handbill_celf_heap
def generateCelfDict(self, mioa_dict, total_budget):
max_s = (0.0, -1, -1)
celf_dict = {}
ss = SeedSelectionMIOA(self.graph_dict, self.seed_cost_dict,
self.product_list, self.epw_list,
self.dag_class, self.r_flag)
for k in range(self.num_product):
for i in self.graph_dict:
s_set = [set() for _ in range(self.num_product)]
s_set[k].add(i)
dag_dict = [{} for _ in range(self.num_product)]
if self.dag_class == 1:
dag_dict = ss.generateDAG1(mioa_dict, s_set)
elif self.dag_class == 2:
dag_dict = ss.generateDAG2(mioa_dict, s_set)
ep = ss.calculateExpectedProfit(dag_dict, s_set)
if ep > max_s[0] and self.seed_cost_dict[i] <= total_budget:
max_s = (ep, k, i)
if ep > 0:
if self.r_flag:
ep = safe_div(ep, self.seed_cost_dict[i])
celf_dict[(k, i)] = ep
return celf_dict, max_s
def generateCelfHeap(self):
# -- calculate expected profit for all combinations of nodes and products --
### celf_item: (list) (mg, k_prod, i_node, flag)
celf_heap = []
diff = Diffusion(self.graph_dict, self.product_list, self.product_weight_list)
for i in self.graph_dict:
s_set = [set() for _ in range(self.num_product)]
s_set[0].add(i)
ep = round(sum([diff.getSeedSetProfit(s_set) for _ in range(self.monte)]) / self.monte, 4)
if ep > 0:
for k in range(self.num_product):
mg = safe_div(ep * self.product_list[k][0], self.product_list[0][0] * self.product_weight_list[0])
if self.r_flag:
mg = safe_div(mg, self.seed_cost_dict[k][i])
celf_item = (mg, k, i, 0)
heap.heappush_max(celf_heap, celf_item)
return celf_heap
def generateCelfHeap(self):
# -- calculate expected profit for all combinations of nodes and products --
### celf_item: (list) (mg, k_prod, i_node, flag)
degree_dict = {}
for i in self.graph_dict:
deg = len(self.graph_dict[i])
if int(deg) in degree_dict:
degree_dict[int(deg)].add(i)
else:
degree_dict[int(deg)] = {i}
num_node20 = round(
sum(deg * len(degree_dict[deg]) for deg in degree_dict) * 0.2, 4)
degree_count_dict = {
deg: round(
abs(
sum([len(degree_dict[d])
for d in degree_dict if d >= deg]) - num_node20), 4)
for deg in degree_dict
}
degree_threshold20 = min(degree_count_dict, key=degree_count_dict.get)
Billboard_set, Handbill_set = set(), set()
for deg in degree_dict:
if deg >= degree_threshold20:
Billboard_set = Billboard_set.union(degree_dict[deg])
else:
Handbill_set = Handbill_set.union(degree_dict[deg])
Billboard_celf_heap, Handbill_celf_heap = [], []
ss = SeedSelectionBCS(self.graph_dict, self.seed_cost_dict,
self.product_list, self.product_weight_list,
self.epw_flag)
for k in range(self.num_product):
for i in self.graph_dict:
s_set = [set() for _ in range(self.num_product)]
s_set[k].add(i)
ep = ss.getSeedSetProfit(s_set)
if ep > 0:
if i in Billboard_set:
celf_item = (ep, k, i, 0)
heap.heappush_max(Billboard_celf_heap, celf_item)
elif i in Handbill_set:
ep = safe_div(ep, self.seed_cost_dict[i])
celf_item = (ep, k, i, 0)
heap.heappush_max(Handbill_celf_heap, celf_item)
return [Billboard_celf_heap, Handbill_celf_heap]
def generateCelfHeap(self):
# -- calculate expected profit for all combinations of nodes and products --
### celf_item: (list) (mg, k_prod, i_node, flag)
celf_heap = []
ss = SeedSelectionNG(self.graph_dict, self.seed_cost_dict,
self.product_list, self.epw_list, True)
for i in self.graph_dict:
s_set = [set() for _ in range(self.num_product)]
s_set[0].add(i)
ep = ss.getSeedSetProfit(s_set)
if ep > 0:
ep = safe_div(ep, self.seed_cost_dict[i])
celf_item = (ep, 0, i, 0)
heap.heappush_max(celf_heap, celf_item)
return celf_heap
def generateCelfHeap(self, mioa_dict):
celf_heap = []
ss = SeedSelectionMIOA(self.graph_dict, self.seed_cost_dict,
self.product_list, self.epw_list,
self.dag_class, self.r_flag)
for k in range(self.num_product):
for i in self.graph_dict:
s_set = [set() for _ in range(self.num_product)]
s_set[k].add(i)
dag_dict = [{} for _ in range(self.num_product)]
if self.dag_class == 1:
dag_dict = ss.generateDAG1(mioa_dict, s_set)
elif self.dag_class == 2:
dag_dict = ss.generateDAG2(mioa_dict, s_set)
ep = ss.calculateExpectedProfit(dag_dict, s_set)
if ep > 0:
if self.r_flag:
ep = safe_div(ep, self.seed_cost_dict[i])
celf_item = (ep, k, i, 0)
heap.heappush_max(celf_heap, celf_item)
return celf_heap
def getSeedSetProfit(self, s_set):
s_total_set = set(s for k in range(self.num_product) for s in s_set[k])
inf_list = [0.0 for _ in range(self.num_product)]
for _ in range(self.monte):
for k in range(self.num_product):
if s_set[k]:
reverse_graph_dict = {i: set() for i in self.graph_dict}
reverse_in_graph_dict = {}
for i in self.graph_dict:
for j in self.graph_dict[i]:
if random.random() <= self.graph_dict[i][j]:
reverse_graph_dict[i].add(j)
activated_prob = self.graph_dict[i][j] * (
self.product_weight_list[k]
if self.epw_flag else 1.0)
if j in reverse_in_graph_dict:
reverse_in_graph_dict[j][
i] = activated_prob
else:
reverse_in_graph_dict[j] = {
i: activated_prob
}
if not reverse_graph_dict[i]:
del reverse_graph_dict[i]
inf_dict, inf_dict2 = {
s_node: 1.0
for s_node in s_total_set
}, {}
i_set = set(i_node for s_node in s_set[k]
if s_node in reverse_graph_dict
for i_node in reverse_graph_dict[s_node]
if i_node not in inf_dict)
while i_set:
inf_set = set(i_node for i_node in i_set
if i_node in reverse_graph_dict)
for i_node in inf_set:
in_list = list(
(1.0 - reverse_in_graph_dict[i_node][in_node] *
inf_dict[in_node])
for in_node in reverse_in_graph_dict[i_node]
if in_node in inf_dict)
i_prod = round(
1.0 - reduce(lambda x, y: x * y, in_list),
4) if in_list else 0.0
inf_dict2[
i_node] = i_prod if i_prod >= self.prob_threshold else 0.0
inf_set2 = set(
i_node2 for i_node2 in inf_dict2
if i_node2 in reverse_graph_dict) if sum(
inf_dict2.values()) != 0.0 else set()
inf_dict = {**inf_dict, **inf_dict2}
i_set = set(i_node for s_node in inf_set2
for i_node in reverse_graph_dict[s_node]
if i_node not in inf_dict)
inf_dict2 = {}
inf_list[k] = round(
sum(inf_dict.values()) - len(s_total_set), 4)
ep = safe_div(
sum(inf_list[k] * self.product_list[k][0] *
(1.0 if self.epw_flag else self.product_weight_list[k])
for k in range(self.num_product)), self.monte)
return ep