def experiment_four(node_num, model):
'''
函数功能:q随时间减小的情况下观察实验结果
node_num:代表初始网络的节点总数
model:代表ER随机网络的类
'''
step = 0 #步长代表横坐标，从0开始
len_dict = len(model.dict_G) #记录剩余节点个数，初始值为未攻击前总节点数
min_node_degree = fc.min_degree(
model.dict_G) #将随机网络的字典传入函数，获得度最小节点的度,min_node_degree表示度数最小的节点的度
degree_dict = {} #degree_dict用来记录每个节点的初始度
for key in model.dict_G.keys():
degree_dict[key] = len(model.dict_G[key])
remain_node_rate = 1 #remain_node_rate代表剩余节点比例,初始值为1
is_crash = 0 #is_crash记录是否发生崩溃，0代表未崩溃，1代表崩溃
start_time = fc.GetNowTime() #获取当前时间作为起始时间
crash_time = 0 #crash_time代表系统崩溃的时间
data_file = open("ex_data4/datafile" + str(timestamp) + ".txt",
'a') #在ex_data1文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n')
while step < 1000000: #小于一定步数进行迭代
for key in list(model.dict_G.keys()
): #遍历节点,item代表节点的键,由于遍历过程中不能修改字典元素，所以将字典转为列表后处理
if min_node_degree <= model.er_ks or (
degree_dict[key] - len(model.dict_G[key])
) / degree_dict[key] > model.er_q: #满足条件k<=ks或者损失邻居节点比例超过q
step += 1 #步长每次加1
if step % 20000 == 0:
model.er_q -= 0.01
data_file.write(str(step))
data_file.write(',')
data_file.write(str(len_dict / node_num))
data_file.write('\n')
if len(model.dict_G[key]
) == min_node_degree: #如果满足k<=ks，从度数最小的节点开始删除
probability = random.random() #取一个0-1之间的随机数
if probability < model.er_f: #按照概率f删除节点
model.dict_G = fc.del_node(model.dict_G,
key) #删除k<ks的节点和其所连接的边
del degree_dict[key] #删除存储初始度节点的字典中的相关项
else:
continue
else:
continue
else:
break
len_dict = len(model.dict_G) #更新剩余节点个数
min_node_degree = fc.min_degree(model.dict_G) #更新度数最小的节点的度
remain_node_rate = len_dict / node_num #计算剩余节点比例
if len_dict < int(model.er_threshold): #达到崩溃阈值时，认定崩溃
is_crash = 1
crash_time = fc.GetNowTime() #获取系统奔溃时的时间
if len_dict < int(model.er_threshold) * 0.1: #剩余节点数过少时，跳出循环
break
end_time = fc.GetNowTime() #获取实验结束时的时间
data_file.close() #关闭记录实验数据的文件
def experiment_one(node_num, model):
'''
函数功能:从节点的度小于ks的节点开始攻击,即传统的k核模型，同时考虑q的影响
node_num:代表初始网络的节点总数
model:代表ER随机网络的类
'''
step = 0 #步长代表横坐标，从0开始
step_threshold = 1000000 #设定实验总步长的阈值,达到阈值停止迭代
len_dict = len(model.dict_G) #记录剩余节点个数，初始值为未攻击前总节点数
min_node_degree = fc.min_degree(
model.dict_G) #将随机网络的字典传入函数，获得度最小节点的度,min_node_degree表示度数最小的节点的度
for key in model.dict_G.keys():
degree_dict[key] = len(model.dict_G[key])
data_file = open("ex_data1/datafile" + str(timestamp) + ".txt",
'a') #在ex_data1文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n')
while step < step_threshold: #小于一定步数进行迭代
for key in list(model.dict_G.keys()
): #遍历节点,item代表节点的键,由于遍历过程中不能修改字典元素，所以将字典转为列表后处理
if min_node_degree <= model.er_ks or (
degree_dict[key] - len(model.dict_G[key])
) / degree_dict[key] > model.er_q: #满足条件k<=ks或者损失邻居节点比例超过q
if step % 2000 == 0:
data_file.write(str(step))
data_file.write(',')
data_file.write(str(len_dict / node_num))
data_file.write('\n')
if len(model.dict_G[key]
) == min_node_degree: #如果满足k<=ks，从度数最小的节点开始删除
probability = random.random() #取一个0-1之间的随机数
if probability < model.er_f: #按照概率f删除节点
model.dict_G = fc.del_node(model.dict_G,
key) #删除k<ks的节点和其所连接的边
del degree_dict[key] #删除存储初始度节点的字典中的相关项
step += 1 #步长每次加1
else:
continue
else:
continue
else:
break
len_dict = len(model.dict_G) #更新剩余节点个数
min_node_degree = fc.min_degree(model.dict_G) #更新度数最小的节点的度
remain_node_rate = len_dict / node_num #计算剩余节点比例
if len_dict < int(model.er_threshold): #达到崩溃阈值时，认定崩溃
is_crash = 1
crash_time = fc.GetNowTime() #获取系统奔溃时的时间
if len_dict < int(model.er_threshold) * 0.1: #剩余节点数过少时，跳出循环
break
end_time = fc.GetNowTime() #获取实验结束时的时间
data_file.close() #关闭记录实验数据的文件
import random #引入随机数模块
import function as fc #引入功能函数模块
import time #引入时间模块
#这个模块实现不同顺序的攻击，一是传统的k-shell分解，从度数小的节点开始攻击，二是从度数大的节点开始攻击，三是先从度数小的节点开始攻击，然后交替攻击
#记录一些全局变量
degree_dict = {} #degree_dict用来记录每个节点的初始度
is_crash = 0 #is_crash记录是否发生崩溃，0代表未崩溃，1代表崩溃
remain_node_rate = 1 #remain_node_rate代表剩余节点比例,初始值为1
start_time = fc.GetNowTime() #获取当前时间作为起始时间
crash_time = 0 #crash_time代表系统崩溃的时间
timestamp = time.time() #获取当前时间戳用于文件命名
#实验一 从度数小的节点开始攻击
def experiment_one(node_num, model):
'''
函数功能:从节点的度小于ks的节点开始攻击,即传统的k核模型，同时考虑q的影响
node_num:代表初始网络的节点总数
model:代表ER随机网络的类
'''
step = 0 #步长代表横坐标，从0开始
step_threshold = 1000000 #设定实验总步长的阈值,达到阈值停止迭代
len_dict = len(model.dict_G) #记录剩余节点个数，初始值为未攻击前总节点数
min_node_degree = fc.min_degree(
model.dict_G) #将随机网络的字典传入函数，获得度最小节点的度,min_node_degree表示度数最小的节点的度
for key in model.dict_G.keys():
degree_dict[key] = len(model.dict_G[key])
data_file = open("ex_data1/datafile" + str(timestamp) + ".txt",
'a') #在ex_data1文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n')
while step < step_threshold: #小于一定步数进行迭代
def experiment(ex_num):
'''
函数功能:从节点的度小于ks的节点开始攻击,即传统的k核模型，同时考虑q的影响
node_num:代表初始网络的节点总数
model:代表ER随机网络的类
'''
mkdir_name = str(timestamp) #创建的文件夹名
paper_file = "E:\\project\\kq\\kq_cascade\\ex_data\\%s" %mkdir_name #文件夹创建路径
os.makedirs(paper_file) #在ex_data文件夹下创建本次试验的文件夹
for i in range(ex_num):
step = 0 #步长代表横坐标，从0开始
is_crash = 0 #is_crash记录是否发生崩溃，0代表未崩溃，1代表崩溃
#每次实验选择实验中的模型,1代表er，2代表exp，3代表sf,4代表facebook真实网络,5代表epa真实网络
model_select = int(input("please input the select of model:")) #选择实验中使用的模型
if model_select == 1:
model = nm.ER_network_model()
my_model = "er"
elif model_select == 2:
model = nm.EXP_network_model()
my_model = "exp"
elif model_select == 3:
model = nm.SF_network_model()
my_model = "sf"
elif model_select == 4:
model = nm.facebook_network_model()
my_model = "facebook"
elif model_select == 5:
model = nm.epa_network_model()
my_model = "epa"
initial_nodes = len(model.dict_G) #记录初始节点总度数
len_dict = len(model.dict_G) #记录剩余节点个数，初始值为未攻击前总节点数
k_max = fc.max_degree(model.dict_G) #当前网络所有节点中度的最大值
k_min = fc.min_degree(model.dict_G) #当前网络所有节点中度的最小值
for key in model.dict_G.keys():
degree_dict[key] = len(model.dict_G[key])
ex_select = int(input("please input the type of attack:")) #选择进行的实验,1代表传统kq模型,2代表从大节点开始攻击，3代表q与节点的初始度值成正比,4代表q与节点的初始度值成反比,5代表先删除10%的大节点
if ex_select == 1:
data_file = open(paper_file + "\\" + str(i) + ".txt",'a') #在ex_data文件夹下的本次试验的文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n') #文件里写入抬头
k = int(input("please input k:")) #输入每次实验的k值
q = float(input("please input q:")) #输入每次实验的q值
f = float(input("please input f:")) #输入每次实验的f值
insert_sql = "insert into experimental_data(model,k,q,f,paper_file)values('%s',%f,%f,%f,'%s')"%(str(my_model),k,q,f,str(mkdir_name))
#print(insert_sql)
cursor.execute(insert_sql)
er_threshold = initial_nodes*0.05 #er_threshold代表临界阈值，即损失超过原始节点的5%视为崩溃
while step < 100000 :
if len_dict < 100:
break
step +=1 #步长每次加1
if step % 5 == 0:
data_file.write(str(step))
data_file.write(',')
data_file.write(str(len_dict / initial_nodes))
data_file.write('\n')
for key in list(model.dict_G.keys()): #遍历节点,item代表节点的键,由于遍历过程中不能修改字典元素，所以将字典转为列表后处理
if len_dict < int(er_threshold): #达到崩溃阈值时，认定崩溃
is_crash = 1
crash_time = fc.GetNowTime() #获取系统奔溃时的时间
if len(model.dict_G[key]) <= k or (degree_dict[key] - len(model.dict_G[key])) / degree_dict[key] > q: #满足条件k<=ks或者损失邻居节点比例超过q
probability = random.random() #取一个0-1之间的随机数
if probability < f: #按照概率f删除节点
model.dict_G = fc.del_node(model.dict_G,key) #删除k<ks的节点和其所连接的边
del degree_dict[key] #删除存储初始度节点的字典中的相关项
len_dict = len(model.dict_G) #更新剩余节点个数
remain_node_rate = len_dict / initial_nodes #计算剩余节点比例
else:
continue
else:
continue
elif ex_select == 2:
data_file = open(paper_file + "\\" + str(i) + ".txt",'a') #在ex_data文件夹下的本次试验的文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n') #文件里写入抬头
k = int(input("please input k:")) #输入每次实验的k值
q = float(input("please input q:")) #输入每次实验的q值
f = float(input("please input f:")) #输入每次实验的f值
insert_sql = "insert into experimental_data(model,k,q,f)values('%s',%f,%f,%f)"%(str(my_model),k,q,f)
#print(insert_sql)
cursor.execute(insert_sql)
er_threshold = initial_nodes*0.05 #er_threshold代表临界阈值，即损失超过原始节点的5%视为崩溃
while step < 100000 :
if len_dict < 100:
break
step +=1 #步长每次加1
if step % 1 == 0:
data_file.write(str(step))
data_file.write(',')
data_file.write(str(len_dict / initial_nodes))
data_file.write('\n')
for key in list(model.dict_G.keys()): #遍历节点,item代表节点的键,由于遍历过程中不能修改字典元素，所以将字典转为列表后处理
if len_dict < int(er_threshold): #达到崩溃阈值时，认定崩溃
is_crash = 1
crash_time = fc.GetNowTime() #获取系统奔溃时的时间
if len(model.dict_G[key]) > k or (degree_dict[key] - len(model.dict_G[key])) / degree_dict[key] > q: #满足条件k>ks或者损失邻居节点比例超过q
probability = random.random() #取一个0-1之间的随机数
if probability < f: #按照概率f删除节点
model.dict_G = fc.del_node(model.dict_G,key) #删除k>ks的节点和其所连接的边
del degree_dict[key] #删除存储初始度节点的字典中的相关项
len_dict = len(model.dict_G) #更新剩余节点个数
remain_node_rate = len_dict / initial_nodes #计算剩余节点比例
else:
continue
else:
continue
elif ex_select == 3:
data_file = open(paper_file + "\\" + str(i) + ".txt",'a') #在ex_data文件夹下的本次试验的文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n') #文件里写入抬头
while step < 100000 :
if len_dict < 100:
break
step +=1 #步长每次加1
if step % 1 == 0:
data_file.write(str(step))
data_file.write(',')
data_file.write(str(len_dict / 10000))
data_file.write('\n')
for key in list(model.dict_G.keys()): #遍历节点,item代表节点的键,由于遍历过程中不能修改字典元素，所以将字典转为列表后处理
k_now = len(model.dict_G[key]) #k_now代表当前节点的度数
var_q = (k_now-k_min)/(k_max-k_min) #变量q的公式
if len_dict < int(er_threshold): #达到崩溃阈值时，认定崩溃
is_crash = 1
crash_time = fc.GetNowTime() #获取系统奔溃时的时间
if len(model.dict_G[key]) > k or (degree_dict[key] - len(model.dict_G[key])) / degree_dict[key] > var_q: #满足条件k>ks或者损失邻居节点比例超过var_q
probability = random.random() #取一个0-1之间的随机数
if probability < f: #按照概率f删除节点
model.dict_G = fc.del_node(model.dict_G,key) #删除k>ks的节点和其所连接的边
del degree_dict[key] #删除存储初始度节点的字典中的相关项
len_dict = len(model.dict_G) #更新剩余节点个数
remain_node_rate = len_dict / 10000 #计算剩余节点比例
else:
continue
else:
continue
elif ex_select == 4:
data_file = open(paper_file + "\\" + str(i) + ".txt",'a') #在ex_data文件夹下的本次试验的文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n') #文件里写入抬头
while step < 100000 :
if len_dict < 100:
break
step +=1 #步长每次加1
if step % 1 == 0:
data_file.write(str(step))
data_file.write(',')
data_file.write(str(len_dict / 10000))
data_file.write('\n')
for key in list(model.dict_G.keys()): #遍历节点,item代表节点的键,由于遍历过程中不能修改字典元素，所以将字典转为列表后处理
k_now = len(model.dict_G[key]) #k_now代表当前节点的度数
var_q = (k_max-k_now)/(k_max-k_min) #变量q的公式
if len_dict < int(er_threshold): #达到崩溃阈值时，认定崩溃
is_crash = 1
crash_time = fc.GetNowTime() #获取系统奔溃时的时间
if len(model.dict_G[key]) > k or (degree_dict[key] - len(model.dict_G[key])) / degree_dict[key] > var_q: #满足条件k>ks或者损失邻居节点比例超过var_q
probability = random.random() #取一个0-1之间的随机数
if probability < f: #按照概率f删除节点
model.dict_G = fc.del_node(model.dict_G,key) #删除k>ks的节点和其所连接的边
del degree_dict[key] #删除存储初始度节点的字典中的相关项
len_dict = len(model.dict_G) #更新剩余节点个数
remain_node_rate = len_dict / 10000 #计算剩余节点比例
else:
continue
else:
continue
elif ex_select == 5:
data_file = open(paper_file + "\\" + str(i) + ".txt",'a') #在ex_data文件夹下的本次试验的文件夹下创建记录实验数据的txt文件
data_file.write('step_size,residual_node_ratio\n') #文件里写入抬头
k = int(input("please input k:")) #输入每次实验的k值
q = float(input("please input q:")) #输入每次实验的q值
f = float(input("please input f:")) #输入每次实验的f值
insert_sql = "insert into experimental_data(model,k,q,f,paper_file)values('%s',%f,%f,%f,'%s')"%(str(my_model),k,q,f,str(mkdir_name))
#print(insert_sql)
cursor.execute(insert_sql)
er_threshold = initial_nodes*0.05 #er_threshold代表临界阈值，即损失超过原始节点的5%视为崩溃
fc.max_delete(model.dict_G) #调用函数删除1%的最大节点
while step < 100000 :
if len_dict < 100:
break
step +=1 #步长每次加1
if step % 5 == 0:
data_file.write(str(step))
data_file.write(',')
data_file.write(str(len_dict / initial_nodes))
data_file.write('\n')
for key in list(model.dict_G.keys()): #遍历节点,item代表节点的键,由于遍历过程中不能修改字典元素，所以将字典转为列表后处理
if len_dict < int(er_threshold): #达到崩溃阈值时，认定崩溃
is_crash = 1
crash_time = fc.GetNowTime() #获取系统奔溃时的时间
if len(model.dict_G[key]) <= k or (degree_dict[key] - len(model.dict_G[key])) / degree_dict[key] > q: #满足条件k<=ks或者损失邻居节点比例超过q
probability = random.random() #取一个0-1之间的随机数
if probability < f: #按照概率f删除节点
model.dict_G = fc.del_node(model.dict_G,key) #删除k<ks的节点和其所连接的边
del degree_dict[key] #删除存储初始度节点的字典中的相关项
len_dict = len(model.dict_G) #更新剩余节点个数
remain_node_rate = len_dict / initial_nodes #计算剩余节点比例
else:
continue
else:
continue
data_file.close() #关闭记录实验数据的文件
end_time = fc.GetNowTime() #获取实验结束的时间