def ccpomdp_clark(ccpomdp_model,b0,out_file,svg,cc,cc_type,terminal_prob,randomization,
propagate_risk,expand_all_open,verbose,log,constraint_fields,
det_schedule,stnu_ref,animation):
"""
Calls CLARK with a generic CC-POMDP model.
"""
planner = RAOStar(ccpomdp_model,node_name='id',cc=cc,cc_type=cc_type,
terminal_prob=terminal_prob,randomization=randomization,
propagate_risk=propagate_risk,expand_all_open=expand_all_open,
verbose=verbose,log=log,animation=animation)
policy,explicit,performance = planner.search(b0)
if len(policy)>0:
rmpyl_policy = policy_to_rmpyl(explicit,policy,
constraint_fields=constraint_fields,
global_end=ccpomdp_model.global_end_event)
#Function to allow RMPyL policies to be manually modified to suit the needs
#of whoever is calling CLARK (oh, Enterprise... why do you torture me?)
rmpyl_post_processing(rmpyl_policy,stnu_ref,det_schedule)
return True,{'policy':policy,'explicit':explicit,'performance':performance,
'rmpyl':rmpyl_policy}
else:
return False,{'policy':policy,'explicit':explicit,'performance':performance,
'rmpyl':None}
def rmpyl_clark(prog,out_file,svg,schedule,cc,cc_type,terminal_prob,randomization,
propagate_risk,expand_all_open,verbose,log,det_schedule,stnu_ref,
animation):
"""
Used CLARK to generate optimal conditional plans from an RMPyL program.
If conditional scheduling is required, uses the unconditional scheduling
strategy first presented at ICAPS14, combined with PARIS.
"""
if schedule:
rmpyl_model = StrongStrongRMPyLUnraveler(verbose=verbose)
else:
rmpyl_model = BaseRMPyLUnraveler(verbose=verbose)
b0 = rmpyl_model.get_initial_belief(prog)
planner = RAOStar(rmpyl_model,node_name='id',cc=cc,cc_type=cc_type,
terminal_prob=terminal_prob,randomization=randomization,
propagate_risk=propagate_risk,expand_all_open=expand_all_open,
verbose=verbose,log=log,animation=animation)
policy,explicit,performance = planner.search(b0)
if len(policy)>0:
rmpyl_policy = policy_to_rmpyl(explicit,policy)
#Function to allow RMPyL policies to be manually modified to suit the needs
#of whoever is calling CLARK (oh, Enterprise... why do you torture me?)
rmpyl_post_processing(rmpyl_policy,stnu_ref,det_schedule)
else:
rmpyl_policy = None
return len(policy)>0,{'policy':policy,'explicit':explicit,'performance':performance,
'rmpyl':rmpyl_policy}
def clark_planner(domain_file,problem_file,max_steps,cc,duration_func,schedule,
timewindow,animation):
"""
Uses CLARK as the planner.
"""
pddl_model = DurativePDDL(domain_file=domain_file,prob_file=problem_file,
perform_scheduling=schedule,
duration_func=duration_func,
max_steps=max_steps,
verbose=1)
initial_constraints=[]
if timewindow != None:
initial_constraints.append(TemporalConstraint(start=pddl_model.global_start_event,
end=pddl_model.global_end_event,
ctype='controllable',lb=0.0,ub=timewindow))
b0 = pddl_model.get_initial_belief(constraints=initial_constraints)
planner = RAOStar(pddl_model,node_name='id',cc=cc,cc_type='overall',
terminal_prob=1.0,randomization=0.0,propagate_risk=True,
expand_all_open=True,verbose=1,log=False,animation=animation)
policy,explicit,performance = planner.search(b0)
if (len(policy)>0) and (performance['optimal_value'] != float('inf')):
rmpyl_policy = policy_to_rmpyl(explicit,policy,
constraint_fields=['constraints'],
global_end=pddl_model.global_end_event)
#Combines controllable temporal constraints.
rmpyl_policy.simplify_temporal_constraints()
else:
rmpyl_policy = None
return {'policy':policy,'explicit':explicit,'performance':performance,
'rmpyl':rmpyl_policy}
b0 = cc_fp.get_initial_belief(prior=prior,initial_site='start_point',goal_site='end_point',
init_tcs=init_tcs)
planner = RAOStar(cc_fp,node_name='id',cc=0.01,cc_type='overall',
terminal_prob=1.0,randomization=0.0,propagate_risk=True,
halt_on_violation=False,verbose=1)
#Searches for the optimal policy
policy,explicit,performance = planner.search(b0)
#Converts policy to graphical SVG format
dot_policy = policy_to_dot(explicit,policy)
dot_policy.write('flightgear_policy.svg',format='svg')
#Converts optimal exploration policy into an RMPyL program
exploration_policy = policy_to_rmpyl(explicit,policy)
#The flight policy has the additional actions of taking off and landing.
flight_policy = RMPyL(name='run()')
flight_policy *= flight_policy.sequence(Episode(action='(takeoff plane)'),
exploration_policy,
Episode(action='(land plane)'))
#Eliminates probabilistic choices from the policy, since Pike (in fact, the
#Lisp tpn package) cannot properly handle them.
for obs in flight_policy.observations:
if obs.type=='probabilistic':
obs.type = 'uncontrollable'
del obs.properties['probability']
#Converts the program to a TPN
'alien_lair':{'coords':(13.0,13.0),'value':100.0}}
prior={'minerals':0.5,
'funny_rock':0.5,
'geiser':0.5,
'alien_lair':0.2}
initial_pos = (-12.5,13.5)
cc_fp = FakePlannerRockSampleModel(sites=sites,path_risks=[0.001],
prob_discovery=0.95,velocities={'max':1.0,'avg':0.5},
verbose=0)
b0 = cc_fp.get_initial_belief(initial_pos=initial_pos,prior=prior)
planner = RAOStar(cc_fp,node_name='id',cc=0.003,cc_type='overall',
terminal_prob=1.0,randomization=0.0,propagate_risk=True,
expand_all_open=True,verbose=1)
policy,explicit,performance = planner.search(b0)
dot_policy = policy_to_dot(explicit,policy)
rmpyl_policy = policy_to_rmpyl(explicit,policy)
#Writes control program to pickle file
with open('rover_policy_rmpyl_fake.pickle','wb') as f:
pickle.dump(rmpyl_policy,f)
dot_policy.write('rover_policy_fake.svg',format='svg')
rmpyl_policy.to_ptpn(filename='rover_policy_rmpyl_fake_ptpn.tpn')
# time_limit=5,drop_penalty=10.0,p_fail=0.1,verbose=0)
# Diagnostic demo, where the robot has to figure out if it is fit for the task
# With this setting of parameters, the robot tries an action a couple of times
# before bugging the human for help.
param_dict = {'p_fail_fit':0.2, #Prob. of failing a task, while being fit
'p_fail_unfit':0.999, #Prob. of failing a task, while not being fit
'p_fit_fit':1.0, #Prob. of remaining fit, if fit before
'p_fit_unfit':0.0, #Prob. becoming fit, if unfit before
'goal_drop_penalty':100.0, #Penalty for not achieving a goal
'robot_action_cost':1.0, #Cost of robot performing an action
'human_action_cost':5.0} #Cost of human performing an action
mitsu_model = DiagnosticMitsubishi(domain_file=dom_file,prob_file=prob_file,
time_limit=5,verbose=1,param_dict=param_dict)
b0 = mitsu_model.get_initial_belief()
planner = RAOStar(mitsu_model,node_name='id',cc=0.3,cc_type='overall',
terminal_prob=1.0,randomization=0.0,propagate_risk=True,
verbose=1,log=False)
policy,explicit,performance = planner.search(b0)
dot_policy = policy_to_dot(explicit,policy)
rmpyl_policy = policy_to_rmpyl(explicit,policy)
dot_policy.write('mitsubishi_policy.svg',format='svg')
rmpyl_policy.to_ptpn(filename='mitsubishi_policy_rmpyl_ptpn.tpn')
end=mitsubishi_model.global_end_event,
ctype='controllable',lb=0.0,ub=2000.0)
b0 = mitsubishi_model.get_initial_belief(constraints=[time_window])
planner = RAOStar(mitsubishi_model,node_name='id',cc=cc,cc_type='overall',
terminal_prob=1.0,randomization=0.0,propagate_risk=True,
expand_all_open=True,verbose=1,log=False,animation=False)
policy,explicit,performance = planner.search(b0)
dot_policy = policy_to_dot(explicit,policy)
dot_policy.write('mitsubishi_durative_policy.svg',format='svg')
rmpyl_policy = policy_to_rmpyl(explicit,policy,
constraint_fields=['constraints'],
global_end=mitsubishi_model.global_end_event)
#Combines controllable temporal constraints.
rmpyl_policy.simplify_temporal_constraints()
rmpyl_policy.to_ptpn(filename='mitsubishi_durative_policy_rmpyl_before_stnu_reform.tpn',
exclude_op=['__stop__','__expand__'])
paris = PARIS()
risk_bound,sc_schedule = paris.stnu_reformulation(rmpyl_policy,makespan=True,cc=cc)
if risk_bound != None:
risk_bound = min(risk_bound,1.0)
print('\nSuccessfully performed STNU reformulation with scheduling risk %f %%!'%(risk_bound*100.0))
rmpyl_policy.to_ptpn(filename='mitsubishi_durative_policy_rmpyl_after_stnu_reform.tpn')
cc_type='overall',
terminal_prob=1.0,
randomization=0.0,
propagate_risk=True,
halt_on_violation=False,
verbose=1)
#Searches for the optimal policy
policy, explicit, performance = planner.search(b0)
#Converts policy to graphical SVG format
dot_policy = policy_to_dot(explicit, policy)
dot_policy.write('flightgear_policy.svg', format='svg')
#Converts optimal exploration policy into an RMPyL program
exploration_policy = policy_to_rmpyl(explicit, policy)
#The flight policy has the additional actions of taking off and landing.
flight_policy = RMPyL(name='run()')
flight_policy *= flight_policy.sequence(Episode(action='(takeoff plane)'),
exploration_policy,
Episode(action='(land plane)'))
#Eliminates probabilistic choices from the policy, since Pike (in fact, the
#Lisp tpn package) cannot properly handle them.
for obs in flight_policy.observations:
if obs.type == 'probabilistic':
obs.type = 'uncontrollable'
del obs.properties['probability']
#Converts the program to a TPN
cc_type='overall',
terminal_prob=1.0,
randomization=0.0,
propagate_risk=True,
expand_all_open=True,
verbose=1,
log=False,
animation=False)
policy, explicit, performance = planner.search(b0)
dot_policy = policy_to_dot(explicit, policy)
dot_policy.write('rss_policy.svg', format='svg')
rmpyl_policy = policy_to_rmpyl(explicit,
policy,
constraint_fields=['constraints'],
global_end=rss_model.global_end_event)
#Combines controllable temporal constraints.
rmpyl_policy.simplify_temporal_constraints()
rmpyl_policy.to_ptpn(filename='rss_policy_rmpyl_before_stnu_reform.tpn',
exclude_op=['__stop__', '__expand__'])
paris = PARIS()
risk_bound, sc_schedule = paris.stnu_reformulation(rmpyl_policy,
makespan=True,
cc=cc)
if risk_bound != None:
risk_bound = min(risk_bound, 1.0)