def retrieve_solutions(
self, result, parameters_cp: ParametersCP = ParametersCP.default()
) -> ResultStorage:
intermediate_solutions = parameters_cp.intermediate_solution
colors = []
objectives = []
solutions_fit = []
if intermediate_solutions:
for i in range(len(result)):
colors += [result[i, "color_graph"]]
objectives += [result[i, "objective"]]
else:
colors += [result["color_graph"]]
objectives += [result["objective"]]
for k in range(len(colors)):
sol = [
colors[k][self.index_nodes_name[self.nodes_name[i]]] - 1
for i in range(self.number_of_nodes)
]
color_sol = ColoringSolution(self.coloring_problem, sol)
fit = self.aggreg_sol(color_sol)
solutions_fit += [(color_sol, fit)]
return ResultStorage(
list_solution_fits=solutions_fit,
limit_store=False,
mode_optim=self.params_objective_function.sense_function)
def solve(self, **args):
max_time_seconds = args.get("max_time_seconds", 5)
result = self.instance.solve(timeout=timedelta(
seconds=max_time_seconds))
print("Result = ", result)
circuit = result["x"]
start_index = self.start_index
path = []
cur_pos = self.start_index
init = False
while cur_pos != self.end_index or not init:
next_pos = circuit[cur_pos] - 1
path += [next_pos]
cur_pos = next_pos
init = True
var_tsp = SolutionTSP(problem=self.tsp_model,
start_index=self.start_index,
end_index=self.end_index,
permutation=path[:-1],
length=None,
lengths=None)
fit = self.aggreg_sol(var_tsp)
return ResultStorage(
list_solution_fits=[(var_tsp, fit)],
mode_optim=self.params_objective_function.sense_function)
def solve(self):
"""Prints solution on console."""
solution = self.routing.SolveWithParameters(self.search_parameters)
print('Objective: {} miles'.format(solution.ObjectiveValue()))
index = self.routing.Start(0)
index_real = self.manager.IndexToNode(index)
sol = [index_real]
route_distance = 0
while not self.routing.IsEnd(index):
previous_index = index
index = solution.Value(self.routing.NextVar(index))
index_real = self.manager.IndexToNode(index)
sol += [index_real]
route_distance += self.routing.GetArcCostForVehicle(
previous_index, index, 0)
print(sol)
variableTSP = SolutionTSP(problem=self.tsp_model,
start_index=self.tsp_model.start_index,
end_index=self.tsp_model.end_index,
permutation=sol[1:-1],
lengths=None,
length=None)
fitness = self.aggreg_sol(variableTSP)
return ResultStorage(
list_solution_fits=[(variableTSP, fitness)],
mode_optim=self.params_objective_function.sense_function)
def solve(self):
res = best_of_greedy(self.knapsack_model)
fit = self.aggreg_sol(res)
return ResultStorage(
list_solution_fits=[(res, fit)],
best_solution=res,
mode_optim=self.params_objective_function.sense_function)
def retrieve_solutions(self, range_solutions: Iterable[int]):
# nObjectives = S.NumObj
solutions = []
fits = []
# x = S.getVars()
for s in range_solutions:
weight = 0
xs = {}
self.model.params.SolutionNumber = s
obj = self.model.getAttr("ObjVal")
for e in self.variable_decision["x"]:
value = self.variable_decision["x"][e].getAttr('Xn')
if value <= 0.1:
xs[e] = 0
continue
xs[e] = 1
weight += self.knapsack_model.index_to_item[e].weight
solutions += [
KnapsackSolution(problem=self.knapsack_model,
value=obj,
weight=weight,
list_taken=[xs[e] for e in sorted(xs)])
]
fits += [self.aggreg_sol(solutions[-1])]
return ResultStorage(
list_solution_fits=[(s, f) for s, f in zip(solutions, fits)],
mode_optim=self.params_objective_function.sense_function)
def retrieve_solutions(self, range_solutions: Iterable[int]):
# nObjectives = S.NumObj
solutions = []
fits = []
# x = S.getVars()
for s in range_solutions:
weight = 0
xs = {}
obj = self.model.objective_values[s]
value_kp = 0
for e in self.variable_decision["x"]:
value = self.variable_decision["x"][e].xi(s)
if value <= 0.1:
xs[e] = 0
continue
xs[e] = 1
weight += self.knapsack_model.index_to_item[e].weight
value_kp += self.knapsack_model.index_to_item[e].value
solutions += [
KnapsackSolution(problem=self.knapsack_model,
value=value_kp,
weight=weight,
list_taken=[xs[e] for e in sorted(xs)])
]
fits += [self.aggreg_sol(solutions[-1])]
print(self.aggreg_sol)
return ResultStorage(
list_solution_fits=[(sol, fit)
for sol, fit in zip(solutions, fits)],
mode_optim=self.params_objective_function.sense_function)
def solve(self):
self.model.SetTimeLimit(60000)
res = self.model.Solve()
resdict = {
0: 'OPTIMAL',
1: 'FEASIBLE',
2: 'INFEASIBLE',
3: 'UNBOUNDED',
4: 'ABNORMAL',
5: 'MODEL_INVALID',
6: 'NOT_SOLVED'
}
print('Result:', resdict[res])
objective = self.model.Objective().Value()
xs = {}
x = self.variable_decision["x"]
weight = 0
for i in x:
sv = x[i].solution_value()
if sv >= 0.5:
xs[i] = 1
weight += self.knapsack_model.index_to_item[i].weight
else:
xs[i] = 0
sol = KnapsackSolution(problem=self.knapsack_model,
value=objective,
weight=weight,
list_taken=[xs[e] for e in sorted(xs)])
fit = self.aggreg_sol(sol)
return ResultStorage(
list_solution_fits=[(sol, fit)],
mode_optim=self.params_objective_function.sense_function)
def solve(self):
sol = KnapsackSolution(problem=self.knapsack_model,
value=0,
weight=0,
list_taken=[0] * self.knapsack_model.nb_items)
fit = self.aggreg_sol(sol)
return ResultStorage(
list_solution_fits=[(sol, fit)],
best_solution=sol,
mode_optim=self.params_objective_function.sense_function)
def solve(self, **kwargs):
if self.manager is None:
self.init_model(**kwargs)
limit_time_s = kwargs.get("limit_time_s", 100)
self.search_parameters.time_limit.seconds = limit_time_s
print("Solving")
solution = self.routing.SolveWithParameters(self.search_parameters)
print(solution)
variable_vrp = self.retrieve(solution)
fit = self.aggreg_sol(variable_vrp)
return ResultStorage(
list_solution_fits=[(variable_vrp, fit)],
mode_optim=self.params_objective_function.sense_function)
def solve(self, **kwargs):
computed_value = self.model.Solve()
print('Total value =', computed_value)
xs = {}
weight = 0
value = 0
for i in range(self.knapsack_model.nb_items):
if self.model.BestSolutionContains(i):
#packed_weights.append(self.knapsack_model.list_items[i].weight)
weight += self.knapsack_model.list_items[i].weight
value += self.knapsack_model.list_items[i].value
xs[self.knapsack_model.list_items[i].index] = 1
else:
xs[self.knapsack_model.list_items[i].index] = 0
sol = KnapsackSolution(problem=self.knapsack_model,
value=value,
weight=weight,
list_taken=[xs[e] for e in sorted(xs)])
fit = self.aggreg_sol(sol)
return ResultStorage(
list_solution_fits=[(sol, fit)],
mode_optim=self.params_objective_function.sense_function)
def solve(self, **kwargs) -> ResultStorage:
solution = [-1] * self.facility_problem.customer_count
capacity_remaining = [
f.capacity for f in self.facility_problem.facilities
]
facility_index = 0
for index in range(len(self.facility_problem.customers)):
customer = self.facility_problem.customers[index]
if capacity_remaining[facility_index] >= customer.demand:
solution[index] = facility_index
capacity_remaining[facility_index] -= customer.demand
else:
facility_index += 1
assert capacity_remaining[facility_index] >= customer.demand
solution[index] = facility_index
capacity_remaining[facility_index] -= customer.demand
sol = FacilitySolution(problem=self.facility_problem,
facility_for_customers=solution)
fit = self.aggreg_sol(sol)
return ResultStorage(
list_solution_fits=[(sol, fit)],
best_solution=sol,
mode_optim=self.params_objective_function.sense_function)
def solve(self, **kwargs):
solver_name = kwargs.get("solver_name", CBC)
do_lns = kwargs.get("do_lns", False)
fraction = kwargs.get("fraction_lns", 0.9)
nb_iteration_max = kwargs.get("nb_iteration_max", 20)
if self.model is None:
kwargs["solver_name"] = solver_name
kwargs["do_lns"] = do_lns
kwargs["fraction_lns"] = fraction
self.init_model(**kwargs)
print("optimizing...")
limit_time_s = kwargs.get("limit_time_s", 10)
self.model.optimize(max_seconds=limit_time_s)
objective = self.model.objective_value
# "C5t0ynWADsH8TEiH"
# Query number of multiple objectives, and number of solutions
finished = False
solutions = []
cost = []
nb_components = []
iteration = 0
rebuilt_solution = []
rebuilt_obj = []
best_solution_rebuilt_index = 0
best_solution_objective_rebuilt = float('inf')
vehicle_count = self.problem.vehicle_count
customers = self.problem.customers
customer_count = self.problem.customer_count
edges_in_customers = self.graph_infos["edges_in_customers"]
edges_out_customers = self.graph_infos["edges_out_customers"]
edges_in_merged_graph = self.graph_infos["edges_in_merged_graph"]
edges_out_merged_graph = self.graph_infos["edges_out_merged_graph"]
edges = self.graph_infos["edges"]
edges_warm_set = self.graph_infos["edges_warm_set"]
g = self.graph
while not finished:
solutions_ll = retreve_solutions(self.model, self.x_var,
vehicle_count, g)
solutions += [solutions_ll[0]["x_solution"]]
cost += [objective]
# print(solutions)
x_solution, rebuilt_dict, \
obj, components, components_global, component_all, component_global_all = \
reevaluate_solutions(solutions_ll, vehicle_count, g,
vrp_problem=self.problem)
# for components_per_vehicle in component_all:
# update_model(self.problem,
# self.model,
# self.x_var,
# components_per_vehicle,
# edges_in_customers,
# edges_out_customers)
for comp in component_global_all:
update_model_2(self.problem, self.model, self.x_var, comp,
edges_in_customers, edges_out_customers)
nb_components += [len(components_global)]
rebuilt_solution += [rebuilt_dict]
rebuilt_obj += [obj]
print('Objective rebuilt : ', rebuilt_obj[-1])
if obj < best_solution_objective_rebuilt:
best_solution_objective_rebuilt = obj
best_solution_rebuilt_index = iteration
iteration += 1
if len(component_global_all[0]) > 1 or True:
edges_to_add = set()
for v in rebuilt_dict:
edges_to_add.update({
(e0, e1)
for e0, e1 in zip(rebuilt_dict[v][:-1], rebuilt_dict[v]
[1:])
})
# print("len rebuilt : ", len(rebuilt_dict[v]))
print("edges to add , ", edges_to_add)
edges_missing = {e for e in edges_to_add if e not in edges}
print("missing : ", edges_missing)
if len(edges_missing) > 0:
g, edges, edges_in_customers, edges_out_customers, edges_in_merged_graph, edges_out_merged_graph = \
update_graph(g, edges, edges_in_customers,
edges_out_customers,
edges_in_merged_graph,
edges_out_merged_graph,
edges_missing,
customers)
# self.model.reset()
self.model = None
tsp_model, x_var, constraint_flow_in, constraint_flow_out, constraint_on_edge = \
init_model_lp(g=g,
edges=edges,
edges_in_customers=edges_in_customers,
edges_out_customers=edges_out_customers,
edges_in_merged_graph=edges_in_merged_graph,
edges_out_merged_graph=edges_out_merged_graph,
edges_warm_set=edges_warm_set,
start_indexes=self.problem.start_indexes,
end_indexes=self.problem.end_indexes,
do_lns=do_lns,
fraction=fraction,
vehicle_count=self.problem.vehicle_count,
vehicle_capacity=self.problem.vehicle_capacities,
solver_name=solver_name)
self.model = tsp_model
self.x_var = x_var
self.constraint_on_edge = constraint_on_edge
self.graph = g
self.graph_infos = {
"edges": edges,
"edges_in_customers": edges_in_customers,
"edges_out_customers": edges_out_customers,
"edges_in_merged_graph": edges_in_merged_graph,
"edges_out_merged_graph": edges_out_merged_graph,
"edges_warm_set": edges_warm_set
}
edges_in_customers = self.graph_infos["edges_in_customers"]
edges_out_customers = self.graph_infos[
"edges_out_customers"]
edges_in_merged_graph = self.graph_infos[
"edges_in_merged_graph"]
edges_out_merged_graph = self.graph_infos[
"edges_out_merged_graph"]
edges = self.graph_infos["edges"]
edges_warm_set = self.graph_infos["edges_warm_set"]
for iedge in self.constraint_on_edge:
self.model.remove(self.constraint_on_edge[iedge])
self.model.update()
self.constraint_on_edge = {}
edges_to_constraint = set(self.x_var.keys())
if do_lns:
edges_to_constraint = set(
random.sample(list(self.x_var.keys()),
int(fraction * len(self.x_var))))
for iedge in self.constraint_on_edge:
self.model.remove(self.constraint_on_edge[iedge])
self.model.update()
self.constraint_on_edge = {}
edges_to_constraint = set()
vehicle = set(
random.sample(range(vehicle_count),
min(4, vehicle_count)))
edges_to_constraint.update(
set([e for e in edges if e[0][0] not in vehicle]))
# customers_to_constraint = set(random.sample(range(1, customer_count),
# int(fraction * customer_count)))
# edges_to_constraint.update(set([edge for edge in edges
# if (edge[0][1] in customers_to_constraint
# or edge[1][1] in customers_to_constraint) ]))
print(len(edges_to_constraint), " edges constraint over ",
len(edges))
# print(rebuilt[0], rebuilt[-1])
# print("len set rebuilt (debug) ", len(set(rebuilt_dict[v])))
iedge = 0
x_var = self.x_var
start = []
if all((e in edges) for e in edges_to_add):
# print("setting default value")
for e in x_var:
val = 0
if e in edges_to_add:
start += [(x_var[e], 1)]
val = 1
else:
start += [(x_var[e], 0)]
if e in edges_to_constraint:
if do_lns:
self.constraint_on_edge[
iedge] = self.model.add_constr(
x_var[e] == val, name=str((e, iedge)))
iedge += 1
self.model.update()
else:
pass
# print([e for e in edges_to_add if e not in edges])
self.model.start = start
self.model.optimize(max_seconds=limit_time_s)
objective = self.model.objective_value
else:
finished = True
finished = finished or iteration >= nb_iteration_max
plot = kwargs.get("plot", True)
if plot:
fig, ax = plt.subplots(2)
for i in range(len(solutions)):
ll = []
for v in solutions[i]:
for e in solutions[i][v]:
ll.append(ax[0].plot(
[customers[e[0][1]].x, customers[e[1][1]].x],
[customers[e[0][1]].y, customers[e[1][1]].y],
color="b"))
ax[1].plot(
[customers[n[1]].x for n in rebuilt_solution[i][v]],
[customers[n[1]].y for n in rebuilt_solution[i][v]],
color="orange")
ax[0].set_title("iter " + str(i) + " obj=" + str(int(cost[i])))
ax[1].set_title("iter " + str(i) + " obj=" +
str(int(rebuilt_obj[i])))
# fig.savefig('./images/vrp_' + str(i) + ".png")
plt.draw()
plt.pause(0.01)
ax[0].lines = []
ax[1].lines = []
plt.show()
print("Best obj : ", best_solution_objective_rebuilt)
print(rebuilt_obj[best_solution_rebuilt_index])
solution = VrpSolution(
problem=self.problem,
list_start_index=self.problem.start_indexes,
list_end_index=self.problem.end_indexes,
list_paths=[[
x[1]
for x in rebuilt_solution[best_solution_rebuilt_index][l][1:-1]
] for l in sorted(rebuilt_solution[best_solution_rebuilt_index])],
length=None,
lengths=None,
capacities=None)
fit = self.aggreg_sol(solution)
return ResultStorage(
list_solution_fits=[(solution, fit)],
mode_optim=self.params_objective_function.sense_function)
def solve(self, **kwargs):
sol, fit = trivial_solution(self.vrp_model)
fit = self.aggreg_sol(sol)
return ResultStorage(list_solution_fits=[(sol, fit)],
mode_optim=self.params_objective_function.sense_function)