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')
