def load_datasets(self):
if self.train_save_path and os.path.exists(self.train_save_path):
print('Loading formatted train data ...')
self.train = load(self.train_save_path)
if self.validation_save_path and os.path.exists(self.validation_save_path):
print('Loading formatted validation data ...')
self.validation = load(self.validation_save_path)
if self.test_save_path and os.path.exists(self.test_save_path):
print('Loading formatted test data ...')
self.test = load(self.test_save_path)
from solvers.value_iter import ValueIterator
from solvers import *
def solve_with_value_iter(mdp,thresh,max_iter):
iterator = ValueIterator(mdp)
solver = IterativeSolver(iterator)
term_conds = [ValueChangeTerminationCondition(thresh),
MaxIterTerminationCondition(max_iter)]
announce = [ValueChangeAnnounce()]
solver.termination_conditions.extend(term_conds)
solver.notifications.extend(announce)
solver.solve()
return iterator.get_value_vector()
if __name__ == '__main__':
parser = ArgumentParser(__file__,\
'Generates an MDP from continuous problem')
parser.add_argument('mdp_in_file',
metavar='FILE',
help='mdp file')
parser.add_argument('sol_out_file',
metavar='FILE',
help='solution out file')
args = parser.parse_args()
mdp = load(args.mdp_in_file)
sol = solve_with_kojima(mdp,1e-9,1e4)
dump(p, args.sol_out_file)
mdp_obj = builder.build_mdp()
return (mdp_obj,discretizer)
if __name__ == '__main__':
parser = ArgumentParser(__file__,'Generates an MDP from continuous problem')
parser.add_argument('problem_in_file',
metavar='FILE',
help='problem file')
parser.add_argument('num_states',
metavar='N',
type=int,
help='number of states per dimension')
parser.add_argument('num_actions',
metavar='A',
type=int,
help='number of actions per dimension')
parser.add_argument('mdp_out_file',
metavar='FILE',
help='mdp save file')
parser.add_argument('disc_out_file',
metavar='FILE',
help='discretizer save file')
args = parser.parse_args()
problem=load(args.problem_in_file)
(mdp,disc) = make_uniform_mdp(problem,
args.num_states,
args.num_actions)
dump(mdp,args.mdp_out_file)
dump(disc,args.disc_out_file)
from mdp.state_functions import InterpolatedFunction
from mdp.solution_process import *
if __name__ == '__main__':
parser = ArgumentParser(__file__,\
'Form a policy from value function')
parser.add_argument('sol_in_file',
metavar='FILE',
help='solution in file')
parser.add_argument('disc_in_file',
metavar='FILE',
help='discretizer in file')
parser.add_argument('mdp_in_file',
metavar='FILE',
help='mdp in file')
parser.add_argument('v_fn_out_file',
metavar='FILE',
help='solution out file')
args = parser.parse_args()
p = load(args.sol_in_file)
disc = load(args.disc_in_file)
mdp = load(args.mdp_in_file)
# Build the q policy
(v,_) = split_solution(mdp,p)
v_fn = InterpolatedFunction(disc,v)
dump(v_fn,args.v_fn_out_file)
def cdf_plot(returns):
for (name,ret) in returns.items():
(x,f) = cdf_points(ret)
plt.plot(x,f,'-',lw=2,label=name)[0]
plt.legend(returns.keys(),loc='best')
plt.show()
def compare(returns,a,*vargs):
x = returns[a]
for comp in vargs:
y = returns[comp]
plt.plot(x,y,'o',label=comp)
plt.xlabel(a)
plt.legend(loc='best')
plt.show()
root = 'data/exper2/hallway'
#results = load(root + '.results.pickle')
returns = load(root + '.return.pickle')
#states = load(root + '.starts.pickle')
#compare(returns,'q','q pert','mcts')
filtered_returns = {}
for (name,ret) in returns.items():
split_name = name.split('_')
filtered_returns[name] = ret
cdf_plot(filtered_returns)
