def compute_by_config(choice_arr):
# 在当前目录调用ReadConfig，读取操作也在当前目录运行，当前目录没有config文件，就会读不到
# 放到上级总目录configs中
res = ReadConfig.readIndex()
impact_arr = res[1]
stops = res[2]
f = []
out = []
totalRes = []
count = len(choice_arr)
# print 'choice_arr:', choice_arr
# for counter in range(1, count-1):
for counter in range(len(choice_arr)):
impact_fn = init_fuzzy(impact_arr[counter])
impact = occur_levels[str(choice_arr[counter])]
# fn_element = num_multiple_fuzzy(choice_arr[counter], impact_fn)
fn_element = multiple_fuzzy(impact, impact_fn)
f.append(fn_element)
fns_of_risks = plus_separately(f, stops)
# 这里获取到的totalRes只有所有风险的模糊风险值，按顺序存放，没有风险名称
totalRes = fns_of_risks
# 依次计算每一类风险的风险等级
# for index, totalRes in enumerate(fns_of_risks):
for index, i in enumerate(totalRes):
# print i[0]
sims1 = []
target_fn = FuzzyNumber.fnWithHeight(i, 1)
for key in score_levels.keys():
# 计算当前风险和所有等级的相似度
level_fn = FuzzyNumber.fnWithHeight(score_levels[key], 1)
sims1.append(
[key,
FuzzyNumber.simlarity_caculator9(target_fn, level_fn)])
# 获取最高相似度
max_sim1 = max(sims1, key=lambda sim1: sim1[1])
sorted_sims1 = sorted(sims1, key=lambda sim1: sim1[1])
# 最高相似度对应的级别
risk_level1 = max_sim1[0]
# print index + 1, Risk_names[index]
# y.append 传给前端[[x1,x2,x3...],[y1,y2,y3...]] x为风险类型，是固定的
# print risk_level1
alarm_level = ""
if risk_level1 in ["absolutely high", "very high"]:
alarm_level = "high"
elif risk_level1 in ["fairly high", "high"]:
alarm_level = "medium"
elif risk_level1 in ["low", "very low", "medium"]:
alarm_level = "low"
if alarm_level != "":
RiskAlarm.riskAlarm(alarm_level)
out.append(risk_level1)
return out
def setFuzzyscore(self):
'''
根据inference确定模糊数的运算公式
:return: None
'''
if inference == 1:
self.fuzzy_score = FuzzyNumber.fuzzy_multiple(
self.fuzzy_probability, self.fuzzy_impact)
# for i in range(fuzzy_size):
# self.fuzzy_score.append(self.fuzzy_probability[i]*self.fuzzy_impact[i])
if sim_caculator == 1:
sims1 = []
sims2 = []
sims3 = []
sims4 = []
sims5 = []
target_fn = FuzzyNumber.fnWithHeight(self.fuzzy_score, 1)
print score_levels.keys()
for key in score_levels.keys():
# 计算当前风险和所有等级的相似度
level_fn = FuzzyNumber.fnWithHeight(score_levels[key], 1)
sims1.append([
key,
FuzzyNumber.simlarity_caculator5(target_fn, level_fn)
])
# sims2.append([key, FuzzyNumber.simlarity_caculator3(target_fn, level_fn)])
# sims3.append([key, FuzzyNumber.simlarity_caculator4(target_fn, level_fn)])
# 多峰值务必放在最后
# sims4.append([key, FuzzyNumber.simlarity_caculator5(target_fn, level_fn)])
# sims5.append([key, FuzzyNumber.simlarity_caculator6(target_fn, level_fn)])
# 选择相似度最高的等级
max_sim1 = max(sims1, key=lambda sim1: sim1[1])
# max_sim2 = max(sims2,key = lambda sim2:sim2[1])
# max_sim3 = max(sims3,key = lambda sim3:sim3[1])
# max_sim4 = max(sims4,key = lambda sim4:sim4[1])
# max_sim5 = max(sims5,key = lambda sim5:sim5[1])
self.risk_level1 = max_sim1[0]
def test():
# 依次读取choice和impact
counter = 1
f = []
out = []
with open(impact_path, 'r') as impact_file, open(choice_path,
'r') as choice_file:
for impact, choice in zip(impact_file, choice_file):
counter = counter + 1
impact_fn = init_fuzzy(impact)
fn_element = num_multiple_fuzzy(choice, impact_fn)
f.append(fn_element)
fns_of_risks = plus_separately(f, stops)
# 这里获取到的totalRes只有所有风险的模糊风险值，按顺序存放，没有风险名称
totalRes = fns_of_risks
# 依次计算每一类风险的风险等级
# for index, totalRes in enumerate(fns_of_risks):
for (index, i) in enumerate(totalRes):
# print i[0]
sims1 = []
target_fn = FuzzyNumber.fnWithHeight(i, 1)
for key in score_levels.keys():
# 计算当前风险和所有等级的相似度
level_fn = FuzzyNumber.fnWithHeight(score_levels[key], 1)
sims1.append(
[key,
FuzzyNumber.simlarity_caculator9(target_fn, level_fn)])
# 获取最高相似度
max_sim1 = max(sims1, key=lambda sim1: sim1[1])
sorted_sims1 = sorted(sims1, key=lambda sim1: sim1[1])
# 最高相似度对应的级别
risk_level1 = max_sim1[0]
# print index+1,Risk_names[index]
# y.append 传给前端[[x1,x2,x3...],[y1,y2,y3...]] x为风险类型，是固定的
# print risk_level1
out.append(risk_level1)
RiskAlarm.riskAlarm(Risk_names, out)
# out不能在循环内
return out
def compute_risk_level(choice_arr):
f = []
out = []
totalRes = []
for counter in range(len(choice_arr)):
impact_fn = init_fuzzy(impact_arr[counter])
fn_element = num_multiple_fuzzy(choice_arr[counter], impact_fn)
f.append(fn_element)
fns_of_risks = plus_separately(f, stops)
# 这里获取到的totalRes只有所有风险的模糊风险值，按顺序存放，没有风险名称
totalRes = fns_of_risks
# 依次计算每一类风险的风险等级
# for index, totalRes in enumerate(fns_of_risks):
for index, i in enumerate(totalRes):
# print i[0]
sims1 = []
target_fn = FuzzyNumber.fnWithHeight(i, 1)
for key in score_levels.keys():
# 计算当前风险和所有等级的相似度
level_fn = FuzzyNumber.fnWithHeight(score_levels[key], 1)
sims1.append(
[key,
FuzzyNumber.simlarity_caculator9(target_fn, level_fn)])
# 获取最高相似度
max_sim1 = max(sims1, key=lambda sim1: sim1[1])
sorted_sims1 = sorted(sims1, key=lambda sim1: sim1[1])
# 最高相似度对应的级别
risk_level1 = max_sim1[0]
# print index+1,Risk_names[index]
# y.append 传给前端[[x1,x2,x3...],[y1,y2,y3...]] x为风险类型，是固定的
out.append(risk_level1)
return out
# function definition
# main function
if __name__ == '__main__':
inputEval()
# 这里获取到的totaoRes包括了所有类型风险的模糊风险值
# [[风险1名称，风险1模糊值]，[风险2名称，风险2模糊值]，[风险3名称，风险3模糊值]，......]
totalRes = getTotalEval()
print totalRes
for i in totalRes:
# print i[0]
sims1 = []
target_fn = FuzzyNumber.fnWithHeight(i[1], 1)
for key in score_levels.keys():
# 计算当前风险和所有等级的相似度
level_fn = FuzzyNumber.fnWithHeight(score_levels[key], 1)
# sims1.append([key, FuzzyNumber.simlarity_caculator7(target_fn, level_fn)])
# sims1.append([key, FuzzyNumber.simlarity_caculator3(target_fn, level_fn)])
# sims1.append([key, FuzzyNumber.simlarity_caculator4(target_fn, level_fn)])
sims1.append(
[key,
FuzzyNumber.simlarity_caculator9(target_fn, level_fn)])
# sims1.append([key, FuzzyNumber.simlarity_caculator6(target_fn, level_fn)])
max_sim1 = max(sims1, key=lambda sim1: sim1[1])
sorted_sims1 = sorted(sims1, key=lambda sim1: sim1[1])
risk_level1 = max_sim1[0]
print i[0] + ':' + risk_level1