def init_model(self, **kwargs): greedy_start = kwargs.get("greedy_start", True) verbose = kwargs.get("verbose", False) use_cliques = kwargs.get("use_cliques", False) if greedy_start: if verbose: print("Computing greedy solution") greedy_solver = GreedyColoring(self.coloring_problem, params_objective_function=self.params_objective_function) result_store = greedy_solver.solve(strategy=NXGreedyColoringMethod.best, verbose=verbose) self.start_solution = result_store.get_best_solution_fit()[0] else: if verbose: print("Get dummy solution") solution = self.coloring_problem.get_dummy_solution() self.start_solution = solution nb_colors = self.start_solution.nb_color color_model = Model("color") colors_var = {} range_node = range(self.number_of_nodes) range_color = range(nb_colors) for node in self.nodes_name: for color in range_color: colors_var[node, color] = color_model.addVar(vtype=GRB.BINARY, obj=0, name="x_" + str((node, color))) one_color_constraints = {} for n in range_node: one_color_constraints[n] = color_model.addConstr(quicksum([colors_var[n, c] for c in range_color]) == 1) color_model.update() cliques = [] g = self.graph.to_networkx() if use_cliques: for c in nx.algorithms.clique.find_cliques(g): cliques += [c] cliques = sorted(cliques, key=lambda x: len(x), reverse=True) else: cliques = [[e[0], e[1]] for e in g.edges()] cliques_constraint = {} index_c = 0 opt = color_model.addVar(vtype=GRB.INTEGER, lb=0, ub=nb_colors, obj=1) if use_cliques: for c in cliques[:100]: cliques_constraint[index_c] = color_model.addConstr(quicksum([(color_i + 1) * colors_var[node, color_i] for node in c for color_i in range_color]) >= sum([i + 1 for i in range(len(c))])) cliques_constraint[(index_c, 1)] = color_model.addConstr(quicksum([colors_var[node, color_i] for node in c for color_i in range_color]) <= opt) index_c += 1 edges = g.edges() constraints_neighbors = {} for e in edges: for c in range_color: constraints_neighbors[(e[0], e[1], c)] = \ color_model.addConstr(colors_var[e[0], c] + colors_var[e[1], c] <= 1) for n in range_node: color_model.addConstr(quicksum([(color_i + 1) * colors_var[n, color_i] for color_i in range_color]) <= opt) color_model.update() color_model.modelSense = GRB.MINIMIZE color_model.setParam(GRB.Param.Threads, 8) color_model.setParam(GRB.Param.PoolSolutions, 10000) color_model.setParam(GRB.Param.Method, -1) color_model.setParam("MIPGapAbs", 0.001) color_model.setParam("MIPGap", 0.001) color_model.setParam("Heuristics", 0.01) self.model = color_model self.variable_decision = {"colors_var": colors_var} self.constraints_dict = {"one_color_constraints": one_color_constraints, "constraints_neighbors": constraints_neighbors} self.description_variable_description = {"colors_var": {"shape": (self.number_of_nodes, nb_colors), "type": bool, "descr": "for each node and each color," " a binary indicator"}} self.description_constraint["one_color_constraints"] = {"descr": "one and only one color " "should be assignated to a node"} self.description_constraint["constraints_neighbors"] = {"descr": "no neighbors can have same color"}
def init_model(self, **kwargs): nb_facilities = self.facility_problem.facility_count nb_customers = self.facility_problem.customer_count use_matrix_indicator_heuristic = kwargs.get("use_matrix_indicator_heuristic", True) if use_matrix_indicator_heuristic: n_shortest = kwargs.get("n_shortest", 10) n_cheapest = kwargs.get("n_cheapest", 10) matrix_fc_indicator, matrix_length = prune_search_space(self.facility_problem, n_cheapest=n_cheapest, n_shortest=n_shortest) else: matrix_fc_indicator, matrix_length = prune_search_space(self.facility_problem, n_cheapest=nb_facilities, n_shortest=nb_facilities) s = Model("facilities") x = {} for f in range(nb_facilities): for c in range(nb_customers): if matrix_fc_indicator[f, c] == 0: x[f, c] = 0 elif matrix_fc_indicator[f, c] == 1: x[f, c] = 1 elif matrix_fc_indicator[f, c] == 2: x[f, c] = s.addVar(vtype=GRB.BINARY, obj=0, name="x_" + str((f, c))) facilities = self.facility_problem.facilities customers = self.facility_problem.customers used = s.addVars(nb_facilities, vtype=GRB.BINARY, name="y") constraints_customer = {} for c in range(nb_customers): constraints_customer[c] = s.addConstr(quicksum([x[f, c] for f in range(nb_facilities)]) == 1) # one facility constraint_capacity = {} for f in range(nb_facilities): s.addConstrs(used[f] >= x[f, c] for c in range(nb_customers)) constraint_capacity[f] = s.addConstr(quicksum([x[f, c] * customers[c].demand for c in range(nb_customers)]) <= facilities[f].capacity) s.update() new_obj_f = LinExpr(0.) new_obj_f += quicksum([facilities[f].setup_cost * used[f] for f in range(nb_facilities)]) new_obj_f += quicksum([matrix_length[f, c] * x[f, c] for f in range(nb_facilities) for c in range(nb_customers)]) s.setObjective(new_obj_f) s.update() s.modelSense = GRB.MINIMIZE s.setParam(GRB.Param.Threads, 4) s.setParam(GRB.Param.PoolSolutions, 10000) s.setParam(GRB.Param.Method, 1) s.setParam("MIPGapAbs", 0.00001) s.setParam("MIPGap", 0.00000001) self.model = s self.variable_decision = {"x": x} self.constraints_dict = {"constraint_customer": constraints_customer, "constraint_capacity": constraint_capacity} self.description_variable_description = {"x": {"shape": (nb_facilities, nb_customers), "type": bool, "descr": "for each facility/customer indicate" " if the pair is active, meaning " "that the customer c is dealt with facility f"}} self.description_constraint = {"Im lazy."} print("Initialized")