def procedure1_nd_tree(n, p, k, w):
print("procedure1_ND_tree n={} p={}".format(n, p))
data = file_parsing.get_data(n, p)
# print("Recherche locale:\n\n")
time1 = time.time()
[allx, ally] = nd_tree.nd_tree(n, k, p, data)
time2 = time.time()
ally_for_file = copy.deepcopy(ally)
# print("Données utilisées: ", data)
# print("Vecteurs d'affectation solutions: ", allx)
# print("Valeurs des évaluations: ", ally)
# print("\n\nElicitation incrémentale:\nNombre de solutions potentielles:", len(ally), "\n\n")
time3 = time.time()
[opt, opt_value, nb_q, _,
_] = incremental_elicitation.mmr_incremental_elicitaiton(
allx, ally, w, [])
time4 = time.time()
# print("Solution optimale: ", opt)
# print("Valeur de la solution: ", opt_value)
# print("Poids du décideur: ", w)
# print("Nombre de questions: ", nb_q)
real_opt = compare_to_file(n, p, k)
file_parsing.write_res_proc1_nd_tree(opt_value, real_opt, n, p, w, nb_q,
time2 - time1, time4 - time3)
def create_starting_solution():
###############
### fonction locale
##############
def find_best_objets(w):
# calculer le score d'un objet selon w
compute_score = lambda i: sum(
[data[i][j] * w[j] for j in range(len(w))])
# ordonner les objets selon leurs scores
index = list(range(len(data)))
index_ordered = sorted(index, key=compute_score)
# ordre croissant
index_ordered = reversed(index_ordered)
# decroissant
index_ordered = list(index_ordered) # convertir a une liste
x = [
1 if i in index_ordered[:k] else 0
for i in list(range(len(data)))
]
# on prend les k meilleurs objets
return x # une solution
############
### main
############
evidence = []
# parametre
m = 2 * n
# Etape 1: on cree un ensemble de vecteur de poids aléatoire simulant les préférences du décideur
ws = []
for i in range(m):
# on crée un vecteur de poids aléatoire simulant les préférences du décideur
w = [random.uniform(0, 1) for i in range(p)]
# on le normalise pour que la somme du vecteur fasse 1
w = [w[i] / sum(w) for i in range(p)]
# on ajoute w dans ws
ws.append(w)
# Etape 2: pour chaque w trouver une solution optimale
xs = [find_best_objets(w) for w in ws]
# pour chaque w trouver une solution optimale
# Etape 3: find le most promising solution within xs
allx = xs
ally = [compute_evaluation(x) for x in xs]
compute_dominance(allx, ally)
x, eval_x, nb_q, evidence, mr = incremental_elicitation.mmr_incremental_elicitaiton(
allx, ally, w, evidence)
return x, eval_x, evidence
def procedure1_PLS(n, p, k, w, start_time):
print("procedure1_PLS n={} p={}".format(n, p))
data = file_parsing.get_data(n, p) # n: nb de objets; p: nb de criteres
# print("Recherche locale:\n\n")
time1 = time.time()
[allx, ally] = local_search.neighbor_local_search(n, k, p, data)
time2 = time.time()
ally_for_file = copy.deepcopy(ally)
#print("Données utilisées: ", data)
#print("Vecteurs d'affectation solutions: ", allx)
#print("Valeurs des évaluations: ", ally)
# print("\n\nElicitation incrémentale:\nNombre de solutions potentielles:", len(ally), "\n\n")
time3 = time.time()
evidence = []
[opt, opty, opt_value, nb_q, _,
_] = incremental_elicitation.mmr_incremental_elicitaiton(
allx, ally, w, evidence)
time4 = time.time()
# print("Solution optimale: ", opt)
# print("Valeur de la solution: ", opt_value)
# print("Poids du décideur: ", w)
# print("Nombre de questions: ", nb_q)
real_opt = compare_to_file(n, p, k)
real_opt = sum(w[i] * real_opt[i] for i in range(len(w)))
file_parsing.write_res_proc1_PLS(opt_value, real_opt, n, p, w, nb_q,
time2 - time1, time4 - time3)
print("END procedure1_PLS n={} p={} time={}".format(n, p, time.time()))
return
def interactive_local_search(n, k, p, data, w):
################
### fonctions locales
###############
def compute_evaluation(x):
y = [0] * p
j = 0
# on fait ici une somme pour faire l'evaluation
while j < p:
i = 0
while i < n:
y[j] += x[i] * data[i][j]
i += 1
j += 1
return y
def create_starting_solution():
###############
### fonction locale
##############
def find_best_objets(w):
# calculer le score d'un objet selon w
compute_score = lambda i: sum(
[data[i][j] * w[j] for j in range(len(w))])
# ordonner les objets selon leurs scores
index = list(range(len(data)))
index_ordered = sorted(index, key=compute_score)
# ordre croissant
index_ordered = reversed(index_ordered)
# decroissant
index_ordered = list(index_ordered) # convertir a une liste
x = [
1 if i in index_ordered[:k] else 0
for i in list(range(len(data)))
]
# on prend les k meilleurs objets
return x # une solution
############
### main
############
evidence = []
# parametre
m = 2 * n
# Etape 1: on cree un ensemble de vecteur de poids aléatoire simulant les préférences du décideur
ws = []
for i in range(m):
# on crée un vecteur de poids aléatoire simulant les préférences du décideur
w = [random.uniform(0, 1) for i in range(p)]
# on le normalise pour que la somme du vecteur fasse 1
w = [w[i] / sum(w) for i in range(p)]
# on ajoute w dans ws
ws.append(w)
# Etape 2: pour chaque w trouver une solution optimale
xs = [find_best_objets(w) for w in ws]
# pour chaque w trouver une solution optimale
# Etape 3: find le most promising solution within xs
allx = xs
ally = [compute_evaluation(x) for x in xs]
compute_dominance(allx, ally)
x, eval_x, nb_q, evidence, mr = incremental_elicitation.mmr_incremental_elicitaiton(
allx, ally, w, evidence)
return x, eval_x, evidence
def compute_dominance(allx, ally):
toremovex = []
toremovey = []
# on calcule les dominance pour chaque paire de solution i et j
i = 0
while i < len(allx):
j = i + 1
while j < len(ally):
k = 0
domi = 0
domj = 0
# on calcul le nombre de fois où j domine i, et le nombre de fois où i domine j
while k < p:
if ally[i][k] < ally[j][k]:
domj += 1
if ally[i][k] > ally[j][k]:
domi += 1
k += 1
# si une des solutions ne domine jamais l'autre strictement, elle est donc dominée faiblement
# on l'ajoute à la liste des solutions à retirer
# attention au cas où les évaluations sont égales!
if domi == 0 and domj > 0 and allx[i] not in toremovex:
toremovex.append(allx[i])
toremovey.append(ally[i])
# print("i",i,j)
if domj == 0 and domi > 0 and allx[j] not in toremovex:
toremovex.append(allx[j])
toremovey.append(ally[j])
# print("j",i,j)
j += 1
i += 1
# on retire les elements dominés des listes allx et ally
for x in toremovex:
allx.remove(x)
for y in toremovey:
ally.remove(y)
def compute_dominance2(allx, ally, newx, newy):
toremove = []
addnew = True
for i in range(len(ally)):
dom1 = 0
dom2 = 0
# on calcul le nombre de fois où j domine i, et le nombre de fois où i domine j
for k in range(p):
if ally[i][k] < newy[k]:
dom2 += 1
if ally[i][k] > newy[k]:
dom1 += 1
if dom1 == 0 and dom2 > 0:
toremove.append(i)
if dom2 == 0 and dom1 > 0:
addnew = False
for i in reversed(toremove):
allx.pop(i)
ally.pop(i)
if addnew:
allx.append(newx)
ally.append(newy)
def neighbors(x, allx, ally):
# on récupère les voisins de la manière suivante:
# si la ième composante vaut 1 et la jème vaut 0
# on fait une copie du vecteur et on met i à 0 et j à 1
# on répète le procédé pour toutes les combinaisons de i et j possible
i = 0
while i < n:
if x[i] == 1:
j = 0
while j < n:
if (x[j] == 0 and i != j):
x1 = copy.deepcopy(x)
x1[i] = 0
x1[j] = 1
# on n'ajoute pas de solution déjà existante dans notre ensemble
if (x1 not in allx):
y1 = compute_evaluation(x1)
#allx.append(x1)
#ally.append(y1)
compute_dominance2(allx, ally, x1, y1)
j += 1
i += 1
#######################
### MAIN : combinaison de LS et Incremental_elicitation
#######################
######################
### Find a promising starting solution
######################
# création d'un vecteur aléatoire et calcule de son évaluation
x, eval_x, evidence = create_starting_solution()
y = compute_evaluation(x)
#######################
### Local improvement
######################
improve = True
nb_q = 0
while improve:
# création de listes pour stocker nos solutions et leur évaluation
allx = []
allx.append(x)
ally = []
ally.append(y)
# recherche du voisinage de x
neighbors(x, allx, ally)
# on supprime les solutions dominées
compute_dominance(allx, ally)
newx, eval_newx, new_nb_q, evidence, mr_x = incremental_elicitation.mmr_incremental_elicitaiton(
allx, ally, w, evidence)
nb_q += new_nb_q
if mr_x > 0:
x = newx
y = eval_newx
else:
improve = False
return x, y, nb_q