def init_one_meta(self, seed): cps = generate_categories_profiles(self.categories) if not self.duplication and self.renewal_method > 0: for crit in self.criteria.values(): if int(crit.id[1:]) <= self.nb_unk_criteria: tmp = random.random() if tmp < 0.5: crit.direction = -1 else: crit.direction = 1 #print(tmp) #print(self.unk_pref_dir_criteria,int(crit.id[1:]),self.criteria) #import pdb; pdb.set_trace() #print(self.criteria,self.renewal_method) #import pdb; pdb.set_trace() model = MRSort(copy.deepcopy(self.criteria), None, None, None, cps) model.id = 'model_%d' % seed meta = MetaMRSortCV4MSJP(model, self.pt_sorted, self.aa_ori, self.lp_weights, self.heur_profiles, self.lp_veto_weights, self.heur_veto_profiles, gamma=self.gamma, renewal_method=self.renewal_method, pretreatment_crit=self.pretreatment_crit, duplication=self.duplication, nb_unk_criteria=self.nb_unk_criteria) random.seed(seed) meta.random_state = random.getstate() meta.auc = meta.model.auc(self.aa_ori, self.pt_sorted.pt) return meta
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 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 sort_models(self, fct_ca=0, heuristic=False): cps = generate_categories_profiles(self.categories) # metas_sorted = sorted(self.metas, key = lambda (k): k.ca, # reverse = True) if not heuristic: if fct_ca == 1: metas_sorted = sorted(self.metas, key=lambda k: k.ca_good, reverse=True) elif fct_ca == 2: metas_sorted = sorted(self.metas, key=lambda k: k.ca_good + k.ca, reverse=True) elif fct_ca == 3: metas_sorted = sorted(self.metas, key=lambda k: 1000 * k.ca_good + k.ca, reverse=True) else: metas_sorted = sorted(self.metas, key=lambda k: k.ca, reverse=True) else: for m in self.metas: #print(self.pt_sorted) modelh = MRSort(copy.deepcopy(m.model.criteria), copy.deepcopy(m.model.cv), copy.deepcopy(m.model.bpt), copy.deepcopy(m.model.lbda), cps) #self.clone_model(self.modelh,self.model) #import pdb; pdb.set_trace() wtotal = 1 - modelh.cv["c1"].value modelh.cv["c1"].value = 0 #print(wtotal, modelh.cv) # if wtotal != 0: # for el in modelh.cv: # el.value /= wtotal modelh.bpt['b1'].performances["c1"] = 0 # print(modelh.criteria,self.pt_sorted.pt) aa_learned = modelh.get_assignments(self.pt_sorted.pt) cah = 0 for alt in self.aa_ori: #print(alt) #import pdb; pdb.set_trace() if alt.category_id == aa_learned(alt.id): cah += 1 m.cah = cah / m.meta.na #if m.num == 0: # print(wtotal, modelh.cv,modelh.lbda) #import pdb; pdb.set_trace() metas_sorted = sorted(self.metas, key=lambda k: ((k.ca) - k.cah), reverse=True) return metas_sorted
def init_one_meta(self, seed): cps = generate_categories_profiles(self.categories) model = MRSort(self.criteria, None, None, None, cps) model.id = 'model_%d' % seed meta = MetaMRSortCV4(model, self.pt_sorted, self.aa_ori, self.lp_weights, self.heur_profiles, self.lp_veto_weights, self.heur_veto_profiles) random.seed(seed) meta.random_state = random.getstate() meta.auc = meta.model.auc(self.aa_ori, self.pt_sorted.pt) return meta
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 test001(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) ap1 = AlternativePerformances('a1', {'c1': 0.3, 'c2': 0.3, 'c3': 0.3}) ap2 = AlternativePerformances('a2', {'c1': 0.8, 'c2': 0.8, 'c3': 0.8}) ap3 = AlternativePerformances('a3', {'c1': 0.3, 'c2': 0.3, 'c3': 0.1}) ap4 = AlternativePerformances('a4', {'c1': 0.3, 'c2': 0.1, 'c3': 0.3}) ap5 = AlternativePerformances('a5', {'c1': 0.1, 'c2': 0.3, 'c3': 0.3}) ap6 = AlternativePerformances('a6', {'c1': 0.8, 'c2': 0.8, 'c3': 0.1}) ap7 = AlternativePerformances('a7', {'c1': 0.8, 'c2': 0.1, 'c3': 0.8}) ap8 = AlternativePerformances('a8', {'c1': 0.1, 'c2': 0.8, 'c3': 0.8}) pt = PerformanceTable([ap1, ap2, ap3, ap4, ap5, ap6, ap7, ap8]) aa = model.get_assignments(pt) self.assertEqual(aa['a1'].category_id, "cat2") self.assertEqual(aa['a2'].category_id, "cat1") self.assertEqual(aa['a3'].category_id, "cat3") self.assertEqual(aa['a4'].category_id, "cat2") self.assertEqual(aa['a5'].category_id, "cat2") self.assertEqual(aa['a6'].category_id, "cat3") self.assertEqual(aa['a7'].category_id, "cat1") self.assertEqual(aa['a8'].category_id, "cat1")
def test001(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) ap1 = AlternativePerformances('a1', {'c1': 0.3, 'c2': 0.3, 'c3': 0.3}) ap2 = AlternativePerformances('a2', {'c1': 0.8, 'c2': 0.8, 'c3': 0.8}) ap3 = AlternativePerformances('a3', {'c1': 0.3, 'c2': 0.3, 'c3': 0.1}) ap4 = AlternativePerformances('a4', {'c1': 0.3, 'c2': 0.1, 'c3': 0.3}) ap5 = AlternativePerformances('a5', {'c1': 0.1, 'c2': 0.3, 'c3': 0.3}) ap6 = AlternativePerformances('a6', {'c1': 0.8, 'c2': 0.8, 'c3': 0.1}) ap7 = AlternativePerformances('a7', {'c1': 0.8, 'c2': 0.1, 'c3': 0.8}) ap8 = AlternativePerformances('a8', {'c1': 0.1, 'c2': 0.8, 'c3': 0.8}) pt = PerformanceTable([ap1, ap2, ap3, ap4, ap5, ap6, ap7, ap8]) aa = model.get_assignments(pt) self.assertEqual(aa['a1'].category_id, "cat2") self.assertEqual(aa['a2'].category_id, "cat1") self.assertEqual(aa['a3'].category_id, "cat3") self.assertEqual(aa['a4'].category_id, "cat2") self.assertEqual(aa['a5'].category_id, "cat2") self.assertEqual(aa['a6'].category_id, "cat3") self.assertEqual(aa['a7'].category_id, "cat1") self.assertEqual(aa['a8'].category_id, "cat1")
def generate_random_mrsort_choquet_model(ncrit, ncat, additivity=None, seed=None, k=3, worst=None, best=None, random_direction=False): if seed is not None: random.seed(int(seed)) c = generate_criteria(ncrit, random_direction=random_direction) if worst is None: worst = generate_worst_ap(c) if best is None: best = generate_best_ap(c) cv = generate_random_mobius_indices(c, additivity, None, k) cat = generate_categories(ncat) cps = generate_categories_profiles(cat) b = cps.get_ordered_profiles() bpt = generate_random_profiles(b, c, None, k, worst, best) lbda = round(random.uniform(0.5, 1), k) return MRSort(c, cv, bpt, lbda, cps)
def generate_random_mrsort_model_msjp(ncrit, ncat, seed = None, k = 3, worst = None, best = None, random_direction = False, random_directions = None): if seed is not None: random.seed(int(seed)) random.seed() #random.seed(int(random.random()*100)) c = generate_criteria_msjp(ncrit, random_direction = random_direction, random_directions = random_directions) random.seed() if worst is None: worst = generate_worst_ap(c) if best is None: best = generate_best_ap(c) random.seed() cv = generate_random_criteria_weights(c, None, k) random.seed() cat = generate_categories(ncat) random.seed() cps = generate_categories_profiles(cat) random.seed() b = cps.get_ordered_profiles() random.seed() bpt = generate_random_profiles(b, c, None, k, worst, best) random.seed() # random.seed(int(random.random()*100)) lbda = round(random.uniform(0.5, 1), k) #import pdb; pdb.set_trace() return MRSort(c, cv, bpt, lbda, cps)
def generate_random_mrsort_model_msjp(ncrit, ncat, seed = None, k = 3, worst = None, best = None, random_direction = False, random_directions = None, fixed_w1 = None, min_w = 0.05, prof_threshold = 0.05): if seed is not None: random.seed(int(seed)) random.seed() #random.seed(int(random.random()*100)) c = generate_criteria_msjp(ncrit, random_direction = random_direction, random_directions = random_directions) random.seed() if worst is None: worst = generate_worst_ap(c) if best is None: best = generate_best_ap(c) no_min_w = True while no_min_w: random.seed() cv = generate_random_criteria_weights_msjp(c, None, k, fixed_w1) #import pdb; pdb.set_trace() if [i for i in list(cv.values()) if i.value < min_w] == []: # and [i for i in list(cv.values()) if i.value == 0] == [] : no_min_w = False # if cv["c1"].value < 0.1: # #print([i.value for i in list(cv.values())]) # maxi = max([i.value for i in list(cv.values())]) # for i in list(cv.values()): # if maxi == i.value: # i.value = round(i.value-0.05,k) # break # cv["c1"].value = round(cv["c1"].value+0.05,k) #print([i.value for i in list(cv.values())]) #import pdb; pdb.set_trace() random.seed() cat = generate_categories_msjp(ncat) random.seed() cps = generate_categories_profiles(cat) random.seed() b = cps.get_ordered_profiles() random.seed() bpt = generate_random_profiles(b, c, None, k, worst, best, prof_threshold = prof_threshold) random.seed() #random.seed(int(random.random()*100)) #lbda = round(random.uniform(0.5, 1), k) # to avoid a dictotorial criteria, we have: #import pdb; pdb.set_trace() lbda = round(random.uniform(max(0.5,cv.max())+0.01, 1), k) #import pdb; pdb.set_trace() #print(cv.max(),lbda) return MRSort(c, cv, bpt, lbda, cps)
def get_output_model(self, criteria): cat_profiles = self.parse_xmcda_file("cat_profiles.xml", "categoriesProfiles", CategoriesProfiles) compatible_alts = self.parse_xmcda_file("compatible_alts.xml", "alternatives", Alternatives) crit_weights = self.parse_xmcda_file("crit_weights.xml", "criteriaValues", CriteriaValues) profiles_perfs = self.parse_xmcda_file("profiles_perfs.xml", "performanceTable", PerformanceTable) lbda = self.parse_xmcda_file_lbda("lambda.xml") return MRSort(criteria, crit_weights, profiles_perfs, lbda, cat_profiles)
def parse_input_files(indir): criteria = parse_xmcda_file(indir + '/criteria.xml', "criteria", Criteria) alternatives = parse_xmcda_file(indir + '/alternatives.xml', "alternatives", Alternatives) categories = parse_xmcda_file(indir + '/categories.xml', "categories", Categories) pt = parse_xmcda_file(indir + '/perfs_table.xml', "performanceTable", PerformanceTable) assignments = parse_xmcda_file(indir + '/assign.xml', "alternativesAffectations", AlternativesAssignments) # Optional parameters params = parse_xmcda_file(indir + '/params.xml', "methodParameters", Parameters) # Partial inference categories_profiles = parse_xmcda_file(indir + '/cat_profiles.xml', "categoriesProfiles", CategoriesProfiles) bpt = parse_xmcda_file(indir + '/profiles_perfs.xml', "performanceTable", PerformanceTable) criteria_values = parse_xmcda_file(indir + '/crit_weights.xml', "criteriaValues", CriteriaValues) if criteria_values: criteria_values.normalize_sum_to_unity() lbda = None solver = DEFAULT_SOLVER if params is not None: if 'lambda' in params: lbda = params['lambda'].value if 'solver' in params: solver = params['solver'].value if categories_profiles is None: categories_profiles = generate_categories_profiles(categories) if categories and criteria and pt: model = MRSort(criteria, criteria_values, bpt, lbda, categories_profiles) else: model = None return solver, model, assignments, pt
def parse_input_files(indir): criteria = parse_xmcda_file(indir + '/criteria.xml', "criteria", Criteria) alternatives = parse_xmcda_file(indir + '/alternatives.xml', "alternatives", Alternatives) categories = parse_xmcda_file(indir + '/categories.xml', "categories", Categories) pt = parse_xmcda_file(indir + '/perfs_table.xml', "performanceTable", PerformanceTable) assignments = parse_xmcda_file(indir + '/assign.xml', "alternativesAffectations", AlternativesAssignments) meta_params = parse_xmcda_file(indir + '/params.xml', "methodParameters", Parameters) categories_profiles = generate_categories_profiles(categories) if categories and criteria and pt: model = MRSort(criteria, None, None, None, categories_profiles) else: model = None return model, assignments, pt, meta_params
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 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
t1 = time.time() if algo == 'meta_mrsort': heur_init_profiles = HeurMRSortInitProfiles lp_weights = LpMRSortWeights heur_profiles = MetaMRSortProfiles4 elif algo == 'meta_mrsortc': heur_init_profiles = HeurMRSortInitProfiles lp_weights = LpMRSortMobius heur_profiles = MetaMRSortProfilesChoquet if algo == 'meta_mrsort' or algo == 'meta_mrsortc': model_type = 'mrsort' cat_profiles = generate_categories_profiles(data.cats) model = MRSort(data.c, None, None, None, cat_profiles) pt_sorted = SortedPerformanceTable(data.pt) meta = MetaMRSortPop3(nmodels, model.criteria, model.categories_profiles.to_categories(), pt_sorted, data.aa, heur_init_profiles, lp_weights, heur_profiles) for i in range(0, nloop): model, ca_learning = meta.optimize(nmeta) print(ca_learning) if ca_learning == 1: break elif algo == 'mip_mrsort': model_type = 'mrsort' cat_profiles = generate_categories_profiles(data.cats)
def test001(self): model = generate_random_mrsort_model(5, 3) mxmcda = model.to_xmcda() model2 = MRSort().from_xmcda(mxmcda) self.assertEqual(model, model2)
xmcda_models_toshow = [] xmcda_models = [] for f in sys.argv[1:]: if not os.path.isfile(f): xmcda_models_toshow.append(f) continue if is_bz2_file(f) is True: f = bz2.BZ2File(f) tree = ElementTree.parse(f) root = tree.getroot() xmcda_models = root.findall(".//ElectreTri") m = MRSort().from_xmcda(xmcda_models[0]) pt_learning = PerformanceTable().from_xmcda(root, 'learning_set') aa_learning = AlternativesAssignments().from_xmcda(root, 'learning_set') uniquevalues = pt_learning.get_unique_values() bname = os.path.basename(os.path.splitext(f.name)[0]) fweights = open('%s-w.dat' % bname, 'w+') fprofiles = open('%s-p.dat' % bname, 'w+') print("Processing %s..." % bname) criteria = m.criteria.keys() for c in criteria: print("{%s} " % criteria_names[c], end='', file=fprofiles)
cv12 = CriterionValue(CriteriaSet(['c1', 'c2']), -0.1) cv13 = CriterionValue(CriteriaSet(['c1', 'c3']), 0.1) cv14 = CriterionValue(CriteriaSet(['c1', 'c4']), -0.1) cv15 = CriterionValue(CriteriaSet(['c1', 'c5']), 0.1) cv23 = CriterionValue(CriteriaSet(['c2', 'c3']), 0.1) cv24 = CriterionValue(CriteriaSet(['c2', 'c4']), -0.1) cv25 = CriterionValue(CriteriaSet(['c2', 'c5']), 0.1) cv34 = CriterionValue(CriteriaSet(['c3', 'c4']), 0.1) cv35 = CriterionValue(CriteriaSet(['c3', 'c5']), -0.1) cv45 = CriterionValue(CriteriaSet(['c4', 'c5']), -0.1) cvs = CriteriaValues([cv1, cv2, cv3, cv4, cv5, cv12, cv13, cv14, cv15, cv23, cv24, cv25, cv34, cv35, cv45]) lbda = 0.6 model = MRSort(c, cvs, bpt, lbda, cps) print(model.lbda, model.cv) a = generate_alternatives(1000) pt = generate_random_performance_table(a, model.criteria) aa = model.get_assignments(pt) lp = LpMRSortMobius(model, pt, aa) lp.solve() print(model.lbda, model.cv) aa2 = model.get_assignments(pt) for a in aa:
from pymcda.generate import generate_criteria from pymcda.generate import generate_categories from pymcda.generate import generate_categories_profiles from pymcda.utils import print_pt_and_assignments from pymcda.utils import compute_number_of_winning_coalitions from pymcda.pt_sorted import SortedPerformanceTable from pymcda.ui.graphic import display_electre_tri_models from pymcda.electre_tri import MRSort from pymcda.types import CriterionValue, CriteriaValues from pymcda.types import AlternativePerformances, PerformanceTable from pymcda.types import AlternativeAssignment, AlternativesAssignments # Generate a random ELECTRE TRI BM model random.seed(127890123456789) ncriteria = 5 model = MRSort() model.criteria = generate_criteria(ncriteria) model.cv = CriteriaValues([CriterionValue('c%d' % (i + 1), 0.2) for i in range(ncriteria)]) b1 = AlternativePerformances('b1', {'c%d' % (i + 1): 0.5 for i in range(ncriteria)}) model.bpt = PerformanceTable([b1]) cat = generate_categories(2) model.categories_profiles = generate_categories_profiles(cat) model.lbda = 0.6 vb1 = AlternativePerformances('b1', {'c%d' % (i + 1): random.uniform(0,0.4) for i in range(ncriteria)}) model.veto = PerformanceTable([vb1]) model.veto_weights = model.cv.copy() model.veto_lbda = 0.4
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
xmcda_csets = root.findall(".//criteriaSets") f.close() ## Weights w = CriteriaValues() for c in criteria: w.append(CriterionValue(c.id, 0.2)) ## Profiles and categories bp1 = AlternativePerformances('b1', {c.id: 0.5 for c in criteria}) bpt = PerformanceTable([bp1]) cat = generate_categories(2, names = ['good', 'bad']) cps = generate_categories_profiles(cat) ## Model model = MRSort(c, w, bpt, 0.6, cps) fmins = [] results = [] for i, xmcda in enumerate(xmcda_csets): result = {} fmins = CriteriaSets().from_xmcda(xmcda) result['fmins'] = fmins result['vector'] = "".join(map(str, sorted([len(fmin) for fmin in sorted(fmins, key = len)]))) print("\n%d. Fmin: %s" % (i + 1, ', '.join("%s" % f for f in fmins))) pt, aa = generate_binary_performance_table_and_assignments(criteria, cat, fmins) aa.id = 'aa' a = Alternatives([Alternative(a.id) for a in aa])
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
w5 = CriterionValue('c5', 0.2) w = CriteriaValues([w1, w2, w3, w4, w5]) ## Profiles and categories b1 = AlternativePerformances('b1', {'c1': 10, 'c2': 10, 'c3': 10, 'c4': 10, 'c5': 10}) bpt = PerformanceTable([b1]) cat = generate_categories(2) cps = generate_categories_profiles(cat) ## Veto thresholds vb1 = AlternativePerformances('b1', {'c1': 2, 'c2': 2, 'c3': 2, 'c4': 2, 'c5': 2}, 'b1') v = PerformanceTable([vb1]) vw = w.copy() model = MRSort(c, w, bpt, 0.6, cps, v, vw, 0.4) # Altenatives a1 = AlternativePerformances('a1', {'c1': 9, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 11}) a2 = AlternativePerformances('a2', {'c1': 9, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 9}) a3 = AlternativePerformances('a3', {'c1': 9, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 11}) a4 = AlternativePerformances('a4', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 9}) a5 = AlternativePerformances('a5', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 11}) a6 = AlternativePerformances('a6', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 9}) a7 = AlternativePerformances('a7', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 11}) a8 = AlternativePerformances('a8', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 9}) a9 = AlternativePerformances('a9', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 11}) a10 = AlternativePerformances('a10', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 9}) a11 = AlternativePerformances('a11', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 11}) a12 = AlternativePerformances('a12', {'c1': 9, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 9}) a13 = AlternativePerformances('a13', {'c1': 9, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 11})
xmcda_models_toshow = [] xmcda_models = [] for f in sys.argv[1:]: if not os.path.isfile(f): xmcda_models_toshow.append(f) continue if is_bz2_file(f) is True: f = bz2.BZ2File(f) tree = ElementTree.parse(f) root = tree.getroot() xmcda_models = root.findall(".//ElectreTri") m = MRSort().from_xmcda(xmcda_models[0]) bname = os.path.basename(os.path.splitext(f.name)[0]) fweights = open('%s-w.dat' % bname, 'w+') fprofiles = open('%s-p.dat' % bname, 'w+') print("Processing %s..." % bname) ncriteria = len(m.criteria) for c in m.criteria.keys(): criteria_names[c] = c criteria_worst[c] = 0 criteria_best[c] = 1 criteria_order = sorted(m.criteria.keys()) criteria_discarded = {c: 0 for c in criteria_order}
cv12 = CriterionValue(CriteriaSet(['c1', 'c2']), -0.1) cv13 = CriterionValue(CriteriaSet(['c1', 'c3']), 0.1) cv14 = CriterionValue(CriteriaSet(['c1', 'c4']), -0.1) cv15 = CriterionValue(CriteriaSet(['c1', 'c5']), 0.1) cv23 = CriterionValue(CriteriaSet(['c2', 'c3']), 0.1) cv24 = CriterionValue(CriteriaSet(['c2', 'c4']), -0.1) cv25 = CriterionValue(CriteriaSet(['c2', 'c5']), 0.1) cv34 = CriterionValue(CriteriaSet(['c3', 'c4']), 0.1) cv35 = CriterionValue(CriteriaSet(['c3', 'c5']), -0.1) cv45 = CriterionValue(CriteriaSet(['c4', 'c5']), -0.1) cvs = CriteriaValues([cv1, cv2, cv3, cv4, cv5, cv12, cv13, cv14, cv15, cv23, cv24, cv25, cv34, cv35, cv45]) lbda = 0.6 model = MRSort(c, cvs, bpt, lbda, cps) print(model.lbda, model.cv) a = generate_alternatives(1000) pt = generate_random_performance_table(a, model.criteria) aa = model.get_assignments(pt) model.cv = None model.lbda = None mip = MipMRSortMobius(model, pt, aa) mip.solve() print(model.lbda, model.cv) aa2 = model.get_assignments(pt)
cv14 = CriterionValue(CriteriaSet(['c1', 'c4']), -0.1) cv15 = CriterionValue(CriteriaSet(['c1', 'c5']), 0.1) cv23 = CriterionValue(CriteriaSet(['c2', 'c3']), 0.1) cv24 = CriterionValue(CriteriaSet(['c2', 'c4']), -0.1) cv25 = CriterionValue(CriteriaSet(['c2', 'c5']), 0.1) cv34 = CriterionValue(CriteriaSet(['c3', 'c4']), 0.1) cv35 = CriterionValue(CriteriaSet(['c3', 'c5']), -0.1) cv45 = CriterionValue(CriteriaSet(['c4', 'c5']), -0.1) cvs = CriteriaValues([ cv1, cv2, cv3, cv4, cv5, cv12, cv13, cv14, cv15, cv23, cv24, cv25, cv34, cv35, cv45 ]) lbda = 0.6 model = MRSort(c, cvs, bpt, lbda, cps) print(model.lbda, model.cv) a = generate_alternatives(1000) pt = generate_random_performance_table(a, model.criteria) aa = model.get_assignments(pt) lp = LpMRSortMobius(model, pt, aa) lp.solve() print(model.lbda, model.cv) aa2 = model.get_assignments(pt) for a in aa:
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_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
for f in sys.argv[1:]: if not os.path.isfile(f): xmcda_models_toshow.append(f) continue if is_bz2_file(f) is True: f = bz2.BZ2File(f) tree = ElementTree.parse(f) root = tree.getroot() xmcda_models += root.findall(".//ElectreTri") models = [] for xmcda_model in xmcda_models: m = MRSort().from_xmcda(xmcda_model) if len(xmcda_models_toshow) > 0 and m.id not in xmcda_models_toshow: continue string = "Model '%s'" % m.id print(string) print('=' * len(string)) print(m.bpt) print(m.cv) print("lambda: %s\n" % m.lbda) if m.veto is not None: print(m.veto) else:
cat = generate_categories(2) cps = generate_categories_profiles(cat) ## Veto thresholds vb1 = AlternativePerformances('b1', { 'c1': 2, 'c2': 2, 'c3': 2, 'c4': 2, 'c5': 2 }, 'b1') v = PerformanceTable([vb1]) vw = w.copy() model = MRSort(c, w, bpt, 0.6, cps, v, vw, 0.4) # Altenatives a1 = AlternativePerformances('a1', { 'c1': 9, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 11 }) a2 = AlternativePerformances('a2', { 'c1': 9, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 9
table_auc_test = [] cmatrix_learning = {} cmatrix_test = {} DATADIR = os.getenv('DATADIR', '%s/pymcda-data' % os.path.expanduser('~')) directory='%s/test-veto2' % (DATADIR) for f in sys.argv[1:]: fname = os.path.splitext(os.path.basename(f))[0] if is_bz2_file(f) is True: f = bz2.BZ2File(f) 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) # # Remove alternatives that cannot be corrected with a veto rule # aa_learning_m2p = discard_undersorted_alternatives(m.categories, # aa_learning,
t1 = time.time() if algo == 'meta_mrsort': heur_init_profiles = HeurMRSortInitProfiles lp_weights = LpMRSortWeights heur_profiles = MetaMRSortProfiles4 elif algo == 'meta_mrsortc': heur_init_profiles = HeurMRSortInitProfiles lp_weights = LpMRSortMobius heur_profiles = MetaMRSortProfilesChoquet if algo == 'meta_mrsort' or algo == 'meta_mrsortc': model_type = 'mrsort' cat_profiles = generate_categories_profiles(data.cats) model = MRSort(data.c, None, None, None, cat_profiles) pt_sorted = SortedPerformanceTable(data.pt) meta = MetaMRSortPop3(nmodels, model.criteria, model.categories_profiles.to_categories(), pt_sorted, data.aa, heur_init_profiles, lp_weights, heur_profiles) for i in range(0, nloop): model, ca_learning = meta.optimize(nmeta) print(ca_learning) if ca_learning == 1: break elif algo == 'mip_mrsort':
table_auc_learning = [] table_auc_test = [] cmatrix_learning = {} cmatrix_test = {} nveto = 0 for f in sys.argv[1:]: f = os.path.abspath(f) if is_bz2_file(f) is True: f = bz2.BZ2File(f) import pdb 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_learning = [] table_ca_test = [] table_auc_learning = [] table_auc_test = [] cmatrix_learning = {} cmatrix_test = {} nveto = 0 for f in sys.argv[1:]: if is_bz2_file(f) is True: f = bz2.BZ2File(f) 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)
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 test001(self): c = generate_criteria(5) w1 = CriterionValue('c1', 0.2) w2 = CriterionValue('c2', 0.2) w3 = CriterionValue('c3', 0.2) w4 = CriterionValue('c4', 0.2) w5 = CriterionValue('c5', 0.2) w = CriteriaValues([w1, w2, w3, w4, w5]) b1 = AlternativePerformances('b1', { 'c1': 10, 'c2': 10, 'c3': 10, 'c4': 10, 'c5': 10 }) bpt = PerformanceTable([b1]) cat = generate_categories(2) cps = generate_categories_profiles(cat) vb1 = AlternativePerformances('b1', { 'c1': 2, 'c2': 2, 'c3': 2, 'c4': 2, 'c5': 2 }, 'b1') v = PerformanceTable([vb1]) vw = w.copy() a1 = AlternativePerformances('a1', { 'c1': 9, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 11 }) a2 = AlternativePerformances('a2', { 'c1': 9, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 9 }) a3 = AlternativePerformances('a3', { 'c1': 9, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 11 }) a4 = AlternativePerformances('a4', { 'c1': 9, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 9 }) a5 = AlternativePerformances('a5', { 'c1': 9, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 11 }) a6 = AlternativePerformances('a6', { 'c1': 9, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 9 }) a7 = AlternativePerformances('a7', { 'c1': 9, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 11 }) a8 = AlternativePerformances('a8', { 'c1': 9, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 9 }) a9 = AlternativePerformances('a9', { 'c1': 9, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 11 }) a10 = AlternativePerformances('a10', { 'c1': 9, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 9 }) a11 = AlternativePerformances('a11', { 'c1': 9, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 11 }) a12 = AlternativePerformances('a12', { 'c1': 9, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 9 }) a13 = AlternativePerformances('a13', { 'c1': 9, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 11 }) a14 = AlternativePerformances('a14', { 'c1': 9, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 9 }) a15 = AlternativePerformances('a15', { 'c1': 9, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 11 }) a16 = AlternativePerformances('a16', { 'c1': 11, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 9 }) a17 = AlternativePerformances('a17', { 'c1': 11, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 11 }) a18 = AlternativePerformances('a18', { 'c1': 11, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 9 }) a19 = AlternativePerformances('a19', { 'c1': 11, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 11 }) a20 = AlternativePerformances('a20', { 'c1': 11, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 9 }) a21 = AlternativePerformances('a21', { 'c1': 11, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 11 }) a22 = AlternativePerformances('a22', { 'c1': 11, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 9 }) a23 = AlternativePerformances('a23', { 'c1': 11, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 11 }) a24 = AlternativePerformances('a24', { 'c1': 11, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 9 }) a25 = AlternativePerformances('a25', { 'c1': 11, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 11 }) a26 = AlternativePerformances('a26', { 'c1': 11, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 9 }) a27 = AlternativePerformances('a27', { 'c1': 11, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 11 }) a28 = AlternativePerformances('a28', { 'c1': 11, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 9 }) a29 = AlternativePerformances('a29', { 'c1': 11, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 11 }) a30 = AlternativePerformances('a30', { 'c1': 11, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 9 }) a31 = AlternativePerformances('a31', { 'c1': 11, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 7 }) a32 = AlternativePerformances('a32', { 'c1': 11, 'c2': 11, 'c3': 11, 'c4': 7, 'c5': 11 }) a33 = AlternativePerformances('a33', { 'c1': 11, 'c2': 11, 'c3': 7, 'c4': 11, 'c5': 11 }) a34 = AlternativePerformances('a34', { 'c1': 11, 'c2': 7, 'c3': 11, 'c4': 11, 'c5': 11 }) a35 = AlternativePerformances('a35', { 'c1': 7, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 11 }) a36 = AlternativePerformances('a36', { 'c1': 11, 'c2': 11, 'c3': 11, 'c4': 7, 'c5': 7 }) a37 = AlternativePerformances('a37', { 'c1': 11, 'c2': 11, 'c3': 7, 'c4': 11, 'c5': 7 }) a38 = AlternativePerformances('a38', { 'c1': 11, 'c2': 7, 'c3': 11, 'c4': 11, 'c5': 7 }) a39 = AlternativePerformances('a39', { 'c1': 7, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 7 }) a40 = AlternativePerformances('a40', { 'c1': 11, 'c2': 11, 'c3': 7, 'c4': 7, 'c5': 11 }) a41 = AlternativePerformances('a41', { 'c1': 11, 'c2': 7, 'c3': 11, 'c4': 7, 'c5': 11 }) a42 = AlternativePerformances('a42', { 'c1': 7, 'c2': 11, 'c3': 11, 'c4': 7, 'c5': 11 }) a43 = AlternativePerformances('a43', { 'c1': 11, 'c2': 7, 'c3': 7, 'c4': 11, 'c5': 11 }) a44 = AlternativePerformances('a44', { 'c1': 7, 'c2': 11, 'c3': 7, 'c4': 11, 'c5': 11 }) a45 = AlternativePerformances('a45', { 'c1': 7, 'c2': 7, 'c3': 11, 'c4': 11, 'c5': 11 }) pt = PerformanceTable([ a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45 ]) ap1 = AlternativeAssignment('a1', 'cat2') ap2 = AlternativeAssignment('a2', 'cat2') ap3 = AlternativeAssignment('a3', 'cat2') ap4 = AlternativeAssignment('a4', 'cat2') ap5 = AlternativeAssignment('a5', 'cat2') ap6 = AlternativeAssignment('a6', 'cat2') ap7 = AlternativeAssignment('a7', 'cat1') ap8 = AlternativeAssignment('a8', 'cat2') ap9 = AlternativeAssignment('a9', 'cat2') ap10 = AlternativeAssignment('a10', 'cat2') ap11 = AlternativeAssignment('a11', 'cat1') ap12 = AlternativeAssignment('a12', 'cat2') ap13 = AlternativeAssignment('a13', 'cat1') ap14 = AlternativeAssignment('a14', 'cat1') ap15 = AlternativeAssignment('a15', 'cat1') ap16 = AlternativeAssignment('a16', 'cat2') ap17 = AlternativeAssignment('a17', 'cat2') ap18 = AlternativeAssignment('a18', 'cat2') ap19 = AlternativeAssignment('a19', 'cat1') ap20 = AlternativeAssignment('a20', 'cat2') ap21 = AlternativeAssignment('a21', 'cat1') ap22 = AlternativeAssignment('a22', 'cat1') ap23 = AlternativeAssignment('a23', 'cat1') ap24 = AlternativeAssignment('a24', 'cat2') ap25 = AlternativeAssignment('a25', 'cat1') ap26 = AlternativeAssignment('a26', 'cat1') ap27 = AlternativeAssignment('a27', 'cat1') ap28 = AlternativeAssignment('a28', 'cat1') ap29 = AlternativeAssignment('a29', 'cat1') ap30 = AlternativeAssignment('a30', 'cat1') ap31 = AlternativeAssignment('a31', 'cat1') ap32 = AlternativeAssignment('a32', 'cat1') ap33 = AlternativeAssignment('a33', 'cat1') ap34 = AlternativeAssignment('a34', 'cat1') ap35 = AlternativeAssignment('a35', 'cat1') ap36 = AlternativeAssignment('a36', 'cat2') ap37 = AlternativeAssignment('a37', 'cat2') ap38 = AlternativeAssignment('a38', 'cat2') ap39 = AlternativeAssignment('a39', 'cat2') ap40 = AlternativeAssignment('a40', 'cat2') ap41 = AlternativeAssignment('a41', 'cat2') ap42 = AlternativeAssignment('a42', 'cat2') ap43 = AlternativeAssignment('a43', 'cat2') ap44 = AlternativeAssignment('a44', 'cat2') ap45 = AlternativeAssignment('a45', 'cat2') aa = AlternativesAssignments([ ap1, ap2, ap3, ap4, ap5, ap6, ap7, ap8, ap9, ap10, ap11, ap12, ap13, ap14, ap15, ap16, ap17, ap18, ap19, ap20, ap21, ap22, ap23, ap24, ap25, ap26, ap27, ap28, ap29, ap30, ap31, ap32, ap33, ap34, ap35, ap36, ap37, ap38, ap39, ap40, ap41, ap42, ap43, ap44, ap45 ]) model = MRSort(c, w, bpt, 0.6, cps, v, vw, 0.4) aa2 = model.pessimist(pt) ok = compare_assignments(aa, aa2) self.assertEqual(ok, 1, "One or more alternatives were wrongly " "assigned")
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 test001(self): c = generate_criteria(5) w1 = CriterionValue('c1', 0.2) w2 = CriterionValue('c2', 0.2) w3 = CriterionValue('c3', 0.2) w4 = CriterionValue('c4', 0.2) w5 = CriterionValue('c5', 0.2) w = CriteriaValues([w1, w2, w3, w4, w5]) b1 = AlternativePerformances('b1', {'c1': 10, 'c2': 10, 'c3': 10, 'c4': 10, 'c5': 10}) bpt = PerformanceTable([b1]) cat = generate_categories(2) cps = generate_categories_profiles(cat) vb1 = AlternativePerformances('b1', {'c1': 2, 'c2': 2, 'c3': 2, 'c4': 2, 'c5': 2}, 'b1') v = PerformanceTable([vb1]) vw = w.copy() a1 = AlternativePerformances('a1', {'c1': 9, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 11}) a2 = AlternativePerformances('a2', {'c1': 9, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 9}) a3 = AlternativePerformances('a3', {'c1': 9, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 11}) a4 = AlternativePerformances('a4', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 9}) a5 = AlternativePerformances('a5', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 11}) a6 = AlternativePerformances('a6', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 9}) a7 = AlternativePerformances('a7', {'c1': 9, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 11}) a8 = AlternativePerformances('a8', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 9}) a9 = AlternativePerformances('a9', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 11}) a10 = AlternativePerformances('a10', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 9}) a11 = AlternativePerformances('a11', {'c1': 9, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 11}) a12 = AlternativePerformances('a12', {'c1': 9, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 9}) a13 = AlternativePerformances('a13', {'c1': 9, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 11}) a14 = AlternativePerformances('a14', {'c1': 9, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 9}) a15 = AlternativePerformances('a15', {'c1': 9, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 11}) a16 = AlternativePerformances('a16', {'c1': 11, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 9}) a17 = AlternativePerformances('a17', {'c1': 11, 'c2': 9, 'c3': 9, 'c4': 9, 'c5': 11}) a18 = AlternativePerformances('a18', {'c1': 11, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 9}) a19 = AlternativePerformances('a19', {'c1': 11, 'c2': 9, 'c3': 9, 'c4': 11, 'c5': 11}) a20 = AlternativePerformances('a20', {'c1': 11, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 9}) a21 = AlternativePerformances('a21', {'c1': 11, 'c2': 9, 'c3': 11, 'c4': 9, 'c5': 11}) a22 = AlternativePerformances('a22', {'c1': 11, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 9}) a23 = AlternativePerformances('a23', {'c1': 11, 'c2': 9, 'c3': 11, 'c4': 11, 'c5': 11}) a24 = AlternativePerformances('a24', {'c1': 11, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 9}) a25 = AlternativePerformances('a25', {'c1': 11, 'c2': 11, 'c3': 9, 'c4': 9, 'c5': 11}) a26 = AlternativePerformances('a26', {'c1': 11, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 9}) a27 = AlternativePerformances('a27', {'c1': 11, 'c2': 11, 'c3': 9, 'c4': 11, 'c5': 11}) a28 = AlternativePerformances('a28', {'c1': 11, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 9}) a29 = AlternativePerformances('a29', {'c1': 11, 'c2': 11, 'c3': 11, 'c4': 9, 'c5': 11}) a30 = AlternativePerformances('a30', {'c1': 11, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 9}) a31 = AlternativePerformances('a31', {'c1': 11, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 7}) a32 = AlternativePerformances('a32', {'c1': 11, 'c2': 11, 'c3': 11, 'c4': 7, 'c5': 11}) a33 = AlternativePerformances('a33', {'c1': 11, 'c2': 11, 'c3': 7, 'c4': 11, 'c5': 11}) a34 = AlternativePerformances('a34', {'c1': 11, 'c2': 7, 'c3': 11, 'c4': 11, 'c5': 11}) a35 = AlternativePerformances('a35', {'c1': 7, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 11}) a36 = AlternativePerformances('a36', {'c1': 11, 'c2': 11, 'c3': 11, 'c4': 7, 'c5': 7}) a37 = AlternativePerformances('a37', {'c1': 11, 'c2': 11, 'c3': 7, 'c4': 11, 'c5': 7}) a38 = AlternativePerformances('a38', {'c1': 11, 'c2': 7, 'c3': 11, 'c4': 11, 'c5': 7}) a39 = AlternativePerformances('a39', {'c1': 7, 'c2': 11, 'c3': 11, 'c4': 11, 'c5': 7}) a40 = AlternativePerformances('a40', {'c1': 11, 'c2': 11, 'c3': 7, 'c4': 7, 'c5': 11}) a41 = AlternativePerformances('a41', {'c1': 11, 'c2': 7, 'c3': 11, 'c4': 7, 'c5': 11}) a42 = AlternativePerformances('a42', {'c1': 7, 'c2': 11, 'c3': 11, 'c4': 7, 'c5': 11}) a43 = AlternativePerformances('a43', {'c1': 11, 'c2': 7, 'c3': 7, 'c4': 11, 'c5': 11}) a44 = AlternativePerformances('a44', {'c1': 7, 'c2': 11, 'c3': 7, 'c4': 11, 'c5': 11}) a45 = AlternativePerformances('a45', {'c1': 7, 'c2': 7, 'c3': 11, 'c4': 11, 'c5': 11}) pt = PerformanceTable([a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, a31, a32, a33, a34, a35, a36, a37, a38, a39, a40, a41, a42, a43, a44, a45]) ap1 = AlternativeAssignment('a1', 'cat2') ap2 = AlternativeAssignment('a2', 'cat2') ap3 = AlternativeAssignment('a3', 'cat2') ap4 = AlternativeAssignment('a4', 'cat2') ap5 = AlternativeAssignment('a5', 'cat2') ap6 = AlternativeAssignment('a6', 'cat2') ap7 = AlternativeAssignment('a7', 'cat1') ap8 = AlternativeAssignment('a8', 'cat2') ap9 = AlternativeAssignment('a9', 'cat2') ap10 = AlternativeAssignment('a10', 'cat2') ap11 = AlternativeAssignment('a11', 'cat1') ap12 = AlternativeAssignment('a12', 'cat2') ap13 = AlternativeAssignment('a13', 'cat1') ap14 = AlternativeAssignment('a14', 'cat1') ap15 = AlternativeAssignment('a15', 'cat1') ap16 = AlternativeAssignment('a16', 'cat2') ap17 = AlternativeAssignment('a17', 'cat2') ap18 = AlternativeAssignment('a18', 'cat2') ap19 = AlternativeAssignment('a19', 'cat1') ap20 = AlternativeAssignment('a20', 'cat2') ap21 = AlternativeAssignment('a21', 'cat1') ap22 = AlternativeAssignment('a22', 'cat1') ap23 = AlternativeAssignment('a23', 'cat1') ap24 = AlternativeAssignment('a24', 'cat2') ap25 = AlternativeAssignment('a25', 'cat1') ap26 = AlternativeAssignment('a26', 'cat1') ap27 = AlternativeAssignment('a27', 'cat1') ap28 = AlternativeAssignment('a28', 'cat1') ap29 = AlternativeAssignment('a29', 'cat1') ap30 = AlternativeAssignment('a30', 'cat1') ap31 = AlternativeAssignment('a31', 'cat1') ap32 = AlternativeAssignment('a32', 'cat1') ap33 = AlternativeAssignment('a33', 'cat1') ap34 = AlternativeAssignment('a34', 'cat1') ap35 = AlternativeAssignment('a35', 'cat1') ap36 = AlternativeAssignment('a36', 'cat2') ap37 = AlternativeAssignment('a37', 'cat2') ap38 = AlternativeAssignment('a38', 'cat2') ap39 = AlternativeAssignment('a39', 'cat2') ap40 = AlternativeAssignment('a40', 'cat2') ap41 = AlternativeAssignment('a41', 'cat2') ap42 = AlternativeAssignment('a42', 'cat2') ap43 = AlternativeAssignment('a43', 'cat2') ap44 = AlternativeAssignment('a44', 'cat2') ap45 = AlternativeAssignment('a45', 'cat2') aa = AlternativesAssignments([ap1, ap2, ap3, ap4, ap5, ap6, ap7, ap8, ap9, ap10, ap11, ap12, ap13, ap14, ap15, ap16, ap17, ap18, ap19, ap20, ap21, ap22, ap23, ap24, ap25, ap26, ap27, ap28, ap29, ap30, ap31, ap32, ap33, ap34, ap35, ap36, ap37, ap38, ap39, ap40, ap41, ap42, ap43, ap44, ap45]) model = MRSort(c, w, bpt, 0.6, cps, v, vw, 0.4) aa2 = model.pessimist(pt) ok = compare_assignments(aa, aa2) self.assertEqual(ok, 1, "One or more alternatives were wrongly " "assigned")
ap3 = AlternativePerformances('a3', {'c1': 1, 'c2': 0, 'c3': 1, 'c4': 0}) ap4 = AlternativePerformances('a4', {'c1': 1, 'c2': 0, 'c3': 0, 'c4': 1}) ap5 = AlternativePerformances('a5', {'c1': 0, 'c2': 1, 'c3': 1, 'c4': 0}) ap6 = AlternativePerformances('a6', {'c1': 0, 'c2': 1, 'c3': 0, 'c4': 1}) pt = PerformanceTable([ap1, ap2, ap3, ap4, ap5, ap6]) aa1 = AlternativeAssignment('a1', 'cat1') aa2 = AlternativeAssignment('a2', 'cat1') aa3 = AlternativeAssignment('a3', 'cat2') aa4 = AlternativeAssignment('a4', 'cat2') aa5 = AlternativeAssignment('a5', 'cat2') aa6 = AlternativeAssignment('a6', 'cat2') aa = AlternativesAssignments([aa1, aa2, aa3, aa4, aa5, aa6]) print_pt_and_assignments(aa.keys(), c.keys(), [aa], pt) model = MRSort(c, None, None, None, cps) worst = pt.get_worst(model.criteria) best = pt.get_best(model.criteria) # Run the MIP mip = MipCMRSort(model, pt, aa) mip.solve() # Display learned model parameters print('Learned model') print('=============') model.bpt.display() model.cv.display() print("lambda: %.7s" % model.lbda)
try: pt_learning = PerformanceTable().from_xmcda(root, 'learning_set') except: pt_learning = None try: pt_test = PerformanceTable().from_xmcda(root, 'test_set') except: pt_test = None aa_learning_m1, aa_learning_m2 = None, None aa_test_m1, aa_test_m2 = None, None if root.find("ElectreTri[@id='initial']") is not None: m1 = MRSort().from_xmcda(root, 'initial') if pt_learning is not None: aa_learning_m1 = m1.pessimist(pt_learning) if pt_test is not None: aa_test_m1 = m1.pessimist(pt_test) elif root.find("AVFSort[@id='initial']") is not None: m1 = AVFSort().from_xmcda(root, 'initial') if pt_learning is not None: aa_learning_m1 = m1.get_assignments(pt_learning) if pt_test is not None: aa_test_m1 = m1.get_assignments(pt_test) else: if root.find("alternativesAffectations[@id='learning_set']") is not None: aa_learning_m1 = AlternativesAssignments().from_xmcda(root, 'learning_set')