def rmpyl_observation_risk(): prog = RMPyL() prog *= prog.observe( { 'name': 'travel', 'ctype': 'probabilistic', 'domain': ['Short', 'Long'], 'probability': [0.7, 0.3] }, Episode(action='(cab-ride-long)', duration={ 'ctype': 'uncontrollable_probabilistic', 'distribution': { 'type': 'uniform', 'lb': 5.0, 'ub': 11.0 } }), Episode(action='(cab-ride-short)', duration={ 'ctype': 'uncontrollable_probabilistic', 'distribution': { 'type': 'uniform', 'lb': 5.0, 'ub': 10.0 } })) prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=10.0) return prog
def nominal_case(blocks, time_window=-1, dur_dict=None): """ Nominal case, where the robot observes what the human has already completed, and acts accordingly """ agent = 'Baxter' manip = 'BaxterRight' prog = RMPyL(name='run()') prog *= prog.sequence( say('Should I start?'), prog.observe( { 'name': 'ask-human', 'ctype': 'probabilistic', 'domain': ['YES', 'NO'], 'probability': [0.9, 0.1] }, observe_decide_act(prog, blocks, manip, agent, dur_dict), say('All done!'))) if time_window > 0.0: prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=time_window) return prog
def rmpyl_nested_uav(): hello = UAV('hello') uav = UAV('uav') prog = RMPyL() prog.plan = prog.sequence( hello.scan(), uav.scan(), prog.decide( { 'name': 'UAV-choice', 'domain': ['Hello', 'UAV'], 'utility': [7, 5] }, prog.sequence( hello.fly(), prog.observe( { 'name': 'hello-success', 'domain': ['Success', 'Failure'], 'ctype': 'probabilistic', 'probability': [0.8, 0.2] }, prog.decide( { 'name': 'hello-assert-success', 'domain': ['Success'], 'utility': [10] }, hello.stop()), prog.decide( { 'name': 'hello-assert-failure', 'domain': ['Failure'], 'utility': [0] }, hello.stop()))), prog.sequence( uav.fly(), prog.observe( { 'name': 'uav-success', 'domain': ['Success', 'Failure'], 'ctype': 'probabilistic', 'probability': [0.95, 0.05] }, prog.decide( { 'name': 'uav-assert-success', 'domain': ['Success'], 'utility': [10] }, uav.stop()), prog.decide( { 'name': 'uav-assert-failure', 'domain': ['Failure'], 'utility': [0] }, uav.stop()))))) return prog
def rmpyl_infeasible(): prog = RMPyL() prog *= Episode(action='(cab-ride)', duration={ 'ctype': 'controllable', 'lb': 10, 'ub': 20 }) prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=5.0) return prog
def rmpyl_low_risk(): prog = RMPyL() prog *= Episode(action='(cab-ride)', duration={ 'ctype': 'uncontrollable_probabilistic', 'distribution': { 'type': 'uniform', 'lb': 5.0, 'ub': 10.0 } }) prog.add_overall_temporal_constraint(ctype='controllable', lb=5.0, ub=9.9) return prog
def rmpyl_uav(): hello = UAV('hello') uav = UAV('uav') prog = RMPyL() # prog *= hello.fly() prog.plan = prog.sequence( hello.scan(), hello.fly(), uav.fly(), uav.scan(), prog.decide( { 'name': 'UAV-choice', 'domain': ['Hello', 'UAV'], 'utility': [5, 7] }, hello.fly(), uav.fly())) prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=18.0) return prog
def nominal_case(blocks): """ Nominal case, where the robot observes what the human has already completed, and acts accordingly """ agent='Baxter' manip='BaxterRight' prog = RMPyL(name='run()') prog *= prog.sequence(say('Should I start?'), prog.observe({'name':'observe-human-%d'%(len(blocks)), 'ctype':'uncontrollable', 'domain':['YES','NO']}, observe_and_act(prog,blocks,manip,agent), say('All done!'))) return prog
def rmpyl_parallel_uav(): hello = UAV('hello') uav = UAV('uav') prog = RMPyL() prog.plan = prog.parallel( prog.sequence( prog.decide( { 'name': 'hello-action', 'domain': ['Fly', 'Scan'], 'utility': [0, 1] }, hello.fly(), hello.scan()), prog.decide( { 'name': 'hello-action', 'domain': ['Fly', 'Scan'], 'utility': [0, 1] }, hello.fly(), hello.scan()), prog.decide( { 'name': 'hello-action', 'domain': ['Fly', 'Scan'], 'utility': [0, 1] }, hello.fly(), hello.scan())), prog.sequence( prog.decide( { 'name': 'uav-action', 'domain': ['Fly', 'Scan'], 'utility': [0, 1] }, uav.fly(), uav.scan()), prog.decide( { 'name': 'uav-action', 'domain': ['Fly', 'Scan'], 'utility': [0, 1] }, uav.fly(), uav.scan()), prog.decide( { 'name': 'uav-action', 'domain': ['Fly', 'Scan'], 'utility': [0, 1] }, uav.fly(), uav.scan()))) return prog
def rmpyl_choice_risk(): prog = RMPyL() prog *= prog.decide( { 'name': 'transport-choice', 'domain': ['Bike', 'Car', 'Stay'], 'utility': [100, 70, 0] }, prog.observe( { 'name': 'travel', 'ctype': 'probabilistic', 'domain': ['Short', 'Long'], 'probability': [0.7, 0.3] }, Episode(action='(cab-ride-long)', duration={ 'ctype': 'uncontrollable_probabilistic', 'distribution': { 'type': 'uniform', 'lb': 5.0, 'ub': 11.0 } }), Episode(action='(cab-ride-short)', duration={ 'ctype': 'uncontrollable_probabilistic', 'distribution': { 'type': 'uniform', 'lb': 5.0, 'ub': 10.0 } })), Episode(action='(drive-car)', duration={ 'ctype': 'controllable', 'lb': 6.0, 'ub': 8.0 }), Episode(action='(stay)')) prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=10.0) return prog
def policy_to_rmpyl(G, policy, name='run()', constraint_fields=['constraints'], global_start=None, global_end=None): """ Returns an RMPyL program corresponding to the RAO* policy, which can be subsequently converted into a pTPN. """ prog = RMPyL(name=name) constraints = set() prog *= _recursive_convert(G, prog, G.root, policy, constraints, constraint_fields, global_end) if global_start != None: constraints.add( TemporalConstraint(start=global_start, end=prog.first_event, ctype='controllable', lb=0.0, ub=float('inf'))) _add_constraints(prog, constraints) return prog
verbose=True) domain, problem, task = model_parser(dom_file, prob_file, remove_static=True) start = time.time() sat_plans = py_sat.plan(task.initial_state, task.goals, time_steps=18) elapsed = time.time() - start print('\n##### All solving took %.4f s' % (elapsed)) if len(sat_plans) > 0: plan = sat_plans[0] print('\n##### Plan found!\n') for t, action in enumerate(plan): print('%d: %s' % (t, action)) prog = RMPyL(name='run()') prog.plan = prog.sequence(*[ Episode(start=Event(name='start-of-' + op), end=Event(name='end-of-' + op), action=op, duration=rss_duration_func(op)) for op in plan ]) prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=2000.0) prog.to_ptpn(filename='rss_pysat_before_stnu_reform.tpn') paris = PARIS() risk_bound, sc_sched = paris.stnu_reformulation(prog, makespan=True, cc=0.001)
def rmpyl_breakfast(): """ Example from (Levine & Williams, ICAPS14). """ #Actions that Alice performs get_mug_ep = Episode(action='(get alice mug)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) get_glass_ep = Episode(action='(get alice glass)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) make_cofee_ep = Episode(action='(make-coffee alice)', duration={ 'ctype': 'controllable', 'lb': 3.0, 'ub': 5.0 }) pour_cofee_ep = Episode(action='(pour-coffee alice mug)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) pour_juice_glass = Episode(action='(pour-juice alice glass)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) get_bagel_ep = Episode(action='(get alice bagel)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) get_cereal_ep = Episode(action='(get alice cereal)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) toast_bagel_ep = Episode(action='(toast alice bagel)', duration={ 'ctype': 'controllable', 'lb': 3.0, 'ub': 5.0 }) add_cheese_bagel_ep = Episode(action='(add-cheese alice bagel)', duration={ 'ctype': 'controllable', 'lb': 1.0, 'ub': 2.0 }) mix_cereal_ep = Episode(action='(mix-cereal alice milk)', duration={ 'ctype': 'controllable', 'lb': 1.0, 'ub': 2.0 }) #Actions that the robot performs get_grounds_ep = Episode(action='(get grounds robot)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) get_juice_ep = Episode(action='(get juice robot)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) get_milk_ep = Episode(action='(get milk robot)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) get_cheese_ep = Episode(action='(get cheese robot)', duration={ 'ctype': 'controllable', 'lb': 0.5, 'ub': 1.0 }) prog = RMPyL() prog *= prog.sequence( prog.parallel( prog.observe( { 'name': 'observe-utensil', 'domain': ['Mug', 'Glass'], 'ctype': 'uncontrollable' }, get_mug_ep, get_glass_ep, id='observe-utensil-ep'), prog.decide( { 'name': 'choose-beverage-ingredient', 'domain': ['Grounds', 'Juice'], 'utility': [0, 0] }, get_grounds_ep, get_juice_ep, id='choose-beverage-ingredient-ep')), prog.observe( { 'name': 'observe-alice-drink', 'domain': ['Coffee', 'Juice'], 'ctype': 'uncontrollable' }, prog.sequence(make_cofee_ep, pour_cofee_ep), pour_juice_glass, id='observe-alice-drink-ep'), prog.parallel(prog.observe( { 'name': 'observe-food', 'domain': ['Bagel', 'Cereal'], 'ctype': 'uncontrollable' }, get_bagel_ep, get_cereal_ep, id='observe-food-ep'), prog.decide( { 'name': 'choose-food-ingredient', 'domain': ['Milk', 'Cheese'], 'utility': [0, 0] }, get_milk_ep, get_cheese_ep, id='choose-food-ingredient-ep'), id='parallel-food-ep'), prog.observe( { 'name': 'observe-alice-food', 'domain': ['Bagel', 'Cereal'], 'ctype': 'uncontrollable' }, prog.sequence(toast_bagel_ep, add_cheese_bagel_ep), mix_cereal_ep), id='breakfast-sequence') extra_tcs = [ TemporalConstraint( start=prog.episode_by_id('breakfast-sequence').start, end=prog.episode_by_id('observe-utensil-ep').start, ctype='controllable', lb=0.0, ub=0.0), TemporalConstraint( start=prog.episode_by_id('breakfast-sequence').start, end=prog.episode_by_id('choose-beverage-ingredient-ep').start, ctype='controllable', lb=0.2, ub=0.3), TemporalConstraint(start=prog.episode_by_id('parallel-food-ep').start, end=prog.episode_by_id('observe-food-ep').start, ctype='controllable', lb=0.0, ub=0.0), TemporalConstraint( start=prog.episode_by_id('parallel-food-ep').start, end=prog.episode_by_id('choose-food-ingredient-ep').start, ctype='controllable', lb=0.2, ub=0.3) ] for tc in extra_tcs: prog.add_temporal_constraint(tc) prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=7.0) prog.simplify_temporal_constraints() return prog
def _fake_plan_path(sites, start_site, goal_site, risk, velocities, duration_type, agent, **kwargs): """ Fakes a chance-constrained path from a start location to a goal location. Specific parameters are given as keyword arguments. """ start = sites[start_site]['coords'] goal = sites[goal_site]['coords'] line_dist = la.norm(goal - start) dist = line_dist * 1.2 if risk < 0.005 else line_dist * 1.1 lb_duration = dist / velocities['max'] ub_duration = dist / velocities['avg'] if duration_type == 'uncontrollable_bounded': duration_dict = { 'ctype': 'uncontrollable_bounded', 'lb': lb_duration, 'ub': ub_duration } elif duration_type == 'uniform': duration_dict = { 'ctype': 'uncontrollable_probabilistic', 'distribution': { 'type': 'uniform', 'lb': lb_duration, 'ub': ub_duration } } elif duration_type == 'gaussian': duration_dict = { 'ctype': 'uncontrollable_probabilistic', 'distribution': { 'type': 'gaussian', 'mean': (lb_duration + ub_duration) / 2.0, 'variance': ((ub_duration - lb_duration)**2) / 36.0 } } elif duration_type == 'no_constraint': duration_dict = { 'ctype': 'controllable', 'lb': 0.0, 'ub': float('inf') } else: raise ValueError( 'Duration type %s currently not supported in Fake Planner.' % duration_type) path_episode = Episode(duration=duration_dict, action='(go-from-to %s %s %s)' % (agent, start_site, goal_site), distance=dist, **kwargs) path_episode.properties['distance'] = dist path_episode.properties['start_coords'] = start path_episode.properties['goal_coords'] = goal prog_path = RMPyL() prog_path.plan = path_episode return prog_path
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 flight_policy.to_ptpn(filename='flightgear_rmpyl.tpn') # Writes control program to pickle file
def rmpyl_icaps14(): """ Example from (Santana & Williams, ICAPS14). """ prog = RMPyL() prog *= prog.decide( { 'name': 'transport-choice', 'domain': ['Bike', 'Car', 'Stay'], 'utility': [100, 70, 0] }, prog.observe( { 'name': 'slip', 'domain': [True, False], 'ctype': 'probabilistic', 'probability': [0.051, 1.0 - 0.051] }, prog.sequence( Episode(action='(ride-bike)', duration={ 'ctype': 'controllable', 'lb': 15, 'ub': 25 }), Episode(action='(change)', duration={ 'ctype': 'controllable', 'lb': 20, 'ub': 30 })), Episode(action='(ride-bike)', duration={ 'ctype': 'controllable', 'lb': 15, 'ub': 25 })), prog.observe( { 'name': 'accident', 'domain': [True, False], 'ctype': 'probabilistic', 'probability': [0.013, 1.0 - 0.013] }, prog.sequence( Episode(action='(tow-vehicle)', duration={ 'ctype': 'controllable', 'lb': 30, 'ub': 90 }), Episode(action='(cab-ride)', duration={ 'ctype': 'controllable', 'lb': 10, 'ub': 20 })), Episode(action='(drive)', duration={ 'ctype': 'controllable', 'lb': 10, 'ub': 20 })), Episode(action='(stay)')) prog.add_overall_temporal_constraint(ctype='controllable', lb=0.0, ub=30.0) return prog
""" Returns the episode representing the rover sending data back to a satellite. """ return Episode(duration={'ctype':'controllable','lb':5,'ub':30}, action='(relay %s)'%(self.name)) loc={'start':(8.751,-8.625), 'minerals':(0.0,-10.0), 'funny_rock':(-5.0,-2.0), 'relay':(0.0,0.0), 'alien_lair':(0.0,10.0)} rov1 = Rover(name='spirit') prog = RMPyL(name='run()')#name=run() is a requirement for Enterprise at the moment prog *= prog.sequence( rov1.go_to(start=loc['start'],goal=loc['minerals'],risk=0.01), rov1.go_to(start=loc['minerals'],goal=loc['funny_rock'],risk=0.01), rov1.go_to(start=loc['funny_rock'],goal=loc['alien_lair'],risk=0.01), rov1.go_to(start=loc['alien_lair'],goal=loc['relay'],risk=0.01)) tc=prog.add_overall_temporal_constraint(ctype='controllable',lb=0.0,ub=2000.0) cc_time = ChanceConstraint(constraint_scope=[tc],risk=0.1) prog.add_chance_constraint(cc_time) #Option to export the RMPyL program to an Enterprise-compliant TPN. prog.to_ptpn(filename='picard_rovers_rmpyl.tpn') #Writes RMPyL program to pickle file. with open('picard_rovers_rmpyl.pickle','wb') as f: print('Writing RMPyL program to pickle file.')
# sat_plans = py_sat.plan(task.initial_state,task.goals,time_steps=30,find_shortest=True) #find optimal plan size sat_plans = py_sat.plan(task.initial_state, task.goals, time_steps=18, find_shortest=True) # find sub-optimal plan # print("---------plan: %d" % len(sat_plans)) if len(sat_plans) > 0: plan = sat_plans[ 0] # get the first plan (default returns a list with one plan) for t, op in enumerate(plan): print('%d: %s' % (t, op)) elapsed = time.time() - start print('\n##### All solving took %.4f s' % (elapsed)) prog = RMPyL(name='run()') pddl_episodes = [ Episode(id=make_episode_id(t, op), start=Event(name='start-of-%d-%s' % (t, op)), end=Event(name='end-of-%d-%s' % (t, op)), action=op, duration=rss_duration_model_func(op)) for t, op in enumerate(plan) ] prog.plan = prog.sequence(*pddl_episodes) # prog.add_overall_temporal_constraint(ctype='controllable',lb=0.0,ub=2000.0) #Adds temporal window to the plan for t, op in enumerate(plan): bounds, tc_type = rss_time_window_model_func(op) for tc in time_window_constraints( tc_type, bounds, prog.first_event,