def tournament(sols, vehicles, nodes, L=30):
selected_sols = []
selected_vehicles = []
selected_nodes = []
while len(selected_sols) < L:
i1 = random.randint(0, len(sols) - 1)
sol1 = sols.pop(i1)
z1 = of(vehicles[i1], nodes[i1], sol1)
i2 = random.randint(0, len(sols) - 1)
sol2 = sols.pop(i2)
z2 = of(vehicles[i2], nodes[i2], sol2)
if z1 < z2:
selected_sols.append(sol1)
selected_vehicles.append(vehicles[i1])
selected_nodes.append(nodes[i1])
sols.insert(i2, sol2)
else:
selected_sols.append(sol2)
selected_vehicles.append(vehicles[i2])
selected_nodes.append(nodes[i2])
sols.insert(i1, sol1)
return selected_sols, selected_nodes, selected_vehicles
def vnd(sol, nodes, vehicles, old_z, l=5):
j = 0
new_sol = copy.deepcopy(sol)
z = old_z
while j <= l:
if j % 3 == 0:
new_sol = two_opt(new_sol, nodes)
z = of(vehicles, nodes, new_sol)
elif j % 3 == 1:
new_sol, z = one_one_exchange(new_sol, nodes, vehicles, z)
elif j % 3 == 2:
new_sol, z = move(new_sol, nodes, vehicles, z)
j += 1
return new_sol, z
def hybrid_ga_vnd(nodes, vehicles, gen=5, l=3, p_mut=0.4, people=60):
sols, complete_nodes, complete_vehicles = grasp(
nodes, vehicles, k=people) # Initial solutions
j = 0
selected_sols = sols
while j < gen:
selected_sols, selected_nodes, selected_vehicles = tournament(
selected_sols, complete_vehicles,
complete_nodes) # Selection by tournament
while len(selected_sols) < people:
index_sol = random.randint(0, len(selected_sols) - 1)
for k in range(l):
child, node, vehicle = one_point_crossover(
selected_sols[index_sol], selected_nodes[index_sol],
selected_vehicles[index_sol])
if child is not None:
z_child = of(vehicle, node, child)
if random.random() < p_mut: # Mutation
child, vehicle, node = mutation(child, vehicle, node)
child, z_child = vnd(child, node, vehicle,
z_child) # Local search
selected_sols.append(child)
selected_nodes.append(node)
selected_vehicles.append(vehicle)
break
j += 1
j = 0
best_z = np.Inf
best_sol = []
for sol in selected_sols:
z = of(selected_vehicles[j], selected_nodes[j], sol)
if z < best_z:
best_z = z
best_sol = sol
j += 1
return best_sol, best_z
def move(sol, nodes, vehicles, old_z):
new_sol = copy.deepcopy(sol)
prev_sol = copy.deepcopy(sol)
for r in range(len(new_sol)):
route = new_sol[r]
n = len(route)
if len(route) > 4:
for i in range(1, n - 2):
for j in range(i + 1, n - 1):
route.insert(j, route.pop(i))
z = of(vehicles, nodes, new_sol)
if z < old_z:
route_prev = prev_sol[r]
route_prev.insert(j, route_prev.pop(i))
old_z = z
else:
route.insert(j, route.pop(i))
return prev_sol, old_z
def hybrid_ga(nodes, vehicles, gen=5, l=3, p_mut=0.4, people=60):
sols, complete_nodes, complete_vehicles = grasp(
nodes, vehicles, k=people) # Initial solutions
j = 0
selected_sols = sols
while j < gen:
selected_sols, selected_nodes, selected_vehicles = tournament(
selected_sols, complete_vehicles,
complete_nodes) # Selection by tournament
while len(selected_sols) < people:
index_sol = random.randint(0, len(selected_sols) - 1)
for k in range(l):
child, node, vehicle = one_point_crossover(
selected_sols[index_sol], selected_nodes[index_sol],
selected_vehicles[index_sol])
if child is not None:
z_child = of(vehicle, node, child)
if random.random() < p_mut: # Mutation
child, vehicle, node = mutation(child, vehicle, node)
selected_sols.append(child)
selected_nodes.append(node)
selected_vehicles.append(vehicle)
break
j += 1
j = 0
best_z = np.Inf
best_sol = []
index = [i for i in range(len(selected_sols))]
selected_sols_aux = list(zip(index, selected_sols))
selected_sols_aux = random.sample(selected_sols_aux, 10)
for t in selected_sols_aux:
sol = t[1]
i = t[0]
sol, z = vnd(sol, selected_nodes[i], selected_vehicles[i],
best_z) # Local search
if z < best_z:
best_z = z
best_sol = sol
j += 1
return best_sol, best_z
def one_one_exchange(sol, nodes, vehicles, old_z):
new_sol = copy.deepcopy(sol)
prev_sol = copy.deepcopy(sol)
for r1 in range(len(new_sol) - 1):
for r2 in range(r1, len(new_sol)):
for i in range(1, len(new_sol[r1]) - 1):
for j in range(1, len(new_sol[r2]) - 1):
new_sol[r1][i], new_sol[r2][j] = new_sol[r2][j], new_sol[r1][i]
nodes['assigned'][i][1], nodes['assigned'][j][1] = nodes['assigned'][j][1], nodes['assigned'][i][1]
if check_route(new_sol[r1], nodes, vehicles['capacity'][nodes['assigned'][i][1]]) and \
check_route(new_sol[r2], nodes, vehicles['capacity'][nodes['assigned'][j][1]]):
new_z = of(vehicles, nodes, new_sol)
if new_z - old_z < 0:
prev_sol = copy.deepcopy(new_sol)
old_z = new_z
else:
new_sol[r1][i], new_sol[r2][j] = new_sol[r2][j], new_sol[r1][i]
nodes['assigned'][i][1], nodes['assigned'][j][1] = nodes['assigned'][j][1], \
nodes['assigned'][i][1]
else:
new_sol[r1][i], new_sol[r2][j] = new_sol[r2][j], new_sol[r1][i]
nodes['assigned'][i][1], nodes['assigned'][j][1] = nodes['assigned'][j][1], \
nodes['assigned'][i][1]
return prev_sol, old_z
file_name_grasp = 'grasp.csv'
file_name_vnd = 'vnd_noise.csv'
outfile_grasp = open(file_name_grasp, 'w')
outfile_vnd = open(file_name_vnd, 'w')
for i in range(1, 22):
print('dataset ' + str(i))
# Read data set
vehicles, nodes = read_data(i)
print('finished reading data')
# Constructive Algorithm
sol = sweep(vehicles, nodes)
z = of(vehicles, nodes, sol)
print('finished constructive solution')
# GRASP
# if i != 20:
# time_prev = time.clock()
# sol_grasp, z_grasp = grasp(nodes, vehicles)
# time_after = time.clock()
# if sol_grasp == 'NaN':
# outfile_grasp.write(str(i) + ',' + str(len(nodes['index'])) + ',' + 'inf,inf,inf\n')
# continue
# print('finished GRASP')
# exec_time = str(round(time_after - time_prev, 2))
# percent = str(round(100 * ((z - z_grasp) / z), 2))
#
# outfile_grasp.write(str(i) + ',' + str(len(nodes['index'])) + ',' + percent + ',' + exec_time + ',' +