def test_mutation_indic_ope(num):
# Permet de calculer sur 100 itérations le nombre de fois où la mutation de
# type choisi (0, 1, 2 ou 3) a réussi à générer une solution fille ayant un
# score de fitness opérationnel supérieur à celui de la meilleure solution
# de la génération initiale.
# Initialisation des dictionnaires pour les conversions de fichiers
dico_transf_init()
# Classement d'une génération
ranked = rankings("1")
# récupération meilleure solution opérationnelle
best_ope = choix_indiv_rg(ranked, "1", "fitness_ope", 1)
iteration_reussie = 0
start_time = time.time()
if best_ope == "0":
constantes.typechoix = 1
else :
constantes.typechoix = 0
# Choix du type de la mutation
mutation = type_mutation(num)
for i in range(100):
print("Iter ",i)
changes_ope = mutation(0, best_ope, 0, True, 1)
if changes_ope == True:
print("Mutation operateur operationnel ok in ", time.time() - start_time)
iteration_reussie += 1
print("nombre d'itérations réussies :", iteration_reussie)
def test_pareto_optimalite(nb_iter):
# 0: mutation_arriere, 1: mutation_DSP, 2: mutation_i_aleatoire
indice_mutation = [0, 1, 2]
scores_cumules = pd.DataFrame(np.nan, index = range(4), columns = range(nb_iter))
scores_cumules.index = ["mut_arr", "mut_DSP", "mut_i_al", "no_mut"]
fitness = pd.DataFrame(np.nan, index = range(8), columns = range(nb_iter))
fitness.index = ["fit_ope_mut_arr", "fit_lis_mut_arr", "fit_ope_mut_DSP", \
"fit_lis_mut_DSP", "fit_ope_mut_i_al", "fit_lis_mut_i_al",\
"fit_ope_no_mut", "fit_lis_no_mut"]
nb_solution_PO = 0
for i in range(nb_iter):
new_indic, new_df = programme(True, 0)
fitness.loc["fit_ope_no_mut"][i] = fitness_ope_indiv(new_indic)
fitness.loc["fit_lis_no_mut"][i] = fitness_lis_indiv(new_indic)
if is_Pareto_opt(fitness.loc["fit_ope_no_mut":"fit_lis_no_mut",:i].T,\
fitness.loc["fit_ope_no_mut"][i], fitness.loc["fit_lis_no_mut"][i], "no_mut") :
nb_solution_PO += 1
scores_cumules.loc["no_mut"][i] = nb_solution_PO
print(scores_cumules)
for mut_type in indice_mutation :
nb_solution_PO = 0
for it in range(nb_iter):
ranked = rankings("1")
sol = choix_indiv_rg(ranked, "1", "fitness_lis", 1)
mutation = type_mutation(mut_type)
mutation(0, sol, 0, True, 1)
# A chaque iteration on réécrit sur la solution test
nom_mut = scores_cumules.index[indice_mutation[mut_type]]
print(nom_mut)
fitness.loc["fit_ope_"+nom_mut][it] = fitness_ope_indiv("solutionTest.csv")
fitness.loc["fit_lis_"+nom_mut][it] = fitness_lis_indiv("solutionTest.csv")
if is_Pareto_opt(fitness.loc["fit_ope_"+nom_mut:"fit_lis_"+nom_mut,:it-1].T,\
fitness.loc["fit_ope_"+nom_mut][it], fitness.loc["fit_lis_"+nom_mut][it],nom_mut) :
nb_solution_PO += 1
scores_cumules.loc[nom_mut][it] = nb_solution_PO
print(scores_cumules)
return fitness, scores_cumules
def test_mutation_cravate(num):
# On cherche ici, à partir de la solution présentant le meilleur score
# pour l'indicateur de lissage de maintenance, à améliorer le score
# opérationnel de cette solution, sans dégrader son score "lissage". Pour
# ce faire on utilise dans le re-bouclage l'algorithme glouton avec l'option
# "cravate" qui présente de bonnes performances opérationnelles lors de la
# création d'une solution.
# Initialisation des dictionnaires pour les conversions de fichiers
dico_transf_init()
# Initialisation : création des individus de la première génération
ranked = rankings("1") # Classement de la premiere génération
# Initialisation des données du Front de Pareto
dataPareto = pd.DataFrame()
dataPareto = addGeneration(ranked, dataPareto)
# Récupération de la solution de la génération 1 ayant le meilleur score "lissage"
best_liss = choix_indiv_rg(ranked, "1", "fitness_lis", 1)
# On utilise le re-bouclage avec option "cravate"
constantes.typechoix = 0
iteration_reussie = 0
gen = 2
# Choix du type de la mutation
mutation = type_mutation(num)
for i in range(10):
nom_fichier_sortie(gen,i)
print("Iter ",i)
changes_ope = mutation(0, best_liss, 0, True, 3)
if changes_ope == True:
print("Fitness operationnelle améliorée par mutation_cravate")
iteration_reussie += 1
print("Nombre d'itérations réussies : ", iteration_reussie)
# Classement et ajout des nouvelles solutions
ranked = rankings("2")
dataPareto = addGeneration(ranked, dataPareto)
drawPareto(dataPareto)
dataPareto.to_csv("ParetoTestCravate.csv",sep=";",index=False,header=None)
def test_mutation_indic_lis(num):
# Permet de calculer sur 100 itérations le nombre de fois où la mutation de
# type choisi (0, 1, 2 ou 3) a réussi à générer une solution fille ayant un
# score de fitness lissage supérieur à celui de la meilleure solution de la
# génération initiale.
# Initialisation des dictionnaires pour les conversions de fichiers
dico_transf_init()
# Classement d'une génération
ranked = rankings("1")
# récupération meilleure solution lissage
best_liss = choix_indiv_rg(ranked, "1", "fitness_lis", 1)
constantes.typechoix = 1
iteration_reussie = 0
start_time = time.time()
# Initialisation des données du Front de Pareto
dataPareto = pd.DataFrame()
dataPareto = addGeneration(ranked, dataPareto)
# Choix du type de la mutation
mutation = type_mutation(num)
for generation in [2,3]:
for i in range(10):
print("Generation", generation, "Iter ",i)
nom_fichier_sortie(generation,i)
changes_lis = mutation(0, best_liss, 0, False, 1)
if changes_lis == True:
print("mutation operateur lissage maintenance OK in ", time.time() - start_time)
iteration_reussie += 1
# Classement et ajout des nouvelles solutions
ranked = rankings(str(generation))
dataPareto = addGeneration(ranked, dataPareto)
print("nombre d'itérations réussies :", iteration_reussie)
drawPareto(dataPareto)
dataPareto.to_csv("ParetoTestMutArriereLis.csv",sep=";",index=False,header=None)
def programme_gen(max_iter, max_time, mut_type):
print("Lancement du programme génétique")
start = time.time()
elapsed = 0
### INITIALISATION
#On remet à zéro le fichier de lecture des données
resetDonneeLecture()
# Si les dossiers n'existent pas on les recrée
if not os.path.exists(paths.indicateurs_path):
os.mkdir(paths.indicateurs_path)
os.mkdir(paths.indicateurs_final_path)
os.mkdir(paths.sitInits_path)
os.mkdir(paths.solutions_path)
os.mkdir(paths.solutions_final_path)
#On vide les répertoires des précédentes solutions
print('Suppression archives')
emptyFolder(paths.indicateurs_path)
#emptyFolder(paths.indicateurs_final_path)
emptyFolder(paths.sitInits_path)
emptyFolder(paths.solutions_path)
#emptyFolder(paths.solutions_final_path)
# Initialisation des dictionnaires pour les conversions de fichiers
dico_transf_init()
# Initialisation : création des individus de la première génération
d = initialisation(
) # Pour avoir un accès aux caractéristiques des missions
miss_pots = {m.nom: [m.pu, str(int(m.pu))]
for m in d["listeMission"]
} # Dico des missions et leur potentiel horaire
ranked = rankings("1") # Classement de la premiere génération
# Initialisation des données du Front de Pareto
dataPareto = pd.DataFrame()
dataPareto = addGeneration(ranked, dataPareto)
# Initialisation du numero de la generation
gen = 1
# Itialisation de l'opérateur de mutation
mutation = type_mutation(mut_type)
### EVOLUTION par CROSSOVER et MUTATION
while ((elapsed <= max_time) & (gen < max_iter)):
gen += 1
gen_str = str(gen)
# CROSSOVER pour les individus X0, X1 selon indicateur opérationnel
# dictionnaire des solutions pour le crossover
sols_ope = {}
sols_ope["best"] = choix_indiv_rg(ranked, gen_str, "fitness_ope", 1)
sols_ope["worst"] = choix_indiv_rg(ranked, gen_str, "fitness_ope", 0)
sols_ope["median"] = choix_indiv_rg(ranked, gen_str, "fitness_ope",
0.5)
# crossover
print("Crossover sur generation", gen, "pour indic operationnel")
sitInit_ope = crossover(sols_ope, gen)
# génération des deux nouveaux individus "solution_gen_0" et "solution_gen_1"
indiv = 0
for x in sitInit_ope:
nom_fichier_sortie(gen, indiv)
programme(False, x)
indiv += 1
# CROSSOVER pour les individus X2, X3 selon indicateur de maintenance
# dictionnaire des solutions pour le crossover
sols_lis = {}
sols_lis["best"] = choix_indiv_rg(ranked, gen_str, "fitness_lis", 1)
sols_lis["worst"] = choix_indiv_rg(ranked, gen_str, "fitness_lis", 0)
sols_lis["median"] = choix_indiv_rg(ranked, gen_str, "fitness_lis",
0.5)
# crossover
print("crossover sur generation", gen, "pour indic maint lissage")
sitInit_lis = crossover(sols_lis, gen)
# génération des deux nouveaux individus "solution_gen_2" et "solution_gen_3"
for x in sitInit_lis:
nom_fichier_sortie(gen, indiv)
programme(False, x)
indiv += 1
# MUTATION pour créer individu "solution_gen_4"
# à partir de l'individu ayant le meilleur score opérationnel
print("mutation sur generation", gen, "pour indic operationnel")
nom_fichier_sortie(gen, 4)
changes_ope = mutation(str(gen - 1), sols_ope["best"], 4, True, 4)
# MUTATION pour créer individu "solution_gen_5" à partir
# de l'individu ayant le meilleur score de lissage de maintenance
print("mutation sur generation", gen, "pour indic maint lissage")
nom_fichier_sortie(gen, 5)
changes_lis = mutation(str(gen - 1), sols_lis["best"], 5, False, 4)
# On conserve les meilleurs individus de la génération précédente et on
# les intègre à la nouvelle génération sous les numéros "gen_6" et "gen_7"
nom_fichier_sortie(gen, 6)
os.rename("solutions\solution" + sols_ope["best"] + ".csv",
"solutions\solution" + gen_str + "6" + ".csv")
os.rename("indicateurs\indicateurs" + sols_ope["best"] + ".csv",
"indicateurs\indicateurs" + gen_str + "6" + ".csv")
if sols_ope["best"] != sols_lis["best"]:
nom_fichier_sortie(gen, 7)
os.rename("solutions\solution" + sols_lis["best"] + ".csv",
"solutions\solution" + gen_str + "7" + ".csv")
os.rename("indicateurs\indicateurs" + sols_lis["best"] + ".csv",
"indicateurs\indicateurs" + gen_str + "7" + ".csv")
# Classement de la nouvelle génération et ajout au front de Pareto
ranked = rankings(gen_str)
dataPareto = addGeneration(ranked, dataPareto)
elapsed = time.time() - start
print(elapsed)
nom_fichier_sortie(gen, 8)
nom_fichier_sortie(gen, 9)
drawPareto(dataPareto)
### AFFICHAGE et SAUVEGARDE du front de Pareto
drawPareto(dataPareto)
dataPareto.to_csv("dataPareto0.csv", sep=";", index=False, header=None)
#On determine les solutions pareto-optimales et on les deplace dans les répertoires _final
pareto_opti = is_pareto_efficient(dataPareto)
print(pareto_opti)
for ind in pareto_opti:
shutil.copy("solutions\solution" + ind + ".csv",
"solutions_final\solution" + ind + ".csv")
addDollars("solutions\solution" + ind + ".csv", d,
miss_pots) #On aoute les dollars pour l'excel
shutil.copy("indicateurs\indicateurs" + ind + ".csv",
"indicateurs_final\indicateurs" + ind + ".csv")
print("temps total", elapsed, "sec")
return dataPareto