def EvaluationOptimiste(lamda, csv_name, direction, type='excel'):
"""
Applique l'évaluation optimiste sur les matrices de surclassement
Args :
lamda : le seuil de majorité
csv_name: le nom du fichier de données placé dans le répertoire data
type: le type de fichier ('excel' ou 'csv')
direction: si on veut maximiser ou minimiser
Return : une liste d'affecation de catégories aux données
"""
df = loadModel(csv_name, type)
_, _, df_criteria_list, _, _, df_criteria_profils, _, categories = parseDataframe(
df)
nb_produits = len(df_criteria_list) #nombre de produits
nb_profils = len(df_criteria_profils) #nombre de profils
SurcHbi = SurclassementHbi(lamda, csv_name, direction, type='excel')
SurcbiH = SurclassementbiH(lamda, csv_name, direction, type='excel')
AffectationOptimiste = []
for i in range(0, nb_produits):
for j in range(0, nb_profils):
if SurcbiH[5 - j, i] == 0:
continue
elif SurcbiH[5 - j, i] == 1 and SurcHbi[i, 5 - j] == 0:
AffectationOptimiste.append(categories.get("C" + str(j)))
break
return AffectationOptimiste
def SurclassementbiH(lamda, csv_name, direction, type='excel'):
"""
Calcule la matrice de surclassement entre les profils et les produits
Args :
lamda : le seuile de majorité
csv_name: le nom du fichier de données placé dans le répertoire data
type: le type de fichier ('excel' ou 'csv')
direction: si on veut maximiser ou minimiser
Return : la matrice de surclassement (bi,H)
"""
df = loadModel(csv_name, type)
_, _, df_criteria_list, _, _, df_criteria_profils, _, _ = parseDataframe(
df)
nb_produits = len(df_criteria_list) #nombre de produits
nb_profils = len(df_criteria_profils) #nombre de profils
globalMatrixbiH = ConcordonceGlobalebiH(csv_name, direction, type='excel')
SurcbiH = np.zeros((nb_profils, nb_produits), dtype=int)
for j in range(0, nb_profils):
for i in range(0, nb_produits):
SurcbiH[j, i] = globalMatrixbiH[j, i] >= lamda
return SurcbiH
def ConcordonceGlobalebiH(csv_name, direction, type='excel'):
"""
Calcule la matrice de concordance globale entre les profils et les produits
Args :
csv_name: le nom du fichier de données placé dans le répertoire data
type: le type de fichier ('excel' ou 'csv')
direction: si on veut maximiser ou minimiser
Return : la matrice de concordance globale (bi,H)
"""
df = loadModel(csv_name, type)
_, coeff_list, df_criteria_list, _, _, df_criteria_profils, _, _ = parseDataframe(
df)
nb_criteria = len(df_criteria_list.columns) - 1 #nb de critères
nb_produits = len(df_criteria_list) #nombre de produits
nb_profils = len(df_criteria_profils) #nombre de profils
listbiH = ConcordancePartiellebiH(csv_name, direction, type='excel')
globalMatrixbiH = np.zeros(
(nb_profils, nb_produits),
dtype=float) #Matrice de concordance globale (bi,H)
sum_weight = 0.0
for z in range(nb_criteria):
sum_weight += coeff_list[z]
for j in range(0, nb_profils):
for i in range(0, nb_produits):
for k in range(0, nb_criteria):
globalMatrixbiH[j, i] += (coeff_list[k] *
listbiH[k][j][i]) / sum_weight
return globalMatrixbiH
def ConcordancePartielleHbi(csv_name, direction, type='excel'):
"""
Calcule la matrice de concordance partielle entre les produits et les profils selon le nombre de critères
Args :
csv_name: le nom du fichier de données placé dans le répertoire data
type: le type de fichier ('excel' ou 'csv')
direction: si on veut maximiser ou minimiser
Return : la matrice de concordance partielle (H,bi)
"""
df = loadModel(csv_name, type)
_, _, df_criteria_list, _, _, df_criteria_profils, _, _ = parseDataframe(
df)
nb_criteria = len(df_criteria_list.columns) #nb de critères
nb_produits = len(df_criteria_list) #nombre de produits
nb_profils = len(df_criteria_profils) #nombre de profils
listHbi = [
] #Liste qui va contenir toutes les matrices de concordance créées
if (direction == "max"):
for z in range(1, nb_criteria):
concMatrixHbi = np.zeros((nb_produits, nb_profils),
dtype=int) #Matrice de concordance (H,bi)
criteria = df_criteria_list.iloc[:, [z]]
profilCriteria = df_criteria_profils.iloc[:, [z]]
for i in range(0, nb_produits):
for j in range(0, nb_profils):
concMatrixHbi[i,
j] = comparesTo(criteria.values[i, 0],
profilCriteria.values[j, 0])
listHbi.append(concMatrixHbi)
elif (direction == "min"):
for z in range(1, nb_criteria):
criteria = df_criteria_list.iloc[:, [z]]
profilCriteria = df_criteria_profils.iloc[:, [z]]
concMatrixHbi = np.zeros((nb_produits, nb_profils),
dtype=int) #Matrice de concordance (H,bi)
for i in range(0, nb_produits):
for j in range(0, nb_profils):
concMatrixHbi[i,
j] = comparesTo(profilCriteria.values[j, 0],
criteria.values[i, 0])
listHbi.append(concMatrixHbi)
return listHbi
def compareClassification(TypeEval, lamda, csv_name, direction, type='excel'):
"""
compare la méthode d'évaluation utilisé avec les résultats obtenues par le magazine
Args :
TypeEval : le type d'évaluation utilisé Optimiste ou Pessimiste
lamda : le seuil de majorité
csv_name: le nom du fichier de données placé dans le répertoire data
type: le type de fichier ('excel' ou 'csv')
direction: si on veut maximiser ou minimiser
Return : un seuil de mauvaise classification
"""
global IMauvC
AffectationOptimiste = EvaluationOptimiste(lamda,
csv_name,
direction,
type='excel')
AffectationPessimiste = EvaluationPessimiste(lamda,
csv_name,
direction,
type='excel')
df = loadModel(csv_name, type)
_, _, df_criteria_list, _, _, _, score_bymagazine, categories = parseDataframe(
df)
nb_produits = len(df_criteria_list) #nombre de produits
if TypeEval == "pessimiste" or TypeEval == "p":
IMauvC = 0 #Indice de mauvaise classification
for i in range(len(AffectationPessimiste)):
if list(categories.keys())[list(categories.values()).index(
AffectationPessimiste[i])] != score_bymagazine[i]:
IMauvC += 1
else:
IMauvC = 0 #Indice de mauvaise classification
for i in range(len(AffectationOptimiste)):
if list(categories.keys())[list(categories.values()).index(
AffectationOptimiste[i])] != score_bymagazine[i]:
IMauvC += 1
return (IMauvC / nb_produits * 100)
def linearProgramSolver(df, eval_expr, direction, model_name, with_scores = False, update_model=None):
"""
Construction et résolution du programme linéaire hors question 4
Args:
df : Dataframe original issu du fichier excel
eval_expr: variable de la fonction objectif ou 'all' pour appliquer direction à toutes les variables
direction: min / max variables
model_name: nom du modèle
with_scores : mode avec ou sans score (Q2 / Q3 / Q4)
update_model : liste des éléments pou la suppression / modification de contraintes
Return: Renvoie un Dataframe prêt à être exporter / afficher
"""
df_score, coeff_list, df_criteria_list, df_criteria_bareme, dict_boundaries, _, _, _= parseDataframe(df)
nb_criteria = len(df_criteria_list.columns)-1
# variables definition
variable_list={}
variable_list_x, variable_list_y = buildVariableDefinitionList(df_criteria_list, df_criteria_bareme, with_scores, dict_boundaries)
variable_list['variable_list_x'] = variable_list_x
variable_list['variable_list_y'] = variable_list_y
#Modification des variables si nécessaire
if update_model is not None:
variable_list = update_variable_list_from_dict(update_model['variable'], variable_list)
# constraint definition
constraint_list = buildConstraintDefinitionList(coeff_list, variable_list, nb_criteria, df_score, with_scores)
#Modification des contraintes si nécessaire
if update_model is not None:
constraint_list = update_constraint_list_from_dict(update_model['constraint'], constraint_list)
#objective definition
for var in variable_list_x + variable_list_y:
if var.name == eval_expr:
obj = Objective(expression=var, direction=direction)
#Model
model = buildModel(constraint_list, obj, model_name)
return model, df_criteria_list