def solve_model(model, postpro=True, nb_iteration=500):
dummy = model.get_dummy_solution()
_, mutations = get_available_mutations(model, dummy)
list_mutation = [
mutate[0].build(model, dummy, **mutate[1]) for mutate in mutations
if mutate[0] == PermutationMutationRCPSP
]
mixed_mutation = BasicPortfolioMutation(list_mutation,
np.ones((len(list_mutation))))
objectives = ['makespan']
objective_weights = [-1]
if postpro:
params_objective_function = ParamsObjectiveFunction(
objective_handling=ObjectiveHandling.AGGREGATE,
objectives=objectives,
weights=objective_weights,
sense_function=ModeOptim.MAXIMIZATION)
aggreg_sol, _, _ = build_aggreg_function_and_params_objective(
model, params_objective_function)
res = RestartHandlerLimit(200,
cur_solution=dummy,
cur_objective=aggreg_sol(dummy))
sa = SimulatedAnnealing(
evaluator=model,
mutator=mixed_mutation,
restart_handler=res,
temperature_handler=TemperatureSchedulingFactor(
temperature=0.5, restart_handler=res, coefficient=0.9999),
mode_mutation=ModeMutation.MUTATE,
params_objective_function=params_objective_function,
store_solution=True,
nb_solutions=10000)
result_ls = sa.solve(dummy,
nb_iteration_max=nb_iteration,
pickle_result=False)
else:
params_objective_function = ParamsObjectiveFunction(
objective_handling=ObjectiveHandling.MULTI_OBJ,
objectives=objectives,
weights=objective_weights,
sense_function=ModeOptim.MAXIMIZATION)
aggreg_sol, _, _ = build_aggreg_function_and_params_objective(
model, params_objective_function)
res = RestartHandlerLimit(200,
cur_solution=dummy,
cur_objective=aggreg_sol(dummy))
sa = HillClimberPareto(
evaluator=model,
mutator=mixed_mutation,
restart_handler=res,
params_objective_function=params_objective_function,
mode_mutation=ModeMutation.MUTATE,
store_solution=True,
nb_solutions=10000)
result_ls = sa.solve(dummy,
nb_iteration_max=nb_iteration,
pickle_result=False,
update_iteration_pareto=10000)
return result_ls
def __init__(self,
knapsack_model: KnapsackModel,
params_objective_function: ParamsObjectiveFunction = None):
self.knapsack_model = knapsack_model
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.knapsack_model,
params_objective_function=params_objective_function)
def __init__(self,
facility_problem: FacilityProblem,
params_objective_function: ParamsObjectiveFunction = None):
self.facility_problem = facility_problem
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.facility_problem,
params_objective_function=params_objective_function)
def __init__(self, problem: FacilityProblem,
initial_method: InitialFacilityMethod,
params_objective_function: ParamsObjectiveFunction):
self.problem = problem
self.initial_method = initial_method
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.problem,
params_objective_function=params_objective_function)
def __init__(self,
problem: VrpProblem,
params_objective_function: ParamsObjectiveFunction = None):
self.problem = problem
self.manager = None
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.problem,
params_objective_function=params_objective_function)
def __init__(self,
rcpsp_model: MultiModeRCPSPModel,
params_objective_function: ParamsObjectiveFunction = None,
**kwargs):
self.rcpsp_model = rcpsp_model
self.aggreg_sol, self.aggreg_from_dict_values, self.params_objective_function = \
build_aggreg_function_and_params_objective(self.rcpsp_model,
params_objective_function=params_objective_function)
def __init__(self, problem: ColoringProblem,
params_objective_function: ParamsObjectiveFunction):
self.problem = problem
self.params_objective_function = params_objective_function
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.problem,
params_objective_function=
self.params_objective_function)
def __init__(self,
color_problem: ColoringProblem,
params_objective_function: ParamsObjectiveFunction = None):
self.color_problem = color_problem
self.nx_graph = self.color_problem.graph.to_networkx()
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.color_problem,
params_objective_function=params_objective_function)
def __init__(self,
rcpsp_model: RCPSPModelCalendar,
params_objective_function: ParamsObjectiveFunction = None,
**kwargs):
self.rcpsp_model = rcpsp_model
self.resources = rcpsp_model.resources
self.non_renewable = rcpsp_model.non_renewable_resources
self.n_jobs = rcpsp_model.n_jobs
self.mode_details = rcpsp_model.mode_details
self.graph = rcpsp_model.compute_graph()
self.nx_graph: nx.DiGraph = self.graph.to_networkx()
self.successors_map = {}
self.predecessors_map = {}
# successors = nx.dfs_successors(self.nx_graph, 1, self.n_jobs+2)
successors = {
n: nx.algorithms.descendants(self.nx_graph, n)
for n in self.nx_graph.nodes()
}
self.source = 1
self.sink = self.n_jobs + 2
self.all_activities = set(range(1, self.n_jobs + 3))
for k in successors:
self.successors_map[k] = {
"succs": successors[k],
"nb": len(successors[k])
}
predecessors = {
n: nx.algorithms.ancestors(self.nx_graph, n)
for n in self.nx_graph.nodes()
}
for k in predecessors:
self.predecessors_map[k] = {
"succs": predecessors[k],
"nb": len(predecessors[k])
}
self.aggreg_from_sol, self.aggreg_from_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.rcpsp_model,
params_objective_function=
params_objective_function)
if isinstance(self.rcpsp_model,
(MultiModeRCPSPModel, RCPSPModelCalendar)):
solver = CP_MRCPSP_MZN_MODES(self.rcpsp_model,
cp_solver_name=CPSolverName.CHUFFED)
params_cp = ParametersCP.default()
params_cp.time_limit = 1
params_cp.pool_solutions = 10000
params_cp.nr_solutions = 1000
#params_cp.nr_solutions = float("inf")
params_cp.all_solutions = False
result_storage = solver.solve(parameters_cp=params_cp,
verbose=True)
one_mode_setting = result_storage[0]
self.modes_dict = {}
for i in range(len(one_mode_setting)):
self.modes_dict[i + 1] = one_mode_setting[i]
else:
self.modes_dict = {t: 1 for t in self.mode_details}
self.with_calendar = isinstance(self.rcpsp_model, RCPSPModelCalendar)
def __init__(self, problem: VrpProblem,
params_objective_function: ParamsObjectiveFunction):
self.problem = problem
self.model = None
self.x_var = None
self.constraint_on_edge = None
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.problem,
params_objective_function=params_objective_function)
def __init__(self,
knapsack_model: KnapsackModel,
cp_solver_name: CPSolverName = CPSolverName.CHUFFED,
params_objective_function: ParamsObjectiveFunction = None):
self.knapsack_model = knapsack_model
self.instance = None
self.cp_solver_name = cp_solver_name
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.knapsack_model,
params_objective_function=params_objective_function)
def __init__(self, tsp_model: TSPModel,
params_objective_function: ParamsObjectiveFunction):
self.tsp_model = tsp_model
self.node_count = self.tsp_model.node_count
self.list_points = self.tsp_model.list_points
self.start_index = self.tsp_model.start_index
self.end_index = self.tsp_model.end_index
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.tsp_model,
params_objective_function=params_objective_function)
def __init__(self,
knapsack_model: KnapsackModel,
params_objective_function: ParamsObjectiveFunction = None):
self.knapsack_model = knapsack_model
self.nb_items = self.knapsack_model.nb_items
self.capacity = self.knapsack_model.max_capacity
self.table = np.zeros((self.nb_items + 1, self.capacity + 1))
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.knapsack_model,
params_objective_function=params_objective_function)
def __init__(self,
model: Union[RCPSPModel, MS_RCPSPModel],
params_objective_function: ParamsObjectiveFunction = None,
ls_solver: LS_SOLVER = LS_SOLVER.SA,
**args):
self.model = model
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.model,
params_objective_function=
params_objective_function)
self.ls_solver = ls_solver
def __init__(self, facility_problem: FacilityProblem,
params_objective_function: ParamsObjectiveFunction):
self.facility_problem = facility_problem
self.model = None
self.variable_decision = {}
self.constraints_dict = {}
self.description_variable_description = {}
self.description_constraint = {}
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.facility_problem,
params_objective_function=params_objective_function)
def __init__(self, knapsack_model: KnapsackModel,
params_objective_function: ParamsObjectiveFunction):
self.knapsack_model = knapsack_model
self.model = None
self.variable_decision = {}
self.constraints_dict = {}
self.description_variable_description = {}
self.description_constraint = {}
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.knapsack_model,
params_objective_function=params_objective_function)
def __init__(self,
rcpsp_model: RCPSPModel,
cp_solver_name: CPSolverName = CPSolverName.CHUFFED,
params_objective_function: ParamsObjectiveFunction = None):
self.rcpsp_model = rcpsp_model
self.instance: Instance = None
self.cp_solver_name = cp_solver_name
self.key_decision_variable = [
"start", "mrun"
] # For now, I've put the var names of the CP model (not the rcpsp_model)
self.aggreg_sol, self.aggreg_from_dict_values, self.params_objective_function = \
build_aggreg_function_and_params_objective(self.rcpsp_model,
params_objective_function=params_objective_function)
def __init__(self,
knapsack_model: KnapsackModel,
milp_solver_name: MilpSolverName,
params_objective_function: ParamsObjectiveFunction = None):
self.knapsack_model = knapsack_model
self.model: MyModelMilp = None
self.milp_solver_name = milp_solver_name
self.solver_name = map_solver[milp_solver_name]
self.variable_decision = {}
self.constraints_dict = {}
self.description_variable_description = {}
self.description_constraint = {}
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.knapsack_model,
params_objective_function=params_objective_function)
def __init__(self,
rcpsp_model: MS_RCPSPModel,
lp_solver: MilpSolverName = MilpSolverName.CBC,
params_objective_function: ParamsObjectiveFunction = None,
**kwargs):
self.rcpsp_model = rcpsp_model
self.model: Model = None
self.lp_solver = lp_solver
self.variable_decision = {}
self.constraints_dict = {}
self.constraints_dict["lns"] = []
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.rcpsp_model,
params_objective_function=
params_objective_function)
def __init__(self, problem: MS_RCPSPModel, params_objective_function: ParamsObjectiveFunction):
self.problem = problem
self.params_objective_function = params_objective_function
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.problem,
params_objective_function=
self.params_objective_function)
self.graph = self.problem.compute_graph()
self.successors = {n: nx.algorithms.descendants(self.graph.graph_nx, n)
for n in self.graph.graph_nx.nodes()}
self.predecessors = {n: nx.algorithms.descendants(self.graph.graph_nx, n)
for n in self.graph.graph_nx.nodes()}
self.immediate_predecessors = {n: self.graph.get_predecessors(n)
for n in self.graph.nodes_name}
def __init__(self,
model: Union[MS_RCPSPModel, MS_RCPSPModel_Variant],
method,
params_objective_function: ParamsObjectiveFunction = None,
**args):
self.model = model
self.model_rcpsp = model.build_multimode_rcpsp_calendar_representative(
)
self.method = method
self.args_solve = args
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.model,
params_objective_function=
params_objective_function)
self.args_solve[
"params_objective_function"] = self.params_objective_function
def __init__(self, coloring_problem: ColoringProblem,
params_objective_function: ParamsObjectiveFunction):
self.coloring_problem = coloring_problem
self.number_of_nodes = self.coloring_problem.number_of_nodes
self.number_of_edges = len(
self.coloring_problem.graph.edges_infos_dict)
self.nodes_name = self.coloring_problem.graph.nodes_name
self.index_nodes_name = self.coloring_problem.index_nodes_name
self.index_to_nodes_name = self.coloring_problem.index_to_nodes_name
self.graph = self.coloring_problem.graph
self.model: Model = None
self.instance: Instance = None
self.g = None
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.coloring_problem,
params_objective_function=params_objective_function)
def __init__(self, rcpsp_model: SingleModeRCPSPModel,
lp_solver=LP_RCPSP_Solver.CBC,
params_objective_function: ParamsObjectiveFunction=None, **kwargs):
self.rcpsp_model = rcpsp_model
self.model: Model = None
self.lp_solver = CBC
if lp_solver == LP_RCPSP_Solver.GRB:
self.lp_solver = GRB
elif lp_solver == LP_RCPSP_Solver.CBC:
self.lp_solver = CBC
self.variable_decision = {}
self.constraints_dict = {}
self.constraints_dict["lns"] = []
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.rcpsp_model,
params_objective_function=
params_objective_function)
def __init__(self,
problem: Problem,
cp_solver: CPSolver,
initial_solution_provider: InitialSolution,
constraint_handler: ConstraintHandler,
post_process_solution: PostProcessSolution = None,
params_objective_function: ParamsObjectiveFunction = None):
self.problem = problem
self.cp_solver = cp_solver
self.initial_solution_provider = initial_solution_provider
self.constraint_handler = constraint_handler
self.post_process_solution = post_process_solution
if self.post_process_solution is None:
self.post_process_solution = TrivialPostProcessSolution()
self.params_objective_function = params_objective_function
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.problem,
params_objective_function=
self.params_objective_function)
def __init__(self, coloring_problem: ColoringProblem,
params_objective_function: ParamsObjectiveFunction=None):
self.coloring_problem = coloring_problem
self.number_of_nodes = self.coloring_problem.number_of_nodes
self.nodes_name = self.coloring_problem.graph.nodes_name
self.index_nodes_name = {self.nodes_name[i]: i for i in range(self.number_of_nodes)}
self.index_to_nodes_name = {i: self.nodes_name[i] for i in range(self.number_of_nodes)}
self.graph = self.coloring_problem.graph
self.model = None
self.variable_decision = {}
self.constraints_dict = {}
self.description_variable_description = {}
self.description_constraint = {}
self.params_objective_function = params_objective_function
self.aggreg_from_sol, self.aggreg_from_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.coloring_problem,
params_objective_function=params_objective_function)
self.sense_optim = self.params_objective_function.sense_function
self.start_solution = None
def __init__(self,
rcpsp_model: MS_RCPSPModel,
cp_solver_name: CPSolverName = CPSolverName.CHUFFED,
params_objective_function: ParamsObjectiveFunction = None,
**kwargs):
self.rcpsp_model = rcpsp_model
self.instance: Instance = None
self.cp_solver_name = cp_solver_name
self.key_decision_variable = [
"start", "mrun"
] # For now, I've put the var names of the CP model (not the rcpsp_model)
self.aggreg_sol, self.aggreg_from_dict_values, self.params_objective_function = \
build_aggreg_function_and_params_objective(self.rcpsp_model,
params_objective_function=params_objective_function)
self.calendar = True
if isinstance(self.rcpsp_model, RCPSPModelCalendar):
self.calendar = True
self.one_ressource_per_task = kwargs.get('one_ressource_per_task',
False)
self.resources_index = None
def __init__(self, tsp_model: TSPModel, model_type: TSP_CPModel,
params_objective_function: ParamsObjectiveFunction):
self.tsp_model = tsp_model
self.model_type = model_type
self.start_index = self.tsp_model.start_index
self.end_index = self.tsp_model.end_index
self.instance = None
self.key_decision_variable = ["x"]
self.distance_matrix = build_matrice_distance(
self.tsp_model.node_count,
self.tsp_model.list_points,
method=self.tsp_model.evaluate_function_indexes)
self.distance_matrix[self.end_index, self.start_index] = 0
self.distance_list_2d = [[
int(x) if model_type == TSP_CPModel.INT_VERSION else x
for x in self.distance_matrix[i, :]
] for i in range(self.distance_matrix.shape[0])]
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.tsp_model,
params_objective_function=params_objective_function)
def __init__(self,
problem: Problem,
encodings: Union[List[str], List[Dict[str, Any]]] = None,
mutations: Optional[Union[List[Mutation],
List[DeapMutation]]] = None,
crossovers: Optional[List[DeapCrossover]] = None,
selections: Optional[List[DeapSelection]] = None,
objective_handling: Optional[ObjectiveHandling] = None,
objectives: Optional[Union[str, List[str]]] = None,
objective_weights: Optional[List[float]] = None,
pop_size: int = None,
max_evals: int = None,
sub_evals: List[int] = None,
mut_rate: float = None,
crossover_rate: float = None,
tournament_size: float = None,
deap_verbose: bool = None):
self.problem = problem
self.encodings = encodings
self.mutations = mutations
self.crossovers = crossovers
self.selections = selections
self.objective_handling = objective_handling
self.objectives = objectives
self.objective_weights = objective_weights
self.pop_size = pop_size
self.max_evals = max_evals
self.sub_evals = sub_evals
self.mut_rate = mut_rate
self.crossover_rate = crossover_rate
self.tournament_size = tournament_size
self.deap_verbose = deap_verbose
self.aggreg_from_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.problem,
params_objective_function=
None)
def __init__(self, vrp_model: VrpProblem, params_objective_function: ParamsObjectiveFunction=None):
self.vrp_model = vrp_model
self.aggreg_sol, self.aggreg_dict, self.params_objective_function = \
build_aggreg_function_and_params_objective(problem=self.vrp_model,
params_objective_function=params_objective_function)
