def main(argv):
domain_path = argv[1]
problem_path = argv[2]
if argv[0] == "-L":
agent = Learner()
else:
agent = MyExecutor()
print LocalSimulator().run(domain_path, problem_path, agent)
def main():
domain_path = "doms and probs/satellite_domain_multi.pddl" #"doms and probs/rover_domain (2).pddl"# # # #sys.argv[2]
problem_path = "doms and probs/satellite_problem_multi.pddl" #"doms and probs/rover_problem (2).pddl" # # # sys.argv[3]
# Find the problem and the world in the problem name
file = open(problem_path, 'r')
policy_name = file.readline().replace("(define (problem ", "")
while policy_name == "\n":
policy_name = file.readline().replace("(define (problem ", "")
policy_name = policy_name[0:policy_name.find(")")] + "_Q_Table"
file.close()
file = open(domain_path)
is_deterministic = file.read().find("probabilistic") == -1
file.close()
file = open(problem_path)
is_transparent = file.read().find("reveal") == -1
file.close()
# if (is_deterministic == False):
# load\create the Qtable
q = q_table.q_table()
q.build_from_file(policy_name)
# if sys.argv[1] == "-E":
# execute mode
#
# if is_deterministic == False:
#print LocalSimulator().run(domain_path, problem_path, Q_learner_executer.executer(q))
# else:
#print LocalSimulator().run(domain_path, problem_path, graph_executor.executer(q,Graph.Read("roverMqsdkJedCB9zj3HW+RaxCJQcsI6i4w3XNYU8vDEdkFo=.graphml", "graphml")))
# elif sys.argv[1] == "-L":
# atexit.register(q.save_to_file, policy_path=policy_name)
# learn mode
print LocalSimulator().run(domain_path, problem_path, learner.learner(q))
# name : yuval saadati # id: 205956634 import sys from pddlsim.local_simulator import LocalSimulator from my_agent import Executor print LocalSimulator().run(str(sys.argv[2]), str(sys.argv[3]), Executor(str(sys.argv[1]), str(sys.argv[4])))
#domain_path = sys.argv[2] #problem_path = sys.argv[3] """ deterministic domain and problem """ # maze domain_path = "maze_domain.pddl" problem_path = "maze_problem.pddl" # freecell domain_path = "freecell_domain.pddl" problem_path = "freecell_problem.pddl" # satellite domain_path = "satellite_domain.pddl" problem_path = "satellite_problem.pddl" # rover """ domain_path = "rover_domain (2).pddl" problem_path = "rover_problem (2).pddl" """ """ NOT deterministic domain and problem """ # maze domain_path = "maze_domain_multi_effect_food.pddl" problem_path = "t_5_5_5_food-prob0.pddl" #problem_path = "t_5_5_5_food-prob1.pddl" #problem_path = "t_10_10_10.pddl" # satellite #domain_path = "satellite_domain_multi.pddl" #problem_path = "satellite_problem_multi.pddl" print LocalSimulator().run(sys.argv[2], sys.argv[3], best_agent())
def run():
print LocalSimulator().run(tools.getDomain(), tools.getProblem(),
MazeExecuter())
perception = Perception(sim.perceive_state)
valid_actions_getter = MyValidActionsGetter(parser, perception)
root_state = perception.get_state()
states = get_all_states(root_state, valid_actions_getter, parser)
actions = [action for action in parser.actions]
goal_states = get_goal_states(parser.goals, states)
distances_from_goals = get_distances_from_goals(goal_states, states,
valid_actions_getter, parser)
state_discovery_reward = defaultdict(float)
for state_index in distances_from_goals:
state_discovery_reward[state_index] = 0
state_distances = distances_from_goals[state_index]
for goal_index in state_distances:
state_discovery_reward[state_index] += 1. / state_distances[goal_index]
max_reward = len(goal_states) * max(state_discovery_reward.values())
state_recurrence_punish = min(state_discovery_reward.values())
bad_action_punish = max(state_discovery_reward.values())
lookahead = 4
known_threshold = len(states) * len(actions)
print(
LocalSimulator(local).run(
domain_path, problem_path,
My_Executer(problem_path, states, actions, goal_states,
state_discovery_reward, max_reward,
state_recurrence_punish, bad_action_punish, lookahead,
known_threshold)))
else:
policy_path = 'POLICYFILE'
train_mode = 'L' in run_mode_flag
clear_policy(policy_path)
global_start_time = datetime.now()
if train_mode:
# Train mode
iterations = 1
moving_average_window = 1
results_moving_average = list()
rewards_moving_average = list()
for current_simulation_id in range(iterations):
iteration_start_time = datetime.now()
simulator = LocalSimulator()
executor = MyExecutor(policy_path=policy_path, train_mode=True)
ret_message = simulator.run(domain_path, problem_path, executor)
print(ret_message)
completion_time = datetime.now()
msg = ''
msg += '[Iter: {}/{}]'.format(current_simulation_id + 1,
iterations)
msg += 'Global runtime: {}\t'.format(completion_time -
global_start_time)
msg += 'iteration runtime: {}\t'.format(completion_time -
iteration_start_time)
print(msg)
print(
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
option = sys.argv[1]
if option == '-s':
plan_path = "simple_football_plan.xml"
domain_path = "simple_football_domain.pddl"
elif option == '-e':
plan_path = "extended_football_plan.xml"
domain_path = "extended_football_domain.pddl"
else:
sys.exit('Error: expected flag to be -s or -e, but flag = ' +
str(option))
try:
N = int(sys.argv[2])
except ValueError:
sys.exit('Error: except N to be a number, but N = ' + sys.argv[2])
problem_path = sys.argv[3]
if not os.path.exists(problem_path):
sys.exit('problem_file path does not exist: ' + problem_path)
else:
sys.exit('Error: missing arguments expected 3 arguments, but got ',
str((len(sys.argv) - 1)))
plan = PlanParser(plan_path).getPlan()
BiuExecutor = BIUExecutor(option, N, plan)
print LocalSimulator(local).run(domain_path, problem_path, BiuExecutor)
while len(reversed_route) is not 0:
item = reversed_route.pop()
route.append(item)
wanted_location = route[1]
return "(move" + " " + str(my_location) + " " + str(
wanted_location) + ")"
def next_action(self):
global count
self.update()
if self.services.goal_tracking.reached_all_goals():
return None
for goal in goals:
if self.goal_reached(goal):
count += 1
continue
if count >= len(goals):
return None
ball = goal.split(" ")[0]
if self.near_ball(ball):
return self.kick_ball(ball)
else:
return self.move_to_ball(ball)
return None
domain_path = argv[1]
problem_path = argv[2]
print LocalSimulator().run(domain_path, problem_path, FootballExecuter())
# from pddlsim.local_simulator import LocalSimulator # from random_walker import RandomExecutor # domain_path = "domain.pddl" # problem_path = "problem.pddl" # print LocalSimulator().run(domain_path, problem_path, RandomExecutor()) from pddlsim.local_simulator import LocalSimulator from pddlsim.executors.plan_dispatch import PlanDispatcher domain_path = "domain.pddl" problem_path = "problem.pddl" print LocalSimulator().run(domain_path, problem_path, PlanDispatcher())
self.steps = []
self.plan = []
def initialize(self, services):
self.services = services
def next_action(self):
if self.services.goal_tracking.reached_all_goals():
return None
self.steps = self.services.valid_actions.get()
if len(self.steps) == 0: return None
if len(self.steps) == 1: return self.steps[0]
if self.plan == []:
problem_path = self.services.problem_generator.generate_problem(
self.services.goal_tracking.uncompleted_goals[0],
self.services.perception.get_state())
self.plan = self.services.planner(self.services.pddl.domain_path,
problem_path)
if len(self.plan) > 0:
return self.plan.pop(0)
return None
from pddlsim.local_simulator import LocalSimulator
domain_path = sys.argv[1]
problem_path = sys.argv[2]
print LocalSimulator().run(domain_path, problem_path, SmartReplanner())
# name : yuval saadati
# id: 205956634
import sys
from pddlsim.executors.plan_dispatch import PlanDispatcher
from pddlsim.local_simulator import LocalSimulator
from my_agent import Executor
with open(str(sys.argv[2])) as fp:
line = fp.readline()
planner = False
while line:
if "probabilistic" in line:
print(LocalSimulator().run(str(sys.argv[2]), str(sys.argv[3]),
Executor(str(sys.argv[1]))))
planner = True
break
line = fp.readline()
if not planner:
print(LocalSimulator().run(str(sys.argv[2]), str(sys.argv[3]),
PlanDispatcher()))
def learn():
LocalSimulator().run(tools.getDomain(), tools.getProblem(), MazeLearner())
BFS.init()
import sys
from pddlsim.local_simulator import LocalSimulator
from pddlsim.planner import local
from StochasticSmartReplanner import StochasticSmartReplanner
# domain_path = "domain.pddl"
# problem_path = "t_5_5_5_multiple.pddl"
# problem_path = "ahinoam_problem.pddl"
# problem_path = "failing_actions_example.pddl"
# domain_path = "freecell_domain.pddl"
# problem_path = "freecell_problem.pddl"
# domain_path = "rover_domain.pddl"
# problem_path = "rover_problem.pddl"
# domain_path = "satellite_domain.pddl"
# problem_path = "satellite_problem.pddl"
domain_path = sys.argv[1]
problem_path = sys.argv[2]
print(
LocalSimulator(local).run(domain_path, problem_path,
StochasticSmartReplanner(problem_path)))
# name : yuval saadati
# id: 205956634
import sys
from pddlsim.local_simulator import LocalSimulator
from my_agent import Executor
print LocalSimulator().run("simple_football_domain_multi.pddl",
"simple_football_problem_multi.pddl", Executor())
#print LocalSimulator().run(str(sys.argv[1]), str(sys.argv[2]), Executor())
class RandomExecutor(object):
""" RandomExecutor - pick a random valid action each step
"""
def __init__(self):
self.successor = None
print "__init__"
print self.successor
def initialize(self, services):
self.services = services
def next_action(self):
if self.services.goal_tracking.reached_all_goals():
return None
options = self.services.valid_actions.get()
print options
if len(options) == 0: return None
if len(options) == 1: return options[0]
return self.pick_from_many(options)
def pick_from_many(self, options):
chosen = random.choice(options)
return chosen
domain_path = "domain.pddl"
problem_path = "problem.pddl"
print LocalSimulator().run(domain_path, problem_path, RandomExecutor())
if len(at) == 0:
return None
person = at[0].split(" ")[0]
location = at[0].split(" ")[3]
query = "from " + location
instruction = ""
item = policy.get(person)
if policy.get(person) is None:
return None
for entry in policy.get(person)[0]:
if query.split(" ")[1] == entry.split(" ")[1]:
instruction = entry
break
if instruction == "":
return None
current = instruction.split(" ")[1]
next = instruction.split(" ")[4]
if self.is_north_of(current, next):
return "(move-north " + person + " " + current + " " + next + ")"
if self.is_south_of(current, next):
return "(move-south " + person + " " + current + " " + next + ")"
if self.is_east_of(current, next):
return "(move-east " + person + " " + current + " " + next + ")"
if self.is_west_of(current, next):
return "(move-west " + person + " " + current + " " + next + ")"
domain_path = argv[1]
problem_path = argv[2]
print LocalSimulator().run(domain_path, problem_path, MazeExecuter())
# name : yuval saadati # id: 205956634 import sys from pddlsim.local_simulator import LocalSimulator from my_agent import Executor domain_path = "attack_domain.pddl" problem1_path = "attack_problem1.pddl" problem2_path = "attack_problem2.pddl" print LocalSimulator().run(domain_path, problem2_path, Executor()) #print LocalSimulator().run(str(sys.argv[1]), str(sys.argv[2]), Executor())