def creer_liste_NEH(self): nb_machines = self.nb_machines L = [ J for J in sorted(self.l_job, key=lambda J: J.duree(), reverse=True) ] O = [] result = [] for J in L: cand = 1000 lcand = [] for k in range(len(result) + 1): copy = [job for job in result] copy.insert(k, J) O.append(o.Ordonnancement(nb_machines)) O[0].ordonnancer_liste_job(copy) if O[0].dur < cand: cand = O[0].dur lcand = copy O.clear() for job in copy: job.date_deb = [0 for d in job.date_deb] result = lcand O.append(o.Ordonnancement(nb_machines)) O.append(o.Ordonnancement(nb_machines)) O[0].ordonnancer_liste_job(result) O[0].afficher() print("Durée NEH : " + str(O[0].dur)) return result, O[0].dur
def creer_liste_NEH(self): m = MAXINT # liste_NEH est le réslutat de l'algorithme NEH liste_NEH = ordonnancement.Ordonnancement(self.nb_machines) # etape 1: Trier les jobs par ordre croissant de leur durée totale self.trier_jobs() # ajout du job ayant la durée totale minimale à une liste l # l contient des numéros de job l = [self.l_job[0].num] for index in range(1, self.nb_jobs): # ajout du job suivant l.append(self.l_job[index].numero()) # list_permutation contient des tuples # chaque tuple est une permutation # des elements de la liste l # list_permutation contient toutes # les permutation #list_permutation = list(itertools.permutations(l)) list_permutation = self.permutations_with_order(l) #print(list_permutation) # list_ordo est une liste qui va contenir tous # les ordonnancements générés par liste_permutation list_ordo = [] for tup in list_permutation: # list_job contient une liste de jobs crées # par les indices contenus dans chaque element # de list_permutation list_jobs = [] for i in tup: list_jobs.append(self.get_job_by_id(i)) ordo = ordonnancement.Ordonnancement(self.nb_machines) ordo.ordonnancer_liste_job(list_jobs) list_ordo.append(ordo) m1 = MAXINT # on cherche dans cette boucle l'ordonnancement # qui est de durée minimale # la variable temp_ordo contient l'ordonnancement # de durée minimale for ordo in list_ordo: if ordo.duree() < m1: #temp_ordo = copy.deepcopy(ordo) temp_ordo = ordo m1 = ordo.duree() # la fonction to_index() renvoie une liste contenant # les numéros des jobs d'un ordonnancement # la liste l mémorise les indices déja visités et enregistré # cela évite lors de l'énumération des différentes # permutations d'éviter d'énumérer des combinaisons # qui ne sont pas intéréssantes l = temp_ordo.to_index() liste_NEH = temp_ordo return liste_NEH
def random_scheduling(F): sequence = random_sequence(F) ordo = o.Ordonnancement(F.nb_machines) ordo.ordonnancer_liste_job(sequence) ordo.afficher() print("The length of this scheduling is {}".format( evaluate(sequence, F.nb_machines))) return sequence
def random_scheduling(F): sequence = [] while F.l_job != []: sequence.append(F.l_job.pop(random.randint(0, len(F.l_job) - 1))) ordo = o.Ordonnancement(F.nb_machines) ordo.ordonnancer_liste_job(sequence) ordo.afficher() print("The length of this scheduling is {}".format( evaluate(sequence, F.nb_machines)))
def evaluation_separation_(self): #flow_shop = self.Flowshop() ordo = flow_shop.definir_par("jeu2.txt") ordo.afficher() liste_NEH = flow_shop.creer_liste_NEH() # liste = [3, 2, 0, 1] liste = ordo.to_index() val = flow_shop.calculer_borne_inf(ordo, liste) s = sommet.Sommet([], liste, val, 0) print("AAAAAAAAAAAAAAAAAAA", s) heap = [] heapq.heappush(heap, s) opt = 1000000 seq_opt = [] while len(heap) != 0: s = heapq.heappop(heap) if len(s.jobs_non_places()) == 0: ordo = ordonnancement.Ordonnancement(flow_shop.nb_machines) list_jobs = [flow_shop.get_job_by_id(i) for i in s.sequence()] ordo.ordonnancer_liste_job(list_jobs) if ordo.duree() <= opt: opt = ordo.duree() seq_opt = s.sequence() else: for j in s.jobs_non_places(): print(s.jobs_non_places()) new_seq = copy.deepcopy(s.sequence()) + [j] new_non_place = copy.deepcopy(s.jobs_non_places()) new_non_place.remove(j) ordo = ordonnancement.Ordonnancement(flow_shop.nb_machines) list_jobs = [flow_shop.get_job_by_id(i) for i in new_seq] ordo.ordonnancer_liste_job(list_jobs) new_val = flow_shop.calculer_borne_inf(ordo, new_seq) new_num = s.numero() + 1 new_s = sommet.Sommet(new_seq, new_non_place, new_val, new_num) if new_s.evaluation() < opt: heapq.heappush(heap, new_s) print("La sequence optimale est : {}\n" "la duree est : {}".format(seq_opt, opt)) return 0
def muter(ordo_initial): n = len(ordo_initial.seq) i = random.randint(0, n - 1) # Dans le pire des cas, on ne fait pas d'échange! j = random.randint(0, n - 1) ordo_initial.seq[i], ordo_initial.seq[j] = ordo_initial.seq[ j], ordo_initial.seq[i] ordo = ordonnancement.Ordonnancement( ordo_initial.nb_machines) # Création d'un nouvel ordonnancement ordo.ordonnancer_liste_job(ordo_initial.seq) return ordo
def evaluation_separation(self): O = o.Ordonnancement(self.nb_machines) compteur = 0 meilleurOrdo, dureeMeilleurOrdo = self.creer_liste_NEH() print("Durée du meilleur ordo initial : " + str(dureeMeilleurOrdo)) sommet = s.Sommet([], self.l_job, self.calculer_borne_inf(O, []), 0) heap = [sommet] while heap != []: compteur += 1 if compteur % 2000 == 0: print(str(compteur) + " noeuds parcourus") sommet = heapq.heappop(heap) O = o.Ordonnancement(self.nb_machines) for j in self.l_job: for operation in range(j.nb_op): O.fixer_date_debut_operation(j, operation, 0) if sommet.non_places == []: non_places = comp(sommet.seq, self.l_job) O.ordonnancer_liste_job(sommet.seq) if O.dur <= dureeMeilleurOrdo: meilleurOrdo = sommet.seq dureeMeilleurOrdo = O.dur print("Nouveau meilleur ordonnancement trouvé ! Durée : " + str(O.dur)) print([j.numero() for j in meilleurOrdo]) O.afficher() else: for J in sommet.jobs_non_places(): nv_non_places = [j for j in sommet.jobs_non_places()] nv_non_places.remove(J) nv_seq = sommet.seq + [J] O.ordonnancer_liste_job(nv_seq) nv_val = self.calculer_borne_inf(O, nv_seq) if nv_val <= dureeMeilleurOrdo: nv_sommet = s.Sommet(nv_seq, nv_non_places, nv_val, 0) heapq.heappush(heap, nv_sommet) print("Recherche terminée") print("La meilleure durée est " + str(dureeMeilleurOrdo)) print("Un ordonnancement optimal est " + str([j.numero() for j in meilleurOrdo])) return meilleurOrdo, dureeMeilleurOrdo
def generation_aleatoire(mon_fichier_txt, N): flow_shop = flowshop.Flowshop() ordo = flow_shop.definir_par( mon_fichier_txt) # Construction d'un problème avec un fichier .txt nb_machines = ordo.nb_machines liste_job = ordo.seq population_initiale = [] i = 0 while (i < N): random.shuffle(liste_job) # Mélange des jobs ordo_new = ordonnancement.Ordonnancement( nb_machines) # Création d'un nouvel ordonnancement ordo_new.ordonnancer_liste_job( liste_job) # Ordonnancer avec la nouvelle liste population_initiale.append(ordo_new) i -= -1 return population_initiale
def definir_par(self, nom): """ crée un problème de flowshop à partir d'un fichier """ # ouverture du fichier en mode lecture fdonnees = open(nom, "r") # lecture de la première ligne ligne = fdonnees.readline() l = ligne.split() # on récupère les valeurs dans une liste self.nb_jobs = int(l[0]) self.nb_machines = int(l[1]) ordo = ordonnancement.Ordonnancement(self.nb_machines) for i in range(self.nb_jobs): ligne = fdonnees.readline() l = ligne.split() # on transforme les chaînes de caractères en entiers l = [int(i) for i in l] j = job.Job(i, l) ordo.ordonnancer_job(j) self.l_job += [j] # fermeture du fichier fdonnees.close() return ordo
def __init__(self, flowshop, alpha, biais_type): """ Initalisation de la méthode GRASP :param flowshop: flowshop du problème """ # Problème de Flowshop self.prob = flowshop # Creation de l'ordonnancement self.ordo = ordonnancement.Ordonnancement(self.prob.nb_machines) # Paramètre alpha de la méthode self.alpha = alpha # Choix du biais self.biais_type = biais_type # Jobs restant à placer dans l'ordonnancement self.jobs = [] self.maj_jobs() # Temps d'exécution self.temps_exe = 0
def evaluate(sequence, nb_machines): ordo = o.Ordonnancement(nb_machines) ordo.ordonnancer_liste_job(sequence) time = ordo.duree() return time
ordo = flow_shop.definir_par("jeu3.txt") liste_NEH = flow_shop.creer_liste_NEH() #liste = [3, 2, 0, 1] liste = ordo.to_index() val = flow_shop.calculer_borne_inf(ordo, liste) s = Sommet([], liste, val, 0) heap = [] heapq.heappush(heap, s) opt = 1000000 seq_opt = [] while len(heap) != 0: s = heapq.heappop(heap) print(s) if len(s.jobs_non_places()) == 0: ordo = ordonnancement.Ordonnancement(flow_shop.nb_machines) list_jobs = [flow_shop.get_job_by_id(i) for i in s.sequence()] ordo.ordonnancer_liste_job(list_jobs) if ordo.duree() <= opt: opt = ordo.duree() seq_opt = s.sequence() else: for j in s.jobs_non_places(): new_seq = copy.deepcopy(s.sequence()) + [j] new_non_place = copy.deepcopy(s.jobs_non_places()) new_non_place.remove(j) ordo = ordonnancement.Ordonnancement(flow_shop.nb_machines) list_jobs = [flow_shop.get_job_by_id(i) for i in new_seq] ordo.ordonnancer_liste_job(list_jobs) #ordo.afficher() new_val = flow_shop.calculer_borne_inf(ordo, new_seq)
def generation_Heuristique(mon_fichier_txt): flow_shop = flowshop.Flowshop() ordo = flow_shop.definir_par( mon_fichier_txt) # Construction d'un probleme avec un fichier .txt nb_machines = ordo.nb_machines liste_job = ordo.seq nbr_Jobs = len(liste_job) t = [] for job in liste_job: t.append(job.duree_op) palmIndex = [0 for i in range(nbr_Jobs) ] #index de pente de Palmer de chaque tache for i in range(nbr_Jobs): sum = 0 for j in range(nb_machines): sum = sum + (nb_machines - 2 * j + 1) * t[i][j] palmIndex[i] = sum johnIndex = [0 for i in range(nbr_Jobs) ] #index de pente de Johnson de chaque tache for i in range(nbr_Jobs): mi = 10000 for j in range(nb_machines - 1): if t[i][j] + t[i][j + 1] < mi: mi = t[i][j] + t[i][j + 1] signe = 1 if (t[i][1] - t[i][nb_machines - 1]) < 0: signe = -1 johnIndex[i] = palmIndex[i] - signe / mi palmerSol = [0] #Solution basee sur indice de Palmer johnsonSol = [0] #Solution basee sur indice de Johnson for k in range(1, nbr_Jobs): ind = 0 while (ind < len(palmerSol) and palmIndex[palmerSol[ind]] < palmIndex[k]): ind += 1 palmerSol.insert(ind, k) for n in range(1, nbr_Jobs): ind2 = 0 while (ind2 < len(johnsonSol) and johnIndex[johnsonSol[ind2]] < johnIndex[k]): ind2 += 1 johnsonSol.insert(ind2, n) liste_job_palmer = [None for i in range(0, nbr_Jobs)] liste_job_johnson = [None for i in range(0, nbr_Jobs)] for job in liste_job: # prob job potentiel manquant dans les deux listes for i in range(0, nbr_Jobs): if job.numero() == palmerSol[i]: liste_job_palmer[i] = job if job.numero() == johnsonSol[i]: liste_job_johnson[i] = job ordo_palmer = ordonnancement.Ordonnancement( nb_machines) # Création d'un nouvel ordonnancement ordo_palmer.ordonnancer_liste_job(liste_job_palmer) ordo_johnson = ordonnancement.Ordonnancement( nb_machines) # Création d'un nouvel ordonnancement ordo_johnson.ordonnancer_liste_job(liste_job_johnson) return (palmerSol, johnsonSol, ordo_palmer, ordo_johnson)
else: for J in sommet.jobs_non_places(): nv_non_places = [j for j in sommet.jobs_non_places()] nv_non_places.remove(J) nv_seq = sommet.seq + [J] O.ordonnancer_liste_job(nv_seq) nv_val = self.calculer_borne_inf(O, nv_seq) if nv_val <= dureeMeilleurOrdo: nv_sommet = s.Sommet(nv_seq, nv_non_places, nv_val, 0) heapq.heappush(heap, nv_sommet) print("Recherche terminée") print("La meilleure durée est " + str(dureeMeilleurOrdo)) print("Un ordonnancement optimal est " + str([j.numero() for j in meilleurOrdo])) return meilleurOrdo, dureeMeilleurOrdo F = Flowshop() F.definir_par("jeu2.txt") O = o.Ordonnancement(F.nb_machines) #NEH, duree = F.creer_liste_NEH() #O = o.Ordonnancement(F.nb_machines) #print("La borne inf de l'ordonnancement NEH est " + str(F.calculer_borne_inf(O, NEH))) F.evaluation_separation() if __name__ == "__main__": pass #Test Commit Juliette #Test Timo #Test Anthony
Cmin_tab.append(population[0].dur) Cmax_tab.append(population[-1].dur) solutions = [population[i].dur for i in range(len(population))] Moy_tab.append(statistics.mean(solutions)) now1 = time.time() population = croisement.croisement_population(population) # Croisement mutation.mutation_population(population, 10) # Mutation population = selection.selection_random( population) # Sélection par tounois #appariement.C_pairing(population) if C > population[0].dur: # Sauvegarde du meilleur individu C = population[0].dur meilleure_sequence = population[0].seq ordo = ordonnancement.Ordonnancement( population[0].nb_machines) # Création d'un nouvel ordonnancement ordo.ordonnancer_liste_job(meilleure_sequence) """ ordo.afficher() # Affichage de notre solution print("\n") """ print("Done") f.write(fichiers[i] + ' ' + str(C) + ' ' + str(round(100 * (Cmin - C) / C, 1)) + '%' + ' ' + str(round(Moy, 1)) + ' ' + str(Cmin) + ' ' + str(Cmax) + ' ' + str(optimal) + '\n') f.close() liste_temps = np.linspace(0, 600, num=len(Cmax_tab)) liste_optimal = np.array(optimum * len(Cmax_tab)) plt.plot(liste_temps, np.array(Cmin_tab), color='g', label='Cmin')