def create_do_from_sk():
rcpsp_domain = MyExampleRCPSPDomain()
do_domain = build_do_domain(rcpsp_domain)
print(do_domain.__class__)
rcpsp_domain = MyExampleMRCPSPDomain_WithCost()
do_domain = build_do_domain(rcpsp_domain)
print(do_domain.__class__)
from skdecide.hub.domain.rcpsp.rcpsp_sk_parser import load_domain, load_multiskill_domain
rcpsp_domain = load_multiskill_domain()
do_domain = build_do_domain(rcpsp_domain)
print(do_domain.__class__)
def _solve_domain(self, domain_factory: Callable[[], D]) -> None:
self.domain = domain_factory()
self.do_domain = build_do_domain(self.domain)
solvers = build_solver(solving_method=self.method,
do_domain=self.do_domain)
solver_class = solvers[0]
key, params = solvers[1]
for k in params:
if k not in self.dict_params:
self.dict_params[k] = params[k]
self.solver = solver_class(self.do_domain, **self.dict_params)
try:
self.solver.init_model(**self.dict_params)
except:
pass
result_storage = self.solver.solve(**self.dict_params)
best_solution: RCPSPSolution = result_storage.get_best_solution()
fits = self.do_domain.evaluate(best_solution)
print("Best solution fitness found : ", fits)
self.best_solution = best_solution
print("Satisfiable ", self.do_domain.satisfy(self.best_solution))
self.policy_object = from_solution_to_policy(
solution=best_solution,
domain=self.domain,
policy_method_params=self.policy_method_params)
def initialize_cpm_data_for_training(self):
self.cpm_data = {}
for domain in self.training_domains:
do_model = build_do_domain(domain)
cpm, cpm_esd = compute_cpm(do_model)
self.cpm_data[domain] = {'cpm': cpm,
'cpm_esd': cpm_esd}
def evaluate_heuristic(self, individual, domains) -> float:
vals = []
func_heuristic = self.toolbox.compile(expr=individual)
# print('individual', individual)
for domain in domains:
###
initial_state = domain.get_initial_state()
do_model = build_do_domain(domain)
modes = [
initial_state.tasks_mode.get(j, 1)
for j in sorted(domain.get_tasks_ids())
]
modes = modes[1:-1]
cpm = self.cpm_data[domain]["cpm"]
cpm_esd = self.cpm_data[domain]["cpm_esd"]
raw_values = []
for task_id in domain.get_available_tasks(initial_state):
input_features = [
feature_function_map[lf](
domain=domain,
cpm=cpm,
cpm_esd=cpm_esd,
task_id=task_id,
state=initial_state,
)
for lf in self.list_feature
]
output_value = func_heuristic(*input_features)
raw_values.append(output_value)
normalized_values = [
x + 1
for x in sorted(
range(len(raw_values)), key=lambda k: raw_values[k], reverse=False
)
]
normalized_values_for_do = [
normalized_values[i] - 2
for i in range(len(normalized_values))
if normalized_values[i] not in {1, len(normalized_values)}
]
solution = RCPSPSolution(
problem=do_model,
rcpsp_permutation=normalized_values_for_do,
rcpsp_modes=modes,
)
last_activity = max(list(solution.rcpsp_schedule.keys()))
do_makespan = solution.rcpsp_schedule[last_activity]["end_time"]
vals.append(do_makespan)
fitness = [np.mean(vals)]
# fitness = [np.max(vals)]
return fitness
def create_do_from_sk():
rcpsp_domain = MyExampleRCPSPDomain()
do_domain = build_do_domain(rcpsp_domain)
print("Loading rcpsp domain :resulting class in DO : ",
do_domain.__class__)
rcpsp_domain = MyExampleMRCPSPDomain_WithCost()
do_domain = build_do_domain(rcpsp_domain)
print("Loading multimode-rcpsp domain : resulting class in DO : ",
do_domain.__class__)
from examples.discrete_optimization.rcpsp_multiskill_parser_example import (
get_data_available_ms, )
from skdecide.hub.domain.rcpsp.rcpsp_sk_parser import load_multiskill_domain
rcpsp_domain = load_multiskill_domain(get_data_available_ms()[0])
do_domain = build_do_domain(rcpsp_domain)
print(
"Loading multiskill-rcpsp domain : resulting class in DO : ",
do_domain.__class__,
)
def evaluate_heuristic_permutation(self, individual, domains) -> float:
vals = []
func_heuristic = self.toolbox.compile(expr=individual)
# print('individual', individual)
for domain in domains:
raw_values = []
initial_state = domain.get_initial_state()
regenerate_cpm = False
if regenerate_cpm:
do_model = build_do_domain(domain)
cpm, cpm_esd = compute_cpm(do_model)
else:
cpm = self.cpm_data[domain]['cpm']
cpm_esd = self.cpm_data[domain]['cpm_esd']
for task_id in domain.get_available_tasks(state=initial_state):
input_features = [feature_function_map[lf](domain=domain,
cpm = cpm,
cpm_esd=cpm_esd,
task_id=task_id,
state=initial_state)
for lf in self.list_feature]
output_value = func_heuristic(*input_features)
raw_values.append(output_value)
most_common_raw_val = max(raw_values, key=raw_values.count)
most_common_count = raw_values.count(most_common_raw_val)
heuristic_permutation = [x + 1 for x in sorted(range(len(raw_values)), key=lambda k: raw_values[k],
reverse=False)]
if self.permutation_distance == PermutationDistance.KTD:
dist, p_value = stats.kendalltau(heuristic_permutation, self.reference_permutations[domain])
dist = -dist
if self.permutation_distance == PermutationDistance.HAMMING:
dist = distance.hamming(heuristic_permutation, self.reference_permutations[domain])
if self.permutation_distance == PermutationDistance.KTD_HAMMING:
ktd, _ = stats.kendalltau(heuristic_permutation, self.reference_permutations[domain])
dist = -ktd + distance.hamming(heuristic_permutation, self.reference_permutations[domain])
penalty = most_common_count / len(raw_values)
# penalty = 0.
penalized_distance = dist + penalty
vals.append(penalized_distance)
fitness = [np.mean(vals)]
# fitness = [np.max(vals)]
return fitness
def get_available_methods(self, domain: SchedulingDomain):
do_domain = build_do_domain(domain)
if isinstance(do_domain, (MS_RCPSPModel)):
from skdecide.builders.discrete_optimization.rcpsp_multiskill.rcpsp_multiskill_solvers import look_for_solver, solvers_map
available = look_for_solver(do_domain)
elif isinstance(
do_domain,
(SingleModeRCPSPModel, RCPSPModel, MultiModeRCPSPModel)):
from skdecide.builders.discrete_optimization.rcpsp.rcpsp_solvers import look_for_solver, solvers_map
available = look_for_solver(do_domain)
smap = [(av, solvers_map[av]) for av in available]
print("available solvers :", smap)
return smap
def _get_next_action(
self, observation: D.T_agent[D.T_observation]
) -> D.T_agent[D.T_concurrency[D.T_event]]:
run_sgs = True
cheat_mode = False
do_model = build_do_domain(self.domain_model)
modes = [
observation.tasks_mode.get(j, 1)
for j in sorted(self.domain.get_tasks_ids())
]
modes = modes[1:-1]
if run_sgs:
scheduled_tasks_start_times = {}
for j in observation.tasks_details.keys():
if observation.tasks_details[j].start is not None:
scheduled_tasks_start_times[j] = observation.tasks_details[j].start
do_model.mode_details[j][1]["duration"] = observation.tasks_details[
j
].sampled_duration
# do_model = build_do_domain(self.domain)
# modes = [observation.tasks_mode.get(j, 1) for j in sorted(self.domain.get_tasks_ids())]
# modes = modes[1:-1]
#
# if run_sgs:
# scheduled_tasks_start_times = {}
# for j in observation.tasks_details.keys():
# if observation.tasks_details[j].start is not None:
# scheduled_tasks_start_times[j] = observation.tasks_details[j].start
# else:
# if not cheat_mode:
# do_model.mode_details[j][1]['duration'] = self.domain_model.sample_task_duration(j, 1, 0.)
if self.recompute_cpm:
cpm, cpm_esd = compute_cpm(do_model)
else:
cpm = self.cpm_data[self.domain]["cpm"]
cpm_esd = self.cpm_data[self.domain]["cpm_esd"]
t = observation.t
raw_values = []
for task_id in self.domain.get_available_tasks(observation):
input_features = [
feature_function_map[lf](
domain=self.domain,
cpm=cpm,
cpm_esd=cpm_esd,
task_id=task_id,
state=observation,
)
for lf in self.list_feature
]
output_value = self.func_heuristic(*input_features)
raw_values.append(output_value)
normalized_values = [
x + 1
for x in sorted(
range(len(raw_values)), key=lambda k: raw_values[k], reverse=False
)
]
normalized_values_for_do = [
normalized_values[i] - 2
for i in range(len(normalized_values))
if normalized_values[i] not in {1, len(normalized_values)}
]
# print(t, ': ', normalized_values)
# print('normalized_values_for_do: ', normalized_values_for_do)
modes_dictionnary = {}
for i in range(len(normalized_values)):
modes_dictionnary[i + 1] = 1
if run_sgs:
solution = RCPSPSolution(
problem=do_model,
rcpsp_permutation=normalized_values_for_do,
rcpsp_modes=modes,
)
solution.generate_schedule_from_permutation_serial_sgs_2(
current_t=t,
completed_tasks={
j: observation.tasks_details[j] for j in observation.tasks_complete
},
scheduled_tasks_start_times=scheduled_tasks_start_times,
)
schedule = solution.rcpsp_schedule
else:
schedule = None
sgs_policy = PolicyRCPSP(
domain=self.domain,
schedule=schedule,
policy_method_params=PolicyMethodParams(
# base_policy_method=BasePolicyMethod.SGS_PRECEDENCE,
# base_policy_method=BasePolicyMethod.SGS_READY,
base_policy_method=self.params_gphh.base_policy_method,
delta_index_freedom=self.params_gphh.delta_index_freedom,
delta_time_freedom=self.params_gphh.delta_time_freedom,
),
permutation_task=normalized_values,
modes_dictionnary=modes_dictionnary,
)
action: SchedulingAction = sgs_policy.sample_action(observation)
# print('action_2: ', action.action)
return action
def _get_next_action(
self, observation: D.T_agent[D.T_observation]
) -> D.T_agent[D.T_concurrency[D.T_event]]:
run_sgs = True
cheat_mode = False
do_model = build_do_domain(self.domain_model)
modes = [
observation.tasks_mode.get(j, 1)
for j in sorted(self.domain.get_tasks_ids())
]
modes = modes[1:-1]
if run_sgs:
scheduled_tasks_start_times = {}
for j in observation.tasks_details.keys():
if observation.tasks_details[j].start is not None:
scheduled_tasks_start_times[j] = observation.tasks_details[j].start
do_model.mode_details[j][1]["duration"] = observation.tasks_details[
j
].sampled_duration
# do_model = build_do_domain(self.domain)
# modes = [observation.tasks_mode.get(j, 1) for j in sorted(self.domain.get_tasks_ids())]
# modes = modes[1:-1]
#
# if run_sgs:
# scheduled_tasks_start_times = {}
# for j in observation.tasks_details.keys():
# # schedule[j] = {}
# if observation.tasks_details[j].start is not None:
# # schedule[j]["start_time"] = observation.tasks_details[j].start
# scheduled_tasks_start_times[j] = observation.tasks_details[j].start
# # if observation.tasks_details[j].end is not None:
# # schedule[j]["end_time"] = observation.tasks_details[j].end
# else:
# if not cheat_mode:
# # print('do_model: ', do_model)
# do_model.mode_details[j][1]['duration'] = self.domain_model.sample_task_duration(j, 1, 0.)
normalized_values = self.fixed_perm
normalized_values_for_do = [
normalized_values[i] - 2
for i in range(len(normalized_values))
if normalized_values[i] not in {1, len(normalized_values)}
]
# print('normalized_values: ', normalized_values)
# print('normalized_values_for_do: ', normalized_values_for_do)
t = observation.t
modes_dictionnary = {}
for i in range(len(normalized_values)):
modes_dictionnary[i + 1] = 1
if run_sgs:
solution = RCPSPSolution(
problem=do_model,
rcpsp_permutation=normalized_values_for_do,
rcpsp_modes=modes,
)
solution.generate_schedule_from_permutation_serial_sgs_2(
current_t=t,
completed_tasks={
j: observation.tasks_details[j] for j in observation.tasks_complete
},
scheduled_tasks_start_times=scheduled_tasks_start_times,
)
schedule = solution.rcpsp_schedule
else:
schedule = None
sgs_policy = PolicyRCPSP(
domain=self.domain,
schedule=schedule,
policy_method_params=PolicyMethodParams(
# base_policy_method=BasePolicyMethod.SGS_PRECEDENCE,
# base_policy_method=BasePolicyMethod.SGS_READY,
base_policy_method=BasePolicyMethod.FOLLOW_GANTT,
# delta_index_freedom=self.params_gphh.delta_index_freedom,
# delta_time_freedom=self.params_gphh.delta_time_freedom
),
permutation_task=normalized_values,
modes_dictionnary=modes_dictionnary,
)
action: SchedulingAction = sgs_policy.sample_action(observation)
# print('action_2: ', action.action)
return action
def _get_next_action(
self, observation: D.T_agent[D.T_observation]
) -> D.T_agent[D.T_concurrency[D.T_event]]:
run_sgs = True
cheat_mode = False
regenerate_cpm = True
do_model = build_do_domain(self.domain_model)
modes = [
observation.tasks_mode.get(j, 1)
for j in sorted(self.domain.get_tasks_ids())
]
modes = modes[1:-1]
if run_sgs:
scheduled_tasks_start_times = {}
for j in observation.tasks_details.keys():
if observation.tasks_details[j].start is not None:
scheduled_tasks_start_times[j] = observation.tasks_details[j].start
do_model.mode_details[j][1]["duration"] = observation.tasks_details[
j
].sampled_duration
# do_model = build_do_domain(self.domain)
# modes = [observation.tasks_mode.get(j, 1) for j in sorted(self.domain.get_tasks_ids())]
# modes = modes[1:-1]
#
# if run_sgs:
# scheduled_tasks_start_times = {}
# for j in observation.tasks_details.keys():
# # schedule[j] = {}
# if observation.tasks_details[j].start is not None:
# # schedule[j]["start_time"] = observation.tasks_details[j].start
# scheduled_tasks_start_times[j] = observation.tasks_details[j].start
# # if observation.tasks_details[j].end is not None:
# # schedule[j]["end_time"] = observation.tasks_details[j].end
# else:
# if not cheat_mode:
# do_model.mode_details[j][1]['duration'] = self.domain_model.sample_task_duration(j, 1, 0.)
if regenerate_cpm:
cpm, cpm_esd = compute_cpm(do_model)
t = observation.t
raw_values = []
for task_id in self.domain.get_available_tasks(observation):
input_features = [
feature_function_map[lf](
domain=self.domain,
cpm=cpm,
cpm_esd=cpm_esd,
task_id=task_id,
state=observation,
)
for lf in self.list_feature
]
output_values = []
for f in self.func_heuristics:
output_value = f(*input_features)
output_values.append(output_value)
# print('output_values: ', output_values)
if self.remove_extremes_values > 0:
the_median = float(np.median(output_values))
tmp = {}
for i in range(len(output_values)):
tmp[i] = abs(output_values[i] - the_median)
tmp = sorted(tmp.items(), key=lambda x: x[1], reverse=True)
to_remove = [tmp[i][0] for i in range(self.remove_extremes_values)]
output_values = list(np.delete(output_values, to_remove))
# print('output_values filtered: ', output_values)
if self.pool_aggregation_method == PoolAggregationMethod.MEAN:
agg_value = np.mean(output_values)
elif self.pool_aggregation_method == PoolAggregationMethod.MEDIAN:
agg_value = np.median(output_values)
elif self.pool_aggregation_method == PoolAggregationMethod.RANDOM:
index = random.randint(len(output_values))
agg_value = output_values[index]
# print('agg_value: ', agg_value)
raw_values.append(agg_value)
normalized_values = [
x + 1
for x in sorted(
range(len(raw_values)), key=lambda k: raw_values[k], reverse=False
)
]
normalized_values_for_do = [
normalized_values[i] - 2
for i in range(len(normalized_values))
if normalized_values[i] not in {1, len(normalized_values)}
]
# print('normalized_values: ', normalized_values)
# print('normalized_values_for_do: ', normalized_values_for_do)
modes_dictionnary = {}
for i in range(len(normalized_values)):
modes_dictionnary[i + 1] = 1
if run_sgs:
solution = RCPSPSolution(
problem=do_model,
rcpsp_permutation=normalized_values_for_do,
rcpsp_modes=modes,
)
solution.generate_schedule_from_permutation_serial_sgs_2(
current_t=t,
completed_tasks={
j: observation.tasks_details[j] for j in observation.tasks_complete
},
scheduled_tasks_start_times=scheduled_tasks_start_times,
)
schedule = solution.rcpsp_schedule
else:
schedule = None
sgs_policy = PolicyRCPSP(
domain=self.domain,
schedule=schedule,
policy_method_params=PolicyMethodParams(
# base_policy_method=BasePolicyMethod.SGS_PRECEDENCE,
# base_policy_method=BasePolicyMethod.SGS_READY,
base_policy_method=self.params_gphh.base_policy_method,
delta_index_freedom=self.params_gphh.delta_index_freedom,
delta_time_freedom=self.params_gphh.delta_time_freedom,
),
permutation_task=normalized_values,
modes_dictionnary=modes_dictionnary,
)
action: SchedulingAction = sgs_policy.sample_action(observation)
# print('action_2: ', action.action)
return action