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, result,
parameters_cp: ParametersCP) -> ResultStorage:
intermediate_solutions = parameters_cp.intermediate_solution
l_items = []
objectives = []
if intermediate_solutions:
for i in range(len(result)):
l_items += [result[i, "list_items"]]
objectives += [result[i, "objective"]]
else:
l_items += [result["list_items"]]
objectives += [result["objective"]]
list_solutions_fit = []
for items, objective in zip(l_items, objectives):
taken = [0] * self.knapsack_model.nb_items
weight = 0
value = 0
for i in range(len(items)):
if items[i] != 0:
taken[self.knapsack_model.list_items[items[i] -
1].index] = 1
weight += self.knapsack_model.list_items[items[i] -
1].weight
value += self.knapsack_model.list_items[items[i] - 1].value
sol = KnapsackSolution(problem=self.knapsack_model,
value=value,
weight=weight,
list_taken=taken)
fit = self.aggreg_sol(sol)
list_solutions_fit += [(sol, fit)]
return ResultStorage(
list_solution_fits=list_solutions_fit,
best_solution=None,
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 apply_local_move(self, solution: KnapsackSolution) -> Solution:
if solution.weight is None:
self.problem.evaluate(solution)
l = getattr(solution, self.attribute)
weight = solution.weight
value = solution.value
for index in self.list_index_flip:
l[index] = (1 - l[index])
if l[index] == 0:
weight -= self.problem.list_items[index].weight
value -= self.problem.list_items[index].value
else:
weight += self.problem.list_items[index].weight
value += self.problem.list_items[index].value
solution.weight = weight
solution.value = value
return solution
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 retrieve(self, items_taken):
taken = [0] * self.knapsack_model.nb_items
weight = 0
value = 0
for i in range(len(items_taken)):
if items_taken[i] != 0:
taken[self.knapsack_model.list_items[i].index] = 1
weight += self.knapsack_model.list_items[i].weight
value += self.knapsack_model.list_items[i].value
return [
KnapsackSolution(problem=self.knapsack_model,
value=value,
weight=weight,
list_taken=taken)
]
def greedy_using_queue(knapsack_model: KnapsackModel,
method_queue=None) -> KnapsackSolution:
if method_queue is None:
method_queue = compute_density
value = 0
weight = 0
taken = [0] * knapsack_model.nb_items
sorted_per_density = method_queue(knapsack_model)
for i in range(len(taken)):
if sorted_per_density[i].weight + weight <= knapsack_model.max_capacity:
taken[sorted_per_density[i].index] = 1
value += sorted_per_density[i].value
weight += sorted_per_density[i].weight
else:
continue
return KnapsackSolution(problem=knapsack_model,
value=value,
weight=weight,
list_taken=taken)
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_np(self, **args):
start_by_most_promising = args.get('greedy_start', False)
stop_after_n_item = args.get('stop_after_n_item', False)
max_items = args.get('max_items', self.knapsack_model.nb_items + 1)
max_time_seconds = args.get('max_time_seconds', None)
if max_time_seconds is None:
do_time = False
else:
do_time = True
if start_by_most_promising:
promising = sorted([
l for l in self.knapsack_model.list_items
if l.weight <= self.knapsack_model.max_capacity
],
key=lambda x: x.value / x.weight,
reverse=True)
index_promising = [l.index for l in promising]
else:
index_promising = [l.index for l in self.knapsack_model.list_items]
if do_time:
t_start = time.time()
cur_indexes = (0, 0)
for nb_item in range(1, max_items):
if do_time:
if time.time() - t_start > max_time_seconds:
break
index_item = self.knapsack_model.index_to_index_list[
index_promising[nb_item - 1]]
weight = self.knapsack_model.list_items[index_item].weight
value = self.knapsack_model.list_items[index_item].value
vec_1 = self.table[nb_item - 1, :]
ind = [
max(capacity - weight, 0)
for capacity in range(self.capacity + 1)
]
vec_2 = vec_1[ind] + value * (ind != 0)
self.table[nb_item, :] = np.maximum(vec_1, vec_2)
cur_indexes = (nb_item, self.capacity)
print("Cur obj : ", self.table[nb_item, self.capacity])
taken = [0] * self.nb_items
weight = 0
value = 0
cur_value = self.table[cur_indexes[0], cur_indexes[1]]
while cur_indexes[0] != 0:
value_left = self.table[cur_indexes[0] - 1, cur_indexes[1]]
if cur_value != value_left:
index_item = self.knapsack_model.index_to_index_list[
index_promising[cur_indexes[0] - 1]]
taken[self.knapsack_model.list_items[index_item].index] = 1
value += self.knapsack_model.list_items[index_item].value
weight += self.knapsack_model.list_items[index_item].weight
cur_indexes = (
cur_indexes[0] - 1, cur_indexes[1] -
self.knapsack_model.list_items[index_item].weight)
else:
cur_indexes = (cur_indexes[0] - 1, cur_indexes[1])
cur_value = self.table[cur_indexes[0], cur_indexes[1]]
sol = KnapsackSolution(problem=self.knapsack_model,
value=value,
weight=weight,
list_taken=taken)
fit = self.aggreg_sol(sol)
return ResultStorage(
list_solution_fits=[(sol, fit)],
best_solution=sol,
mode_optim=self.params_objective_function.sense_function)
def apply_local_move(self, solution: KnapsackSolution) -> KnapsackSolution:
new_list_taken = solution.list_taken.copy()
new_list_taken[self.i] = abs(new_list_taken[self.i] - 1)
new_solution = KnapsackSolution(problem=self.problem, list_taken=new_list_taken)
return new_solution