def vns_opt(initial_solution, value_of_initial, limit_k, iterations, dist_matrix):
problem_size = len(initial_solution)
value_best_solution = value_of_initial
best_solution = initial_solution[:]
echo("Primera Solucion", value_best_solution)
stop_condition = 0
#intento de VNS
#se hace hasta que se alcance el criterio de parada
while stop_condition < iterations:
neigborhood = 1
#repito hasta que alcance al limite de vecindarios
while neigborhood < limit_k:
#creo una solucion de el vecindario correspondiente a neigborhood
k = problem_size/(neigborhood)
neighbor = perturb(best_solution, k, problem_size)
value_neighbor = fobj(neighbor, dist_matrix)
local_optima, value_local_optima = find_local_optima_2opt(neighbor, value_neighbor, dist_matrix)
#print "partial solution",value_local_optima,"best solution",best_solution,"neig",k
if value_local_optima < value_best_solution:
#me muevo a la nueva solucion
echo("new best solution", value_local_optima)
value_best_solution = value_local_optima
best_solution = local_optima[:]
neigborhood = 1
else:
neigborhood+=1
stop_condition+=1
solution_validator(best_solution, problem_size)
return value_best_solution,best_solution
def vns_opt(initial_solution, value_of_initial, limit_k, iterations,
dist_matrix):
problem_size = len(initial_solution)
value_best_solution = value_of_initial
best_solution = initial_solution[:]
echo("Primera Solucion", value_best_solution)
stop_condition = 0
#intento de VNS
#se hace hasta que se alcance el criterio de parada
while stop_condition < iterations:
neigborhood = 1
#repito hasta que alcance al limite de vecindarios
while neigborhood < limit_k:
#creo una solucion de el vecindario correspondiente a neigborhood
k = problem_size / (neigborhood)
neighbor = perturb(best_solution, k, problem_size)
value_neighbor = fobj(neighbor, dist_matrix)
local_optima, value_local_optima = find_local_optima_2opt(
neighbor, value_neighbor, dist_matrix)
#print "partial solution",value_local_optima,"best solution",best_solution,"neig",k
if value_local_optima < value_best_solution:
#me muevo a la nueva solucion
echo("new best solution", value_local_optima)
value_best_solution = value_local_optima
best_solution = local_optima[:]
neigborhood = 1
else:
neigborhood += 1
stop_condition += 1
solution_validator(best_solution, problem_size)
return value_best_solution, best_solution
def opt2_(solution=[], dist_matrix=[]):
"""
Implementacion del algoritmo 2-Optimo o como se supone que deveria
funcionar el algoritmo de arriba
"""
n_vertex = len(solution)
soluc = solution[:]
for i in xrange(n_vertex - 2):
for j in xrange(i+2, n_vertex - 1):
sol = soluc[:]
ini = soluc[:i+1]
med = soluc[i+1:j+1]
med.reverse()
fin = soluc[j+1:]
sol = ini + med + fin
if fobj(sol, dist_matrix) < fobj(soluc, dist_matrix):
soluc = sol[:]
return soluc
def opt2_(solution=[], dist_matrix=[]):
"""
Implementacion del algoritmo 2-Optimo o como se supone que deveria
funcionar el algoritmo de arriba
"""
n_vertex = len(solution)
soluc = solution[:]
for i in xrange(n_vertex - 2):
for j in xrange(i + 2, n_vertex - 1):
sol = soluc[:]
ini = soluc[:i + 1]
med = soluc[i + 1:j + 1]
med.reverse()
fin = soluc[j + 1:]
sol = ini + med + fin
if fobj(sol, dist_matrix) < fobj(soluc, dist_matrix):
soluc = sol[:]
return soluc
def vns_opt_improved(initial_solution, value_of_initial, limit_k, iterations,
probability, dist_matrix):
maximum = 1
problem_size = len(initial_solution)
value_best_solution = value_of_initial
best_solution = initial_solution[:]
memory = create_memory(problem_size)
echo("Primera Solucion", value_best_solution)
stop_condition = 0
#intento de VNS
#se hace hasta que se alcance el criterio de parada
iter_counter = 0
invert_mode = False
while stop_condition < iterations:
neigborhood = 1
#repito hasta que alcance al limite de vecindarios
while neigborhood < limit_k:
iter_counter += 1
#creo una solucion de el vecindario correspondiente a neigborhood
k = problem_size / (neigborhood)
#k = problem_size-((problem_size/limit_k)*neigborhood)
#neighbor = perturb(best_solution, k, problem_size)
if iter_counter == 50:
invert_mode = True
#memory = create_memory(problem_size)
neighbor = create_neighbor(best_solution, k, memory, maximum,
probability, dist_matrix, invert_mode)
value_neighbor = fobj(neighbor, dist_matrix)
local_optima, value_local_optima = find_local_optima_2opt(
neighbor, value_neighbor, dist_matrix)
#print "partial solution",value_local_optima,"best solution",value_best_solution,"neig",k
if value_local_optima <= (value_best_solution * 1.1):
#memory,maximum = update_memory(memory,local_optima,maximum)
memory, maximum = update_memory(memory, neighbor, maximum)
#print "memory updated", value_local_optima, (value_best_solution*1.1)
#else:
#print "no update", value_local_optima, (value_best_solution*1.1)
if value_local_optima < value_best_solution:
#me muevo a la nueva solucion
echo("new best solution", value_local_optima, "iter",
iter_counter)
value_best_solution = value_local_optima
best_solution = local_optima[:]
neigborhood = 1
iter_counter = 0
invert_mode = False
else:
neigborhood += 1
stop_condition += 1
echo(iter_counter)
solution_validator(best_solution, problem_size)
return value_best_solution, best_solution
def vns_opt_improved(initial_solution, value_of_initial, limit_k, iterations, probability, dist_matrix):
maximum = 1
problem_size = len(initial_solution)
value_best_solution = value_of_initial
best_solution = initial_solution[:]
memory = create_memory(problem_size)
echo("Primera Solucion", value_best_solution)
stop_condition = 0
#intento de VNS
#se hace hasta que se alcance el criterio de parada
iter_counter = 0
invert_mode = False
while stop_condition < iterations:
neigborhood = 1
#repito hasta que alcance al limite de vecindarios
while neigborhood < limit_k:
iter_counter += 1
#creo una solucion de el vecindario correspondiente a neigborhood
k = problem_size/(neigborhood)
#k = problem_size-((problem_size/limit_k)*neigborhood)
#neighbor = perturb(best_solution, k, problem_size)
if iter_counter == 50:
invert_mode = True
#memory = create_memory(problem_size)
neighbor = create_neighbor(best_solution,k,memory,maximum,probability,dist_matrix,invert_mode)
value_neighbor = fobj(neighbor, dist_matrix)
local_optima, value_local_optima = find_local_optima_2opt(neighbor, value_neighbor, dist_matrix)
#print "partial solution",value_local_optima,"best solution",value_best_solution,"neig",k
if value_local_optima <= (value_best_solution*1.1):
#memory,maximum = update_memory(memory,local_optima,maximum)
memory,maximum = update_memory(memory,neighbor,maximum)
#print "memory updated", value_local_optima, (value_best_solution*1.1)
#else:
#print "no update", value_local_optima, (value_best_solution*1.1)
if value_local_optima < value_best_solution:
#me muevo a la nueva solucion
echo("new best solution", value_local_optima, "iter", iter_counter)
value_best_solution = value_local_optima
best_solution = local_optima[:]
neigborhood = 1
iter_counter = 0
invert_mode = False
else:
neigborhood += 1
stop_condition+=1
echo(iter_counter)
solution_validator(best_solution, problem_size)
return value_best_solution, best_solution
def find_local_optima_2opt(solution_o = [],value_of_solution = 0, distances = []):
"""
Aplica una heurística hasta que encuentra un optimo local
"""
solution = solution_o[:]
value_temp = 0
local_optima = 0
while not local_optima:
temp_solution = opt2(solution,distances)
value_temp = fobj(temp_solution, distances)
if value_of_solution == value_temp:
local_optima = 1
if value_temp < value_of_solution:
solution = temp_solution
value_of_solution = value_temp
return solution, value_of_solution
def find_local_optima_2opt(solution_o=[], value_of_solution=0, distances=[]):
"""
Aplica una heurística hasta que encuentra un optimo local
"""
solution = solution_o[:]
value_temp = 0
local_optima = 0
while not local_optima:
temp_solution = opt2(solution, distances)
value_temp = fobj(temp_solution, distances)
if value_of_solution == value_temp:
local_optima = 1
if value_temp < value_of_solution:
solution = temp_solution
value_of_solution = value_temp
return solution, value_of_solution
def find_local_optima_2optmod(solution = [],value_of_solution = 0, distances = []):
"""
Aplica una heurística hasta que encuentra un optimo local
"""
value_temp = 0
local_optima = 0
counter = 0
while not local_optima:
temp_solution = vns_opt2(solution,distances)
value_temp = fobj(temp_solution, distances)
if value_of_solution == value_temp:
local_optima = 1
if value_temp < value_of_solution:
solution = temp_solution
value_of_solution = value_temp
counter +=1
print counter
return solution, value_of_solution
def find_local_optima_2optmod(solution=[], value_of_solution=0, distances=[]):
"""
Aplica una heurística hasta que encuentra un optimo local
"""
value_temp = 0
local_optima = 0
counter = 0
while not local_optima:
temp_solution = vns_opt2(solution, distances)
value_temp = fobj(temp_solution, distances)
if value_of_solution == value_temp:
local_optima = 1
if value_temp < value_of_solution:
solution = temp_solution
value_of_solution = value_temp
counter += 1
print counter
return solution, value_of_solution
