def calculate_DM_item(W_index):
p = []
temp = [0.]
for i in range(len(globals.quants)):
temp.append(globals.quants[i])
temp.append(1.0)
for i in range(1, len(temp)):
p.append(temp[i] - temp[i - 1])
lowvals = np.zeros([len(globals.CQ_assess) + len(globals.TQ_assess)])
higvals = np.zeros([len(globals.CQ_assess) + len(globals.TQ_assess)])
x_o = np.zeros([len(globals.CQ_assess) + len(globals.TQ_assess)])
x_n = np.zeros([len(globals.CQ_assess) + len(globals.TQ_assess)])
strs = ["" for x in range(len(globals.experts))]
fin_str = ["" for x in range(len(globals.experts))]
i = 0
for CQ_value in globals.CQ_values:
lowvals[i] = CQ_value.value
higvals[i] = CQ_value.value
quant = []
for CQ_asses in globals.CQ_assess:
if CQ_value.name == CQ_asses.prod_name:
for j in range(len(CQ_asses.vals)):
if CQ_asses.vals[0] > -900:
if lowvals[i] > CQ_asses.vals[j]:
lowvals[i] = CQ_asses.vals[j]
if higvals[i] < CQ_asses.vals[j]:
higvals[i] = CQ_asses.vals[j]
if CQ_value.dist.lower() == "uni":
x_o[i] = lowvals[i] - globals.k * (higvals[i] - lowvals[i])
x_n[i] = higvals[i] + globals.k * (higvals[i] - lowvals[i])
quant.append(x_o[i])
quant.append(x_n[i])
nexp = 0
for expert in globals.experts:
for CQ_asses in globals.CQ_assess:
if CQ_value.name == CQ_asses.prod_name and CQ_asses.exp_id == expert.id:
if expert.w_CQ_asses_norm[i] == 0 or CQ_asses.vals[0] < -900. or math.isnan(
expert.w_CQ_asses_norm[i]):
strs[nexp] = ' 0'
else:
string1 = "[ " + str(x_o[i])
for ii in range(len(CQ_asses.vals)):
string1 = string1 + "," + str(CQ_asses.vals[ii])
string1 = string1 + "," + str(x_n[i]) + " ]"
strs[nexp] = ' {:}*unif_dnes_v1(x, {:}, {:})'.format(expert.w_CQ_asses_norm[i], string1,
str(p))
for j in range(len(CQ_asses.vals)):
quant.append(CQ_asses.vals[j])
nexp = nexp + 1
fin_str[0] = strs[0]
for j in range(1, len(strs)):
fin_str[j] = fin_str[j - 1] + " + " + strs[j]
X = np.sort(np.unique(quant))
CQ_value.X_DM.append(X[0])
CQ_value.F_DM.append(0)
integral = 0
for j in range(1, len(X)):
x = X[j]
CQ_value.X_DM.append(X[j])
CQ_value.f_DM.append(eval(fin_str[len(strs) - 1]))
dintegral = quad(eval("lambda x: " + fin_str[len(strs) - 1]), X[j - 1], X[j])
integral = integral + dintegral[0]
CQ_value.F_DM.append(integral)
vals = globals.quants # get p here?
DM_vals = np.interp(vals, CQ_value.F_DM, CQ_value.X_DM)
CQ_value.DM.append(x_o[i])
CQ_value.DM.extend(DM_vals)
CQ_value.DM.append(x_n[i])
elif CQ_value.dist.lower() == "log_uni" or CQ_value.dist.lower() == "log":
x_o[i] = math.log(lowvals[i]) - globals.k * (math.log(higvals[i]) - math.log(lowvals[i]))
x_n[i] = math.log(higvals[i]) + globals.k * (math.log(higvals[i]) - math.log(lowvals[i]))
quant.append(x_o[i])
quant.append(x_n[i])
nexp = 0
for expert in globals.experts:
for CQ_asses in globals.CQ_assess:
if CQ_value.name == CQ_asses.prod_name and CQ_asses.exp_id == expert.id:
if expert.w_CQ_asses_norm[i] == 0 or CQ_asses.vals[0] < -900. or math.isnan(
expert.w_CQ_asses_norm[i]):
strs[nexp] = ' 0'
else:
string1 = "[ " + str(x_o[i])
for ii in range(len(CQ_asses.vals)):
string1 = string1 + "," + str(math.log(CQ_asses.vals[ii]))
string1 = string1 + "," + str(x_n[i]) + " ]"
strs[nexp] = ' {:}*unif_dnes_v1(x, {:}, {:})'.format(expert.w_CQ_asses_norm[i], string1,
str(p))
for j in range(len(CQ_asses.vals)):
quant.append(math.log(CQ_asses.vals[j]))
nexp = nexp + 1
fin_str[0] = strs[0]
for j in range(1, len(strs)):
fin_str[j] = fin_str[j - 1] + " + " + strs[j]
X = np.sort(np.unique(quant))
F_DM = [0]
CQ_value.X_DM.append(X[0])
CQ_value.F_DM.append(0)
integral = 0
for j in range(1, len(X)):
x = X[j]
CQ_value.X_DM.append(X[j])
CQ_value.f_DM.append(eval(fin_str[len(strs) - 1]))
dintegral = quad(eval("lambda x: " + fin_str[len(strs) - 1]), X[j - 1], X[j])
integral = integral + dintegral[0]
CQ_value.F_DM.append(integral)
vals = [0.05, 0.5, 0.95] # get p here?
DM_vals = np.interp(vals, CQ_value.F_DM, CQ_value.X_DM)
CQ_value.DM.append(math.exp(x_o[i]))
CQ_value.DM.extend([math.exp(DM_vals[0]), math.exp(DM_vals[1]), math.exp(DM_vals[2])])
CQ_value.DM.append(math.exp(x_n[i]))
else:
print('Wrong background measure of item ' + CQ_value.name)
i = i + 1
i = 0
for TQ_value in globals.TQ_values:
lowvals[i] = 1e6
higvals[i] = -1e6
quant = []
for TQ_asses in globals.TQ_assess:
if TQ_value.name == TQ_asses.prod_name:
for j in range(len(TQ_asses.vals)):
if TQ_asses.vals[0] > -900:
if lowvals[i] > TQ_asses.vals[j]:
lowvals[i] = TQ_asses.vals[j]
if higvals[i] < TQ_asses.vals[j]:
higvals[i] = TQ_asses.vals[j]
if TQ_value.dist.lower() == "uni":
x_o[i] = lowvals[i] - globals.k * (higvals[i] - lowvals[i])
x_n[i] = higvals[i] + globals.k * (higvals[i] - lowvals[i])
quant.append(x_o[i])
quant.append(x_n[i])
nexp = 0
for expert in globals.experts:
for TQ_asses in globals.TQ_assess:
if TQ_value.name == TQ_asses.prod_name and TQ_asses.exp_id == expert.id:
if expert.w_tq_norm[i] == 0 or TQ_asses.vals[0] < -900. or math.isnan(expert.w_tq_norm[i]):
strs[nexp] = ' 0'
else:
string1 = "[ " + str(x_o[i])
for ii in range(len(TQ_asses.vals)):
string1 = string1 + "," + str(TQ_asses.vals[ii])
string1 = string1 + "," + str(x_n[i]) + " ]"
strs[nexp] = ' {:}*unif_dnes_v1(x, {:}, {:})'.format(expert.w_tq_norm[i], string1, str(p))
for j in range(len(TQ_asses.vals)):
quant.append(TQ_asses.vals[j])
nexp = nexp + 1
fin_str[0] = strs[0]
for j in range(1, len(strs)):
fin_str[j] = fin_str[j - 1] + " + " + strs[j]
X = np.sort(np.unique(quant))
F_DM = [0]
TQ_value.X_DM.append(X[0])
TQ_value.F_DM.append(0)
integral = 0
for j in range(1, len(X)):
x = X[j]
TQ_value.X_DM.append(X[j])
TQ_value.f_DM.append(eval(fin_str[len(strs) - 1]))
dintegral = quad(eval("lambda x: " + fin_str[len(strs) - 1]), X[j - 1], X[j])
integral = integral + dintegral[0]
TQ_value.F_DM.append(integral)
DM_vals = np.interp(globals.quants, TQ_value.F_DM, TQ_value.X_DM)
TQ_value.DM.append(x_o[i])
TQ_value.DM.extend(DM_vals)
TQ_value.DM.append(x_n[i])
elif TQ_value.dist.lower() == "log_uni" or TQ_value.dist.lower() == "log":
x_o[i] = math.log(lowvals[i]) - globals.k * (math.log(higvals[i]) - math.log(lowvals[i]))
x_n[i] = math.log(higvals[i]) + globals.k * (math.log(higvals[i]) - math.log(lowvals[i]))
quant.append(x_o[i])
quant.append(x_n[i])
nexp = 0
for expert in globals.experts:
for TQ_asses in globals.TQ_assess:
if TQ_value.name == TQ_asses.prod_name and TQ_asses.exp_id == expert.id:
if expert.w_tq_norm[i] == 0 or TQ_asses.vals[0] < -900. or math.isnan(expert.w_tq_norm[i]):
strs[nexp] = ' 0'
else:
string1 = "[ " + str(x_o[i])
for ii in range(len(TQ_asses.vals)):
string1 = string1 + "," + str(math.log(TQ_asses.vals[ii]))
string1 = string1 + "," + str(x_n[i]) + " ]"
strs[nexp] = ' {:}*unif_dnes_v1(x, {:}, {:})'.format(expert.w_tq_norm[i], string1,
str(p))
for j in range(len(TQ_asses.vals)):
quant.append(math.log(TQ_asses.vals[j]))
nexp = nexp + 1
fin_str[0] = strs[0]
for j in range(1, len(strs)):
fin_str[j] = fin_str[j - 1] + " + " + strs[j]
X = np.sort(np.unique(quant))
integral = 0
for j in range(1, len(X)):
x = X[j]
TQ_value.X_DM.append(X[j])
TQ_value.f_DM.append(eval(fin_str[len(strs) - 1]))
dintegral = quad(eval("lambda x: " + fin_str[len(strs) - 1]), X[j - 1], X[j])
integral = integral + dintegral[0]
TQ_value.F_DM.append(integral)
DM_vals = np.interp(globals.quants, TQ_value.F_DM, TQ_value.X_DM)
TQ_value.DM.append(math.exp(x_o[i]))
TQ_value.DM.extend([math.exp(DM_vals[ii]) for ii in range(len(globals.quants))])
TQ_value.DM.append(math.exp(x_n[i]))
else:
print('Wrong background measure of item ' + TQ_value.name)
i = i + 1
# now add to CQ_assesing and to globals.TQ_assess
id_DM = len(globals.experts) + 1
globals.experts.append(
exp(id_DM, "DM", np.zeros(len(globals.TQ_index)), np.zeros(len(globals.CQ_values)), len(globals.quants)))
for TQ_value in globals.TQ_values:
globals.TQ_assess.append(CQ_assesing(id_DM, "DM", TQ_value.id, TQ_value.name, TQ_value.dist,
[TQ_value.DM[ii + 1] for ii in range(len(globals.quants))]))
for CQ_value in globals.CQ_values:
globals.CQ_assess.append(
CQ_assesing(id_DM, "DM", CQ_value.id, CQ_value.name, CQ_value.dist,
[CQ_value.DM[ii + 1] for ii in range(len(globals.quants))]))
global_weights(W_index + 1)
return
def Checking_Robustness_items(incl_cal_pwr, cal_power):
prodlist = []
robustness_table = []
cal_power_l = cal_power
for CQ_value in globals.CQ_values:
prodlist.append(CQ_value.id)
for i in range(0, globals.N_max_it):
Remove_CQ_values = []
m = list(combinations(prodlist, i + 1))
for kn in range(len(m)):
Remove_CQ_values.append([m[kn][l] for l in range(len(m[kn]))])
if incl_cal_pwr == "yes":
cal_power_l = (len(globals.CQ_values) - float(i)) / len(
globals.CQ_values)
for remove_CQ_value in Remove_CQ_values:
string1 = ('Excluded questions: ' + str(remove_CQ_value)[1:-1])
revert.revert()
rem_lin = []
i = 0
for CQ_value in globals.CQ_values:
if CQ_value.id in remove_CQ_value:
rem_lin.append(i)
i = i + 1
for j in reversed(rem_lin):
globals.CQ_values.remove(globals.CQ_values[j])
rem_lin = []
i = 0
for CQ_asses in globals.CQ_assess:
if CQ_asses.prod_id in remove_CQ_value:
rem_lin.append(i)
i = i + 1
for j in reversed(rem_lin):
globals.CQ_assess.remove(globals.CQ_assess[j])
if not globals.optimization:
if globals.weight_type == 'global':
global_weights(0)
exp_ar = []
for expert in globals.experts:
exp_ar.append(expert.W[0][3])
if np.array_equal(exp_ar, np.zeros(len(globals.experts))):
string2 = 'Not possible to calculate the DM. All weights are zero'
robustness_table.append([string1, string2, "", ""])
else:
calculate_DM_global(0)
elif globals.weight_type == 'item':
global_weights(0)
exp_ar = []
for expert in globals.experts:
exp_ar.append([
expert.w_CQ_asses[i]
for i in range(len(globals.CQ_values))
])
if np.array_equal(
exp_ar,
np.zeros((len(globals.experts),
len(globals.CQ_values)))):
string2 = 'Not possible to calculate the DM. All weights are zero'
robustness_table.append([string1, string2, "", ""])
else:
calculate_DM_item(0)
else:
print("Robustness only for item and global")
else:
DM_optimization()
robustness_table.append([
string1, globals.experts[-1].W[1][2],
globals.experts[-1].W[1][1], globals.experts[-1].W[1][0]
])
return robustness_table
def DM_optimization():
if globals.weight_type == "global":
global_weights(0)
calculate_DM_global(0)
initial_alpha = 0
alphas = [initial_alpha]
for expert in globals.experts:
alphas.append(expert.W[0][0])
alphas = np.sort(np.unique(alphas))
alpha_select = initial_alpha
W_max = globals.experts[-1].W[1][3]
for alpha in alphas:
revert.revert()
globals.alpha = alpha
global_weights(0)
calculate_DM_global(0)
if W_max <= globals.experts[-1].W[1][3]:
W_max = globals.experts[-1].W[1][3]
alpha_select = alpha
globals.alpha = alpha_select
revert.revert()
global_weights(0)
calculate_DM_global(0)
elif globals.weight_type == "item":
initial_alpha = 0
global_weights(0)
calculate_DM_item(0)
alphas = [initial_alpha]
for expert in globals.experts:
alphas.append(expert.W[0][0])
W_max = globals.experts[-1].W[1][3]
globals.alpha = initial_alpha
alpha_select = initial_alpha
for alpha in alphas:
revert.revert()
globals.alpha = alpha
global_weights(0)
calculate_DM_item(0)
if W_max <= globals.experts[-1].W[1][3]:
W_max = globals.experts[-1].W[1][3]
alpha_select = alpha
revert.revert()
globals.alpha = alpha_select
global_weights(0)
calculate_DM_item(0)
else:
print("wrong weight_type! only global or item are allowed")
return
def anduryl(assessments, realisations, quants, alpha, k, cal_power,
weight_type, optimization, robust, N_max_it, N_max_ex, output,
output_items, user_w):
globals.init(alpha, k, cal_power, weight_type, optimization, robust,
N_max_it, N_max_ex, quants)
warnings.filterwarnings("ignore")
if not os.path.exists(output_items[0]):
os.makedirs(output_items[0])
importfiles(assessments, realisations, quants)
error, errortext = check_input()
print(errortext)
unanswered.unanswered()
backup.backup()
# caluclate DMs
if not optimization:
if weight_type == 'global':
global_weights(0)
calculate_DM_global(0)
elif weight_type == 'equal':
for expert in globals.experts:
expert.W[0][4] = float(1. / len(globals.experts))
globals.alpha = 0
calculate_DM_global(0)
elif weight_type == 'item':
global_weights(0)
calculate_DM_item(0)
elif weight_type == 'user':
if len(user_w) == 0:
print(
"user weight not specified, considering all equal weights")
for i in range(len(globals.experts)):
user_w.append(1.0)
if len(user_w) != len(globals.experts):
sys.exit("user weight does not have the same length")
i = 0
for expert in globals.experts:
expert.W[0][4] = float(user_w[i]) / np.sum(user_w)
i = i + 1
globals.alpha = 0
calculate_DM_global(0)
else:
DM_optimization()
if output[1]: print_data(output_items[1])
if output[0]:
plotting_itemwise(globals.CQ_values, globals.CQ_assess,
globals.TQ_assess, globals.TQ_values,
globals.experts, globals.weight_type,
globals.optimization, output_items[0])
# goto robustness
if robust:
if weight_type == "global" or weight_type == "item":
w_index = 0
revert.revert()
incl_cal_pwr = "yes"
robust_table_item = Checking_Robustness_items(
incl_cal_pwr, cal_power)
if output[0]: plot_robust(robust_table_item, output_path)
w_index = 0
revert.revert()
randomisation = False
if randomisation:
distr = randomise()
averages = np.average(distr, axis=0)
stdevs = np.std(distr, axis=0)
print('experts: ' + str(len(globals.experts) - 1))
print('items: ' + str(len(globals.CQ_values)))
print(
'Average {:10.5e} {:10.5e} {:10.5e} {:10.5e} {:10.5e}'.format(
averages[0], averages[1], averages[2], averages[3],
averages[4]))
print(
'Stdev {:10.5e} {:10.5e} {:10.5e} {:10.5e} {:10.5e}'.format(
stdevs[0], stdevs[1], stdevs[2], stdevs[3], stdevs[4]))
def Checking_Robustness_expert(CQ_values, CQ_assess, TQ_assess, experts,
TQ_index, TQ_values, k, alpha, w_index, N_max,
weight_type, optimization, incl_cal_pwr,
cal_power):
explist = []
robustness_table = []
cal_power_l = cal_power
for expert in experts:
explist.append(expert.id)
robust_row = 0
for i in range(0, N_max):
Remove_experts = []
m = list(combinations(explist, i + 1))
for k in range(len(m)):
Remove_experts.append([m[k][l] for l in range(len(m[k]))])
if incl_cal_pwr == "yes":
cal_power_l = (len(CQ_values) - float(i)) / len(CQ_values)
for remove_expert in Remove_experts:
string1 = ('Excluded questions: ' + str(remove_expert)[1:-1])
CQ_values_temp = copy.deepcopy(CQ_values)
CQ_assess_temp = copy.deepcopy(CQ_assess)
TQ_assess_temp = copy.deepcopy(TQ_assess)
TQ_values_temp = copy.deepcopy(TQ_values)
experts_temp = copy.deepcopy(experts)
TQ_index_temp = copy.deepcopy(TQ_index)
rem_lin = []
i = 0
for expert in experts_temp:
if expert.id in remove_expert:
rem_lin.append(i)
i = i + 1
for j in reversed(rem_lin):
experts_temp.remove(experts_temp[j])
rem_lin = []
i = 0
for CQ_asses in CQ_assess_temp:
if CQ_asses.exp_id in remove_expert:
rem_lin.append(i)
i = i + 1
for j in reversed(rem_lin):
CQ_assess_temp.remove(CQ_assess_temp[j])
rem_lin = []
i = 0
for TQ_asses in TQ_assess_temp:
if TQ_asses.exp_id in remove_expert:
rem_lin.append(i)
i = i + 1
for j in reversed(rem_lin):
TQ_assess_temp.remove(TQ_assess_temp[j])
if not optimization:
if weight_type == 'global':
global_weights(CQ_values_temp)
exp_ar = []
# print(len(experts_temp))
for expert in experts_temp:
exp_ar.append(expert.W[0][3])
if np.array_equal(exp_ar, np.zeros(len(experts_temp))):
string2 = 'Not possible to calculate the DM. All weights are zero'
robustness_table.append([string1, string2, "", ""])
else:
calculate_DM_global(CQ_values_temp)
elif weight_type == 'item':
global_weights(CQ_values_temp)
exp_ar = []
# print(len(experts_temp))
for expert in experts_temp:
exp_ar.append([
expert.w_CQ_asses[i]
for i in range(len(CQ_values_temp))
])
if np.array_equal(
exp_ar,
np.zeros(
(len(experts_temp), len(CQ_values_temp)))):
string2 = 'Not possible to calculate the DM. All weights are zero'
robustness_table.append([string1, string2, "", ""])
else:
calculate_DM_item(CQ_values_temp)
else:
print("Robustness only for item and global")
else:
DM_optimization()
robustness_table.append([
string1, experts_temp[-1].W[1][1], experts_temp[-1].W[1][2],
experts_temp[-1].W[1][0]
])
return robustness_table