def optimize(self, nmeta): self.lp.update_linear_program() obj = self.lp.solve() self.meta.rebuild_tables() # ca = self.meta.good / self.meta.na aa2 = self.model.pessimist(self.pt_sorted.pt) ca = compute_ca(self.aa_ori, aa2) best_bpt = self.model.bpt.copy() best_ca = ca for i in range(nmeta): cah = self.meta.optimize() aa2 = self.model.pessimist(self.pt_sorted.pt) ca = compute_ca(self.aa_ori, aa2) if ca > best_ca: best_ca = ca best_bpt = self.model.bpt.copy() if cah == 1: break self.model.bpt = best_bpt self.ca = best_ca aa2 = self.model.pessimist(self.pt_sorted.pt) return compute_ca(self.aa_ori, aa2)
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 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 run_metaheuristic(pipe, model, pt, aa, algo, n, use_heur=False, worst=None, best=None): random.seed(0) pt_sorted = SortedPerformanceTable(pt) if use_heur is True: heur = HeurMRSortInitProfiles(model, pt_sorted, aa) heur.solve() else: model.bpt = generate_random_profiles(model.profiles, model.criteria, worst=worst, best=best) if algo == "Meta 3": meta = MetaMRSortProfiles3(model, pt_sorted, aa) elif algo == "Meta 4": meta = MetaMRSortProfiles4(model, pt_sorted, aa) else: print("Invalid algorithm %s" % algo) pipe.close() return f = compute_ca(aa, meta.aa) pipe.send([model.copy(), f]) for i in range(1, n + 1): meta.optimize() f = compute_ca(aa, meta.aa) pipe.send([model.copy(), f]) if f == 1: break pipe.close()
def run_lp_avf(pipe, criteria, categories, worst, best, css, pt, aa): lp = LpAVFSort(criteria, css, categories, worst, best) obj, cvs, cfs, catv = lp.solve(aa, pt) model = AVFSort(criteria, cvs, cfs, catv) aa2 = model.get_assignments(pt) ca = compute_ca(aa, aa2) pipe.send([model, ca]) pipe.close()
def run_metaheuristic(pipe, model, pt, aa, algo, n, use_heur = False, worst = None, best = None): random.seed(0) pt_sorted = SortedPerformanceTable(pt) if use_heur is True: heur = HeurMRSortInitProfiles(model, pt_sorted, aa) heur.solve() else: model.bpt = generate_random_profiles(model.profiles, model.criteria, worst = worst, best = best) if algo == "Meta 3": meta = MetaMRSortProfiles3(model, pt_sorted, aa) elif algo == "Meta 4": meta = MetaMRSortProfiles4(model, pt_sorted, aa) else: print("Invalid algorithm %s" % algo) pipe.close() return f = compute_ca(aa, meta.aa) pipe.send([model.copy(), f]) for i in range(1, n + 1): meta.optimize() f = compute_ca(aa, meta.aa) pipe.send([model.copy(), f]) if f == 1: break pipe.close()
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, 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, 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)
mwinning = compute_minimal_winning_coalitions(lp.fmins) for win in mwinning: win = list(win) win.sort(key=criteria_order.index) buf = "" for c in win: buf += "%s, " % criteria_names[c] print('[%s]' % buf[:-2], file=fcoalitions) fcoalitions.close() aa_learned = m.pessimist(pt_learning) fca = open('%s-ca.dat' % bname, 'w+') ca = compute_ca(aa_learning, aa_learned) print("%.4f" % ca, end='', file=fca) fca.close() fauc = open('%s-auc.dat' % bname, 'w+') auc = m.auc(aa_learning, pt_learning) print("%.4f" % auc, end='', file=fauc) fauc.close() fmisclassified = open('%s-misclassified.dat' % bname, 'w+') print("{Alternative} ", file=fmisclassified, end='') print("{Original assignment} ", file=fmisclassified, end='') print("{Model assignment}", file=fmisclassified, end='') for c in criteria: print(" {%s}" % criteria_names[c], file=fmisclassified, end='') print("\n", file=fmisclassified, end='')
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
for cat in model.categories_profiles.get_ordered_categories(): pc = len(aa.get_alternatives_in_category(cat)) / len(aa) * 100 print("Percentage of alternatives in %s: %g %%" % (cat, pc)) # Learn the weights with random generated profiles for i in range(10): model2 = model.copy() b = model.categories_profiles.get_ordered_profiles() model2.bpt = generate_random_profiles(b, model2.criteria) lp_weights = LpMRSortWeights(model2, pt, aa) lp_weights.solve() aa2 = model2.pessimist(pt) ca2 = compute_ca(aa, aa2) win2, loose2 = compute_winning_and_loosing_coalitions( model2.cv, model2.lbda) coal2_ni = list((set(winning) ^ set(win2)) & set(winning)) coal2_add = list((set(winning) ^ set(win2)) & set(win2)) print("Classification accuracy with random profiles: %g" % ca2) print("Coalitions: total: %d, common: %d, added: %d" % \ (len(win2), (len(winning) - len(coal2_ni)), len(coal2_add))) # Learn the weights with profiles generated by the heuristic model3 = model.copy() heur = HeurMRSortInitProfiles(model3, sorted_pt, aa) heur.solve()
def run_test(seed, data, pclearning, nseg): random.seed(seed) # Separate learning data and test data pt_learning, pt_test = data.pt.split(2, [pclearning, 100 - pclearning]) aa_learning = data.aa.get_subset(pt_learning.keys()) aa_test = data.aa.get_subset(pt_test.keys()) worst = data.pt.get_worst(data.c) best = data.pt.get_best(data.c) # Run the linear program t1 = time.time() css = CriteriaValues([]) for c in data.c: cs = CriterionValue(c.id, nseg) css.append(cs) lp = LpAVFSort(data.c, css, data.cats, worst, best) obj, cvs, cfs, catv = lp.solve(aa_learning, pt_learning) t_total = time.time() - t1 model = AVFSort(data.c, cvs, cfs, catv) ordered_categories = model.categories # CA learning set aa_learning2 = model.get_assignments(pt_learning) ca_learning = compute_ca(aa_learning, aa_learning2) auc_learning = model.auc(aa_learning, pt_learning) diff_learning = compute_confusion_matrix(aa_learning, aa_learning2, ordered_categories) # Compute CA of test setting if len(aa_test) > 0: aa_test2 = model.get_assignments(pt_test) ca_test = compute_ca(aa_test, aa_test2) auc_test = model.auc(aa_test, pt_test) diff_test = compute_confusion_matrix(aa_test,aa_test2, ordered_categories) else: ca_test = 0 auc_test = 0 ncat = len(data.cats) diff_test = OrderedDict([((a, b), 0) for a in ordered_categories \ for b in ordered_categories]) # Compute CA of whole set aa2 = model.get_assignments(data.pt) ca = compute_ca(data.aa, aa2) auc = model.auc(data.aa, data.pt) diff_all = compute_confusion_matrix(data.aa, aa2, ordered_categories) t = test_result("%s-%d-%d-%d" % (data.name, seed, nseg, pclearning)) model.id = 'learned' aa_learning.id, aa_test.id = 'learning_set', 'test_set' pt_learning.id, pt_test.id = 'learning_set', 'test_set' save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, aa_learning, aa_test, pt_learning, pt_test) t['seed'] = seed t['na'] = len(data.a) t['nc'] = len(data.c) t['ncat'] = len(data.cats) t['ns'] = nseg t['pclearning'] = pclearning t['na_learning'] = len(aa_learning) t['na_test'] = len(aa_test) t['obj'] = obj t['ca_learning'] = ca_learning t['ca_test'] = ca_test t['ca_all'] = ca t['auc_learning'] = auc_learning t['auc_test'] = auc_test t['auc_all'] = auc for k, v in diff_learning.items(): t['learn_%s_%s' % (k[0], k[1])] = v for k, v in diff_test.items(): t['test_%s_%s' % (k[0], k[1])] = v for k, v in diff_all.items(): t['all_%s_%s' % (k[0], k[1])] = v t['t_total'] = t_total return t
for i in range(0, 501): print('%d: fitness: %g' % (i, f)) model2.bpt.display(criterion_ids = cids, alternative_ids = model2.profiles) if f >= best_f: best_f = f best_bpt = model2.bpt.copy() if f == 1: break f = meta.optimize() model2.bpt = best_bpt aa2 = model2.pessimist(pt_learn) f = compute_ca(aa_err, aa2) print('Learned model') print('=============') print("Number of iterations: %d" % i) print("Fitness score: %g %%" % (float(f) * 100)) model2.bpt.display(criterion_ids = cids, alternative_ids = model2.profiles) model2.cv.display(criterion_ids=cids) print("lambda: %.7s" % model2.lbda) aa2 = model2.pessimist(pt) total = len(a) nok = nok_erroned = 0 anok = [] for alt in a:
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 run_test(seed, data, pclearning, nloop, nmodels, nmeta): random.seed(seed) # Separate learning data and test data pt_learning, pt_test = data.pt.split(2, [pclearning, 100 - pclearning]) aa_learning = data.aa.get_subset(pt_learning.keys()) aa_test = data.aa.get_subset(pt_test.keys()) # Initialize a random model cat_profiles = generate_categories_profiles(data.cats) worst = data.pt.get_worst(data.c) best = data.pt.get_best(data.c) b = generate_alternatives(len(data.cats) - 1, 'b') bpt = None cvs = None lbda = None model = MRSort(data.c, cvs, bpt, lbda, cat_profiles) # Run the metaheuristic t1 = time.time() pt_sorted = SortedPerformanceTable(pt_learning) # Algorithm meta = meta_mrsort(nmodels, model.criteria, model.categories_profiles.to_categories(), pt_sorted, aa_learning, seed=seed * 100) #lp_weights = lp_weights, #heur_profiles = heur_profiles, #lp_veto_weights = lp_veto_weights, #heur_veto_profiles = heur_veto_profiles, for i in range(0, nloop): model, ca_learning = meta.optimize(nmeta) if ca_learning == 1: break t_total = time.time() - t1 aa_learning2 = model.pessimist(pt_learning) ca_learning = compute_ca(aa_learning, aa_learning2) auc_learning = model.auc(aa_learning, pt_learning) diff_learning = compute_confusion_matrix(aa_learning, aa_learning2, model.categories) # Compute CA of test setting if len(aa_test) > 0: aa_test2 = model.pessimist(pt_test) ca_test = compute_ca(aa_test, aa_test2) auc_test = model.auc(aa_test, pt_test) diff_test = compute_confusion_matrix(aa_test, aa_test2, model.categories) else: ca_test = 0 auc_test = 0 ncat = len(data.cats) diff_test = OrderedDict([((a, b), 0) for a in model.categories \ for b in model.categories]) # Compute CA of whole set aa2 = model.pessimist(data.pt) ca = compute_ca(data.aa, aa2) auc = model.auc(data.aa, data.pt) diff_all = compute_confusion_matrix(data.aa, aa2, model.categories) t = test_result("%s-%d-%d-%d-%d-%d" % (data.name, seed, nloop, nmodels, nmeta, pclearning)) model.id = 'learned' aa_learning.id, aa_test.id = 'learning_set', 'test_set' pt_learning.id, pt_test.id = 'learning_set', 'test_set' save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, aa_learning, aa_test, pt_learning, pt_test) t['seed'] = seed t['na'] = len(data.a) t['nc'] = len(data.c) t['ncat'] = len(data.cats) t['pclearning'] = pclearning t['nloop'] = nloop t['nmodels'] = nmodels t['nmeta'] = nmeta t['na_learning'] = len(aa_learning) t['na_test'] = len(aa_test) t['ca_learning'] = ca_learning t['ca_test'] = ca_test t['ca_all'] = ca t['auc_learning'] = auc_learning t['auc_test'] = auc_test t['auc_all'] = auc for k, v in diff_learning.items(): t['learn_%s_%s' % (k[0], k[1])] = v for k, v in diff_test.items(): t['test_%s_%s' % (k[0], k[1])] = v for k, v in diff_all.items(): t['all_%s_%s' % (k[0], k[1])] = v t['t_total'] = t_total 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
win = list(win) win.sort(key=criteria_order.index) buf = "" for c in win: buf += "%s, " % criteria_names[c] print('[%s]' % buf[:-2], file=fcoalitions) fcoalitions.close() pt_learning = PerformanceTable().from_xmcda(root, 'learning_set') aa_learning = AlternativesAssignments().from_xmcda(root, 'learning_set') aa_learned = m.pessimist(pt_learning) fca = open('%s-ca_learning.dat' % bname, 'w+') ca = compute_ca(aa_learning, aa_learned) print("%.4f" % ca, end = '', file=fca) fca.close() fauc = open('%s-auc_learning.dat' % bname, 'w+') auc = m.auc(aa_learning, pt_learning) print("%.4f" % auc, end = '', file=fauc) fauc.close() ca_learning.append(ca) auc_learning.append(auc) pt_test = PerformanceTable().from_xmcda(root, 'test_set') aa_test = AlternativesAssignments().from_xmcda(root, 'test_set') aa_test2 = m.pessimist(pt_test)
print("Invalid algorithm!") sys.exit(1) t_total = time.time() - t1 model.id = 'learned' data.pt.id = 'learning_set' data.aa.id = 'learning_set' dt = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") save_to_xmcda("%s/%s-all-%s-%s.bz2" % (DATADIR, algo, data.name, dt), data.aa, data.pt, model) aa2 = model.get_assignments(data.pt) ca = compute_ca(data.aa, aa2) auc = model.auc(data.aa, data.pt) anok = [] for a in data.a: if data.aa[a.id].category_id != aa2[a.id].category_id: anok.append(a) if len(anok) > 0: print("Alternatives wrongly assigned:") print_pt_and_assignments(anok.keys(), data.c.keys(), [data.aa, aa2], data.pt) print("Model parameters:") cids = model.criteria.keys() if model_type == 'mrsort':
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_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
root = tree.getroot() m = MRSort().from_xmcda(root, 'learned') pt_learning = PerformanceTable().from_xmcda(root, 'learning_set') pt_test = PerformanceTable().from_xmcda(root, 'test_set') aa_learning = AlternativesAssignments().from_xmcda(root, 'learning_set') aa_test = AlternativesAssignments().from_xmcda(root, 'test_set') aa_learning_m2 = m.pessimist(pt_learning) aa_test_m2 = m.pessimist(pt_test) # Compute classification accuracy ca_learning = compute_ca(aa_learning, aa_learning_m2) ca_test = compute_ca(aa_test, aa_test_m2) table_ca_learning.append(ca_learning) table_ca_test.append(ca_test) # Compute area under the curve auc_learning = m.auc(aa_learning, pt_learning) auc_test = m.auc(aa_test, pt_test) table_auc_learning.append(auc_learning) table_auc_test.append(auc_test) if m.veto_lbda is not None: nveto += 1
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 run_test(seed, data, pclearning): random.seed(seed) # Separate learning data and test data pt_learning, pt_test = data.pt.split(2, [pclearning, 100 - pclearning]) aa_learning = data.aa.get_subset(pt_learning.keys()) aa_test = data.aa.get_subset(pt_test.keys()) # Initialize ELECTRE-TRI BM model cat_profiles = generate_categories_profiles(data.cats) worst = data.pt.get_worst(data.c) best = data.pt.get_best(data.c) b = generate_alternatives(len(data.cats) - 1, 'b') bpt = None cvs = None lbda = None model = MRSort(data.c, cvs, bpt, lbda, cat_profiles) # Run the linear program t1 = time.time() mip = mip_mrsort(model, pt_learning, aa_learning) obj = mip.solve() t_total = time.time() - t1 # CA learning set aa_learning2 = model.pessimist(pt_learning) ca_learning = compute_ca(aa_learning, aa_learning2) auc_learning = model.auc(aa_learning, pt_learning) diff_learning = compute_confusion_matrix(aa_learning, aa_learning2, model.categories) # Compute CA of test setting if len(aa_test) > 0: aa_test2 = model.pessimist(pt_test) ca_test = compute_ca(aa_test, aa_test2) auc_test = model.auc(aa_test, pt_test) diff_test = compute_confusion_matrix(aa_test, aa_test2, model.categories) else: ca_test = 0 auc_test = 0 ncat = len(data.cats) diff_test = OrderedDict([((a, b), 0) for a in model.categories \ for b in model.categories]) # Compute CA of whole set aa2 = model.pessimist(data.pt) ca = compute_ca(data.aa, aa2) auc = model.auc(data.aa, data.pt) diff_all = compute_confusion_matrix(data.aa, aa2, model.categories) t = test_result("%s-%d-%d" % (data.name, seed, pclearning)) model.id = 'learned' aa_learning.id, aa_test.id = 'learning_set', 'test_set' pt_learning.id, pt_test.id = 'learning_set', 'test_set' save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, aa_learning, aa_test, pt_learning, pt_test) t['seed'] = seed t['na'] = len(data.a) t['nc'] = len(data.c) t['ncat'] = len(data.cats) t['pclearning'] = pclearning t['na_learning'] = len(aa_learning) t['na_test'] = len(aa_test) t['obj'] = obj t['ca_learning'] = ca_learning t['ca_test'] = ca_test t['ca_all'] = ca t['auc_learning'] = auc_learning t['auc_test'] = auc_test t['auc_all'] = auc for k, v in diff_learning.items(): t['learn_%s_%s' % (k[0], k[1])] = v for k, v in diff_test.items(): t['test_%s_%s' % (k[0], k[1])] = v for k, v in diff_all.items(): t['all_%s_%s' % (k[0], k[1])] = v t['t_total'] = t_total return t
def run_test(seed, data, pclearning): random.seed(seed) # Separate learning data and test data pt_learning, pt_test = data.pt.split(2, [pclearning, 100 - pclearning]) aa_learning = data.aa.get_subset(pt_learning.keys()) aa_test = data.aa.get_subset(pt_test.keys()) # Initialize ELECTRE-TRI BM model cat_profiles = generate_categories_profiles(data.cats) worst = data.pt.get_worst(data.c) best = data.pt.get_best(data.c) b = generate_alternatives(len(data.cats) - 1, 'b') bpt = None cvs = None lbda = None model = MRSort(data.c, cvs, bpt, lbda, cat_profiles) # Run the linear program t1 = time.time() mip = mip_mrsort(model, pt_learning, aa_learning) obj = mip.solve() t_total = time.time() - t1 # CA learning set aa_learning2 = model.pessimist(pt_learning) ca_learning = compute_ca(aa_learning, aa_learning2) auc_learning = model.auc(aa_learning, pt_learning) diff_learning = compute_confusion_matrix(aa_learning, aa_learning2, model.categories) # Compute CA of test setting if len(aa_test) > 0: aa_test2 = model.pessimist(pt_test) ca_test = compute_ca(aa_test, aa_test2) auc_test = model.auc(aa_test, pt_test) diff_test = compute_confusion_matrix(aa_test, aa_test2, model.categories) else: ca_test = 0 auc_test = 0 ncat = len(data.cats) diff_test = OrderedDict([((a, b), 0) for a in model.categories \ for b in model.categories]) # Compute CA of whole set aa2 = model.pessimist(data.pt) ca = compute_ca(data.aa, aa2) auc = model.auc(data.aa, data.pt) diff_all = compute_confusion_matrix(data.aa, aa2, model.categories) t = test_result("%s-%d-%d" % (data.name, seed, pclearning)) model.id = 'learned' aa_learning.id, aa_test.id = 'learning_set', 'test_set' pt_learning.id, pt_test.id = 'learning_set', 'test_set' save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, aa_learning, aa_test, pt_learning, pt_test) t['seed'] = seed t['na'] = len(data.a) t['nc'] = len(data.c) t['ncat'] = len(data.cats) t['pclearning'] = pclearning t['na_learning'] = len(aa_learning) t['na_test'] = len(aa_test) t['obj'] = obj t['ca_learning'] = ca_learning t['ca_test'] = ca_test t['ca_all'] = ca t['auc_learning'] = auc_learning t['auc_test'] = auc_test t['auc_all'] = auc for k, v in diff_learning.items(): t['learn_%s_%s' % (k[0], k[1])] = v for k, v in diff_test.items(): t['test_%s_%s' % (k[0], k[1])] = v for k, v in diff_all.items(): t['all_%s_%s' % (k[0], k[1])] = v t['t_total'] = t_total return t
i = None for i in range(0, 501): print('%d: fitness: %g' % (i, f)) model2.bpt.display(criterion_ids=cids, alternative_ids=model2.profiles) if f >= best_f: best_f = f best_bpt = model2.bpt.copy() if f == 1: break f = meta.optimize() model2.bpt = best_bpt aa2 = model2.pessimist(pt_learn) f = compute_ca(aa_err, aa2) print('Learned model') print('=============') print("Number of iterations: %d" % i) print("Fitness score: %g %%" % (float(f) * 100)) model2.bpt.display(criterion_ids=cids, alternative_ids=model2.profiles) model2.cv.display(criterion_ids=cids) print("lambda: %.7s" % model2.lbda) aa2 = model2.pessimist(pt) total = len(a) nok = nok_erroned = 0 anok = [] for alt in a: if aa(alt.id) != aa2(alt.id):
def run_test(seed, data, pclearning, nloop, nmodels, nmeta): random.seed(seed) global aaa global allm global fct_ca global LOO # Separate learning data and test data if LOO: pt_learning, pt_test = data.pt.split_LOO(seed) else: pt_learning, pt_test = data.pt.split(2, [pclearning, 100 - pclearning]) aa_learning = data.aa.get_subset(pt_learning.keys()) aa_test = data.aa.get_subset(pt_test.keys()) #import pdb; pdb.set_trace() # Initialize a random model cat_profiles = generate_categories_profiles(data.cats) worst = data.pt.get_worst(data.c) best = data.pt.get_best(data.c) b = generate_alternatives(len(data.cats) - 1, 'b') bpt = None cvs = None lbda = None model = MRSort(data.c, cvs, bpt, lbda, cat_profiles) # if LOO: # print(data.c, cvs, bpt, lbda, cat_profiles) # print(model.categories_profiles.to_categories()) # print(model.categories) # import pdb; pdb.set_trace() # Run the metaheuristic t1 = time.time() pt_sorted = SortedPerformanceTable(pt_learning) # Algorithm meta = meta_mrsort(nmodels, model.criteria, model.categories_profiles.to_categories(), pt_sorted, aa_learning, seed = seed * 100) # if LOO: # print(nmodels, model.criteria, # model.categories_profiles.to_categories(), # pt_sorted, aa_learning) #import pdb; pdb.set_trace() #lp_weights = lp_weights, #heur_profiles = heur_profiles, #lp_veto_weights = lp_veto_weights, #heur_veto_profiles = heur_veto_profiles, for i in range(0, nloop): model, ca_learning, all_models = meta.optimize(nmeta, fct_ca) #import pdb; pdb.set_trace() if ca_learning == 1: break t_total = time.time() - t1 aa_learning2 = model.pessimist(pt_learning) ca_learning = compute_ca(aa_learning, aa_learning2) ca_learning_good = compute_ca_good(aa_learning, aa_learning2) #import pdb; pdb.set_trace() auc_learning = model.auc(aa_learning, pt_learning) diff_learning = compute_confusion_matrix(aa_learning, aa_learning2, model.categories) # Compute CA of test setting if len(aa_test) > 0: aa_test2 = model.pessimist(pt_test) ca_test = compute_ca(aa_test, aa_test2) ca_test_good = compute_ca_good(aa_test, aa_test2) auc_test = model.auc(aa_test, pt_test) diff_test = compute_confusion_matrix(aa_test, aa_test2, model.categories) #import pdb; pdb.set_trace() else: ca_test = 0 auc_test = 0 ncat = len(data.cats) diff_test = OrderedDict([((a, b), 0) for a in model.categories \ for b in model.categories]) # Compute CA of whole set aa2 = model.pessimist(data.pt) ca = compute_ca(data.aa, aa2) ca_good = compute_ca_good(data.aa, aa2) auc = model.auc(data.aa, data.pt) diff_all = compute_confusion_matrix(data.aa, aa2, model.categories) t = test_result("%s-%d-%d-%d-%d-%d" % (data.name, seed, nloop, nmodels, nmeta, pclearning)) model.id = 'learned' aa_learning.id, aa_test.id = 'learning_set', 'test_set' pt_learning.id, pt_test.id = 'learning_set', 'test_set' save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), model, aa_learning, aa_test, pt_learning, pt_test) t['seed'] = seed t['na'] = len(data.a) t['nc'] = len(data.c) t['ncat'] = len(data.cats) t['pclearning'] = pclearning t['nloop'] = nloop t['nmodels'] = nmodels t['nmeta'] = nmeta t['na_learning'] = len(aa_learning) t['na_test'] = len(aa_test) t['ca_learning'] = ca_learning t['ca_test'] = ca_test t['ca_all'] = ca t['ca_learning_good'] = ca_learning_good t['ca_test_good'] = ca_test_good t['ca_all_good'] = ca_good t['auc_learning'] = auc_learning t['auc_test'] = auc_test t['auc_all'] = auc # import pdb; pdb.set_trace() aaa[seed]=dict() aaa[seed]['id'] = seed aaa[seed]['learning_asgmt_id'] = [i.id for i in aa_learning] aaa[seed]['learning_asgmt'] = [i.category_id for i in aa_learning] aaa[seed]['learning_asgmt2'] = [i.category_id for i in aa_learning2] aaa[seed]['test_asgmt_id'] = [i.id for i in aa_test] aaa[seed]['test_asgmt'] = [i.category_id for i in aa_test] aaa[seed]['test_asgmt2'] = [i.category_id for i in aa_test2] aaa[seed]['criteria'] = [i for i,j in model.criteria.items()] aaa[seed]['criteria_weights'] = [str(i.value) for i in model.cv.values()] aaa[seed]['profiles_values'] = [str(model.bpt['b1'].performances[i]) for i,j in model.criteria.items()] aaa[seed]['lambda'] = model.lbda #[model.bpt['b1'].performances[i] for i,j in model.criteria.items()] allm[seed]=dict() allm[seed]['id'] = seed current_model = 0 allm[seed]['mresults'] = dict() for all_model in list(all_models)[1:]: current_model += 1 # skipping the 1rst model already treated allm[seed]['mresults'][current_model] = ["",""] aa_learning2_allm = all_model.model.pessimist(pt_learning) ca_learning_allm = compute_ca(aa_learning, aa_learning2_allm) ca_learning_good_allm = compute_ca_good(aa_learning, aa_learning2_allm) auc_learning_allm = all_model.model.auc(aa_learning, pt_learning) # diff_learning_allm = compute_confusion_matrix(aa_learning, aa_learning2_allm, # all_model.model.categories) # Compute CA of test setting if len(aa_test) > 0: aa_test2_allm = all_model.model.pessimist(pt_test) ca_test_allm = compute_ca(aa_test, aa_test2_allm) ca_test_good_allm = compute_ca_good(aa_test, aa_test2_allm) auc_test_allm = all_model.model.auc(aa_test, pt_test) # diff_test_allm = compute_confusion_matrix(aa_test, aa_test2_allm, # all_model.categories) else: ca_test_allm = 0 auc_test_allm = 0 ncat_allm = len(data.cats) # diff_test_allm = OrderedDict([((a, b), 0) for a in all_model.categories \ # for b in all_model.model.categories]) # Compute CA of whole set aa2_allm = all_model.model.pessimist(data.pt) ca_allm = compute_ca(data.aa, aa2_allm) ca_good_allm = compute_ca_good(data.aa, aa2_allm) auc_allm = all_model.model.auc(data.aa, data.pt) #diff_all_allm = compute_confusion_matrix(data.aa, aa2_allm, all_model.model.categories) allm[seed]['mresults'][current_model][0] = 'na_learning,na_test,ca_learning,ca_test,ca_all,ca_learning_good,ca_test_good,ca_all_good,auc_learning,auc_test,auc_all' allm[seed]['mresults'][current_model][1] = str(len(aa_learning)) + "," + str(len(aa_test)) + "," + str(ca_learning_allm) + "," + str(ca_test_allm) + "," + str(ca_allm) + "," + str(ca_learning_good_allm) + "," + str(ca_test_good_allm) + "," + str(ca_good_allm) + "," + str(auc_learning_allm) + "," + str(auc_test_allm) + "," + str(auc_allm) #allm[seed]['mresults'][current_model][1] = #all_model.model.bpt['b1'].performances #all_model.model.cv.values() #import pdb; pdb.set_trace() # allm[seed][current_model]['na_learning'] = len(aa_learning) # allm[seed][current_model]['na_test'] = len(na_test) # allm[seed][current_model]['ca_learning'] = ca_learning_allm # allm[seed][current_model]['ca_test'] = ca_test_allm # allm[seed][current_model]['ca_all'] = ca_allm # allm[seed][current_model]['ca_learning_good'] = ca_learning_good_allm # allm[seed][current_model]['ca_test_good'] = ca_test_good_allm # allm[seed][current_model]['ca_all_good'] = ca_good_allm # allm[seed][current_model]['auc_learning'] = auc_learning_allm # allm[seed][current_model]['auc_test'] = auc_test_allm # allm[seed][current_model]['auc_all'] = auc_allm for k, v in diff_learning.items(): t['learn_%s_%s' % (k[0], k[1])] = v for k, v in diff_test.items(): t['test_%s_%s' % (k[0], k[1])] = v for k, v in diff_all.items(): t['all_%s_%s' % (k[0], k[1])] = v 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_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
print("Invalid algorithm!") sys.exit(1) t_total = time.time() - t1 model.id = 'learned' data.pt.id = 'learning_set' data.aa.id = 'learning_set' dt = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") save_to_xmcda("%s/%s-all-%s-%s.bz2" % (DATADIR, algo, data.name, dt), data.aa, data.pt, model) aa2 = model.get_assignments(data.pt) ca = compute_ca(data.aa, aa2) auc = model.auc(data.aa, data.pt) anok = [] for a in data.a: if data.aa[a.id].category_id != aa2[a.id].category_id: anok.append(a) if len(anok) > 0: print("Alternatives wrongly assigned:") print_pt_and_assignments(anok.keys(), data.c.keys(), [data.aa, aa2], data.pt) print("Model parameters:") cids = model.criteria.keys() if model_type == 'mrsort': print(model.bpt)
model.cv.display(criterion_ids=cids) print("lambda\t%.7s" % model.lbda) model.veto.display(criterion_ids=cids) model.veto_weights.display(criterion_ids=cids) print("veto_lambda\t%.7s" % model.veto_lbda) ncriteria = len(model.criteria) ncategories = len(model.categories) pt_sorted = SortedPerformanceTable(pt) model2 = model.copy() model2.veto = None model2.veto_weights = None model2.veto_lambda = None aa2 = model2.pessimist(pt) print(compute_ca(aa, aa2)) t1 = time.time() meta = MetaMRSortVCPop3(10, model2, pt_sorted, aa) for i in range(nloops): model2, ca = meta.optimize(nmeta) print("%d: ca: %f" % (i, ca)) if ca == 1: break t2 = time.time() print("Computation time: %g secs" % (t2 - t1)) print('Learned model') print('=============')
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 run_test(seed, data, pclearning, nloop, nmodels, nmeta): random.seed(seed) # Separate learning data and test data pt_learning, pt_test = data.pt.split(2, [pclearning, 100 - pclearning]) aa_learning = data.aa.get_subset(pt_learning.keys()) aa_test = data.aa.get_subset(pt_test.keys()) # Initialize a random model cat_profiles = generate_categories_profiles(data.cats) worst = data.pt.get_worst(data.c) best = data.pt.get_best(data.c) b = generate_alternatives(len(data.cats) - 1, 'b') bpt = None cvs = None lbda = None model = MRSort(data.c, cvs, bpt, lbda, cat_profiles) # Run the metaheuristic t1 = time.time() pt_sorted = SortedPerformanceTable(pt_learning) # Algorithm meta = MetaMRSortPop3(nmodels, model.criteria, model.categories_profiles.to_categories(), pt_sorted, aa_learning, heur_init_profiles, lp_weights, heur_profiles) for i in range(0, nloop): model, ca_learning = meta.optimize(nmeta) t_total = time.time() - t1 aa_learning2 = compute_assignments_majority(meta.models, pt_learning) ca_learning = compute_ca(aa_learning, aa_learning2) auc_learning = compute_auc_majority(meta.models, pt_learning) diff_learning = compute_confusion_matrix(aa_learning, aa_learning2, model.categories) # Compute CA of test setting if len(aa_test) > 0: aa_test2 = compute_assignments_majority(meta.models, pt_test) ca_test = compute_ca(aa_test, aa_test2) auc_test = compute_auc_majority(meta.models, pt_test) diff_test = compute_confusion_matrix(aa_test, aa_test2, model.categories) else: ca_test = 0 auc_test = 0 ncat = len(data.cats) diff_test = OrderedDict([((a, b), 0) for a in model.categories \ for b in model.categories]) # Compute CA of whole set aa2 = compute_assignments_majority(meta.models, data.pt) ca = compute_ca(data.aa, aa2) auc = compute_auc_majority(meta.models, data.pt) diff_all = compute_confusion_matrix(data.aa, aa2, model.categories) t = test_result("%s-%d-%d-%d-%d-%d" % (data.name, seed, nloop, nmodels, nmeta, pclearning)) model.id = 'learned' aa_learning.id, aa_test.id = 'learning_set', 'test_set' pt_learning.id, pt_test.id = 'learning_set', 'test_set' save_to_xmcda("%s/%s.bz2" % (directory, t.test_name), aa_learning, aa_test, pt_learning, pt_test, *meta.models) t['seed'] = seed t['na'] = len(data.a) t['nc'] = len(data.c) t['ncat'] = len(data.cats) t['pclearning'] = pclearning t['nloop'] = nloop t['nmodels'] = nmodels t['nmeta'] = nmeta t['na_learning'] = len(aa_learning) t['na_test'] = len(aa_test) t['ca_learning'] = ca_learning t['ca_test'] = ca_test t['ca_all'] = ca t['auc_learning'] = auc_learning t['auc_test'] = auc_test t['auc_all'] = auc for k, v in diff_learning.items(): t['learn_%s_%s' % (k[0], k[1])] = v for k, v in diff_test.items(): t['test_%s_%s' % (k[0], k[1])] = v for k, v in diff_all.items(): t['all_%s_%s' % (k[0], k[1])] = v t['t_total'] = t_total return t
# # Remove alternatives that cannot be corrected with a veto rule # aa_learning_m2p = discard_undersorted_alternatives(m.categories, # aa_learning, # aa_learning_m2) # aa_learning_m2p = discard_alternatives_in_category(aa_learning_m2p, # m.categories[0]) # Run the metaheuristic meta = MetaMRSortVCPop3(10, m, SortedPerformanceTable(pt_learning), aa_learning) nloops = 10 nmeta = 20 for i in range(nloops): m2, ca = meta.optimize(nmeta) ca_learning_m2 = compute_ca(aa_learning, aa_learning_m2) aa_learning_m3 = m2.pessimist(pt_learning) ca_learning_m3 = compute_ca(aa_learning, aa_learning_m3) if ca_learning_m2 >= ca_learning_m3: model = m else: model = m2 model.id = 'learned' aa_learning.id, aa_test.id = 'learning_set', 'test_set' pt_learning.id, pt_test.id = 'learning_set', 'test_set' save_to_xmcda("%s/%s.bz2" % (directory, fname), model, aa_learning, aa_test, pt_learning, pt_test)
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): # 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
pdb.set_trace() tree = ElementTree.parse(f) root = tree.getroot() m = MRSort().from_xmcda(root, 'learned') pt_learning = PerformanceTable().from_xmcda(root, 'learning_set') pt_test = PerformanceTable().from_xmcda(root, 'test_set') aa_learning = AlternativesAssignments().from_xmcda(root, 'learning_set') aa_test = AlternativesAssignments().from_xmcda(root, 'test_set') aa_learning_m2 = m.pessimist(pt_learning) aa_test_m2 = m.pessimist(pt_test) # Compute classification accuracy ca_learning = compute_ca(aa_learning, aa_learning_m2) ca_test = compute_ca(aa_test, aa_test_m2) table_ca_learning.append(ca_learning) table_ca_test.append(ca_test) # Compute area under the curve auc_learning = m.auc(aa_learning, pt_learning) auc_test = m.auc(aa_test, pt_test) table_auc_learning.append(auc_learning) table_auc_test.append(auc_test) if m.veto_lbda is not None: nveto += 1
for cat in model.categories_profiles.get_ordered_categories(): pc = len(aa.get_alternatives_in_category(cat)) / len(aa) * 100 print("Percentage of alternatives in %s: %g %%" % (cat, pc)) # Learn the weights with random generated profiles for i in range(10): model2 = model.copy() b = model.categories_profiles.get_ordered_profiles() model2.bpt = generate_random_profiles(b, model2.criteria) lp_weights = LpMRSortWeights(model2, pt, aa) lp_weights.solve() aa2 = model2.pessimist(pt) ca2 = compute_ca(aa, aa2) win2, loose2 = compute_winning_and_loosing_coalitions(model2.cv, model2.lbda) coal2_ni = list((set(winning) ^ set(win2)) & set(winning)) coal2_add = list((set(winning) ^ set(win2)) & set(win2)) print("Classification accuracy with random profiles: %g" % ca2) print("Coalitions: total: %d, common: %d, added: %d" % \ (len(win2), (len(winning) - len(coal2_ni)), len(coal2_add))) # Learn the weights with profiles generated by the heuristic model3 = model.copy() heur = HeurMRSortInitProfiles(model3, sorted_pt, aa) heur.solve()
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
for win in mwinning: win = list(win) win.sort(key=criteria_order.index) buf = "" for c in win: buf += "%s, " % criteria_names[c] print('[%s]' % buf[:-2], file=fcoalitions) fcoalitions.close() pt_learning = PerformanceTable().from_xmcda(root, 'learning_set') aa_learning = AlternativesAssignments().from_xmcda(root, 'learning_set') aa_learned = m.pessimist(pt_learning) fca = open('%s-ca_learning.dat' % bname, 'w+') ca = compute_ca(aa_learning, aa_learned) print("%.4f" % ca, end='', file=fca) fca.close() fauc = open('%s-auc_learning.dat' % bname, 'w+') auc = m.auc(aa_learning, pt_learning) print("%.4f" % auc, end='', file=fauc) fauc.close() ca_learning.append(ca) auc_learning.append(auc) pt_test = PerformanceTable().from_xmcda(root, 'test_set') aa_test = AlternativesAssignments().from_xmcda(root, 'test_set') aa_test2 = m.pessimist(pt_test)
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 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_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