def checkAdditiveModel(csv_name, eval_expr, direction, model_name, type='excel', with_scores=False, update_model=None):
"""
Résolution du programme linéaire
Args:
csv_name : path du fichier de données (répertoire data)
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
type: excel par défaut, 'csv' possible
with_scores : mode avec ou sans score (Q2 / Q3 / Q4)
update_model : liste des éléments pou la suppression / modification de contraintes
Return: message d'erreur si pas de solution
Dataframe avec les résultats corespondants dans la colonne score
Cas max al (Q4) Dataframe avec toutes les solutions correspondants
au max des variables dans la colonne score
"""
df = loadModel(csv_name, type)
if eval_expr != 'all':
model, df_criteria_list = linearProgramSolver(df, eval_expr, direction , model_name, with_scores, update_model)
if model.status == 'infeasible':
result = f'Le {model.name} \n du fichier {csv_name} n\'admet pas de solution'
else:
result = displayModel(model, df_criteria_list)
else:
result = displayAllProductMaxScore(df, direction , model_name, update_model)
return result
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)