def descenteStochastique(nomFichier):
affectation, carac, listeServeurs, dicoRangees, dicoObstacles = methodeGloutonne2(
nomFichier)
cpt = 0
maxIteration = 5000
# dicoCaracServeur["id du serveur"] = [taille du serveur, capacite du serveur]
dicoCaracServeur = {}
for serveur in listeServeurs:
dicoCaracServeur[str(serveur[0])] = [serveur[1], serveur[2]]
while cpt < maxIteration:
nouvelleAffectation, nouveauDicoObstacles = voisinage.uneAffectationVoisine(
affectation, carac, listeServeurs, dicoObstacles, dicoCaracServeur,
0.30, 0.66)
if outils.calculScore(nouvelleAffectation, carac,
dicoCaracServeur) > outils.calculScore(
affectation, carac, dicoCaracServeur):
affectation = deepcopy(nouvelleAffectation)
dicoObstacles = deepcopy(nouveauDicoObstacles)
cpt += 1
outils.genererFichierSolution(affectation, nomFichier,
"descenteStochastique")
print "Score descente stochastique: ", outils.calculScore(
affectation, carac, dicoCaracServeur)
def recuitSimule(nomFichier):
affectation, carac, listeServeurs, dicoRangees, dicoObstacles = methodeGloutonne2(
nomFichier)
temperature = 5 #Il faut jouer ici
cpt = 0
# nouveauDicoObstacles = dicoObstacles
RX = deepcopy(affectation)
X = deepcopy(affectation)
tmp = 0.99
# dicoCaracServeur["id du serveur"] = [taille du serveur, capacite du serveur]
dicoCaracServeur = {}
for serveur in listeServeurs:
dicoCaracServeur[str(serveur[0])] = [serveur[1], serveur[2]]
while (temperature > math.pow(10, -3)):
# Y, nouveauDicoObstacles = voisinage.uneAffectationVoisine2(X,carac,listeServeurs,dicoObstacles, dicoCaracServeur)
Y, nouveauDicoObstacles = voisinage.uneAffectationVoisine(
X, carac, listeServeurs, dicoObstacles, dicoCaracServeur, 0.30,
0.60)
scoreY = outils.calculScore(Y, carac, dicoCaracServeur)
scoreRX = outils.calculScore(RX, carac, dicoCaracServeur)
scoreX = outils.calculScore(X, carac, dicoCaracServeur)
#print("ScoreY, ScoreX, ScoreRX")
#print( scoreY, scoreX, scoreRX)
if scoreY > scoreRX:
RX = deepcopy(Y)
dicoObstacles = deepcopy(nouveauDicoObstacles)
if scoreY > scoreX:
X = deepcopy(Y)
dicoObstacles = deepcopy(nouveauDicoObstacles)
else:
RND = random.random() #Il faut jouer ici
# print("ScoreY, ScoreX")
#print( scoreY, scoreX)
if (RND <= math.exp((scoreY - scoreX) / temperature)):
#print("pris")
# print("Hasard",RND,math.exp( (scoreY - scoreX) / temperature) )
X = deepcopy(Y)
dicoObstacles = deepcopy(nouveauDicoObstacles)
if cpt % 100 == 0:
temperature = temperature * tmp
cpt += 1
#bla +=1
#print("nombre de tours",bla)
outils.genererFichierSolution(RX, nomFichier, "recuitSimule")
print("Score recuit simule: ",
outils.calculScore(RX, carac, dicoCaracServeur))
def methodeGloutonne1(nomFichier):
"""
Implementation de l'algorithme glouton de la Q 1.1. du sujet
- Entree :
nomFichier, nom de l'instance sur laquelle on applique l'algorithme
- Sortie :
genere un fichier enregistrant l'affectation,
affiche la repartition des serveurs sur les rangees et le score dans la console
retourne les differentes structure de donnees generees
"""
carac, dicoObstacles, listeServeurs, dicoRangees = outils.creeStructureDonnees(
nomFichier)
affectation = {}
slotTrouve = False
#Creer affectation
for s in listeServeurs:
for r in range(carac["R"]):
numSlot = outils.positionServeurSlot(dicoObstacles[str(r)], s[1],
carac["S"])
if numSlot != None:
for i in range(s[1]):
dicoObstacles[str(r)].append(numSlot + i)
dicoRangees[str(r)][numSlot + i] = str(s[0])
dicoObstacles[str(r)].sort()
slotTrouve = True
affectation[str(s[0])] = [r, numSlot]
break
if slotTrouve == False:
affectation[str(s[0])] = 'x'
slotTrouve = False
#Affection des pools
numPool = -1
valTemp = None
for k in dicoRangees.keys():
for v in dicoRangees[k]:
if not v == 'x':
if not v == valTemp:
if numPool < carac["P"] - 1:
numPool += 1
else:
numPool = 0
affectation[v].append(numPool)
valTemp = v
outils.genererFichierSolution(affectation, nomFichier, "glouton1")
# dicoCaracServeur["id du serveur"] = [taille du serveur, capacite du serveur]
dicoCaracServeur = {}
for serveur in listeServeurs:
dicoCaracServeur[str(serveur[0])] = [serveur[1], serveur[2]]
score = outils.calculScore(affectation, carac, dicoCaracServeur)
print "Score methode gloutonne 1 : ", score
return affectation, carac, listeServeurs, dicoRangees, dicoObstacles
def methodeGloutonne2(nomFichier):
"""
Implementation de notre l'algorithme personnelle glouton de la Q 1.2. du sujet
- Entree :
nomFichier, nom de l'instance sur laquelle on applique l'algorithme
- Sortie :
genere un fichier enregistrant l'affectation,
affiche la repartition des serveurs sur les rangees et le score dans la console
retourne les differentes structure de donnees generees
"""
carac, dicoObstacles, listeServeurs, dicoRangees = outils.creeStructureDonnees(
nomFichier)
listeServeurs = outils.donnerPoolAuxServeurs(listeServeurs, carac)
dicoPoolsCapacite = {}
affectation = {}
slotTrouve = False
# dictionnaire dicoPoolsCapacite
# cle : numero de pool, valeur : [numero de rangee, capacite dans la rangee de ce pool]
for i in range(0, carac['P']):
dicoPoolsCapacite[str(i)] = []
for j in range(0, carac['R']):
dicoPoolsCapacite[str(i)].append([j, 0])
for s in listeServeurs:
for r in dicoPoolsCapacite[str(s[3])]:
numSlot = outils.positionServeurSlot((dicoObstacles[str(r[0])]),
s[1], carac["S"])
if numSlot != None:
for i in range(s[1]):
dicoObstacles[str(r[0])].append(numSlot + i)
dicoRangees[str(r[0])][numSlot + i] = str(s[0])
dicoObstacles[str(r[0])].sort()
slotTrouve = True
affectation[str(s[0])] = [r[0], numSlot, s[3]]
r[1] += s[2]
dicoPoolsCapacite[str(s[3])].sort(key=lambda tup: tup[1])
break
if slotTrouve == False:
affectation[str(s[0])] = 'x'
slotTrouve = False
outils.genererFichierSolution(affectation, nomFichier, "glouton2")
# dicoCaracServeur["id du serveur"] = [taille du serveur, capacite du serveur]
dicoCaracServeur = {}
for serveur in listeServeurs:
dicoCaracServeur[str(serveur[0])] = [serveur[1], serveur[2]]
score = outils.calculScore(affectation, carac, dicoCaracServeur)
print "Score methode gloutonne 2 : ", score
return affectation, carac, listeServeurs, dicoRangees, dicoObstacles
def heuristiqueArrondiPerso2(nomFichier, pourcentage, z_mrsi, dicoCaracServeur,
carac):
# z_mrsi, dicoCaracServeur, carac = resolution_PL(nomFichier, pourcentage, "pl")
masqueServeurLibre = {}
listeTriee = []
for m in z_mrsi.keys():
masqueServeurLibre[m] = True
for r in z_mrsi[m].keys():
for s in z_mrsi[m][r].keys():
for i in z_mrsi[m][r][s].keys():
listeTriee.append((m, r, s, i, z_mrsi[m][r][s][i].x))
listeTriee.sort(key=lambda tup: tup[4], reverse=True)
dicoVerif = {}
affectation = {}
rangeeCapacitesPools = {}
for i in range(0, carac['R']):
dicoVerif[str(i)] = ['' for j in range(carac['S'])]
rangeeCapacitesPools[i] = []
for j in range(0, carac['P']):
rangeeCapacitesPools[i].append([j, 0])
for elt in listeTriee:
placementOk = True
taille = dicoCaracServeur[elt[0]][0]
if masqueServeurLibre[elt[0]]:
for s in range(taille):
if (dicoVerif[elt[1]][int(elt[2]) + s] != ''):
placementOk = False
break
if placementOk:
affectation[elt[0]] = [
int(elt[1]),
int(elt[2]), rangeeCapacitesPools[int(elt[1])][0][0]
] # affecte le pool qui a le moins de capacite
rangeeCapacitesPools[int(elt[1])][0][1] += dicoCaracServeur[
elt[0]][1] #ajoute sa capacité au pool
rangeeCapacitesPools[int(elt[1])].sort(key=lambda tup: tup[1])
masqueServeurLibre[
elt[0]] = False #marque ce serveur comme déjà place
for s in range(taille):
dicoVerif[elt[1]][int(elt[2]) + s] = elt[0]
else:
affectation[elt[0]] = 'x'
score = outils.calculScore(affectation, carac, dicoCaracServeur)
print "Score obtenu avec notre heuristique perso 2 :", score
def heuristiqueArrondi(nomFichier, pourcentage):
z_mrsi, dicoCaracServeur, carac = resolution_PL(nomFichier, pourcentage,
"pl")
# cle : id du serveur, valeur : True / False pour savoir par la suite si le serveur est deja affecte ou non
masqueServeurLibre = {}
listeTriee = []
for m in z_mrsi.keys():
masqueServeurLibre[m] = True
for r in z_mrsi[m].keys():
for s in z_mrsi[m][r].keys():
for i in z_mrsi[m][r][s].keys():
listeTriee.append((m, r, s, i, z_mrsi[m][r][s][i].x))
listeTriee.sort(key=lambda tup: tup[4], reverse=True)
dicoVerif = {}
affectation = {}
for i in range(0, carac['R']):
dicoVerif[str(i)] = ['' for j in range(carac['S'])]
for elt in listeTriee:
placementOk = True
taille = dicoCaracServeur[elt[0]][0]
if masqueServeurLibre[elt[0]]:
for s in range(taille):
if (dicoVerif[elt[1]][int(elt[2]) + s] != ''):
placementOk = False
break
# Si on peut le placer et que le serveur n'a pas encore ete affecte, on le place et on l'affecte
if placementOk:
affectation[elt[0]] = [int(elt[1]), int(elt[2]), int(elt[3])]
masqueServeurLibre[elt[0]] = False
for s in range(taille):
dicoVerif[elt[1]][int(elt[2]) + s] = elt[0]
else:
affectation[elt[0]] = 'x'
score = outils.calculScore(affectation, carac, dicoCaracServeur)
print "Score obtenu avec l'heuristique arrondi :", score
return z_mrsi, dicoCaracServeur, carac