def main(self, filename):
# #拿到图
initG = commons.get_networkByFile(filename)
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 1)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG, T = commons.propagation1(max_sub_graph, source_list)
infectG1, T = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
# 将在这里进行单源测试。
subinfectG1 = commons.get_subGraph_true(infectG1)
# 多个观察点
result_node = self.mutiple_Observation(infectG, subinfectG,
subinfectG1, source_list[0])
print('真实源是', source_list[0])
print('预测源是', result_node[0])
distance = nx.shortest_path_length(subinfectG,
source=source_list[0],
target=result_node[0])
print('结果是', distance)
return distance
def delete_high_betweenness_edge_centrality_second(self, infectG):
subinfectG = commons.get_subGraph_true(infectG)
# 根据中介性分层然后删除。
commons_node_list = []
one_subgraph = None
two_subgraph = None
commons_node_list_copy = []
flag = 1
while flag:
sort_list = Partion_common.get_layer_edge_between(subinfectG)
print('sort_list', sort_list)
print('sort_list[0][0][0]', sort_list[0][0][0])
subinfectG.remove_edge(sort_list[0][0][0], sort_list[0][0][1])
commons_node_list.append(sort_list[0][0][0])
commons_node_list.append(sort_list[0][0][1])
# 重新计算一下那个中介
one_subgraph_nodelist, two_subgraph_nodelist = self.judge_two_subgraph2(
subinfectG)
print('one_subgraph', one_subgraph_nodelist)
if one_subgraph_nodelist and two_subgraph_nodelist:
one_subgraph_nodelist, two_subgraph_nodelist = one_subgraph_nodelist, two_subgraph_nodelist
commons_node_list_copy = copy.deepcopy(commons_node_list)
# print('commons_node_liost', commons_node_list.extend(one_subgraph_nodelist))
commons_node_list.extend(one_subgraph_nodelist)
commons_node_list_copy.extend(two_subgraph_nodelist)
break
return [commons_node_list, commons_node_list_copy]
def delete_high_betweenness_centrality(self, infectG):
subinfectG = commons.get_subGraph_true(infectG)
sort_list = Partion_common.get_layer_node_between(subinfectG)
#根据中介性分层然后删除。
print('sort_list', sort_list) #先验证高中介性节点是否在中间。
# for every_node in sort_list:
first_layer_between = [x[0] for x in sort_list[0]] #取第一层节点
two_source = random.sample(first_layer_between,
2) # 从list中随机获取2个元素，作为一个片断返回
lengthA_B = 100000
good_two_result = []
best_node_two_result = None
for iter in range(0, 100):
# 对这两个点进行Djstra，计算所有点到他们的距离。
print('two_source', two_source)
lengthA_dict = nx.single_source_bellman_ford_path_length(
subinfectG, two_source[0], weight='weight')
lengthB_dict = nx.single_source_bellman_ford_path_length(
subinfectG, two_source[1], weight='weight')
# 初始化两个集合，用来保存两个类别节点集合。
node_twolist = [[], []] # 保存两个类别节点集合
node_diff_twolist = [[], []] # 保存不同点
for node in list(subinfectG.nodes):
if lengthA_dict[node] > lengthB_dict[node]: # 这个点离b近一些。
node_twolist[1].append(node)
node_diff_twolist[1].append(node)
elif lengthA_dict[node] < lengthB_dict[node]:
node_twolist[0].append(node)
node_diff_twolist[0].append(node)
else:
node_twolist[0].append(node)
node_twolist[1].append(node)
print('node_twolist', len(node_twolist[1]))
# 在两个list中找到中心位置，有几种中心性可以度量的。或者进行快速算法。
# 判断这次找的两个中心好不好。
lengthA_sum = 0 # a这个不同点，
lengthB_sum = 0
for i in node_diff_twolist[0]: # 距离a近，第一个源点近的点。统计它跟自己区域点的距离之和
lengthA_sum += lengthA_dict[i]
for j in node_diff_twolist[1]: # 距离b近，第二个源点近的点。统计它跟自己区域点的距离之和
lengthB_sum += lengthB_dict[j]
sums = lengthA_sum + lengthB_sum
if sums < lengthA_B:
print('sums', sums)
# 是比原来好的的两个源。
lengthA_B = sums
good_two_result = two_source
best_node_two_result = node_twolist
else:
# 重新长生两个源吧。这里还是可以做优化的，选择的方向问题。
two_source = random.sample(first_layer_between, 2)
print('good_two_result', good_two_result)
print('good_node_two_result', best_node_two_result)
return [[good_two_result[0], best_node_two_result[0]],
[good_two_result[1], best_node_two_result[1]]]
def delete_high_betweenness_edge_centrality(self, infectG):
subinfectG = commons.get_subGraph_true(infectG)
# 根据中介性分层然后删除。
sort_list = Partion_common.get_layer_edge_between(subinfectG)
print('sort_list', sort_list)
commons_node_list = []
one_subgraph = None
two_subgraph = None
for edge, between in sort_list: #
print(edge, between)
subinfectG.remove_edge(edge[0], edge[1])
commons_node_list.append(edge[0])
commons_node_list.append(edge[1])
#重新计算一下那个中介
one_subgraph_nodelist, two_subgraph_nodelist = self.judge_two_subgraph(
subinfectG)
print('one_subgraph', one_subgraph_nodelist)
if len(one_subgraph_nodelist) > 1:
print('true')
one_subgraph_nodelist, two_subgraph_nodelist = one_subgraph_nodelist, two_subgraph_nodelist
break
commons_node_list_copy = copy.deepcopy(commons_node_list)
print('commons_node_liost',
commons_node_list.extend(one_subgraph_nodelist))
commons_node_list.extend(one_subgraph_nodelist)
commons_node_list_copy.extend(two_subgraph_nodelist)
return [commons_node_list, commons_node_list_copy]
def jaya_add_coverage(self, infectG):
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
print('传播图的点个数为', subinfectG.number_of_nodes())
print('传播图的边个数为', subinfectG.number_of_edges())
print('传播子图是否连通？', )
sub_connect_infect = self.judge_connect(subinfectG)
singleRegionList = list(sub_connect_infect.nodes)
results = commons.jayawith_dynami_H(infectG, singleRegionList, 2,
[4, 5, 6, 7], singleRegionList)
print(results)
node_coverage1 = []
node_coverage2 = []
# #计算两个传播区域的重合区域。
node_coverage1.extend(
list(
nx.bfs_tree(infectG,
source=results[0][0],
depth_limit=results[1])))
node_coverage2.extend(
list(
nx.bfs_tree(infectG,
source=results[0][1],
depth_limit=results[1])))
return [[results[0][0], node_coverage1],
[results[0][1], node_coverage2]]
def main(self, filename):
# #拿到图
initG = commons.get_networkByFile(filename)
max_sub_graph = commons.judge_data(initG)
print('是否是一棵树？', nx.is_tree(max_sub_graph))
# source_list = product_sourceList(max_sub_graph, 2)
source_list = self.produce_source(max_sub_graph, 1)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG, T = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
# 将在这里进行单源测试。
''' 第一种，就是jarden center '''
#
object_single = single_Source_detection.Single_source()
reverse_node = object_single.revsitionAlgorithm_singlueSource(
subinfectG)
result_node = self.single_source_bound_ture(subinfectG,
reverse_node[0],
source_list[0])
print('真实源是', source_list[0])
print('预测源是', result_node[0])
distance = nx.shortest_path_length(subinfectG,
source=source_list[0],
target=result_node[0])
print('结果是', distance)
return distance
def main(self, filename):
# #拿到图
initG = commons.get_networkByFile(filename)
# ecc=nx.eccentricity(initG)
# sort_ecc=sorted(ecc.items(),key=lambda x:x[1])
# product_srouce =sort_ecc[0][0]
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 1)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG, T = commons.propagation1(max_sub_graph, [1000])
# infectG1, T = commons.propagation1(max_sub_graph, [source_list])
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
#将在这里进行单源测试。
print(sorted(list(subinfectG.nodes())))
#
# result_node = self.revsitionAlgorithm_singlueSource(subinfectG)
# ''' 第二种，就是coverage/distance'''
# result_node= self.single_source_bydistance_coverage(infectG,subinfectG,source_list[0])
# ''' 第3种，距离中心'''
# result_node = self.single_source_bydistance( subinfectG)
#''' 第6种，质量距离中心'''
# result_node = self.single_source_byQuality_centrality(infectG,subinfectG)
# #''''第7种，特征向量中心性
# result_node = self.single_source_bybetweenness_centrality( subinfectG)
# #''''第8种，反转加t性
# result_node = self.single_source_get_T_jarden_center( T,subinfectG)
#第9种，谣言中心性‘’
result_node = self.rumor_center(infectG, subinfectG, 1000)
#
# # #’‘ 乔丹中心性
# result_node = self.jarden_cente_networkx(infectG,subinfectG,source_list[0])
# 覆盖率加我们的操作
# result_node = self.coverage_BFS_single_source(infectG,subinfectG,source_list[0])
# #多个观察点
# result_node = self.coverage_BFS_single_source(infectG,subinfectG,source_list[0])
#基于覆盖率的计算方式
# result_node = self.belief_algorithm(infectG, subinfectG,1000)
print('真实源是', source_list[0])
# print('预测源是',result_node[0])
distance = nx.shortest_path_length(subinfectG,
source=1000,
target=result_node[0])
print('结果他们的距离是', distance)
return distance
def main(self, filename):
# #拿到图
# subGraph=self.get_Graph('../Propagation_subgraph/many_methods/result/chouqu.txt')
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/3regular_tree1000.txt')
# initG = commons.get_networkByFile('../../data/4_regular_graph_3000_data.txt')
initG = commons.get_networkByFile(filename)
# initG = commons.get_networkByFile('../../../data/4_regular_graph_3000_data.txt')
# initG = commons.get_networkByFile('../../../data/email-Eu-core.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 2)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG = commons.propagation1(max_sub_graph, source_list)
# subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
single_Source_detection_object = single_Source_detection.Single_source(
)
'''
底下将是所有的步骤组合操作。目前是2源的。
1 抽取子图操作
2 分区
3 分别多源定位
'''
# 1 抽取子图操作，共有3种抽取子图操作。我们选择那3种呢?
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''''' '# 2 分区，分区的太多了，我们看看那种好。' ''
result = self.findmultiplesource(infectG, subinfectG, sourceNumber=2)
result_source_list = []
for community in result:
subsubinfectG = nx.Graph()
for edge in list(subinfectG.edges()):
if edge[0] in community and (edge[1] in community):
subsubinfectG.add_edge(edge[0], edge[1])
# 看下图连通吗。
maxsubsubinfectG = self.judge_data(subsubinfectG)
# 开始单源定位了。
'''jar center'''
source_node = single_Source_detection_object.revsitionAlgorithm_singlueSource(
maxsubsubinfectG)
# source_node = single_Source_detection_object.single_source_bydistance_coverage(infectG, maxsubsubinfectG)
result_source_list.append(source_node[0])
distance = commons.cal_distance(max_sub_graph, source_list,
result_source_list)
return distance
def main(self, filename):
# #拿到图
# subGraph=self.get_Graph('../Propagation_subgraph/many_methods/result/chouqu.txt')
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/3regular_tree1000.txt')
# initG = commons.get_networkByFile('../../data/4_regular_graph_3000_data.txt')
initG = commons.get_networkByFile(filename)
# initG = commons.get_networkByFile('../../../data/4_regular_graph_3000_data.txt')
# initG = commons.get_networkByFile('../../../data/email-Eu-core.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 2)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''
底下将是所有的步骤组合操作。目前是2源的。
1 抽取子图操作
2 分区
3 分别多源定位
'''
# 1 抽取子图操作，共有3种抽取子图操作。我们选择那3种呢?
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''''' '# 2 分区，分区的太多了，我们看看那种好。' ''
result = self.findmultiplesource(infectG, subinfectG, sourceNumber=2)
distance = commons.cal_distance(max_sub_graph, source_list, result)
return distance
def main(self, filename, method):
# #拿到图
initG = commons.get_networkByFile(filename)
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 1)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
# 将在这里进行种子节点覆盖。
''' 第1种，就是coverage/distance'''
func = getattr(self, method)
sort_partion = func(infectG, subinfectG, source_list[0])
return sort_partion
def main(self, filename):
# #拿到图
# subGraph=self.get_Graph('../Propagation_subgraph/many_methods/result/chouqu.txt')
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/3regular_tree1000.txt')
initG = commons.get_networkByFile(filename)
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/4_regular_graph_3000_data.txt')
# initG = commons.get_networkByFile('../../../data/email-Eu-core.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 2)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
self.judge_data(subinfectG)
# single_source = commons.revsitionAlgorithm_singlueSource(subinfectG)
distance_iter = nx.shortest_path_length(subinfectG)
everynode_distance = []
for node, node_distance in distance_iter:
# print(node_distance)
sort_list = sorted(node_distance.items(),
key=lambda x: x[1],
reverse=True)
# print('sort_list',sort_list)
everynode_distance.append([node, sort_list[0][0], sort_list[0][1]])
# print('everynode_idstance',everynode_distance)
sort_every_distance = sorted(everynode_distance,
key=lambda x: x[2],
reverse=True)
print('sort_every_distance', sort_every_distance)
#从两个最远的点进行BFS直到找到单源的位置。
# print(nx.shortest_path_length(infectG,source=single_source[0],target=sort_every_distance[0][0]))
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[0][1]))
#
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[1][0]))
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[1][1]))
#
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[2][0]))
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[2][1]))
# #根据最远得点，把我们的那个啥，分区，然后利用分区点进行单源定位。。
node_twolist = [[], []]
lengthA_dict = nx.single_source_bellman_ford_path_length(
subinfectG, sort_every_distance[0][0], weight='weight')
lengthB_dict = nx.single_source_bellman_ford_path_length(
subinfectG, sort_every_distance[0][1], weight='weight')
for node in list(subinfectG.nodes):
if lengthA_dict[node] > lengthB_dict[node]: # 这个点离b近一些。
node_twolist[1].append(node)
elif lengthA_dict[node] < lengthB_dict[node]:
node_twolist[0].append(node)
# else:
# node_twolist[0].append(node)
# node_twolist[1].append(node)
print('len(node_twolist[0]', len(node_twolist[0]))
print('len(node_twolist[1]', len(node_twolist[1]))
# 边界点。
bound_list = []
for node_temp in list(infectG.nodes()):
# print(node_temp)
if infectG.node[node_temp]['SI'] == 2:
neighbors_list = list(nx.neighbors(infectG, node_temp))
neighbors_infect_list = [
x for x in neighbors_list if infectG.node[x]['SI'] == 2
]
if len(neighbors_list) != 1 and len(
neighbors_infect_list) == 1:
# if len(neighbors_infect_list) == 1:
bound_list.append(node_temp)
print('boundelist', len(bound_list))
print('len(kjlk)',
len([x for x in bound_list if x in list(subinfectG.nodes())]))
left = [x for x in bound_list if x in node_twolist[0]]
right = [x for x in bound_list if x in node_twolist[1]]
print('left', left)
print('right', right)
left_source = commons.revsitionAlgorithm_singlueSource_receive(
subinfectG, left)
right_source = commons.revsitionAlgorithm_singlueSource_receive(
subinfectG, right)
if set(left) < set(list(subinfectG.nodes())):
print('left在感染点里面啊')
if set(right) < set(list(subinfectG.nodes())):
print('left在感染点里面啊')
distance = commons.cal_distance(infectG,
[left_source[0], right_source[0]],
source_list)
return distance
def main(self, filename):
# #拿到图
# subGraph=self.get_Graph('../Propagation_subgraph/many_methods/result/chouqu.txt')
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/3regular_tree1000.txt')
initG = commons.get_networkByFile(filename)
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/4_regular_graph_3000_data.txt')
# initG = commons.get_networkByFile('../../../data/email-Eu-core.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 2)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''
思路：
1 借助概率p= 0，5以及不同的时间t生成大量的集合。假设知道时间吧。
2 然后用这些集合去覆盖感染区域，尽可能让blue中点多，而红色区域少。
这种方法还可以用来确定种子节点的。
'''
# 1 抽取子图操作，共有3种抽取子图操作。我们选择那3种呢?
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''''' '# 2 分区，分区的太多了，我们看看那种好。' ''
self.product_many_region(0.5, 6, infectG, subinfectG, source_list)
partion_graph_object = Partion_graph.Partion_graph()
result = partion_graph_object.other_k_center(infectG,
subinfectG,
source_list,
source_number=2)
single_Source_detection_object = single_Source_detection.Single_source(
)
print('result', result)
# 对每一个感染的点建图，用真实的建成一个传播子图
result_source_list = []
'''
3 针对2传回来的多个区域，开始定位源点。
'''
for community in result:
subsubinfectG = nx.Graph()
for edge in list(subinfectG.edges()):
if edge[0] in community and (edge[1] in community):
subsubinfectG.add_edge(edge[0], edge[1])
# 看下图连通吗。
maxsubsubinfectG = self.judge_data(subsubinfectG)
# 开始单源定位了。
'''jar center'''
# source_node = single_Source_detection_object.revsitionAlgorithm_singlueSource(maxsubsubinfectG)
source_node = single_Source_detection_object.single_source_bydistance_coverage(
infectG, maxsubsubinfectG)
#
# source_node = single_Source_detection_object.single_source_bydistance(maxsubsubinfectG)
result_source_list.append(source_node[0])
distance = commons.cal_distance(max_sub_graph, source_list,
result_source_list)
return distance
def main(self):
# #拿到图
# subGraph=self.get_Graph('../Propagation_subgraph/many_methods/result/chouqu.txt')
# initG = commons.get_networkByFile('../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../data/3regular_tree1000.txt')
initG = commons.get_networkByFile(
'../../data/4_regular_graph_3000_data.txt')
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/4_regular_graph_3000_data.txt')
# initG = commons.get_networkByFile('../../../data/email-Eu-core.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 2)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''
底下将是所有的步骤组合操作。目前是2源的。
1 抽取子图操作
2 分区
3 分别多源定位
'''
# 1 抽取子图操作，共有3种抽取子图操作。我们选择那3种呢?
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''''' '# 2 分区，分区的太多了，我们看看那种好。' ''
'''2.1 Different'''
result = self.Parttion_Different_Time(infectG, sourceNumber=2)
print('result', len(result))
single_Source_detection_object = single_Source_detection.Single_source(
)
print('result', result)
# 对每一个感染的点建图，用真实的建成一个传播子图
result_source_list = []
'''
3 针对2传回来的多个区域，开始定位源点。
'''
for community_node, community in result:
subsubinfectG = nx.Graph()
for edge in list(subinfectG.edges()):
if edge[0] in community and (edge[1] in community):
subsubinfectG.add_edge(edge[0], edge[1])
# 看下图连通吗。
maxsubsubinfectG = self.judge_data(subsubinfectG)
# 开始单源定位了。
source_node = single_Source_detection_object.revsitionAlgorithm_singlueSource(
maxsubsubinfectG)
result_source_list.append(source_node[0])
distance = commons.cal_distance(max_sub_graph, source_list,
result_source_list)
return distance
def main(self, filename):
# #拿到图
# subGraph=self.get_Graph('../Propagation_subgraph/many_methods/result/chouqu.txt')
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/3regular_tree1000.txt')
initG = commons.get_networkByFile(filename)
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/4_regular_graph_3000_data.txt')
# initG = commons.get_networkByFile('../../../data/email-Eu-core.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 2)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG = commons.propagation1(max_sub_graph, source_list)
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
self.judge_data(subinfectG)
'''
思路：
1 借助概率p= 0，5以及不同的时间t生成大量的集合。假设知道时间吧。
2 然后用这些集合去覆盖感染区域，尽可能让blue中点多，而红色区域少。
这种方法还可以用来确定种子节点的。
'''
# 1 抽取子图操作，共有3种抽取子图操作。我们选择那3种呢?
subinfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
'''''' '# 2 分区，分区的太多了，我们看看那种好。' ''
partion_graph_object = Partion_graph.Partion_graph()
#开始分区，怎么分呢？
#根据边界节点来。两部分的边界节点，能够找到两个点使得他们到边界点的距离最短？
#
# result = partion_graph_object.other_k_center(infectG, subinfectG, source_list, source_number=2)
#
# single_source = commons.revsitionAlgorithm_singlueSource(subinfectG)
distance_iter = nx.shortest_path_length(subinfectG)
everynode_distance = []
for node, node_distance in distance_iter:
# print(node_distance)
sort_list = sorted(node_distance.items(),
key=lambda x: x[1],
reverse=True)
# print('sort_list',sort_list)
everynode_distance.append([node, sort_list[0][0], sort_list[0][1]])
# print('everynode_idstance',everynode_distance)
sort_every_distance = sorted(everynode_distance,
key=lambda x: x[2],
reverse=True)
print('sort_every_distance', sort_every_distance)
#从两个最远的点进行BFS直到找到单源的位置。
# print(nx.shortest_path_length(infectG,source=single_source[0],target=sort_every_distance[0][0]))
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[0][1]))
#
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[1][0]))
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[1][1]))
#
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[2][0]))
# print(nx.shortest_path_length(infectG, source=single_source[0], target=sort_every_distance[2][1]))
# #根据最远得点，把我们的那个啥，分区，然后利用分区点进行单源定位。。
node_twolist = [[], []]
lengthA_dict = nx.single_source_bellman_ford_path_length(
subinfectG, sort_every_distance[0][0], weight='weight')
lengthB_dict = nx.single_source_bellman_ford_path_length(
subinfectG, sort_every_distance[0][1], weight='weight')
for node in list(subinfectG.nodes):
if lengthA_dict[node] > lengthB_dict[node]: # 这个点离b近一些。
node_twolist[1].append(node)
elif lengthA_dict[node] < lengthB_dict[node]:
node_twolist[0].append(node)
# else:
# node_twolist[0].append(node)
# node_twolist[1].append(node)
print('len(node_twolist[0]', len(node_twolist[0]))
print('len(node_twolist[1]', len(node_twolist[1]))
# 边界点。
bound_list = []
for node_temp in list(infectG.nodes()):
# print(node_temp)
if infectG.node[node_temp]['SI'] == 2:
neighbors_list = list(nx.neighbors(infectG, node_temp))
neighbors_infect_list = [
x for x in neighbors_list if infectG.node[x]['SI'] == 2
]
if len(neighbors_list) != 1 and len(
neighbors_infect_list) == 1:
# if len(neighbors_infect_list) == 1:
bound_list.append(node_temp)
print('boundelist', len(bound_list))
print('len(kjlk)',
len([x for x in bound_list if x in list(subinfectG.nodes())]))
left = [x for x in bound_list if x in node_twolist[0]]
right = [x for x in bound_list if x in node_twolist[1]]
print('left', left)
print('right', right)
left_source = commons.revsitionAlgorithm_singlueSource_receive(
subinfectG, left)
right_source = commons.revsitionAlgorithm_singlueSource_receive(
subinfectG, right)
if set(left) < set(list(subinfectG.nodes())):
print('left在感染点里面啊')
if set(right) < set(list(subinfectG.nodes())):
print('left在感染点里面啊')
distance = commons.cal_distance(infectG,
[left_source[0], right_source[0]],
source_list)
return distance
def Partion_graph_K_center_seed(self,
G,
subinfectG,
true_source_list,
source_number_=2):
# 开始分区，输出每个区域的点和边。当前是两源的。
sort_list = commons.partion_layer_dict_bfs(G,
subinfectG,
2,
number_layer=10) # 分层
first_layer = [x[0] for x in sort_list] # 用第一层的节点。
# 先验证源点在不在第一层。
b = set(true_source_list)
print('源点在不在第一层呢？', b.issubset(first_layer))
print('第一层节点个数', len(first_layer))
subinfectG = commons.get_subGraph_true(G) # 获取真实的传播图
# 判断是否连通看看。
self.judge_connect(subinfectG)
print('如果不连通，这个方法就会出问题，一定要是连连通的。')
two_source = random.sample(first_layer, 2) # 从list中随机获取2个元素，作为一个片断返回
flag = 1
lengthA_B = 10000
good_two_result = []
best_node_two_result = None
averageA = 1
averageB = 1
for iter in range(0, 100):
# 对这两个点进行Djstra，计算所有点到他们的距离。
print('two_source', two_source)
lengthA_dict = nx.single_source_bellman_ford_path_length(
subinfectG, two_source[0], weight='weight')
lengthB_dict = nx.single_source_bellman_ford_path_length(
subinfectG, two_source[1], weight='weight')
# 统计两者距离相等的点个数
count = 0
for node, distance in lengthB_dict.items():
if lengthA_dict[node] == lengthB_dict[node]:
count += 1
print('两者距离相等的点个数为', count)
# 初始化两个集合，用来保存两个类别节点集合。
node_twolist = [[], []] # 保存两个类别节点集合
node_diff_twolist = [[], []] # 保存不同点
count = 0
for node in list(subinfectG.nodes):
if lengthA_dict[node] > lengthB_dict[node]: # 这个点离b近一些。
node_twolist[1].append(node)
node_diff_twolist[1].append(node)
elif lengthA_dict[node] < lengthB_dict[node]:
node_twolist[0].append(node)
node_diff_twolist[0].append(node)
else:
node_twolist[0].append(node)
node_twolist[1].append(node)
count += 1
print('node_twolist1 ', len(node_twolist[1]))
print('node_twolist2 ', len(node_twolist[0]))
print('count是公共节点数目', count)
# 在两个list中找到中心位置，有几种中心性可以度量的。或者进行快速算法。
# 判断这次找的两个中心好不好。
lengthA_sum = 0 # a这个不同点，
lengthB_sum = 0
for i in node_diff_twolist[0]: # 距离a近，第一个源点近的点。统计它跟第二个区域点的距离之和
lengthA_sum += lengthB_dict[i]
for j in node_diff_twolist[1]: # 距离b近，第二个源点近的点。统计它跟第二个区域点的距离之和
lengthB_sum += lengthA_dict[j]
print('平均距离计算')
average_lengthA = lengthA_sum / len(node_diff_twolist[0])
average_lengthB = lengthB_sum / len(node_diff_twolist[1])
sums = lengthA_sum + lengthB_sum
print(lengthA_B)
print('平均距离有增大就可以了。')
if average_lengthA > averageA and average_lengthB > averageB:
averageA = average_lengthA
averageB = average_lengthB
print('sums', sums)
# 是比原来好的的两个源。
print('node_diff_twolist', len(node_diff_twolist[0]))
print('node_diff_twolist', len(node_diff_twolist[1]))
print('更行sums', sums)
lengthA_B = sums
good_two_result = two_source
best_node_two_result = node_twolist
else:
# 重新长生两个源吧。这里还是可以做优化的，选择的方向问题。
two_source = random.sample(first_layer, 2)
print('新生成两个源是', two_source)
print('传播子图所有节点个数', len(list(subinfectG.nodes())))
print('len(good_two_result[0]', len(best_node_two_result[0]))
print('len(good_two_result[0]', len(best_node_two_result[1]))
print('分开的两个区域的点的交集大小。')
print(
'LEN',
len([
x for x in best_node_two_result[0]
if x in best_node_two_result[1]
]))
print('good_two_result', good_two_result)
print(
'short_length',
nx.shortest_path_length(subinfectG,
source=good_two_result[0],
target=good_two_result[1]))
print('good_node_two_result', best_node_two_result)
return [[good_two_result[0], best_node_two_result[0]],
[good_two_result[1], best_node_two_result[1]]]
print('down_message_dict_temp',down_messages_dict_temp[jordan_center])
print(upmessage_dict_temps[jordan_center])
return jordan_center
if __name__ == '__main__':
# #拿到图
initG = commons.get_networkByFile('../../../data/3regular_tree9.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 1)
# print('两个节点的距离', nx.shortest_path_length(max_sub_graph, source=source_list[0], target=source_list[1]))
infectG, T = commons.propagation1(max_sub_graph,source_list)
# infectG1, T = commons.propagation1(max_sub_graph, [source_list])
subInfectG = commons.get_subGraph_true(infectG) # 只取感染点，为2表示,真实的感染图。
# result_node = rumor_center(infectG, subinfectG, source_list[0])
# 将图构造成两个list，一个是感染点list，一个是感染和它的邻居点构造成的list
# infect_node = []
# infect_neighbour_list = []
# print(infectG.number_of_nodes())
# random_node = random.choice(list(subInfectG.nodes()))
# subinfectG_temp = nx.bfs_tree(subInfectG, source=source_list[0])
# subinfectG = subinfectG_temp.to_undirected()
jordan_center_object = jordan()
center = jordan_center_object.jordan_centrality(subInfectG)
print('center', center)
def main(self, filename):
# #拿到图
# subGraph=self.get_Graph('../Propagation_subgraph/many_methods/result/chouqu.txt')
# initG = commons.get_networkByFile('../../../data/CA-GrQc.txt')
# initG = commons.get_networkByFile('../../../data/3regular_tree1000.txt')
initG = commons.get_networkByFile(filename)
# initG = commons.get_networkByFile('../../../data/4_regular_graph_3000_data.txt')
max_sub_graph = commons.judge_data(initG)
# source_list = product_sourceList(max_sub_graph, 2)
source_list = commons.product_sourceList(max_sub_graph, 2)
print(
'两个节点的距离',
nx.shortest_path_length(max_sub_graph,
source=source_list[0],
target=source_list[1]))
#看下分区效果行不行，传播两次，就好了，
# 一个是SI为2，一个是SI为3。交叉区域为4。
infectG = commons.propagation_dif_sigl(max_sub_graph, source_list[0],
3) #3表示一个源点。
infectG_other = commons.propagation_dif_sigl(infectG, source_list[1],
4) # 4标示表示一个源点。 如果两个标示重合，
#那就取5
#提起其中某些节点的东西，提取3，4，5
node_list3 = []
node_list4 = []
node_list5 = []
for nodes in list(infectG_other.nodes):
if infectG_other.node[nodes]['SIDIF'] == 3:
node_list3.append(nodes)
elif infectG_other.node[nodes]['SIDIF'] == 4:
node_list4.append(nodes)
elif infectG_other.node[nodes]['SIDIF'] == 5:
node_list5.append(nodes)
node_list3.extend(node_list5)
node_list4.extend(node_list5)
print('first——node_list3', len(node_list3))
print('second——node_list4', len(node_list4))
print('common_node_list', len(node_list5))
subinfectG = commons.get_subGraph_true(
infectG_other) #只取感染点，为2表示,真实的感染图。
#然后将感染点之间所有边都相连接起来。
#第一种方法。
'''
应该在这个地方进行传播分区的各种实验，先做好2源的分区。
'''
# twosource_node_list =self.Partion_graph_K_center(infectG_other,source_list,2)
#第3种方式
# twosource_node_list = self.Partion_graph_K_center_seed(infectG_other,subinfectG,source_list,2)
# twosource_node_list = self.other_k_center(infectG_other, subinfectG, source_list, 2)
twosource_node_list = self.randmo_BFS(infectG_other, subinfectG,
source_list)
#进行覆盖率走，并进行jaya算法。
# twosource_node_list=self.jaya_add_coverage(infectG_other)
#进行删除边操作。
# twosource_node_list = self.delete_high_betweenness_edge_centrality_second(infectG_other)
# print(twosource_node_list)
# return self.verification(twosource_node_list, [node_list3, node_list4])
#
# # 第7种方法。
#
# twosource_node_list = self.label_progration_community(subinfectG)
# print(twosource_node_list)
# return self.verification(twosource_node_list,[node_list3,node_list4])
#
# # #第四种，进行判断高中介性点为中间点。判断比例
# # twosource_node_list= self.delete_high_betweenness_centrality(infectG_other)
# #
#
# 最后一种，分区的方法了
# twosource_node_list = self.other_k_center(subinfectG)
# print(twosource_node_list)
return self.verification(twosource_node_list, [node_list3, node_list4])
