def solve_cplex(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.MIP_optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
for c in self.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = self.lp.solution.get_values('w_' + c.id)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lp.solution.get_values("lambda")
pt = PerformanceTable()
for p in self.__profiles:
ap = AlternativePerformances(p)
for c in self.criteria:
perf = self.lp.solution.get_values("g_%s_%s" % (p, c.id))
ap.performances[c.id] = round(perf, 5)
pt.append(ap)
self.model.bpt = pt
self.model.bpt.update_direction(self.model.criteria)
return obj
def solve_cplex(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.MIP_optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
m = ['m_%d' % i for i in range(len(self.mindices))]
mindices_map = dict(zip(self.mindices, m))
for m, vname in mindices_map.items():
cv = CriterionValue()
if len(m) > 1:
cv.id = CriteriaSet(m)
else:
cv.id = next(iter(m))
cv.value = self.lp.solution.get_values(vname)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lp.solution.get_values("lambda")
return obj
def solve_glpk(self):
self.lp.solvopt(method='exact', integer='advanced')
self.lp.solve()
status = self.lp.status()
if status != 'opt':
raise RuntimeError("Solver status: %s" % self.lp.status())
#print(self.lp.reportKKT())
obj = self.lp.vobj()
cvs = CriteriaValues()
for c in self.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = float(self.w[c.id].primal)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lbda.primal
pt = PerformanceTable()
for p in self.__profiles:
ap = AlternativePerformances(p)
for c in self.criteria:
perf = self.g[p][c.id].primal
ap.performances[c.id] = round(perf, 5)
pt.append(ap)
self.model.bpt = pt
self.model.bpt.update_direction(self.model.criteria)
return obj
def solve_cplex(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.MIP_optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
for c in self.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = self.lp.solution.get_values('w_' + c.id)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lp.solution.get_values("lambda")
pt = PerformanceTable()
for p in self.__profiles:
ap = AlternativePerformances(p)
for c in self.criteria:
perf = self.lp.solution.get_values("g_%s_%s" % (p, c.id))
ap.performances[c.id] = round(perf, 5)
pt.append(ap)
self.model.bpt = pt
self.model.bpt.update_direction(self.model.criteria)
return obj
def solve_glpk(self):
self.lp.solvopt(method='exact', integer='advanced')
self.lp.solve()
status = self.lp.status()
if status != 'opt':
raise RuntimeError("Solver status: %s" % self.lp.status())
#print(self.lp.reportKKT())
obj = self.lp.vobj()
cvs = CriteriaValues()
for c in self.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = float(self.w[c.id].primal)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lbda.primal
pt = PerformanceTable()
for p in self.__profiles:
ap = AlternativePerformances(p)
for c in self.criteria:
perf = self.g[p][c.id].primal
ap.performances[c.id] = round(perf, 5)
pt.append(ap)
self.model.bpt = pt
self.model.bpt.update_direction(self.model.criteria)
return obj
def solve_cplex(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
m = ['m_%d' % i for i in range(len(self.mindices))]
mindices_map = dict(zip(self.mindices, m))
for m, vname in mindices_map.items():
cv = CriterionValue()
if len(m) > 1:
cv.id = CriteriaSet(m)
else:
cv.id = next(iter(m))
cv.value = self.lp.solution.get_values(vname)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lp.solution.get_values("lambda")
return obj
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 generate_random_capacities(criteria, seed = None, k = 3):
if seed is not None:
random.seed(seed)
n = len(criteria)
r = [round(random.random(), k) for i in range(2 ** n - 2)] + [1.0]
r.sort()
j = 0
cvs = CriteriaValues()
for i in range(1, n + 1):
combis = [c for c in combinations(criteria.keys(), i)]
random.shuffle(combis)
for combi in combis:
if i == 1:
cid = combi[0]
else:
cid = CriteriaSet(combi)
cv = CriterionValue(cid, r[j])
cvs.append(cv)
j += 1
return cvs
def generate_random_criteria_values(crits, seed = None, k = 3,
type = 'float', vmin = 0, vmax = 1):
if seed is not None:
random.seed(seed)
cvals = CriteriaValues()
for c in crits:
cval = CriterionValue()
cval.id = c.id
if type == 'integer':
cval.value = random.randint(vmin, vmax)
else:
cval.value = round(random.uniform(vmin, vmax), k)
cvals.append(cval)
return cvals
def generate_random_criteria_values(crits, seed = None, k = 3,
type = 'float', vmin = 0, vmax = 1):
if seed is not None:
random.seed(seed)
cvals = CriteriaValues()
for c in crits:
cval = CriterionValue()
cval.id = c.id
if type == 'integer':
cval.value = random.randint(vmin, vmax)
else:
cval.value = round(random.uniform(vmin, vmax), k)
cvals.append(cval)
return cvals
def solve_scip(self):
solution = self.lp.minimize(objective=self.obj)
if solution is None:
raise RuntimeError("No solution found")
obj = solution.objective
cvs = CriteriaValues()
for c in self.model.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = solution[self.w[c.id]]
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = solution[self.lbda]
return obj
def solve_scip(self):
solution = self.lp.minimize(objective=self.obj)
if solution is None:
raise RuntimeError("No solution found")
obj = solution.objective
cvs = CriteriaValues()
for c in self.model.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = solution[self.w[c.id]]
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = solution[self.lbda]
return obj
def solve(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.MIP_optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
for c in self.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = self.lp.solution.get_values('w_' + c.id)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lp.solution.get_values("lambda")
pt = PerformanceTable()
for p in self.__profiles:
ap = AlternativePerformances(p)
for c in self.criteria:
perf = self.lp.solution.get_values("g_%s_%s" % (p, c.id))
ap.performances[c.id] = round(perf, 5)
pt.append(ap)
self.model.bpt = pt
self.model.bpt.update_direction(self.model.criteria)
wv = CriteriaValues()
for c in self.criteria:
w = CriterionValue()
w.id = c.id
w.value = self.lp.solution.get_values('z_' + c.id)
wv.append(w)
self.model.veto_weights = wv
self.model.veto_lbda = self.lp.solution.get_values("LAMBDA")
v = PerformanceTable()
for p in self.__profiles:
vp = AlternativePerformances(p, {})
for c in self.criteria:
perf = self.lp.solution.get_values('v_%s_%s' % (p, c.id))
vp.performances[c.id] = round(perf, 5)
v.append(vp)
self.model.veto = v
return obj
def solve_cplex(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
for c in self.model.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = self.lp.solution.get_values('w' + c.id)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lp.solution.get_values("lambda")
return obj
def solve_cplex(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
for c in self.model.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = self.lp.solution.get_values('w'+c.id)
cvs.append(cv)
self.model.veto_weights = cvs
self.model.veto_lbda = self.lp.solution.get_values("lambda")
return obj
def solve_glpk(self):
self.lp.solve()
status = self.lp.status()
if status != 'opt':
raise RuntimeError("Solver status: %s" % self.lp.status())
#print(self.lp.reportKKT())
obj = self.lp.vobj()
cvs = CriteriaValues()
for j, c in enumerate(self.model.criteria):
cv = CriterionValue()
cv.id = c.id
cv.value = float(self.w[j].primal)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = float(self.lbda.primal)
return obj
def generate_random_criteria_weights(crits, seed = None, k = 3):
if seed is not None:
random.seed(seed)
weights = [ random.random() for i in range(len(crits) - 1) ]
weights.sort()
cvals = CriteriaValues()
for i, c in enumerate(crits):
cval = CriterionValue()
cval.id = c.id
if i == 0:
cval.value = round(weights[i], k)
elif i == len(crits) - 1:
cval.value = round(1 - weights[i - 1], k)
else:
cval.value = round(weights[i] - weights[i - 1], k)
cvals.append(cval)
return cvals
def solve_glpk(self):
self.lp.solve()
status = self.lp.status()
if status != 'opt':
raise RuntimeError("Solver status: %s" % self.lp.status())
#print(self.lp.reportKKT())
obj = self.lp.vobj()
cvs = CriteriaValues()
for j, c in enumerate(self.model.criteria):
cv = CriterionValue()
cv.id = c.id
cv.value = float(self.w[j].primal)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = float(self.lbda.primal)
return obj
def generate_random_criteria_weights_msjp(crits,
seed=None,
k=3,
fixed_w1=None):
if seed is not None:
random.seed(seed)
if fixed_w1 is None:
weights = [random.random() for i in range(len(crits) - 1)]
else:
weights = [
round(random.uniform(0, 1 - fixed_w1), k)
for i in range(len(crits) - 2)
]
weights = [(fixed_w1 + i) for i in weights]
weights = weights + [round(fixed_w1, k)]
weights.sort()
cvals = CriteriaValues()
for i, c in enumerate(crits):
cval = CriterionValue()
cval.id = c.id
if i == 0:
cval.value = round(weights[i], k)
elif i == len(crits) - 1:
cval.value = round(1 - weights[i - 1], k)
else:
cval.value = round(weights[i] - weights[i - 1], k)
cvals.append(cval)
return cvals
def solve_cplex(self):
self.__add_variables_cplex()
self.__add_constraints_cplex()
self.__add_objective_cplex()
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.MIP_optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs2 = CriteriaValues()
for cv in self.cvs:
cv2 = CriterionValue(cv.id)
cv2.value = int(self.lp.solution.get_values("w_%s" % cv.id))
cvs2.append(cv2)
lbda2 = int(self.lp.solution.get_values("lambda"))
return obj, cvs2, lbda2
def solve_cplex(self, aa, pt):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cfs = CriteriaFunctions()
cvs = CriteriaValues()
for cs in self.cs:
cv = CriterionValue(cs.id, 1)
cvs.append(cv)
nseg = cs.value
x_points = range(nseg)
p1 = Point(self.points[cs.id][0], 0)
ui = 0
f = PiecewiseLinear([])
for i in x_points:
uivar = 'w_' + cs.id + "_%d" % (i + 1)
ui += self.lp.solution.get_values(uivar)
x = self.points[cs.id][i + 1]
p2 = Point(x, ui)
s = Segment("s%d" % (i + 1), p1, p2)
f.append(s)
p1 = p2
s.p1_in = True
s.p2_in = True
cf = CriterionFunction(cs.id, f)
cfs.append(cf)
cat = {v: k for k, v in self.cat.items()}
catv = CategoriesValues()
ui_a = 0
for i in range(1, len(cat)):
ui_b = self.lp.solution.get_values("u_%d" % i)
catv.append(CategoryValue(cat[i], Interval(ui_a, ui_b)))
ui_a = ui_b
catv.append(CategoryValue(cat[i + 1], Interval(ui_a, 1)))
return obj, cvs, cfs, catv
def capacities_to_mobius(criteria, capacities):
cvs = CriteriaValues()
n = len(criteria)
for i in range(1, n + 1):
for combi in [c for c in combinations(criteria.keys(), i)]:
cid = combi[0] if (i == 1) else CriteriaSet(combi)
m = capacities[cid].value
for j in range(1, i):
for combi2 in [c for c in combinations(combi, j)]:
cidj = combi2[0] if (j == 1) else CriteriaSet(combi2)
m -= cvs[cidj].value
cv = CriterionValue(cid, m)
cvs.append(cv)
return cvs
def mobius_to_capacities(criteria, mobius):
cvs = CriteriaValues()
n = len(criteria)
for i in range(1, n + 1):
for combi in [c for c in combinations(criteria.keys(), i)]:
cid = combi[0] if (i == 1) else CriteriaSet(combi)
v = 0
for j in range(1, i + 1):
for combi2 in [c for c in combinations(combi, j)]:
cidj = combi2[0] if (j == 1) else CriteriaSet(combi2)
if cidj in mobius:
v += mobius[cidj].value
cv = CriterionValue(cid, v)
cvs.append(cv)
return cvs
def solve_glpk(self, aa, pt):
self.lp.solve()
status = self.lp.status()
if status != 'opt':
raise RuntimeError("Solver status: %s" % self.lp.status())
obj = self.lp.vobj()
cfs = CriteriaFunctions()
cvs = CriteriaValues()
for cid, points in self.points.items():
cv = CriterionValue(cid, 1)
cvs.append(cv)
p1 = Point(self.points[cid][0], 0)
ui = 0
f = PiecewiseLinear([])
for i in range(len(points) - 1):
uivar = 'w_' + cid + "_%d" % (i + 1)
ui += self.w[cid][i].primal
p2 = Point(self.points[cid][i + 1], ui)
s = Segment(p1, p2)
f.append(s)
p1 = p2
s.p2_in = True
cf = CriterionFunction(cid, f)
cfs.append(cf)
cat = {v: k for k, v in self.cat.items()}
catv = CategoriesValues()
ui_a = 0
for i in range(0, len(cat) - 1):
ui_b = self.u[i].primal
catv.append(CategoryValue(cat[i + 1], Interval(ui_a, ui_b)))
ui_a = ui_b
catv.append(CategoryValue(cat[i + 2], Interval(ui_a, 1)))
return obj, cvs, cfs, catv
def solve(self):
self.lp.solve()
status = self.lp.solution.get_status()
if status != self.lp.solution.status.MIP_optimal:
raise RuntimeError("Solver status: %s" % status)
obj = self.lp.solution.get_objective_value()
cvs = CriteriaValues()
for c in self.criteria:
cv = CriterionValue()
cv.id = c.id
cv.value = self.lp.solution.get_values('w_' + c.id)
cvs.append(cv)
self.model.cv = cvs
self.model.lbda = self.lp.solution.get_values("lambda")
pt = PerformanceTable()
for p in self.__profiles:
ap = AlternativePerformances(p)
for c in self.criteria:
perf = self.lp.solution.get_values("g_%s_%s" % (p, c.id))
ap.performances[c.id] = round(perf, 5)
pt.append(ap)
self.model.bpt = pt
self.model.bpt.update_direction(self.model.criteria)
wv = CriteriaValues()
for c in self.criteria:
w = CriterionValue()
w.id = c.id
w.value = self.lp.solution.get_values('z_' + c.id)
wv.append(w)
self.model.veto_weights = wv
self.model.veto_lbda = self.lp.solution.get_values("LAMBDA")
v = PerformanceTable()
for p in self.__profiles:
vp = AlternativePerformances(p, {})
for c in self.criteria:
perf = self.lp.solution.get_values('v_%s_%s' % (p, c.id))
vp.performances[c.id] = round(perf, 5)
v.append(vp)
self.model.veto = v
return obj
def on_button_run(self):
if hasattr(self, 'started') and self.started is True:
self.thread.stop()
return
if not hasattr(self, 'model'):
self.on_button_generate()
if self.combobox_type.currentIndex() == COMBO_AVFSORT:
self.init_results_avf()
ns = self.spinbox_nsegments.value()
css = CriteriaValues([])
for c in self.model.criteria:
cs = CriterionValue(c.id, ns)
css.append(cs)
self.thread = qt_thread_avf(self.model.criteria, self.categories,
self.worst, self.best, css, self.pt,
self.aa, None)
else:
self.init_results_mr()
nmodels = self.spinbox_nmodels.value()
niter = self.spinbox_niter.value()
nmeta = self.spinbox_nmeta.value()
self.thread = qt_thread_mr(self.model.criteria, self.categories,
self.worst, self.best, nmodels, niter,
nmeta, self.pt, self.aa, None)
self.connect(self.thread, QtCore.SIGNAL("update(int)"),
self.update)
self.connect(self.thread, QtCore.SIGNAL("finished()"), self.finished)
self.label_time2.setText("")
self.start_time = time.time()
self.timer.start(100)
self.thread.start()
self.button_run.setText("Stop")
self.groupbox_result.setVisible(True)
self.started = True
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 one_test(self, seed, na, nc, ncat, ns):
u = generate_random_avfsort_model(nc, ncat, ns, ns, seed)
a = generate_alternatives(na)
pt = generate_random_performance_table(a, u.criteria)
aa = u.get_assignments(pt)
css = CriteriaValues([])
for cf in u.cfs:
cs = CriterionValue(cf.id, len(cf.function))
css.append(cs)
cat = u.cat_values.to_categories()
lp = LpAVFSort(u.criteria, css, cat, pt.get_worst(u.criteria),
pt.get_best(u.criteria))
obj, cvs, cfs, catv = lp.solve(aa, pt)
u2 = AVFSort(u.criteria, cvs, cfs, catv)
aa2 = u2.get_assignments(pt)
self.assertEqual(aa, aa2)
def 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 generate_random_criteria_weights(crits, seed = None, k = 3):
if seed is not None:
random.seed(seed)
weights = [ random.random() for i in range(len(crits) - 1) ]
weights.sort()
cvals = CriteriaValues()
for i, c in enumerate(crits):
cval = CriterionValue()
cval.id = c.id
if i == 0:
cval.value = round(weights[i], k)
elif i == len(crits) - 1:
cval.value = round(1 - weights[i - 1], k)
else:
cval.value = round(weights[i] - weights[i - 1], k)
cvals.append(cval)
return cvals
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
app.exec_()
if __name__ == "__main__":
from pymcda.types import Criterion, Criteria
from pymcda.types import CriterionValue, CriteriaValues
from pymcda.types import PiecewiseLinear, Segment, Point
from pymcda.types import CriterionFunction, CriteriaFunctions
c1 = Criterion("c1")
c2 = Criterion("c2")
c3 = Criterion("c3")
c = Criteria([c1, c2, c3])
cv1 = CriterionValue("c1", 0.5)
cv2 = CriterionValue("c2", 0.25)
cv3 = CriterionValue("c3", 0.25)
cvs = CriteriaValues([cv1, cv2, cv3])
f1 = PiecewiseLinear([
Segment('s1', Point(0, 0), Point(2.5, 0.2)),
Segment('s2', Point(2.5, 0.2), Point(5, 1), True, True)
])
f2 = PiecewiseLinear([
Segment('s1', Point(0, 0), Point(2.5, 0.8)),
Segment('s2', Point(2.5, 0.8), Point(5, 1), True, True)
])
f3 = PiecewiseLinear([
Segment('s1', Point(0, 0), Point(2.5, 0.5)),
Segment('s2', Point(2.5, 0.5), Point(5, 1), True, True)
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)
model = MRSort(data.c, None, None, None, cat_profiles)
mip = MipMRSort(model, data.pt, data.aa)
mip.solve()
elif algo == 'lp_utadis':
model_type = 'utadis'
css = CriteriaValues(CriterionValue(c.id, nseg) for c in data.c)
lp = LpAVFSort(data.c, css, data.cats, worst, best)
obj, cvs, cfs, catv = lp.solve(data.aa, data.pt)
model = AVFSort(data.c, cvs, cfs, catv)
elif algo == 'lp_utadis_compat':
model_type = 'utadis'
css = CriteriaValues(CriterionValue(c.id, nseg) for c in data.c)
print("LpAVFSortCompat")
lp = LpAVFSortCompat(data.c, css, data.cats, worst, best)
obj, cvs, cfs, catv = lp.solve(data.aa, data.pt)
model = AVFSort(data.c, cvs, cfs, catv)
else:
print("Invalid algorithm!")
sys.exit(1)
t_total = time.time() - t1
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, 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
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
# Generate a set of alternatives
a = generate_alternatives(1000)
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
import time
from pymcda.generate import generate_random_mrsort_model
from pymcda.generate import generate_alternatives
from pymcda.generate import generate_random_performance_table
from pymcda.generate import generate_random_profiles
from pymcda.types import CriteriaValues, CriterionValue
from pymcda.types import CriteriaSet
from pymcda.utils import print_pt_and_assignments
from pymcda.utils import compute_ca
from pymcda.utils import compute_number_of_winning_coalitions
from pymcda.pt_sorted import SortedPerformanceTable
from pymcda.ui.graphic import display_electre_tri_models
# Generate a random ELECTRE TRI BM model
model = generate_random_mrsort_model(5, 3, 123)
cv1 = CriterionValue('c1', 0.2)
cv2 = CriterionValue('c2', 0.2)
cv3 = CriterionValue('c3', 0.2)
cv4 = CriterionValue('c4', 0.2)
cv5 = CriterionValue('c5', 0.2)
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([
print('Criteria weights:')
cv.display()
print('Criteria functions:')
cfs.display()
print('Categories values:')
catv.display()
print("Errors in alternatives assignments: %g %%" \
% (len(aa_erroned) / len(a) * 100))
# Learn the parameters from assignment examples
gi_worst = pt.get_worst(c)
gi_best = pt.get_best(c)
css = CriteriaValues([])
for cf in cfs:
cs = CriterionValue(cf.id, len(cf.function))
css.append(cs)
lp = LpAVFSortCompat(c, css, cat, gi_worst, gi_best)
obj, cvs, cfs, catv = lp.solve(aa_err, pt)
print('=============')
print('Learned model')
print('=============')
print('Criteria weights:')
cvs.display()
print('Criteria functions:')
cfs.display()
print('Categories values:')
catv.display()