def test002(self):
c = generate_criteria(3)
cat = generate_categories(3)
cps = generate_categories_profiles(cat)
bp1 = AlternativePerformances('b1',
{'c1': 0.75, 'c2': 0.75, 'c3': 0.75})
bp2 = AlternativePerformances('b2',
{'c1': 0.25, 'c2': 0.25, 'c3': 0.25})
bpt = PerformanceTable([bp1, bp2])
cv1 = CriterionValue('c1', 0.2)
cv2 = CriterionValue('c2', 0.2)
cv3 = CriterionValue('c3', 0.2)
cv12 = CriterionValue(CriteriaSet(['c1', 'c2']), -0.1)
cv23 = CriterionValue(CriteriaSet(['c2', 'c3']), 0.2)
cv13 = CriterionValue(CriteriaSet(['c1', 'c3']), 0.3)
cvs = CriteriaValues([cv1, cv2, cv3, cv12, cv23, cv13])
lbda = 0.6
model = MRSort(c, cvs, bpt, lbda, cps)
a = generate_alternatives(10000)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
model2 = MRSort(c, None, bpt, None, cps)
lp = LpMRSortMobius(model2, pt, aa)
obj = lp.solve()
aa2 = model2.get_assignments(pt)
self.assertEqual(obj, 0)
self.assertEqual(aa, aa2)
def test001(self):
random.seed(1)
c = generate_criteria(4)
cv1 = CriterionValue('c1', 0.25)
cv2 = CriterionValue('c2', 0.25)
cv3 = CriterionValue('c3', 0.25)
cv4 = CriterionValue('c4', 0.25)
cv = CriteriaValues([cv1, cv2, cv3, cv4])
cat = generate_categories(2)
cps = generate_categories_profiles(cat)
bp = AlternativePerformances('b1', {'c1': 0.5, 'c2': 0.5,
'c3': 0.5, 'c4': 0.5})
bpt = PerformanceTable([bp])
lbda = 0.5
etri = MRSort(c, cv, bpt, 0.5, cps)
a = generate_alternatives(1000)
pt = generate_random_performance_table(a, c)
aas = etri.pessimist(pt)
for aa in aas:
w = 0
perfs = pt[aa.id].performances
for c, val in perfs.items():
if val >= bp.performances[c]:
w += cv[c].value
if aa.category_id == 'cat2':
self.assertLess(w, lbda)
else:
self.assertGreaterEqual(w, lbda)
def one_test2(self, seed, ncrit, ncat, na):
model = generate_random_mrsort_model(ncrit, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
model2 = model.copy()
model2.cvs = None
lp_weights = LpMRSortWeights(model2, pt, aa)
bids = model.categories_profiles.get_ordered_profiles()
bpt = generate_random_profiles(bids, model.criteria)
model.bpt = model2.bpt = bpt
aa = model.pessimist(pt)
lp_weights.aa_ori = aa
lp_weights.update_linear_program()
lp_weights.solve()
aa2 = model2.pessimist(pt)
self.assertEqual(aa, aa2)
def test003(self):
model = generate_random_mrsort_model(5, 2, seed = 3)
a = generate_alternatives(10)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
self.mcda_object_to_xmcda_file(model.criteria.to_xmcda(),
"criteria.xml")
categories = model.categories_profiles.to_categories()
self.mcda_object_to_xmcda_file(categories.to_xmcda(),
"categories.xml")
self.mcda_object_to_xmcda_file(a.to_xmcda(), "alternatives.xml")
self.mcda_object_to_xmcda_file(pt.to_xmcda(), "perfs_table.xml")
self.mcda_object_to_xmcda_file(aa.to_xmcda(), "assign.xml")
self.mcda_object_to_xmcda_file(model.bpt.to_xmcda(),
"profiles_perfs.xml")
mrsort_mip(self.indir, self.outdir)
self.check_output_is_complete()
model2 = self.get_output_model(model.criteria)
aa2 = model2.get_assignments(pt)
self.assertEqual(aa, aa2)
self.assertEqual(model.bpt, model2.bpt)
def test003(self):
model = generate_random_mrsort_model(5, 2, seed=3)
a = generate_alternatives(10)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
self.mcda_object_to_xmcda_file(model.criteria.to_xmcda(),
"criteria.xml")
categories = model.categories_profiles.to_categories()
self.mcda_object_to_xmcda_file(categories.to_xmcda(), "categories.xml")
self.mcda_object_to_xmcda_file(a.to_xmcda(), "alternatives.xml")
self.mcda_object_to_xmcda_file(pt.to_xmcda(), "perfs_table.xml")
self.mcda_object_to_xmcda_file(aa.to_xmcda(), "assign.xml")
self.mcda_object_to_xmcda_file(model.bpt.to_xmcda(),
"profiles_perfs.xml")
mrsort_mip(self.indir, self.outdir)
self.check_output_is_complete()
model2 = self.get_output_model(model.criteria)
aa2 = model2.get_assignments(pt)
self.assertEqual(aa, aa2)
self.assertEqual(model.bpt, model2.bpt)
def one_test2(self, seed, ncrit, ncat, na):
model = generate_random_mrsort_model(ncrit, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
model2 = model.copy()
model2.cvs = None
lp_weights = LpMRSortWeights(model2, pt, aa)
bids = model.categories_profiles.get_ordered_profiles()
bpt = generate_random_profiles(bids, model.criteria)
model.bpt = model2.bpt = bpt
aa = model.pessimist(pt)
lp_weights.aa_ori = aa
lp_weights.update_linear_program()
lp_weights.solve()
aa2 = model2.pessimist(pt)
self.assertEqual(aa, aa2)
def generate_assignments(self):
ncrit = len(self.model.criteria)
ncat = len(self.model.categories)
nalt = self.spinbox_nalt.value()
self.a = generate_alternatives(nalt)
self.pt = generate_random_performance_table(self.a,
self.model.criteria)
self.aa = self.model.get_assignments(self.pt)
def test_heur_mrsort_init_profiles(seed, na, nc, ncat, pcerrors):
# Generate an ELECTRE TRI model and assignment examples
model = generate_random_mrsort_model(nc, ncat, seed)
model2 = model.copy()
model3 = model.copy()
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
# Compute assignments
aa = model.pessimist(pt)
# Initialize the second model with random generated profiles
b = model.categories_profiles.get_ordered_profiles()
model2.bpt = generate_random_profiles(b, model2.criteria)
# Run the heuristic
cats = model.categories_profiles.to_categories()
pt_sorted = SortedPerformanceTable(pt)
heur = HeurMRSortInitProfiles(model3, pt_sorted, aa)
heur.solve()
# Learn the weights and cut threshold
cps = model.categories_profiles
lp_weights = LpMRSortWeights(model2, pt, aa)
lp_weights.solve()
lp_weights = LpMRSortWeights(model3, pt, aa)
lp_weights.solve()
# Compute the classification accuracy
aa2 = model2.pessimist(pt)
aa3 = model3.pessimist(pt)
ca2 = compute_ca(aa, aa2)
ca3 = compute_ca(aa, aa3)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%g" % (seed, na, nc, ncat, pcerrors))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['pcerrors'] = pcerrors
# Output params
t['ca_rdom'] = ca2
t['ca_heur'] = ca3
return t
def generate_alt(self):
ncrit = len(self.model.criteria)
ncat = len(self.model.categories)
nalt = self.spinbox_nalt.value()
self.a = generate_alternatives(nalt)
self.pt = generate_random_performance_table(self.a,
self.model.criteria,
worst = self.worst,
best = self.best)
self.aa = self.model.pessimist(self.pt)
def test_heur_mrsort_init_profiles(seed, na, nc, ncat, pcerrors):
# Generate an ELECTRE TRI model and assignment examples
model = generate_random_mrsort_model(nc, ncat, seed)
model2 = model.copy()
model3 = model.copy()
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
# Compute assignments
aa = model.pessimist(pt)
# Initialize the second model with random generated profiles
b = model.categories_profiles.get_ordered_profiles()
model2.bpt = generate_random_profiles(b, model2.criteria)
# Run the heuristic
cats = model.categories_profiles.to_categories()
pt_sorted = SortedPerformanceTable(pt)
heur = HeurMRSortInitProfiles(model3, pt_sorted, aa)
heur.solve()
# Learn the weights and cut threshold
cps = model.categories_profiles
lp_weights = LpMRSortWeights(model2, pt, aa)
lp_weights.solve()
lp_weights = LpMRSortWeights(model3, pt, aa)
lp_weights.solve()
# Compute the classification accuracy
aa2 = model2.pessimist(pt)
aa3 = model3.pessimist(pt)
ca2 = compute_ca(aa, aa2)
ca3 = compute_ca(aa, aa3)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%g" % (seed, na, nc, ncat, pcerrors))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['pcerrors'] = pcerrors
# Output params
t['ca_rdom'] = ca2
t['ca_heur'] = ca3
return t
def generate_alt(self):
ncrit = len(self.model.criteria)
ncat = len(self.model.categories)
nalt = self.spinbox_nalt.value()
self.a = generate_alternatives(nalt)
self.pt = generate_random_performance_table(self.a,
self.model.criteria,
worst=self.worst,
best=self.best)
self.aa = self.model.pessimist(self.pt)
def test003_auc_no_errors(self):
random.seed(3)
crits = generate_criteria(5)
model = generate_random_mrsort_model(len(crits), 3)
alts = generate_alternatives(1000)
pt = generate_random_performance_table(alts, crits)
aa = model.get_assignments(pt)
auc = model.auc(aa, pt)
self.assertEqual(auc, 1)
def test003_auc_no_errors(self):
random.seed(3)
crits = generate_criteria(5)
model = generate_random_mrsort_model(len(crits), 3)
alts = generate_alternatives(1000)
pt = generate_random_performance_table(alts, crits)
aa = model.get_assignments(pt)
auc = model.auc(aa, pt)
self.assertEqual(auc, 1)
def test002_auck_all_errors(self):
random.seed(2)
crits = generate_criteria(5)
model = generate_random_mrsort_model(len(crits), 2)
alts = generate_alternatives(1000)
pt = generate_random_performance_table(alts, crits)
aa = model.get_assignments(pt)
aa_err = add_errors_in_assignments(aa, model.categories, 1)
auck = model.auck(aa_err, pt, 1)
self.assertEqual(auck, 0)
def test002_auck_all_errors(self):
random.seed(2)
crits = generate_criteria(5)
model = generate_random_mrsort_model(len(crits), 2)
alts = generate_alternatives(1000)
pt = generate_random_performance_table(alts, crits)
aa = model.get_assignments(pt)
aa_err = add_errors_in_assignments(aa, model.categories, 1)
auck = model.auck(aa_err, pt, 1)
self.assertEqual(auck, 0)
def test002(self):
random.seed(2)
c = generate_criteria(4)
cv1 = CriterionValue('c1', 0.25)
cv2 = CriterionValue('c2', 0.25)
cv3 = CriterionValue('c3', 0.25)
cv4 = CriterionValue('c4', 0.25)
cv = CriteriaValues([cv1, cv2, cv3, cv4])
cat = generate_categories(3)
cps = generate_categories_profiles(cat)
bp1 = AlternativePerformances('b1', {
'c1': 0.75,
'c2': 0.75,
'c3': 0.75,
'c4': 0.75
})
bp2 = AlternativePerformances('b2', {
'c1': 0.25,
'c2': 0.25,
'c3': 0.25,
'c4': 0.25
})
bpt = PerformanceTable([bp1, bp2])
lbda = 0.5
etri = MRSort(c, cv, bpt, 0.5, cps)
a = generate_alternatives(1000)
pt = generate_random_performance_table(a, c)
aas = etri.pessimist(pt)
for aa in aas:
w1 = w2 = 0
perfs = pt[aa.id].performances
for c, val in perfs.items():
if val >= bp1.performances[c]:
w1 += cv[c].value
if val >= bp2.performances[c]:
w2 += cv[c].value
if aa.category_id == 'cat3':
self.assertLess(w1, lbda)
self.assertLess(w2, lbda)
elif aa.category_id == 'cat2':
self.assertLess(w1, lbda)
self.assertGreaterEqual(w2, lbda)
else:
self.assertGreaterEqual(w1, lbda)
self.assertGreaterEqual(w2, lbda)
def test003(self):
random.seed(0)
crits = generate_criteria(5)
model = generate_random_mrsort_model(len(crits), 2)
alts = generate_alternatives(1000)
pt = generate_random_performance_table(alts, crits)
aa = model.get_assignments(pt)
aa = model.get_assignments(pt)
self.assertEqual(len(aa.get_alternatives_in_categories(['cat1'])), 65)
self.assertEqual(len(aa.get_alternatives_in_categories(['cat2'])), 935)
def test003(self):
random.seed(0)
crits = generate_criteria(5)
model = generate_random_mrsort_model(len(crits), 2)
alts = generate_alternatives(1000)
pt = generate_random_performance_table(alts, crits)
aa = model.get_assignments(pt)
aa = model.get_assignments(pt)
self.assertEqual(len(aa.get_alternatives_in_categories(['cat1'])), 65)
self.assertEqual(len(aa.get_alternatives_in_categories(['cat2'])), 935)
def one_test(self, seed, ncrit, ncat, na):
model = generate_random_mrsort_model(ncrit, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
model2 = model.copy()
model2.cvs = None
lp_weights = LpMRSortWeights(model2, pt, aa)
lp_weights.solve()
aa2 = model2.pessimist(pt)
self.assertEqual(aa, aa2)
def one_test(self, seed, ncrit, ncat, na):
model = generate_random_mrsort_model(ncrit, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
model2 = model.copy()
model2.cvs = None
lp_weights = LpMRSortWeights(model2, pt, aa)
lp_weights.solve()
aa2 = model2.pessimist(pt)
self.assertEqual(aa, aa2)
def one_test(self, seed, na, nc, ncat, ca_expected):
model = generate_random_mrsort_model(nc, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
pt_sorted = SortedPerformanceTable(pt)
heur = HeurMRSortInitProfiles(model, pt_sorted, aa)
heur.solve()
aa2 = model.pessimist(pt)
ca = compute_ca(aa, aa2)
self.assertEqual(ca, ca_expected)
def one_test(self, seed, na, nc, ncat, ca_expected):
model = generate_random_mrsort_model(nc, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
pt_sorted = SortedPerformanceTable(pt)
heur = HeurMRSortInitProfiles(model, pt_sorted, aa)
heur.solve()
aa2 = model.pessimist(pt)
ca = compute_ca(aa, aa2)
self.assertEqual(ca, ca_expected)
def count_veto(seed, na, nc, ncat, veto_param):
# Generate a random ELECTRE TRI BM model
if veto_type == COALITIONS_VETO:
model = generate_random_mrsort_model_with_coalition_veto(
nc,
ncat,
seed,
veto_weights=True,
veto_func=veto_function,
veto_param=veto_param)
elif veto_type == BINARY_VETO:
model = generate_random_mrsort_model_with_binary_veto(
nc, ncat, seed, veto_func=veto_function, veto_param=veto_param)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
return sum([model.count_veto_pessimist(ap) for ap in pt])
def count_veto(seed, na, nc, ncat, veto_param):
# Generate a random ELECTRE TRI BM model
if veto_type == COALITIONS_VETO:
model = generate_random_mrsort_model_with_coalition_veto(nc, ncat,
seed,
veto_weights = True,
veto_func = veto_function,
veto_param = veto_param)
elif veto_type == BINARY_VETO:
model = generate_random_mrsort_model_with_binary_veto(nc, ncat,
seed,
veto_func = veto_function,
veto_param = veto_param)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
return sum([model.count_veto_pessimist(ap) for ap in pt])
def test002(self):
c = generate_criteria(3)
cat = generate_categories(3)
cps = generate_categories_profiles(cat)
bp1 = AlternativePerformances('b1', {
'c1': 0.75,
'c2': 0.75,
'c3': 0.75
})
bp2 = AlternativePerformances('b2', {
'c1': 0.25,
'c2': 0.25,
'c3': 0.25
})
bpt = PerformanceTable([bp1, bp2])
cv1 = CriterionValue('c1', 0.2)
cv2 = CriterionValue('c2', 0.2)
cv3 = CriterionValue('c3', 0.2)
cv12 = CriterionValue(CriteriaSet(['c1', 'c2']), -0.1)
cv23 = CriterionValue(CriteriaSet(['c2', 'c3']), 0.2)
cv13 = CriterionValue(CriteriaSet(['c1', 'c3']), 0.3)
cvs = CriteriaValues([cv1, cv2, cv3, cv12, cv23, cv13])
lbda = 0.6
model = MRSort(c, cvs, bpt, lbda, cps)
a = generate_alternatives(10000)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
model2 = MRSort(c, None, bpt, None, cps)
lp = LpMRSortMobius(model2, pt, aa)
obj = lp.solve()
aa2 = model2.get_assignments(pt)
self.assertEqual(obj, 0)
self.assertEqual(aa, aa2)
def test_heur_mrsort_coalitions(seed, na, nc, ncat, pcexamples, pcerrors):
# Generate an ELECTRE TRI model and assignment examples
model = generate_random_mrsort_model(nc, ncat, seed)
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
# Compute assignments
aa = model.pessimist(pt)
# Run the heuristic
heur = HeurMRSortCoalitions(model.criteria, model.categories, pt, aa)
coal2 = heur.find_coalitions(int(na * pcexamples))
# Compute the original winning coalitions
winning, loosing = compute_winning_and_loosing_coalitions(
model.cv, model.lbda)
# Compare orignal and computed coalitions
coal_ni = list((set(winning) ^ set(coal2)) & set(winning))
coal_add = list((set(winning) ^ set(coal2)) & set(coal2))
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%g-%g" %
(seed, na, nc, ncat, pcexamples, pcerrors))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['pcexamples'] = pcexamples
t['pcerrors'] = pcerrors
# Output params
t['ncoal'] = len(winning)
t['ncoal_ni'] = len(coal_ni)
t['ncoal_add'] = len(coal_add)
return t
def one_test(self, seed, na, nc, ncat, ns):
u = generate_random_avfsort_model(nc, ncat, ns, ns, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, u.criteria)
aa = u.get_assignments(pt)
css = CriteriaValues([])
for cf in u.cfs:
cs = CriterionValue(cf.id, len(cf.function))
css.append(cs)
cat = u.cat_values.to_categories()
lp = LpAVFSort(u.criteria, css, cat, pt.get_worst(u.criteria),
pt.get_best(u.criteria))
obj, cvs, cfs, catv = lp.solve(aa, pt)
u2 = AVFSort(u.criteria, cvs, cfs, catv)
aa2 = u2.get_assignments(pt)
self.assertEqual(aa, aa2)
def one_test(self, seed, na, nc, ncat, ns):
u = generate_random_avfsort_model(nc, ncat, ns, ns, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, u.criteria)
aa = u.get_assignments(pt)
css = CriteriaValues([])
for cf in u.cfs:
cs = CriterionValue(cf.id, len(cf.function))
css.append(cs)
cat = u.cat_values.to_categories()
lp = LpAVFSort(u.criteria, css, cat, pt.get_worst(u.criteria),
pt.get_best(u.criteria))
obj, cvs, cfs, catv = lp.solve(aa, pt)
u2 = AVFSort(u.criteria, cvs, cfs, catv)
aa2 = u2.get_assignments(pt)
self.assertEqual(aa, aa2)
def one_test(self, seed, na, nc, ncat, pcerrors):
model = generate_random_mrsort_model(nc, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
aa_err = aa.copy()
add_errors_in_assignments(aa_err, model.categories, pcerrors / 100)
model2 = model.copy()
model2.bpt = None
model2.cv = None
model2.lbda = None
mip = MipMRSort(model2, pt, aa_err)
obj = mip.solve()
aa2 = model2.pessimist(pt)
ca = compute_ca(aa, aa2)
ca2 = compute_ca(aa_err, aa2)
self.assertEqual(ca2, obj / len(a))
self.assertLessEqual(pcerrors / 100, ca2)
def one_test(self, seed, na, nc, ncat, max_loop, n):
model = generate_random_mrsort_model(nc, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
model2 = model.copy()
bids = model2.categories_profiles.get_ordered_profiles()
model2.bpt = generate_random_profiles(bids, model.criteria)
pt_sorted = SortedPerformanceTable(pt)
meta = MetaMRSortProfiles4(model2, pt_sorted, aa)
for i in range(1, max_loop + 1):
ca = meta.optimize()
if ca == 1:
break
aa2 = model2.pessimist(pt)
self.assertEqual(i, n)
self.assertEqual(aa, aa2)
def one_test(self, seed, na, nc, ncat, pcerrors):
model = generate_random_mrsort_model(nc, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
aa_err = aa.copy()
add_errors_in_assignments(aa_err, model.categories, pcerrors / 100)
model2 = model.copy()
model2.bpt = None
model2.cv = None
model2.lbda = None
mip = MipMRSort(model2, pt, aa_err)
obj = mip.solve()
aa2 = model2.pessimist(pt)
ca = compute_ca(aa, aa2)
ca2 = compute_ca(aa_err, aa2)
self.assertEqual(ca2, obj / len(a))
self.assertLessEqual(pcerrors / 100, ca2)
def one_test(self, seed, na, nc, ncat, max_loop, n):
model = generate_random_mrsort_model(nc, ncat, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
model2 = model.copy()
bids = model2.categories_profiles.get_ordered_profiles()
model2.bpt = generate_random_profiles(bids, model.criteria)
pt_sorted = SortedPerformanceTable(pt)
meta = MetaMRSortProfiles4(model2, pt_sorted, aa)
for i in range(1, max_loop + 1):
ca = meta.optimize()
if ca == 1:
break
aa2 = model2.pessimist(pt)
self.assertEqual(i, n)
self.assertEqual(aa, aa2)
def test_meta_electre_tri_profiles(seed, na, nc, ncat, na_gen, pcerrors,
max_loops):
# Generate an ELECTRE TRI model and assignment examples
model = generate_random_mrsort_model(nc, ncat, seed)
model2 = model.copy()
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Initiate model with random profiles
model2.bpt = generate_random_profiles(model.profiles, model.criteria)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, model.categories,
pcerrors / 100)
# Sort the performance table
pt_sorted = SortedPerformanceTable(pt)
t1 = time.time()
# Run the algorithm
meta = algo(model2, pt_sorted, aa_err)
ca2_iter = [1] * (max_loops + 1)
aa2 = model2.pessimist(pt)
ca2 = compute_ca(aa_err, aa2)
ca2_best = ca2
best_bpt = model2.bpt.copy()
ca2_iter[0] = ca2
nloops = 0
for k in range(max_loops):
if ca2_best == 1:
break
meta.optimize()
nloops += 1
aa2 = meta.aa
ca2 = compute_ca(aa_err, aa2)
ca2_iter[k + 1] = ca2
if ca2 > ca2_best:
ca2_best = ca2
best_bpt = model2.bpt.copy()
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
model2.bpt = best_bpt
aa2 = model2.pessimist(pt)
ok = ok_errors = ok2_errors = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
total = len(a)
ca_best = ok / total
ca_best_errors = ok_errors / total
ca2_best_errors = ok2_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g-%d" % (seed, na, nc, ncat, na_gen,
pcerrors, max_loops))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
t['max_loops'] = max_loops
# Ouput params
t['ca_best'] = ca_best
t['ca_best_errors'] = ca_best_errors
t['ca2_best'] = ca2_best
t['ca2_best_errors'] = ca2_best_errors
t['ca_gen'] = ca_gen
t['nloops'] = nloops
t['t_total'] = t_total
t['ca2_iter'] = ca2_iter
return t
from pymcda.generate import generate_categories
from pymcda.generate import generate_categories_profiles
from pymcda.generate import generate_alternatives
from pymcda.generate import generate_random_performance_table
from pymcda.generate import generate_random_profiles
from pymcda.generate import generate_random_plinear_preference_function
random.seed(123)
criteria = generate_criteria(5)
crit_weights = generate_random_criteria_weights(criteria)
categories = generate_categories(5)
cat_profiles = generate_categories_profiles(categories)
a = generate_alternatives(100)
pt = generate_random_performance_table(a, criteria)
ap_best = pt.get_best(criteria)
ap_worst = pt.get_worst(criteria)
b = cat_profiles.get_ordered_profiles()
bpt = generate_random_profiles(b, criteria)
pf = generate_random_plinear_preference_function(criteria, ap_worst,
ap_best)
print(crit_weights)
print(categories)
print(cat_profiles)
print(bpt)
print(pf)
model = flowsort(criteria, crit_weights, cat_profiles, bpt, pf)
print(model.get_assignments(pt))
def test_meta_electre_tri_global(seed, na, nc, ncat, na_gen, pcerrors,
max_oloops, nmodels, max_loops):
# Generate a random ELECTRE TRI BM model
if random_model_type == 'mrsort':
model = generate_random_mrsort_model(nc, ncat, seed)
elif random_model_type == 'ncs':
model = generate_random_mrsort_choquet_model(nc, ncat, 2, seed)
elif random_model_type == 'mrsortcv':
model = generate_random_mrsort_model_with_coalition_veto2(
nc, ncat, seed)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
categories = model.categories_profiles.to_categories()
aa_erroned = add_errors_in_assignments_proba(aa_err, model.categories,
pcerrors / 100)
na_err = len(aa_erroned)
# Sort the performance table
pt_sorted = SortedPerformanceTable(pt)
meta = algo(nmodels, model.criteria, categories, pt_sorted, aa)
metas_sorted = meta.sort_models()
ca2_iter = [metas_sorted[0].ca] + [1] * (max_loops)
t1 = time.time()
for i in range(0, max_loops):
model2, ca2_best = meta.optimize(max_oloops)
ca2_iter[i + 1] = ca2_best
if ca2_best == 1:
break
nloops = i + 1
t_total = time.time() - t1
aa2 = model2.pessimist(pt)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err,
model.categories,
pcerrors / 100)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result(
"%s-%d-%d-%d-%d-%g-%d-%d-%d" %
(seed, na, nc, ncat, na_gen, pcerrors, max_loops, nmodels, max_oloops))
model.id = 'initial'
model2.id = 'learned'
pt.id, pt_gen.id = 'learning_set', 'test_set'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, model2, pt,
pt_gen)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
t['max_loops'] = max_loops
t['nmodels'] = nmodels
t['max_oloops'] = max_oloops
# Ouput params
t['na_err'] = na_err
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca2_best'] = ca2_best
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['nloops'] = nloops
t['t_total'] = t_total
t['ca2_iter'] = ca2_iter
return t
from pymcda.generate import generate_categories
from pymcda.generate import generate_categories_profiles
from pymcda.utils import add_errors_in_assignments
from pymcda.utils import print_pt_and_assignments
from pymcda.utils import compute_winning_and_loosing_coalitions
from pymcda.types import AlternativesAssignments, PerformanceTable
from pymcda.types import AlternativePerformances
from pymcda.types import CriteriaValues, CriterionValue
from pymcda.electre_tri import MRSort
# MR-Sort model
model = generate_random_mrsort_model_with_coalition_veto(5, 3, 4)
# Generate random alternatives
a = generate_alternatives(15000)
pt = generate_random_performance_table(a, model.criteria)
errors = 0.0
delta = 0.0001
nlearn = 1.00
# Assign the alternative with the model
aa = model.pessimist(pt)
a_learn = random.sample(a, int(nlearn*len(a)))
aa_learn = AlternativesAssignments([ aa[alt.id] for alt in a_learn ])
pt_learn = PerformanceTable([ pt[alt.id] for alt in a_learn ])
aa_err = aa_learn.copy()
aa_erroned = add_errors_in_assignments(aa_err, model.categories, errors)
def get_best_ap(self):
a = AlternativePerformances('best', {})
for cid in self.cids:
a.performances[cid] = self.sorted_values[cid][-1]
return a
if __name__ == "__main__":
from pymcda.generate import generate_alternatives
from pymcda.generate import generate_criteria
from pymcda.generate import generate_random_performance_table
import time
a = generate_alternatives(500)
c = generate_criteria(5)
pt = generate_random_performance_table(a, c, 1234)
sorted_pt = SortedPerformanceTable(pt)
t1 = time.time()
# print len(sorted_pt.get_below('c1', 0.1)[0])
# print len(sorted_pt.get_above('c1', 0.1)[0])
# print len(sorted_pt.get_middle('c1', 0, 1)[0])
# print sorted_pt.get_below_len('c1', 0.1)
# print sorted_pt.get_above_len('c1', 0.1)
# print sorted_pt.get_middle_len('c1', 0, 1)
# print sorted_pt.get_middle_len('c1', 1, 0)
# print len(sorted_pt.get_all('c1'))
# print sorted_pt.get_worst_ap()
# print sorted_pt.get_best_ap()
# print time.time() - t1
def test_meta_electre_tri_global(seed, na, nc, ncat, na_gen, pcerrors):
# Generate a random ELECTRE TRI BM model
if random_model_type == 'default':
model = generate_random_mrsort_model(nc, ncat, seed)
elif random_model_type == 'choquet':
model = generate_random_mrsort_choquet_model(nc, ncat, 2, seed)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments_proba(aa_err, model.categories,
pcerrors / 100)
na_err = len(aa_erroned)
# Run the MIP
t1 = time.time()
model2 = MRSort(model.criteria, None, None, None,
model.categories_profiles, None, None, None)
mip = MipMRSort(model2, pt, aa_err)
obj = mip.solve()
ca2_best = obj / na
aa2 = model2.get_assignments(pt)
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
aa2 = model2.pessimist(pt)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err,
model.categories,
pcerrors / 100)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g" %
(seed, na, nc, ncat, na_gen, pcerrors))
model.id = 'initial'
model2.id = 'learned'
pt.id, pt_gen.id = 'learning_set', 'test_set'
aa.id = 'aa'
aa_err.id = 'aa_err'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, model2, pt,
pt_gen, aa, aa_err)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Ouput params
t['na_err'] = na_err
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca2_best'] = ca2_best
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['t_total'] = t_total
return t
def test_lp_avfsort(seed, na, nc, ncat, ns, na_gen, pcerrors):
# Generate a random UTADIS model and assignment examples
model = generate_random_avfsort_model(nc, ncat, ns, ns)
model.set_equal_weights()
cat = model.cat_values.to_categories()
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments_proba(aa_err, cat.keys(),
pcerrors / 100)
na_err = len(aa_erroned)
gi_worst = AlternativePerformances('worst',
{crit.id: 0
for crit in model.criteria})
gi_best = AlternativePerformances('best',
{crit.id: 1
for crit in model.criteria})
css = CriteriaValues([])
for cf in model.cfs:
cs = CriterionValue(cf.id, len(cf.function))
css.append(cs)
# Run linear program
t1 = time.time()
lp = LpAVFSort(model.criteria, css, cat, gi_worst, gi_best)
t2 = time.time()
obj, cv_l, cfs_l, catv_l = lp.solve(aa_err, pt)
t3 = time.time()
model2 = AVFSort(model.criteria, cv_l, cfs_l, catv_l)
# Compute new assignment and classification accuracy
aa2 = model2.get_assignments(pt)
ok = ok_errors = ok2 = ok2_errors = altered = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id):
ok2 += 1
if alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
ok += 1
if alt.id in aa_erroned:
ok_errors += 1
elif alt.id not in aa_erroned:
altered += 1
total = len(a)
ca2 = ok2 / total
ca2_errors = ok2_errors / total
ca = ok / total
ca_errors = ok_errors / total
# Perform the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.get_assignments(pt_gen)
aa_gen2 = model2.get_assignments(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err,
cat.keys(),
pcerrors / 100)
aa_gen2 = model2.get_assignments(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%d-%g" % (seed, na, nc, ncat, ns,
na_gen, pcerrors))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['ns'] = ns
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Output params
t['na_err'] = na_err
t['obj'] = obj
t['ca'] = ca
t['ca_errors'] = ca_errors
t['altered'] = altered
t['ca2'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['t_total'] = t3 - t1
t['t_const'] = t2 - t1
t['t_solve'] = t3 - t2
return t
def test_lp_avfsort(seed, na, nc, ncat, ns, na_gen, pcerrors):
# Generate a random ELECTRE TRI model and assignment examples
model = generate_random_mrsort_model(nc, ncat, seed)
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, model.categories,
pcerrors / 100)
gi_worst = AlternativePerformances('worst',
{c.id: 0
for c in model.criteria})
gi_best = AlternativePerformances('best',
{c.id: 1
for c in model.criteria})
css = CriteriaValues([])
for c in model.criteria:
cs = CriterionValue(c.id, ns)
css.append(cs)
# Run linear program
t1 = time.time()
lp = LpAVFSort(model.criteria, css,
model.categories_profiles.to_categories(), gi_worst,
gi_best)
t2 = time.time()
obj, cv_l, cfs_l, catv_l = lp.solve(aa_err, pt)
t3 = time.time()
model2 = AVFSort(model.criteria, cv_l, cfs_l, catv_l)
# Compute new assignment and classification accuracy
aa2 = model2.get_assignments(pt)
ok = ok_errors = ok2 = ok2_errors = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id):
ok2 += 1
if alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
ok += 1
if alt.id in aa_erroned:
ok_errors += 1
total = len(a)
ca2 = ok2 / total
ca2_errors = ok2_errors / total
ca = ok / total
ca_errors = ok_errors / total
# Perform the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa = model.pessimist(pt_gen)
aa2 = model2.get_assignments(pt_gen)
ca_gen = compute_ca(aa, aa2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%d-%g" %
(seed, na, nc, ncat, ns, na_gen, pcerrors))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['ns'] = ns
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Output params
t['obj'] = obj
t['ca'] = ca
t['ca_errors'] = ca_errors
t['ca2'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['t_total'] = t3 - t1
t['t_const'] = t2 - t1
t['t_solve'] = t3 - t2
return t
from pymcda.utils import print_pt_and_assignments
# Generate an avfsort model
c = generate_criteria(7, random_direction = True)
cv = generate_random_criteria_values(c, seed = 1)
cv.normalize_sum_to_unity()
cat = generate_categories(3)
cfs = generate_random_criteria_functions(c, nseg_min = 3, nseg_max = 3)
catv = generate_random_categories_values(cat)
u = AVFSort(c, cv, cfs, catv)
# Generate random alternative and compute assignments
a = generate_alternatives(1000)
pt = generate_random_performance_table(a, c)
aa = u.get_assignments(pt)
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, cat.keys(), 0.0)
print('==============')
print('Original model')
print('==============')
print("Number of alternatives: %d" % len(a))
print('Criteria weights:')
cv.display()
print('Criteria functions:')
cfs.display()
print('Categories values:')
catv.display()
print("Errors in alternatives assignments: %g %%" \
def test_meta_electre_tri_global(seed, na, nc, ncat, ns, na_gen, pcerrors,
max_oloops, nmodels, max_loops):
# Generate a random UTADIS model
model = generate_random_avfsort_model(nc, ncat, ns, ns, seed)
cats = model.cat_values.get_ordered_categories()
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, cats, pcerrors / 100)
# Sort the performance table
pt_sorted = SortedPerformanceTable(pt)
t1 = time.time()
# Perform at max oloops on the set of metas
meta = MetaMRSortPop3(nmodels, model.criteria,
model.cat_values.to_categories(), pt_sorted, aa_err)
ca2_iter = [meta.metas[0].ca] + [1] * (max_loops)
nloops = 0
for i in range(0, max_loops):
model2, ca2 = meta.optimize(max_oloops)
ca2_iter[i + 1] = ca2
nloops += 1
if ca2 == 1:
break
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
aa2 = model2.pessimist(pt)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.get_assignments(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
# Save all infos in test_result class
t = test_result(
"%s-%d-%d-%d-%d-%g-%d-%d-%d" %
(seed, na, nc, ncat, na_gen, pcerrors, max_loops, nmodels, max_oloops))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['ns'] = ns
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
t['max_loops'] = max_loops
t['nmodels'] = nmodels
t['max_oloops'] = max_oloops
# Ouput params
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca2_best'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['nloops'] = nloops
t['t_total'] = t_total
t['ca2_iter'] = ca2_iter
return t
def test_lp_avfsort(seed, na, nc, ncat, ns, na_gen, pcerrors):
# Generate a random ELECTRE TRI model and assignment examples
model = generate_random_mrsort_model(nc, ncat, seed)
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, model.categories,
pcerrors / 100)
gi_worst = AlternativePerformances('worst', {c.id: 0
for c in model.criteria})
gi_best = AlternativePerformances('best', {c.id: 1
for c in model.criteria})
css = CriteriaValues([])
for c in model.criteria:
cs = CriterionValue(c.id, ns)
css.append(cs)
# Run linear program
t1 = time.time()
lp = LpAVFSort(model.criteria, css,
model.categories_profiles.to_categories(),
gi_worst, gi_best)
t2 = time.time()
obj, cv_l, cfs_l, catv_l = lp.solve(aa_err, pt)
t3 = time.time()
model2 = AVFSort(model.criteria, cv_l, cfs_l, catv_l)
# Compute new assignment and classification accuracy
aa2 = model2.get_assignments(pt)
ok = ok_errors = ok2 = ok2_errors = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id):
ok2 += 1
if alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
ok += 1
if alt.id in aa_erroned:
ok_errors += 1
total = len(a)
ca2 = ok2 / total
ca2_errors = ok2_errors / total
ca = ok / total
ca_errors = ok_errors / total
# Perform the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa = model.pessimist(pt_gen)
aa2 = model2.get_assignments(pt_gen)
ca_gen = compute_ca(aa, aa2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%d-%g" % (seed, na, nc, ncat, ns,
na_gen, pcerrors))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['ns'] = ns
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Output params
t['obj'] = obj
t['ca'] = ca
t['ca_errors'] = ca_errors
t['ca2'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['t_total'] = t3 - t1
t['t_const'] = t2 - t1
t['t_solve'] = t3 - t2
return t
def test_meta_electre_tri_global(seed, na, nc, ncat, na_gen, pcerrors,
max_oloops, nmodels, max_loops):
# Generate a random ELECTRE TRI BM model
if random_model_type == 'mrsort':
model = generate_random_mrsort_model(nc, ncat, seed)
elif random_model_type == 'ncs':
model = generate_random_mrsort_choquet_model(nc, ncat, 2, seed)
elif random_model_type == 'mrsortcv':
model = generate_random_mrsort_model_with_coalition_veto2(nc, ncat,
seed)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
categories = model.categories_profiles.to_categories()
aa_erroned = add_errors_in_assignments_proba(aa_err,
model.categories,
pcerrors / 100)
na_err = len(aa_erroned)
# Sort the performance table
pt_sorted = SortedPerformanceTable(pt)
meta = algo(nmodels, model.criteria, categories, pt_sorted, aa)
metas_sorted = meta.sort_models()
ca2_iter = [metas_sorted[0].ca] + [1] * (max_loops)
t1 = time.time()
for i in range(0, max_loops):
model2, ca2_best = meta.optimize(max_oloops)
ca2_iter[i + 1] = ca2_best
if ca2_best == 1:
break
nloops = i + 1
t_total = time.time() - t1
aa2 = model2.pessimist(pt)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err,
model.categories,
pcerrors / 100)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g-%d-%d-%d" % (seed, na, nc, ncat,
na_gen, pcerrors, max_loops, nmodels, max_oloops))
model.id = 'initial'
model2.id = 'learned'
pt.id, pt_gen.id = 'learning_set', 'test_set'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name),
model, model2, pt, pt_gen)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
t['max_loops'] = max_loops
t['nmodels'] = nmodels
t['max_oloops'] = max_oloops
# Ouput params
t['na_err'] = na_err
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca2_best'] = ca2_best
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['nloops'] = nloops
t['t_total'] = t_total
t['ca2_iter'] = ca2_iter
return t
def test_meta_electre_tri_global(seed, na, nc, ncat, ns, na_gen, pcerrors,
max_oloops, nmodels, max_loops):
# Generate a random UTADIS model
model = generate_random_avfsort_model(nc, ncat, ns, ns, seed)
cats = model.cat_values.get_ordered_categories()
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, cats,
pcerrors / 100)
# Sort the performance table
pt_sorted = SortedPerformanceTable(pt)
t1 = time.time()
# Perform at max oloops on the set of metas
meta = MetaMRSortPop3(nmodels, model.criteria,
model.cat_values.to_categories(),
pt_sorted, aa_err)
ca2_iter = [meta.metas[0].ca] + [1] * (max_loops)
nloops = 0
for i in range(0, max_loops):
model2, ca2 = meta.optimize(max_oloops)
ca2_iter[i + 1] = ca2
nloops += 1
if ca2 == 1:
break
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
aa2 = model2.pessimist(pt)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.get_assignments(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g-%d-%d-%d" % (seed, na, nc, ncat,
na_gen, pcerrors, max_loops, nmodels, max_oloops))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['ns'] = ns
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
t['max_loops'] = max_loops
t['nmodels'] = nmodels
t['max_oloops'] = max_oloops
# Ouput params
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca2_best'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['nloops'] = nloops
t['t_total'] = t_total
t['ca2_iter'] = ca2_iter
return t
def test_meta_electre_tri_global(seed, na, nc, ncat, na_gen, pcerrors):
# Generate a random ELECTRE TRI BM model
if random_model_type == 'default':
model = generate_random_mrsort_model(nc, ncat, seed)
elif random_model_type == 'choquet':
model = generate_random_mrsort_choquet_model(nc, ncat, 2, seed)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments_proba(aa_err,
model.categories,
pcerrors / 100)
na_err = len(aa_erroned)
# Run the MIP
t1 = time.time()
model2 = MRSort(model.criteria, None, None, None,
model.categories_profiles, None, None, None)
mip = MipMRSort(model2, pt, aa_err)
obj = mip.solve()
ca2_best = obj / na
aa2 = model2.get_assignments(pt)
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
aa2 = model2.pessimist(pt)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err,
model.categories,
pcerrors / 100)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g" % (seed, na, nc, ncat,
na_gen, pcerrors))
model.id = 'initial'
model2.id = 'learned'
pt.id, pt_gen.id = 'learning_set', 'test_set'
aa.id = 'aa'
aa_err.id = 'aa_err'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name),
model, model2, pt, pt_gen, aa, aa_err)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Ouput params
t['na_err'] = na_err
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca2_best'] = ca2_best
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['t_total'] = t_total
return t
def test_lp_learning_weights(seed, na, nc, ncat, na_gen, pcerrors):
# Generate an ELECTRE TRI model and assignment examples
if random_model_type == 'default':
model = generate_random_mrsort_model(nc, ncat, seed)
elif random_model_type == 'choquet':
model = generate_random_mrsort_choquet_model(nc, ncat, 2, seed)
model2 = model.copy()
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, model.categories,
pcerrors / 100)
# Run linear program
t1 = time.time()
if random_model_type == 'default':
lp_weights = LpMRSortWeights(model2, pt, aa_err, 0.0001)
else:
lp_weights = LpMRSortMobius(model2, pt, aa_err, 0.0001)
t2 = time.time()
obj = lp_weights.solve()
t3 = time.time()
# Compute new assignment and classification accuracy
aa2 = model2.pessimist(pt)
ok = ok_errors = ok2 = ok2_errors = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id):
ok2 += 1
if alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
ok += 1
if alt.id in aa_erroned:
ok_errors += 1
total = len(a)
ca2 = ok2 / total
ca2_errors = ok2_errors / total
ca = ok / total
ca_errors = ok_errors / total
# Perform the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa = model.pessimist(pt_gen)
aa2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa, aa2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g" % (seed, na, nc, ncat, na_gen,
pcerrors))
model.id = 'initial'
model2.id = 'learned'
pt.id, pt_gen.id = 'learning_set', 'test_set'
aa.id = 'aa'
aa_err.id = 'aa_err'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name),
model, model2, pt, pt_gen, aa, aa_err)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Output params
t['obj'] = obj
t['ca'] = ca
t['ca_errors'] = ca_errors
t['ca2'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['t_total'] = t3 - t1
t['t_const'] = t2 - t1
t['t_solve'] = t3 - t2
return t
def test_mip_mrsort_vc(seed, na, nc, ncat, na_gen, veto_param, pcerrors):
# Generate a random ELECTRE TRI BM model
if vetot == 'binary':
model = generate_random_mrsort_model_with_binary_veto(nc, ncat,
seed,
veto_func = veto_func,
veto_param = veto_param)
elif vetot == 'coalition':
model = generate_random_mrsort_model_with_coalition_veto(nc, ncat,
seed,
veto_weights = indep_veto_weights,
veto_func = veto_func,
veto_param = veto_param)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
nv_m1_learning = sum([model.count_veto_pessimist(ap) for ap in pt])
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments_proba(aa_err,
model.categories,
pcerrors / 100)
na_err = len(aa_erroned)
# Run the MIP
t1 = time.time()
model2 = MRSort(model.criteria, None, None, None,
model.categories_profiles, None, None, None)
if algo == MipMRSortVC and vetot == 'binary':
w = {c.id: 1 / len(model.criteria) for c in model.criteria}
w1 = w.keys()[0]
w[w1] += 1 - sum(w.values())
model2.veto_weights = CriteriaValues([CriterionValue(c.id,
w[c.id])
for c in model.criteria])
model2.veto_lbda = min(w.values())
if algo == MipMRSortVC:
mip = MipMRSortVC(model2, pt, aa, indep_veto_weights)
else:
mip = MipMRSort(model2, pt, aa)
mip.solve()
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
aa2 = model2.pessimist(pt)
nv_m2_learning = sum([model2.count_veto_pessimist(ap) for ap in pt])
cmatrix_learning = compute_confusion_matrix(aa, aa2, model.categories)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
nv_m1_gen = sum([model.count_veto_pessimist(ap) for ap in pt_gen])
nv_m2_gen = sum([model2.count_veto_pessimist(ap) for ap in pt_gen])
if len(aa_gen) > 0:
cmatrix_gen = compute_confusion_matrix(aa_gen, aa_gen2,
model.categories)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err,
model.categories,
pcerrors / 100)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%s-%d" % (seed, na, nc, ncat,
na_gen, veto_param, pcerrors))
model.id = 'initial'
model2.id = 'learned'
a.id, pt.id = 'learning_set', 'learning_set'
aa.id, aa2.id = 'learning_set_m1', 'learning_set_m2'
a_gen.id, pt_gen.id = 'test_set', 'test_set'
aa_gen.id, aa_gen2.id = 'test_set_m1', 'test_set_m2'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name),
model, model2, a, a_gen, pt, pt_gen, aa, aa2,
aa_gen, aa_gen2)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['veto_param'] = veto_param
t['pcerrors'] = pcerrors
# Ouput params
t['na_err'] = na_err
t['nv_m1_learning'] = nv_m1_learning
t['nv_m2_learning'] = nv_m2_learning
t['nv_m1_gen'] = nv_m1_gen
t['nv_m2_gen'] = nv_m2_gen
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['t_total'] = t_total
for k, v in cmatrix_learning.items():
t['learn_%s_%s' % (k[0], k[1])] = v
for k, v in cmatrix_gen.items():
t['test_%s_%s' % (k[0], k[1])] = v
return t
def test_meta_electre_tri_profiles(seed, na, nc, ncat, na_gen, pcerrors,
max_loops):
# Generate an ELECTRE TRI model and assignment examples
model = generate_random_mrsort_model(nc, ncat, seed)
model2 = model.copy()
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Initiate model with random profiles
model2.bpt = generate_random_profiles(model.profiles, model.criteria)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, model.categories,
pcerrors / 100)
# Sort the performance table
pt_sorted = SortedPerformanceTable(pt)
t1 = time.time()
# Run the algorithm
meta = algo(model2, pt_sorted, aa_err)
ca2_iter = [1] * (max_loops + 1)
aa2 = model2.pessimist(pt)
ca2 = compute_ca(aa_err, aa2)
ca2_best = ca2
best_bpt = model2.bpt.copy()
ca2_iter[0] = ca2
nloops = 0
for k in range(max_loops):
if ca2_best == 1:
break
meta.optimize()
nloops += 1
aa2 = meta.aa
ca2 = compute_ca(aa_err, aa2)
ca2_iter[k + 1] = ca2
if ca2 > ca2_best:
ca2_best = ca2
best_bpt = model2.bpt.copy()
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
model2.bpt = best_bpt
aa2 = model2.pessimist(pt)
ok = ok_errors = ok2_errors = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
total = len(a)
ca_best = ok / total
ca_best_errors = ok_errors / total
ca2_best_errors = ok2_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g-%d" %
(seed, na, nc, ncat, na_gen, pcerrors, max_loops))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
t['max_loops'] = max_loops
# Ouput params
t['ca_best'] = ca_best
t['ca_best_errors'] = ca_best_errors
t['ca2_best'] = ca2_best
t['ca2_best_errors'] = ca2_best_errors
t['ca_gen'] = ca_gen
t['nloops'] = nloops
t['t_total'] = t_total
t['ca2_iter'] = ca2_iter
return t
def test_mip_mrsort_vc(seed, na, nc, ncat, na_gen, veto_param, pcerrors):
# Generate a random ELECTRE TRI BM model
if vetot == 'binary':
model = generate_random_mrsort_model_with_binary_veto(
nc, ncat, seed, veto_func=veto_func, veto_param=veto_param)
elif vetot == 'coalition':
model = generate_random_mrsort_model_with_coalition_veto(
nc,
ncat,
seed,
veto_weights=indep_veto_weights,
veto_func=veto_func,
veto_param=veto_param)
# Generate a set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
nv_m1_learning = sum([model.count_veto_pessimist(ap) for ap in pt])
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments_proba(aa_err, model.categories,
pcerrors / 100)
na_err = len(aa_erroned)
# Run the MIP
t1 = time.time()
model2 = MRSort(model.criteria, None, None, None,
model.categories_profiles, None, None, None)
if algo == MipMRSortVC and vetot == 'binary':
w = {c.id: 1 / len(model.criteria) for c in model.criteria}
w1 = w.keys()[0]
w[w1] += 1 - sum(w.values())
model2.veto_weights = CriteriaValues(
[CriterionValue(c.id, w[c.id]) for c in model.criteria])
model2.veto_lbda = min(w.values())
if algo == MipMRSortVC:
mip = MipMRSortVC(model2, pt, aa, indep_veto_weights)
else:
mip = MipMRSort(model2, pt, aa)
mip.solve()
t_total = time.time() - t1
# Determine the number of erroned alternatives badly assigned
aa2 = model2.pessimist(pt)
nv_m2_learning = sum([model2.count_veto_pessimist(ap) for ap in pt])
cmatrix_learning = compute_confusion_matrix(aa, aa2, model.categories)
ok_errors = ok2_errors = ok = 0
for alt in a:
if aa(alt.id) == aa2(alt.id):
if alt.id in aa_erroned:
ok_errors += 1
ok += 1
if aa_err(alt.id) == aa2(alt.id) and alt.id in aa_erroned:
ok2_errors += 1
total = len(a)
ca2_errors = ok2_errors / total
ca_best = ok / total
ca_errors = ok_errors / total
# Generate alternatives for the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.pessimist(pt_gen)
aa_gen2 = model2.pessimist(pt_gen)
nv_m1_gen = sum([model.count_veto_pessimist(ap) for ap in pt_gen])
nv_m2_gen = sum([model2.count_veto_pessimist(ap) for ap in pt_gen])
if len(aa_gen) > 0:
cmatrix_gen = compute_confusion_matrix(aa_gen, aa_gen2,
model.categories)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err,
model.categories,
pcerrors / 100)
aa_gen2 = model2.pessimist(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%s-%d" %
(seed, na, nc, ncat, na_gen, veto_param, pcerrors))
model.id = 'initial'
model2.id = 'learned'
a.id, pt.id = 'learning_set', 'learning_set'
aa.id, aa2.id = 'learning_set_m1', 'learning_set_m2'
a_gen.id, pt_gen.id = 'test_set', 'test_set'
aa_gen.id, aa_gen2.id = 'test_set_m1', 'test_set_m2'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, model2, a,
a_gen, pt, pt_gen, aa, aa2, aa_gen, aa_gen2)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['veto_param'] = veto_param
t['pcerrors'] = pcerrors
# Ouput params
t['na_err'] = na_err
t['nv_m1_learning'] = nv_m1_learning
t['nv_m2_learning'] = nv_m2_learning
t['nv_m1_gen'] = nv_m1_gen
t['nv_m2_gen'] = nv_m2_gen
t['ca_best'] = ca_best
t['ca_errors'] = ca_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['t_total'] = t_total
for k, v in cmatrix_learning.items():
t['learn_%s_%s' % (k[0], k[1])] = v
for k, v in cmatrix_gen.items():
t['test_%s_%s' % (k[0], k[1])] = v
return t
def test_lp_avfsort(seed, na, nc, ncat, ns, na_gen, pcerrors):
# Generate a random UTADIS model and assignment examples
model = generate_random_avfsort_model(nc, ncat, ns, ns)
model.set_equal_weights()
cat = model.cat_values.to_categories()
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.get_assignments(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments_proba(aa_err, cat.keys(),
pcerrors / 100)
na_err = len(aa_erroned)
gi_worst = AlternativePerformances('worst',
{crit.id: 0
for crit in model.criteria})
gi_best = AlternativePerformances('best',
{crit.id: 1
for crit in model.criteria})
css = CriteriaValues([])
for cf in model.cfs:
cs = CriterionValue(cf.id, len(cf.function))
css.append(cs)
# Run linear program
t1 = time.time()
lp = LpAVFSort(model.criteria, css, cat, gi_worst, gi_best)
t2 = time.time()
obj, cv_l, cfs_l, catv_l = lp.solve(aa_err, pt)
t3 = time.time()
model2 = AVFSort(model.criteria, cv_l, cfs_l, catv_l)
# Compute new assignment and classification accuracy
aa2 = model2.get_assignments(pt)
ok = ok_errors = ok2 = ok2_errors = altered = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id):
ok2 += 1
if alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
ok += 1
if alt.id in aa_erroned:
ok_errors += 1
elif alt.id not in aa_erroned:
altered += 1
total = len(a)
ca2 = ok2 / total
ca2_errors = ok2_errors / total
ca = ok / total
ca_errors = ok_errors / total
# Perform the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa_gen = model.get_assignments(pt_gen)
aa_gen2 = model2.get_assignments(pt_gen)
ca_gen = compute_ca(aa_gen, aa_gen2)
aa_gen_err = aa_gen.copy()
aa_gen_erroned = add_errors_in_assignments_proba(aa_gen_err, cat.keys(),
pcerrors / 100)
aa_gen2 = model2.get_assignments(pt_gen)
ca_gen_err = compute_ca(aa_gen_err, aa_gen2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%d-%g" %
(seed, na, nc, ncat, ns, na_gen, pcerrors))
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['ns'] = ns
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Output params
t['na_err'] = na_err
t['obj'] = obj
t['ca'] = ca
t['ca_errors'] = ca_errors
t['altered'] = altered
t['ca2'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['ca_gen_err'] = ca_gen_err
t['t_total'] = t3 - t1
t['t_const'] = t2 - t1
t['t_solve'] = t3 - t2
return t
def test_lp_learning_weights(seed, na, nc, ncat, na_gen, pcerrors):
# Generate an ELECTRE TRI model and assignment examples
if random_model_type == 'default':
model = generate_random_mrsort_model(nc, ncat, seed)
elif random_model_type == 'choquet':
model = generate_random_mrsort_choquet_model(nc, ncat, 2, seed)
model2 = model.copy()
# Generate a first set of alternatives
a = generate_alternatives(na)
pt = generate_random_performance_table(a, model.criteria)
aa = model.pessimist(pt)
# Add errors in assignment examples
aa_err = aa.copy()
aa_erroned = add_errors_in_assignments(aa_err, model.categories,
pcerrors / 100)
# Run linear program
t1 = time.time()
if random_model_type == 'default':
lp_weights = LpMRSortWeights(model2, pt, aa_err, 0.0001)
else:
lp_weights = LpMRSortMobius(model2, pt, aa_err, 0.0001)
t2 = time.time()
obj = lp_weights.solve()
t3 = time.time()
# Compute new assignment and classification accuracy
aa2 = model2.pessimist(pt)
ok = ok_errors = ok2 = ok2_errors = 0
for alt in a:
if aa_err(alt.id) == aa2(alt.id):
ok2 += 1
if alt.id in aa_erroned:
ok2_errors += 1
if aa(alt.id) == aa2(alt.id):
ok += 1
if alt.id in aa_erroned:
ok_errors += 1
total = len(a)
ca2 = ok2 / total
ca2_errors = ok2_errors / total
ca = ok / total
ca_errors = ok_errors / total
# Perform the generalization
a_gen = generate_alternatives(na_gen)
pt_gen = generate_random_performance_table(a_gen, model.criteria)
aa = model.pessimist(pt_gen)
aa2 = model2.pessimist(pt_gen)
ca_gen = compute_ca(aa, aa2)
# Save all infos in test_result class
t = test_result("%s-%d-%d-%d-%d-%g" %
(seed, na, nc, ncat, na_gen, pcerrors))
model.id = 'initial'
model2.id = 'learned'
pt.id, pt_gen.id = 'learning_set', 'test_set'
aa.id = 'aa'
aa_err.id = 'aa_err'
save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, model2, pt,
pt_gen, aa, aa_err)
# Input params
t['seed'] = seed
t['na'] = na
t['nc'] = nc
t['ncat'] = ncat
t['na_gen'] = na_gen
t['pcerrors'] = pcerrors
# Output params
t['obj'] = obj
t['ca'] = ca
t['ca_errors'] = ca_errors
t['ca2'] = ca2
t['ca2_errors'] = ca2_errors
t['ca_gen'] = ca_gen
t['t_total'] = t3 - t1
t['t_const'] = t2 - t1
t['t_solve'] = t3 - t2
return t