def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
# Log performance of randomly initialized policy with FIXED goal [0.1, 0.1]
logger.log("Initializing report...")
log_dir = logger.get_snapshot_dir() # problem with logger module here!!
if log_dir is None:
log_dir = "/home/michael/"
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=3)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
inner_env = normalize(AntMazeEnv())
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
fixed_start_generator = FixedStateGenerator(state=v['ultimate_goal'])
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=fixed_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[-3:-1],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
inner_weight=v['inner_weight'],
goal_weight=v['goal_weight'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16, 16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
#baseline = LinearFeatureBaseline(env_spec=env.spec)
if v["baseline"] == "MLP":
baseline = GaussianMLPBaseline(env_spec=env.spec)
else:
baseline = LinearFeatureBaseline(env_spec=env.spec)
# load the state collection from data_upload
all_starts = StateCollection(distance_threshold=v['coll_eps'], states_transform=lambda x: x[:, :2])
# can also filter these starts optionally
load_dir = 'sandbox/young_clgan/experiments/starts/maze/maze_ant/'
all_feasible_starts = pickle.load(
open(osp.join(config.PROJECT_PATH, load_dir, 'good_all_feasible_starts.pkl'), 'rb'))
logger.log("We have %d feasible starts" % all_feasible_starts.size)
min_reward = 0.1
max_reward = 0.9
improvement_threshold = 0
old_rewards = None
# hardest to easiest
init_pos = [[0, 0],
[1, 0],
[2, 0],
[3, 0],
[4, 0],
[4, 1],
[4, 2],
[4, 3],
[4, 4],
[3, 4],
[2, 4],
[1, 4]
][::-1]
for pos in init_pos:
pos.extend([0.55, 1, 0, 0, 0, 0, 1, 0, -1, 0, -1, 0, 1, ])
array_init_pos = np.array(init_pos)
init_pos = [tuple(pos) for pos in init_pos]
online_start_generator = Online_TCSL(init_pos)
for outer_iter in range(1, v['outer_iters']):
logger.log("Outer itr # %i" % outer_iter)
logger.log("Sampling starts")
report.save()
# generate starts from the previous seed starts, which are defined below
dist = online_start_generator.get_distribution() # added
logger.log(np.array_str(online_start_generator.get_q()))
# how to log Q values?
# with logger.tabular_prefix("General: "):
# logger.record_tabular("Q values:", online_start_generator.get_q())
logger.log(np.array_str(dist))
# Following code should be indented
with ExperimentLogger(log_dir, outer_iter // 50, snapshot_mode='last', hold_outter_log=True):
logger.log("Updating the environment start generator")
#TODO: might be faster to sample if we just create a roughly representative UniformListStateGenerator?
env.update_start_generator(
ListStateGenerator(
init_pos, dist
)
)
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
trpo_paths = algo.train()
logger.log("Labeling the starts")
[starts, labels, mean_rewards, updated] = label_states_from_paths(trpo_paths, n_traj=v['n_traj'], key='goal_reached', # using the min n_traj
as_goal=False, env=env, return_mean_rewards=True, order_of_states=init_pos)
start_classes, text_labels = convert_label(labels)
plot_labeled_states(starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'])
online_start_generator.update_q(np.array(mean_rewards), np.array(updated)) # added
labels = np.logical_and(labels[:, 0], labels[:, 1]).astype(int).reshape((-1, 1))
# append new states to list of all starts (replay buffer): Not the low reward ones!!
filtered_raw_starts = [start for start, label in zip(starts, labels) if label[0] == 1]
if v['seed_with'] == 'only_goods':
if len(filtered_raw_starts) > 0: # add a ton of noise if all the states I had ended up being high_reward!
logger.log("We have {} good starts!".format(len(filtered_raw_starts)))
seed_starts = filtered_raw_starts
elif np.sum(start_classes == 0) > np.sum(start_classes == 1): # if more low reward than high reward
logger.log("More bad starts than good starts, sampling seeds from replay buffer")
seed_starts = all_starts.sample(300) # sample them from the replay
else:
logger.log("More good starts than bad starts, resampling")
seed_starts = generate_starts(env, starts=starts, horizon=v['horizon'] * 2, subsample=v['num_new_starts'], size=10000,
variance=v['brownian_variance'] * 10)
elif v['seed_with'] == 'all_previous':
seed_starts = starts
else:
raise Exception
all_starts.append(filtered_raw_starts)
# need to put this last! otherwise labels variable gets confused
logger.log("Labeling on uniform starts")
with logger.tabular_prefix("Uniform_"):
unif_starts = all_feasible_starts.sample(100)
mean_reward, paths = evaluate_states(unif_starts, env, policy, v['horizon'], n_traj=v['n_traj'], key='goal_reached',
as_goals=False, full_path=True)
env.log_diagnostics(paths)
mean_rewards = mean_reward.reshape(-1, 1)
labels = compute_labels(mean_rewards, old_rewards=old_rewards, min_reward=min_reward, max_reward=max_reward,
improvement_threshold=improvement_threshold)
logger.log("Starts labelled")
plot_labeled_states(unif_starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
# report.add_text("Success: " + str(np.mean(mean_reward)))
with logger.tabular_prefix("Fixed_"):
mean_reward, paths = evaluate_states(array_init_pos, env, policy, v['horizon'], n_traj=5, key='goal_reached',
as_goals=False, full_path=True)
env.log_diagnostics(paths)
mean_rewards = mean_reward.reshape(-1, 1)
labels = compute_labels(mean_rewards, old_rewards=old_rewards, min_reward=min_reward, max_reward=max_reward,
improvement_threshold=improvement_threshold)
logger.log("Starts labelled")
plot_labeled_states(array_init_pos, labels, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
report.add_text("Fixed Success: " + str(np.mean(mean_reward)))
report.new_row()
report.save()
logger.record_tabular("Fixed test set_success: ", np.mean(mean_reward))
logger.dump_tabular()
def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
# Log performance of randomly initialized policy with FIXED goal [0.1, 0.1]
logger.log("Initializing report...")
log_dir = logger.get_snapshot_dir() # problem with logger module here!!
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=4)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
report.save()
inner_env = normalize(Arm3dDiscEnv())
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
fixed_start_generator = FixedStateGenerator(state=v['ultimate_goal'])
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=fixed_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[-1 * v['goal_size']:],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
inner_weight=v['inner_weight'],
goal_weight=v['goal_weight'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16,
16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
baseline = LinearFeatureBaseline(env_spec=env.spec)
# load the state collection from data_upload
load_dir = 'data_upload/state_collections/'
all_feasible_starts = pickle.load(
open(
osp.join(config.PROJECT_PATH, load_dir,
'disc_all_feasible_states_min.pkl'), 'rb'))
print("we have %d feasible starts" % all_feasible_starts.size)
all_starts = StateCollection(distance_threshold=v['coll_eps'])
# brownian_starts = StateCollection(distance_threshold=v['regularize_starts'])
# with env.set_kill_outside():
# seed_starts = generate_starts(env, starts=[v['start_goal']], horizon=10, # this is smaller as they are seeds!
# variance=v['brownian_variance'], subsample=v['num_new_starts']) # , animated=True, speedup=1)
#
# with env.set_kill_outside():
# find_all_feasible_states(env, seed_starts, distance_threshold=0.1, brownian_variance=1, animate=False)
# show where these states are:
# shuffled_starts = np.array(all_feasible_starts.state_list)
# np.random.shuffle(shuffled_starts)
# generate_starts(env, starts=shuffled_starts, horizon=100, variance=v['brownian_variance'], animated=True, speedup=10)
# Use asymmetric self-play to run Alice to generate starts for Bob.
env_alice = AliceEnv(env, env, policy, v['horizon'])
policy_alice = GaussianMLPPolicy(
env_spec=env_alice.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16,
16), # this is only used if adaptive_std is true!
output_gain=v['output_gain_alice'],
init_std=v['policy_init_std_alice'],
)
baseline_alice = LinearFeatureBaseline(env_spec=env_alice.spec)
algo_alice = TRPO(
env=env_alice,
policy=policy_alice,
baseline=baseline_alice,
batch_size=v['pg_batch_size_alice'],
max_path_length=v['horizon'],
n_itr=v['inner_iters_alice'],
step_size=0.01,
discount=v['discount_alice'],
plot=False,
)
for outer_iter in range(1, v['outer_iters']):
logger.log("Outer itr # %i" % outer_iter)
logger.log("Sampling starts")
# with env.set_kill_outside():
# starts = generate_starts(env, starts=seed_starts, horizon=v['brownian_horizon'], variance=v['brownian_variance'])
# regularization of the brownian starts
# brownian_starts.empty()
# brownian_starts.append(starts)
# starts = brownian_starts.sample(size=v['num_new_starts'])
starts = generate_starts_alice(env_bob=env,
env_alice=env_alice,
policy_bob=policy,
policy_alice=policy_alice,
algo_alice=algo_alice,
start_states=[v['start_goal']],
num_new_starts=v['num_new_starts'],
alice_factor=v['alice_factor'],
log_dir=log_dir)
if v['replay_buffer'] and outer_iter > 0 and all_starts.size > 0:
old_starts = all_starts.sample(v['num_old_starts'])
starts = np.vstack([starts, old_starts])
with ExperimentLogger(log_dir,
'last',
snapshot_mode='last',
hold_outter_log=True):
logger.log("Updating the environment start generator")
env.update_start_generator(
UniformListStateGenerator(
starts.tolist(),
persistence=v['persistence'],
with_replacement=v['with_replacement'],
))
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
trpo_paths = algo.train()
if v['use_trpo_paths']:
logger.log("labeling starts with trpo rollouts")
[starts, labels] = label_states_from_paths(
trpo_paths,
n_traj=2,
key='goal_reached', # using the min n_traj
as_goal=False,
env=env)
paths = [path for paths in trpo_paths for path in paths]
else:
logger.log("labeling starts manually")
labels, paths = label_states(starts,
env,
policy,
v['horizon'],
as_goals=False,
n_traj=v['n_traj'],
key='goal_reached',
full_path=True)
with logger.tabular_prefix("OnStarts_"):
env.log_diagnostics(paths)
logger.record_tabular('starts', starts.size)
start_classes, text_labels = convert_label(labels)
total_starts = labels.shape[0]
logger.record_tabular('GenStarts_evaluated', total_starts)
start_class_frac = OrderedDict(
) # this needs to be an ordered dict!! (for the log tabular)
for k in text_labels.keys():
frac = np.sum(start_classes == k) / total_starts
logger.record_tabular('GenStart_frac_' + text_labels[k], frac)
start_class_frac[text_labels[k]] = frac
labels = np.logical_and(labels[:, 0],
labels[:, 1]).astype(int).reshape((-1, 1))
logger.log("Labeling on uniform starts")
with logger.tabular_prefix("Uniform_"):
unif_starts = all_feasible_starts.sample(1000)
mean_reward, paths = evaluate_states(unif_starts,
env,
policy,
v['horizon'],
n_traj=1,
key='goal_reached',
as_goals=False,
full_path=True)
env.log_diagnostics(paths)
logger.dump_tabular(with_prefix=True)
# append new states to list of all starts (replay buffer): Not the low reward ones!!
logger.log("Appending good goals to replay and generating seeds")
filtered_raw_starts = [
start for start, label in zip(starts, labels) if label[0] == 1
]
all_starts.append(filtered_raw_starts)
def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
sampling_res = 2 if 'sampling_res' not in v.keys() else v['sampling_res']
samples_per_cell = 10 # for the oracle rejection sampling
# Log performance of randomly initialized policy with FIXED goal [0.1, 0.1]
logger.log("Initializing report and plot_policy_reward...")
log_dir = logger.get_snapshot_dir() # problem with logger module here!!
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=5)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
inner_env = normalize(PointMazeEnv(maze_id=v['maze_id']))
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
uniform_start_generator = UniformStateGenerator(state_size=v['start_size'], bounds=v['start_range'],
center=v['start_center'])
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=uniform_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[:v['goal_size']],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
only_feasible=v['only_feasible'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16, 16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
if v['constant_baseline']:
logger.log("Using constant baseline")
baseline = ConstantBaseline(env_spec=env.spec, value=1.0)
else:
logger.log("Using linear baseline")
baseline = LinearFeatureBaseline(env_spec=env.spec)
# initialize all logging arrays on itr0
outer_iter = 0
logger.log('Generating the Initial Heatmap...')
plot_policy_means(policy, env, sampling_res=2, report=report, limit=v['goal_range'], center=v['goal_center'])
test_and_plot_policy(policy, env, as_goals=False, max_reward=v['max_reward'], sampling_res=sampling_res,
n_traj=v['n_traj'],
itr=outer_iter, report=report, center=v['goal_center'],
limit=v['goal_range']) # use goal for plot
report.new_row()
all_starts = StateCollection(distance_threshold=v['coll_eps'])
seed_starts = generate_starts(env, starts=[v['ultimate_goal']], subsample=v['num_new_starts'])
for outer_iter in range(1, v['outer_iters']):
logger.log("Outer itr # %i" % outer_iter)
logger.log("Sampling starts")
starts = generate_starts(env, starts=seed_starts, subsample=v['num_new_starts'],
horizon=v['brownian_horizon'], variance=v['brownian_variance'])
labels = label_states(starts, env, policy, v['horizon'],
as_goals=False, n_traj=v['n_traj'], key='goal_reached')
plot_labeled_states(starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
report.save()
if v['replay_buffer'] and outer_iter > 0 and all_starts.size > 0:
old_starts = all_starts.sample(v['num_old_starts'])
starts = np.vstack([starts, old_starts])
with ExperimentLogger(log_dir, 'last', snapshot_mode='last', hold_outter_log=True):
logger.log("Updating the environment start generator")
env.update_start_generator(
UniformListStateGenerator(
starts.tolist(), persistence=v['persistence'], with_replacement=v['with_replacement'],
)
)
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
trpo_paths = algo.train()
if v['use_trpo_paths']:
logger.log("labeling starts with trpo rollouts")
[starts, labels] = label_states_from_paths(trpo_paths, n_traj=2, key='goal_reached', # using the min n_traj
as_goal=False, env=env)
paths = [path for paths in trpo_paths for path in paths]
else:
logger.log("labeling starts manually")
labels, paths = label_states(starts, env, policy, v['horizon'], as_goals=False, n_traj=v['n_traj'],
key='goal_reached', full_path=True)
with logger.tabular_prefix("OnStarts_"):
env.log_diagnostics(paths)
logger.log('Generating the Heatmap...')
plot_policy_means(policy, env, sampling_res=2, report=report, limit=v['goal_range'], center=v['goal_center'])
test_and_plot_policy(policy, env, as_goals=False, max_reward=v['max_reward'], sampling_res=sampling_res,
n_traj=v['n_traj'],
itr=outer_iter, report=report, center=v['goal_center'], limit=v['goal_range'])
logger.log("Labeling the starts")
#labels = label_states(starts, env, policy, v['horizon'], as_goals=False, n_traj=v['n_traj'], key='goal_reached')
plot_labeled_states(starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'])
start_classes, text_labels = convert_label(labels)
# ###### extra for deterministic:
# logger.log("Labeling the goals deterministic")
# with policy.set_std_to_0():
# labels_det = label_states(goals, env, policy, v['horizon'], n_traj=v['n_traj'], n_processes=1)
# plot_labeled_states(goals, labels_det, report=report, itr=outer_iter, limit=v['goal_range'], center=v['goal_center'])
labels = np.logical_and(labels[:, 0], labels[:, 1]).astype(int).reshape((-1, 1))
logger.dump_tabular(with_prefix=False)
report.new_row()
# append new states to list of all starts (replay buffer): Not the low reward ones!!
filtered_raw_starts = [start for start, label in zip(starts, labels) if label[0] == 1]
all_starts.append(filtered_raw_starts)
if v['seed_with'] == 'only_goods':
if len(filtered_raw_starts) > 0: # add a tone of noise if all the states I had ended up being high_reward!
seed_starts = filtered_raw_starts
elif np.sum(start_classes == 0) > np.sum(start_classes == 1): # if more low reward than high reward
seed_starts = all_starts.sample(300) # sample them from the replay
else:
seed_starts = generate_starts(env, starts=starts, horizon=int(v['horizon'] * 10), subsample=v['num_new_starts'],
variance=v['brownian_variance'] * 10)
elif v['seed_with'] == 'all_previous':
seed_starts = starts
elif v['seed_with'] == 'on_policy':
seed_starts = generate_starts(env, policy, starts=starts, horizon=v['horizon'], subsample=v['num_new_starts'])
def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
# Log performance of randomly initialized policy with FIXED goal [0.1, 0.1]
logger.log("Initializing report...")
log_dir = logger.get_snapshot_dir() # problem with logger module here!!
if log_dir is None:
log_dir = "/home/michael/"
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=2)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
inner_env = normalize(AntMazeEnv())
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
fixed_start_generator = FixedStateGenerator(state=v['ultimate_goal'])
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=fixed_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[-3:-1],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
inner_weight=v['inner_weight'],
goal_weight=v['goal_weight'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16,
16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
if v["baseline"] == "MLP":
baseline = GaussianMLPBaseline(env_spec=env.spec)
else:
baseline = LinearFeatureBaseline(env_spec=env.spec)
load_dir = 'sandbox/young_clgan/experiments/starts/maze/maze_ant/'
all_feasible_starts = pickle.load(
open(
osp.join(config.PROJECT_PATH, load_dir,
'good_all_feasible_starts.pkl'), 'rb'))
logger.log("We have %d feasible starts" % all_feasible_starts.size)
min_reward = 0.1
max_reward = 0.9
improvement_threshold = 0
old_rewards = None
uniform_start_generator = UniformListStateGenerator(
state_list=all_feasible_starts.state_list)
init_pos = [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0], [4, 1], [4, 2], [4, 3],
[4, 4], [3, 4], [2, 4], [1, 4]][::-1]
for pos in init_pos:
pos.extend([
0.55,
1,
0,
0,
0,
0,
1,
0,
-1,
0,
-1,
0,
1,
])
init_pos = np.array(init_pos)
env.update_start_generator(uniform_start_generator)
for outer_iter in range(1, v['outer_iters']):
logger.log("Outer itr # %i" % outer_iter)
logger.log("Sampling starts")
# Following code should be indented
with ExperimentLogger(log_dir,
outer_iter // 50,
snapshot_mode='last',
hold_outter_log=True):
logger.log("Updating the environment start generator")
# env.update_start_generator(uniform_start_generator)
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
algo.train()
logger.log("Labeling on uniform starts")
with logger.tabular_prefix("Uniform_"):
unif_starts = all_feasible_starts.sample(100)
mean_reward, paths = evaluate_states(unif_starts,
env,
policy,
v['horizon'],
n_traj=3,
key='goal_reached',
as_goals=False,
full_path=True)
env.log_diagnostics(paths)
mean_rewards = mean_reward.reshape(-1, 1)
labels = compute_labels(
mean_rewards,
old_rewards=old_rewards,
min_reward=min_reward,
max_reward=max_reward,
improvement_threshold=improvement_threshold)
logger.log("Starts labelled")
plot_labeled_states(unif_starts,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
report.add_text("Success: " + str(np.mean(mean_reward)))
with logger.tabular_prefix("Fixed_"):
mean_reward, paths = evaluate_states(init_pos,
env,
policy,
v['horizon'],
n_traj=5,
key='goal_reached',
as_goals=False,
full_path=True)
env.log_diagnostics(paths)
mean_rewards = mean_reward.reshape(-1, 1)
labels = compute_labels(
mean_rewards,
old_rewards=old_rewards,
min_reward=min_reward,
max_reward=max_reward,
improvement_threshold=improvement_threshold)
logger.log("Starts labelled")
plot_labeled_states(init_pos,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
report.add_text("Fixed Success: " + str(np.mean(mean_reward)))
report.new_row()
report.save()
logger.record_tabular("Fixed test set_success: ", np.mean(mean_reward))
logger.dump_tabular()
def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
# Log performance of randomly initialized policy with FIXED goal [0.1, 0.1]
logger.log("Initializing report...")
log_dir = logger.get_snapshot_dir() # problem with logger module here!!
if log_dir is None:
log_dir = "/home/michael/"
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=3)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
inner_env = normalize(AntMazeEnv())
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
fixed_start_generator = FixedStateGenerator(state=v['ultimate_goal'])
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=fixed_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[-3:-1],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
inner_weight=v['inner_weight'],
goal_weight=v['goal_weight'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16,
16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
if v["baseline"] == "MLP":
baseline = GaussianMLPBaseline(env_spec=env.spec)
else:
baseline = LinearFeatureBaseline(env_spec=env.spec)
# create Alice
env_alice = AliceEnv(env_alice=env,
env_bob=env,
policy_bob=policy,
max_path_length=v['alice_horizon'],
alice_factor=v['alice_factor'],
alice_bonus=v['alice_bonus'],
gamma=1,
stop_threshold=v['stop_threshold'])
policy_alice = GaussianMLPPolicy(
env_spec=env_alice.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16,
16), # this is only used if adaptive_std is true!
output_gain=v['output_gain_alice'],
init_std=v['policy_init_std_alice'],
)
if v["baseline"] == "MLP":
baseline_alice = GaussianMLPBaseline(env_spec=env.spec)
else:
baseline_alice = LinearFeatureBaseline(env_spec=env.spec)
algo_alice = TRPO(
env=env_alice,
policy=policy_alice,
baseline=baseline_alice,
batch_size=v['pg_batch_size_alice'],
max_path_length=v['horizon'],
n_itr=v['inner_iters_alice'],
step_size=0.01,
discount=v['discount_alice'],
plot=False,
)
# load the state collection from data_upload
all_starts = StateCollection(distance_threshold=v['coll_eps'],
states_transform=lambda x: x[:, :2])
load_dir = 'sandbox/young_clgan/experiments/starts/maze/maze_ant/'
all_feasible_starts = pickle.load(
open(
osp.join(config.PROJECT_PATH, load_dir,
'good_all_feasible_starts.pkl'), 'rb'))
logger.log("We have %d feasible starts" % all_feasible_starts.size)
min_reward = 0.1
max_reward = 0.9
improvement_threshold = 0
old_rewards = None
init_pos = [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0], [4, 1], [4, 2], [4, 3],
[4, 4], [3, 4], [2, 4], [1, 4]][::-1]
for pos in init_pos:
pos.extend([
0.55,
1,
0,
0,
0,
0,
1,
0,
-1,
0,
-1,
0,
1,
])
init_pos = np.array(init_pos)
for outer_iter in range(1, v['outer_iters']):
logger.log("Outer itr # %i" % outer_iter)
logger.log("Sampling starts")
report.save()
starts, t_alices = generate_starts_alice(
env_alice=env_alice,
algo_alice=algo_alice,
start_states=[v['start_goal']],
num_new_starts=v['num_new_starts'],
log_dir=log_dir)
if v['filter_bad_starts']:
logger.log("Prefilter starts: {}".format(len(starts)))
starts = parallel_check_feasibility(
env=env,
starts=starts,
max_path_length=v['feasibility_path_length'])
logger.log("Filtered starts: {}".format(len(starts)))
logger.log("Total number of starts in buffer: {}".format(
all_starts.size))
if v['replay_buffer'] and outer_iter > 0 and all_starts.size > 0:
old_starts = all_starts.sample(v['num_old_starts'])
starts = np.vstack([starts, old_starts])
# Following code should be indented
with ExperimentLogger(log_dir,
outer_iter // 50,
snapshot_mode='last',
hold_outter_log=True):
logger.log("Updating the environment start generator")
env.update_start_generator(
UniformListStateGenerator(
starts.tolist(),
persistence=v['persistence'],
with_replacement=v['with_replacement'],
))
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
trpo_paths = algo.train()
with logger.tabular_prefix('Outer_'):
logger.record_tabular('t_alices', np.mean(t_alices))
logger.log("Labeling the starts")
[starts, labels] = label_states_from_paths(
trpo_paths,
n_traj=v['n_traj'],
key='goal_reached', # using the min n_traj
as_goal=False,
env=env)
# labels = label_states(starts, env, policy, v['horizon'], as_goals=False, n_traj=v['n_traj'], key='goal_reached')
start_classes, text_labels = convert_label(labels)
plot_labeled_states(starts,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'])
labels = np.logical_and(labels[:, 0],
labels[:, 1]).astype(int).reshape((-1, 1))
# append new states to list of all starts (replay buffer): Not the low reward ones!!
filtered_raw_starts = [
start for start, label in zip(starts, labels) if label[0] == 1
]
if len(
filtered_raw_starts
) == 0: # add a tone of noise if all the states I had ended up being high_reward!
logger.log("Bad Alice! All goals are high reward!")
all_starts.append(filtered_raw_starts)
# Useful plotting and metrics (basic test set)
# need to put this last! otherwise labels variable gets confused
logger.log("Labeling on uniform starts")
with logger.tabular_prefix("Uniform_"):
unif_starts = all_feasible_starts.sample(100)
mean_reward, paths = evaluate_states(unif_starts,
env,
policy,
v['horizon'],
n_traj=v['n_traj'],
key='goal_reached',
as_goals=False,
full_path=True)
env.log_diagnostics(paths)
mean_rewards = mean_reward.reshape(-1, 1)
labels = compute_labels(
mean_rewards,
old_rewards=old_rewards,
min_reward=min_reward,
max_reward=max_reward,
improvement_threshold=improvement_threshold)
logger.log("Starts labelled")
plot_labeled_states(unif_starts,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
# report.add_text("Success: " + str(np.mean(mean_reward)))
with logger.tabular_prefix("Fixed_"):
mean_reward, paths = evaluate_states(init_pos,
env,
policy,
v['horizon'],
n_traj=5,
key='goal_reached',
as_goals=False,
full_path=True)
env.log_diagnostics(paths)
mean_rewards = mean_reward.reshape(-1, 1)
labels = compute_labels(
mean_rewards,
old_rewards=old_rewards,
min_reward=min_reward,
max_reward=max_reward,
improvement_threshold=improvement_threshold)
logger.log("Starts labelled")
plot_labeled_states(init_pos,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
report.add_text("Fixed Success: " + str(np.mean(mean_reward)))
report.new_row()
report.save()
logger.record_tabular("Fixed test set_success: ", np.mean(mean_reward))
logger.dump_tabular()
def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
logger.log("Initializing report...")
log_dir = logger.get_snapshot_dir()
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=1000)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
inner_env = normalize(AntMazeEnv())
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
fixed_start_generator = FixedStateGenerator(state=v['ultimate_goal'])
load_dir = 'sandbox/young_clgan/experiments/starts/maze/maze_ant/'
save_dir = 'data/debug/'
# with open(os.path.join(config.PROJECT_PATH, save_dir, "test.pkl"), 'wb') as handle:
# pickle.dump({}, handle)
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=fixed_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[-3:-1],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
inner_weight=v['inner_weight'],
goal_weight=v['goal_weight'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16,
16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
if v["baseline"] == "MLP":
baseline = GaussianMLPBaseline(env_spec=env.spec)
else:
baseline = LinearFeatureBaseline(env_spec=env.spec)
# load the state collection from data_upload
all_starts = StateCollection(distance_threshold=v['coll_eps'],
states_transform=lambda x: x[:, :2])
# initial brownian horizon and size are pretty important
logger.log("Brownian horizon: {}".format(v['initial_brownian_horizon']))
seed_starts = generate_starts(
env,
starts=[v['start_goal']],
horizon=v['initial_brownian_horizon'],
size=15000,
variance=v['brownian_variance'],
animated=False,
)
if v['filter_bad_starts']:
logger.log("Prefilter seed starts: {}".format(len(seed_starts)))
seed_starts = parallel_check_feasibility(
env=env,
starts=seed_starts,
max_path_length=v['feasibility_path_length'])
logger.log("Filtered seed starts: {}".format(len(seed_starts)))
# can also filter these starts optionally
# all_feasible_starts = pickle.load(
# open(osp.join(config.PROJECT_PATH, load_dir, 'good_all_feasible_starts.pkl'), 'rb'))
# logger.log("We have %d feasible starts" % all_feasible_starts.size)
min_reward = 0.1
max_reward = 0.9
improvement_threshold = 0
old_rewards = None
init_pos = [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0], [4, 1], [4, 2], [4, 3],
[4, 4], [3, 4], [2, 4], [1, 4]][::-1]
for pos in init_pos:
pos.extend([
0.55,
1,
0,
0,
0,
0,
1,
0,
-1,
0,
-1,
0,
1,
])
init_pos = np.array(init_pos)
with open(osp.join(log_dir, 'init_pos.json'), 'w') as f:
json.dump(init_pos.tolist(), f)
for outer_iter in range(1, v['outer_iters'] + 1):
logger.log("Outer itr # %i" % outer_iter)
logger.log("Sampling starts")
report.save()
# generate starts from the previous seed starts, which are defined below
starts = generate_starts(env,
starts=seed_starts,
subsample=v['num_new_starts'],
size=2000,
horizon=v['brownian_horizon'],
variance=v['brownian_variance'])
# note: this messes with the balance between starts and old_starts!
if v['filter_bad_starts']:
logger.log("Prefilter starts: {}".format(len(starts)))
starts = parallel_check_feasibility(
env=env,
starts=starts,
max_path_length=v['feasibility_path_length'])
logger.log("Filtered starts: {}".format(len(starts)))
logger.log("Total number of starts in buffer: {}".format(
all_starts.size))
if v['replay_buffer'] and outer_iter > 0 and all_starts.size > 0:
# with open(os.path.join(config.PROJECT_PATH, save_dir, "qval{}.pkl".format(outer_iter)), 'wb') as handle:
# pickle.dump(all_starts.q_vals, handle)
# with open(os.path.join(config.PROJECT_PATH, save_dir, "preval{}.pkl".format(outer_iter)), 'wb') as handle:
# pickle.dump(all_starts.prev_vals, handle)
old_starts = all_starts.sample(v['num_old_starts'])
starts = np.vstack([starts, old_starts])
# plot starts before training
# takes too much time
# labels = label_states(starts, env, policy, v['horizon'],
# as_goals=False, n_traj=v['n_traj'], key='goal_reached')
# plot_labeled_states(starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
# center=v['goal_center'], maze_id=v['maze_id'],
# summary_string_base='initial starts labels:\n')
# Following code should be indented
with ExperimentLogger(log_dir,
outer_iter // 50,
snapshot_mode='last',
hold_outter_log=True):
logger.log("Updating the environment start generator")
env.update_start_generator(
UniformListStateGenerator(
starts.tolist(),
persistence=v['persistence'],
with_replacement=v['with_replacement'],
))
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
trpo_paths = algo.train()
logger.log("Labeling the starts")
[starts, labels] = label_states_from_paths(trpo_paths,
n_traj=v['n_traj'],
key='goal_reached',
as_goal=False,
env=env)
start_classes, text_labels = convert_label(labels)
plot_labeled_states(starts,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'])
labels = np.logical_and(labels[:, 0],
labels[:, 1]).astype(int).reshape((-1, 1))
filtered_raw_starts = [
start for start, label in zip(starts, labels) if label[0] == 1
]
all_starts.append(filtered_raw_starts)
if v['seed_with'] == 'only_goods':
if len(
filtered_raw_starts
) > 0: # add a ton of noise if all the states I had ended up being high_reward!
logger.log("We have {} good starts!".format(
len(filtered_raw_starts)))
seed_starts = filtered_raw_starts
elif np.sum(start_classes == 0) > np.sum(
start_classes == 1): # if more low reward than high reward
logger.log(
"More bad starts than good starts, sampling seeds from replay buffer"
)
seed_starts = all_starts.sample(
300) # sample them from the replay
else:
logger.log("More good starts than bad starts, resampling")
seed_starts = generate_starts(env,
starts=starts,
horizon=v['horizon'] * 2,
subsample=v['num_new_starts'],
size=10000,
variance=v['brownian_variance'] *
10)
elif v['seed_with'] == 'all_previous':
seed_starts = starts
filtered_raw_starts = starts # no filtering done
else:
raise Exception
# need to put this last! otherwise labels variable gets confused
logger.log("Labeling on uniform starts")
if not v["debug"]:
# with logger.tabular_prefix("Uniform_"):
# unif_starts = all_feasible_starts.sample(100)
# mean_reward, paths = evaluate_states(unif_starts, env, policy, v['horizon'], n_traj=v['n_traj'], key='goal_reached',
# as_goals=False, full_path=True)
# env.log_diagnostics(paths)
# mean_rewards = mean_reward.reshape(-1, 1)
# labels = compute_labels(mean_rewards, old_rewards=old_rewards, min_reward=min_reward, max_reward=max_reward,
# improvement_threshold=improvement_threshold)
# logger.log("Starts labelled")
# plot_labeled_states(unif_starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
# center=v['goal_center'], maze_id=v['maze_id'],
# summary_string_base='initial starts labels:\n')
# report.add_text("Uniform Success: " + str(np.mean(mean_reward)))
with logger.tabular_prefix("Fixed_"):
mean_reward, paths = evaluate_states(init_pos,
env,
policy,
v['horizon'],
n_traj=5,
key='goal_reached',
as_goals=False,
full_path=True)
with open(
osp.join(log_dir,
'init_pos_per_state_mean_return.csv'),
'a') as f:
writer = csv.writer(f)
row = [outer_iter] + list(mean_reward)
writer.writerow(row)
env.log_diagnostics(paths)
mean_rewards = mean_reward.reshape(-1, 1)
labels = compute_labels(
mean_rewards,
old_rewards=old_rewards,
min_reward=min_reward,
max_reward=max_reward,
improvement_threshold=improvement_threshold)
logger.log("Starts labelled")
plot_labeled_states(
init_pos,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'],
summary_string_base='initial starts labels:\n')
report.add_text("Fixed Success: " + str(np.mean(mean_reward)))
report.new_row()
report.save()
logger.record_tabular("Fixed test set_success: ",
np.mean(mean_reward))
logger.dump_tabular()
if outer_iter == 1 or outer_iter % 5 == 0 and v.get(
'scratch_dir', False):
command = 'rsync -a --delete {} {}'.format(
os.path.join(log_dir, ''), os.path.join(v['scratch_dir'], ''))
print("Running command:\n{}".format(command))
subprocess.run(command.split(), check=True)
if v.get('scratch_dir', False):
command = 'rsync -a {} {}'.format(os.path.join(log_dir, ''),
os.path.join(v['scratch_dir'], ''))
print("Running command:\n{}".format(command))
subprocess.run(command.split(), check=True)
def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
sampling_res = 2 if 'sampling_res' not in v.keys() else v['sampling_res']
logger.log("Initializing report and plot_policy_reward...")
log_dir = logger.get_snapshot_dir()
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=1000)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
inner_env = normalize(PointMazeEnv(maze_id=v['maze_id']))
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
uniform_start_generator = UniformStateGenerator(state_size=v['start_size'], bounds=v['start_range'],
center=v['start_center'])
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=uniform_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[:v['goal_size']],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
only_feasible=v['only_feasible'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16, 16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
if v["baseline"] == "MLP":
baseline = GaussianMLPBaseline(env_spec=env.spec)
else:
baseline = LinearFeatureBaseline(env_spec=env.spec)
# initialize all logging arrays on itr0
outer_iter = 0
all_starts = StateCollection(distance_threshold=v['coll_eps'])
# seed_starts: from which we will be performing brownian motion exploration
seed_starts = generate_starts(env, starts=[v['ultimate_goal']], subsample=v['num_new_starts'])
def plot_states(states, report, itr, summary_string, **kwargs):
states = np.array(states)
if states.size == 0:
states = np.zeros((1, 2))
img = plot_labeled_samples(
states, np.zeros(len(states), dtype='uint8'), markers={0: 'o'}, text_labels={0: "all"}, **kwargs)
report.add_image(img, 'itr: {}\n{}'.format(itr, summary_string), width=500)
for outer_iter in range(1, v['outer_iters']):
report.new_row()
logger.log("Outer itr # %i" % outer_iter)
logger.log("Sampling starts")
plot_states(
seed_starts, report=report, itr=outer_iter, limit=v['goal_range'], center=v['goal_center'],
maze_id=v['maze_id'], summary_string="seed starts")
starts = generate_starts(env, starts=seed_starts, subsample=v['num_new_starts'],
horizon=v['brownian_horizon'], variance=v['brownian_variance'])
plot_states(
starts, report=report, itr=outer_iter, limit=v['goal_range'], center=v['goal_center'],
maze_id=v['maze_id'], summary_string="brownian starts")
sampled_from_buffer = []
if v['replay_buffer'] and outer_iter > 0 and all_starts.size > 0:
sampled_from_buffer = all_starts.sample(v['num_old_starts'])
starts = np.vstack([starts, sampled_from_buffer])
plot_states(
sampled_from_buffer, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'], summary_string="states sampled from buffer")
labels = label_states(starts, env, policy, v['horizon'], as_goals=False, n_traj=v['n_traj'], key='goal_reached')
plot_labeled_states(starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'],
summary_string_base='all starts before update\n')
with ExperimentLogger(log_dir, 'last', snapshot_mode='last', hold_outter_log=True):
logger.log("Updating the environment start generator")
env.update_start_generator(
UniformListStateGenerator(
starts.tolist(), persistence=v['persistence'], with_replacement=v['with_replacement'],
)
)
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
trpo_paths = algo.train()
if v['use_trpo_paths']:
logger.log("labeling starts with trpo rollouts")
[starts, labels] = label_states_from_paths(
trpo_paths, n_traj=2, key='goal_reached', as_goal=False, env=env)
paths = [path for paths in trpo_paths for path in paths]
else:
logger.log("labeling starts manually")
labels, paths = label_states(
starts, env, policy, v['horizon'], as_goals=False, n_traj=v['n_traj'], key='goal_reached', full_path=True)
start_classes, text_labels = convert_label(labels)
plot_labeled_states(starts, labels, report=report, itr=outer_iter, limit=v['goal_range'],
center=v['goal_center'], maze_id=v['maze_id'],
summary_string_base="all starts after update\n")
with logger.tabular_prefix("OnStarts_"):
env.log_diagnostics(paths)
labels = np.logical_and(labels[:, 0], labels[:, 1]).astype(int).reshape((-1, 1))
# append new states to list of all starts (replay buffer): Not the low reward ones!!
filtered_raw_starts = [start for start, label in zip(starts, labels) if label[0] == 1]
all_starts.append(filtered_raw_starts)
if v['seed_with'] == 'only_goods':
if len(filtered_raw_starts) > 0:
logger.log("Only goods A")
seed_starts = filtered_raw_starts
elif np.sum(start_classes == 0) > np.sum(start_classes == 1): # if more low reward than high reward
logger.log("Only goods B")
seed_starts = all_starts.sample(300) # sample them from the replay
else:
logger.log("Only goods C")
# add a ton of noise if all the states I had ended up being high_reward
seed_starts = generate_starts(
env, starts=starts, horizon=int(v['horizon'] * 10),
subsample=v['num_new_starts'], variance=v['brownian_variance'] * 10)
elif v['seed_with'] == 'all_previous':
seed_starts = starts
elif v['seed_with'] == 'on_policy':
seed_starts = generate_starts(env, policy, starts=starts, horizon=v['horizon'], subsample=v['num_new_starts'])
logger.log('Generating Heatmap...')
plot_policy_means(
policy, env, sampling_res=sampling_res, report=report, limit=v['goal_range'], center=v['goal_center'])
_, _, states, returns, successes = test_and_plot_policy2(
policy, env, as_goals=False, max_reward=v['max_reward'], sampling_res=sampling_res, n_traj=v['n_traj'],
itr=outer_iter, report=report, center=v['goal_center'], limit=v['goal_range'])
eval_state_path = osp.join(log_dir, "eval_states.json")
if not osp.exists(eval_state_path):
with open(eval_state_path, 'w') as f:
json.dump(np.array(states).tolist(), f)
with open(osp.join(log_dir, 'eval_pos_per_state_mean_return.csv'), 'a') as f:
writer = csv.writer(f)
row = [outer_iter] + list(returns)
writer.writerow(row)
with open(osp.join(log_dir, 'eval_pos_per_state_mean_success.csv'), 'a') as f:
writer = csv.writer(f)
row = [outer_iter] + list(successes)
writer.writerow(row)
logger.dump_tabular()
report.save()
if outer_iter == 1 or outer_iter % 5 == 0 and v.get('scratch_dir', False):
command = 'rsync -a {} {}'.format(os.path.join(log_dir, ''), os.path.join(v['scratch_dir'], ''))
print("Running command:\n{}".format(command))
subprocess.run(command.split(), check=True)
if v.get('scratch_dir', False):
command = 'rsync -a {} {}'.format(os.path.join(log_dir, ''), os.path.join(v['scratch_dir'], ''))
print("Running command:\n{}".format(command))
subprocess.run(command.split(), check=True)
def run_task(v):
random.seed(v['seed'])
np.random.seed(v['seed'])
sampling_res = 2 if 'sampling_res' not in v.keys() else v['sampling_res']
# Log performance of randomly initialized policy with FIXED goal [0.1, 0.1]
logger.log("Initializing report and plot_policy_reward...")
log_dir = logger.get_snapshot_dir() # problem with logger module here!!
report = HTMLReport(osp.join(log_dir, 'report.html'), images_per_row=4)
report.add_header("{}".format(EXPERIMENT_TYPE))
report.add_text(format_dict(v))
tf_session = tf.Session()
inner_env = normalize(PointMazeEnv(maze_id=v['maze_id']))
fixed_goal_generator = FixedStateGenerator(state=v['ultimate_goal'])
uniform_start_generator = UniformStateGenerator(state_size=v['start_size'],
bounds=v['start_range'],
center=v['start_center'])
env = GoalStartExplorationEnv(
env=inner_env,
start_generator=uniform_start_generator,
obs2start_transform=lambda x: x[:v['start_size']],
goal_generator=fixed_goal_generator,
obs2goal_transform=lambda x: x[:v['goal_size']],
terminal_eps=v['terminal_eps'],
distance_metric=v['distance_metric'],
extend_dist_rew=v['extend_dist_rew'],
only_feasible=v['only_feasible'],
terminate_env=True,
)
policy = GaussianMLPPolicy(
env_spec=env.spec,
hidden_sizes=(64, 64),
# Fix the variance since different goals will require different variances, making this parameter hard to learn.
learn_std=v['learn_std'],
adaptive_std=v['adaptive_std'],
std_hidden_sizes=(16,
16), # this is only used if adaptive_std is true!
output_gain=v['output_gain'],
init_std=v['policy_init_std'],
)
baseline = LinearFeatureBaseline(env_spec=env.spec)
# initialize all logging arrays on itr0
outer_iter = 0
logger.log('Generating the Initial Heatmap...')
plot_policy_means(policy,
env,
sampling_res=2,
report=report,
limit=v['start_range'],
center=v['start_center'])
# test_and_plot_policy(policy, env, as_goals=False, max_reward=v['max_reward'], sampling_res=sampling_res, n_traj=v['n_traj'],
# itr=outer_iter, report=report, limit=v['goal_range'], center=v['goal_center'])
# GAN
logger.log("Instantiating the GAN...")
gan_configs = {key[4:]: value for key, value in v.items() if 'GAN_' in key}
for key, value in gan_configs.items():
if value is tf.train.AdamOptimizer:
gan_configs[key] = tf.train.AdamOptimizer(gan_configs[key +
'_stepSize'])
if value is tflearn.initializations.truncated_normal:
gan_configs[key] = tflearn.initializations.truncated_normal(
stddev=gan_configs[key + '_stddev'])
gan = StateGAN(
state_size=v['start_size'],
evaluater_size=v['num_labels'],
state_range=v['start_range'],
state_center=v['start_center'],
state_noise_level=v['start_noise_level'],
generator_layers=v['gan_generator_layers'],
discriminator_layers=v['gan_discriminator_layers'],
noise_size=v['gan_noise_size'],
tf_session=tf_session,
configs=gan_configs,
)
logger.log("pretraining the GAN...")
if v['smart_init']:
feasible_starts = generate_starts(
env, starts=[v['ultimate_goal']],
horizon=50) # without giving the policy it does brownian mo.
labels = np.ones((feasible_starts.shape[0],
2)).astype(np.float32) # make them all good goals
plot_labeled_states(feasible_starts,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'])
dis_loss, gen_loss = gan.pretrain(states=feasible_starts,
outer_iters=v['gan_outer_iters'])
print("Loss of Gen and Dis: ", gen_loss, dis_loss)
else:
gan.pretrain_uniform(outer_iters=500,
report=report) # v['gan_outer_iters'])
# log first samples form the GAN
initial_starts, _ = gan.sample_states_with_noise(v['num_new_starts'])
logger.log("Labeling the starts")
labels = label_states(initial_starts,
env,
policy,
v['horizon'],
as_goals=False,
n_traj=v['n_traj'],
key='goal_reached')
plot_labeled_states(initial_starts,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'])
report.new_row()
all_starts = StateCollection(distance_threshold=v['coll_eps'])
for outer_iter in range(1, v['outer_iters']):
logger.log("Outer itr # %i" % outer_iter)
# Sample GAN
logger.log("Sampling starts from the GAN")
raw_starts, _ = gan.sample_states_with_noise(v['num_new_starts'])
if v['replay_buffer'] and outer_iter > 0 and all_starts.size > 0:
old_starts = all_starts.sample(v['num_old_starts'])
starts = np.vstack([raw_starts, old_starts])
else:
starts = raw_starts
with ExperimentLogger(log_dir,
'last',
snapshot_mode='last',
hold_outter_log=True):
logger.log("Updating the environment start generator")
env.update_start_generator(
UniformListStateGenerator(
starts.tolist(),
persistence=v['persistence'],
with_replacement=v['with_replacement'],
))
logger.log("Training the algorithm")
algo = TRPO(
env=env,
policy=policy,
baseline=baseline,
batch_size=v['pg_batch_size'],
max_path_length=v['horizon'],
n_itr=v['inner_iters'],
step_size=0.01,
discount=v['discount'],
plot=False,
)
trpo_paths = algo.train()
if v['use_trpo_paths']:
logger.log("labeling starts with trpo rollouts")
[starts, labels] = label_states_from_paths(
trpo_paths,
n_traj=2,
key='goal_reached', # using the min n_traj
as_goal=False,
env=env)
paths = [path for paths in trpo_paths for path in paths]
else:
logger.log("labeling starts manually")
labels, paths = label_states(starts,
env,
policy,
v['horizon'],
as_goals=False,
n_traj=v['n_traj'],
key='goal_reached',
full_path=True)
with logger.tabular_prefix("OnStarts_"):
env.log_diagnostics(paths)
plot_labeled_states(starts,
labels,
report=report,
itr=outer_iter,
limit=v['goal_range'],
center=v['goal_center'],
maze_id=v['maze_id'])
logger.log('Generating the Heatmap...')
plot_policy_means(policy,
env,
sampling_res=2,
report=report,
limit=v['start_range'],
center=v['start_center'])
test_and_plot_policy(policy,
env,
as_goals=False,
max_reward=v['max_reward'],
sampling_res=sampling_res,
n_traj=v['n_traj'],
itr=outer_iter,
report=report,
limit=v['goal_range'],
center=v['goal_center'])
# ###### extra for deterministic:
# logger.log("Labeling the goals deterministic")
# with policy.set_std_to_0():
# labels_det = label_states(goals, env, policy, v['horizon'], n_traj=v['n_traj'], n_processes=1)
# plot_labeled_states(goals, labels_det, report=report, itr=outer_iter, limit=v['goal_range'], center=v['goal_center'])
labels = np.logical_and(labels[:, 0],
labels[:, 1]).astype(int).reshape((-1, 1))
logger.log("Training the GAN")
if np.any(labels):
gan.train(
starts,
labels,
v['gan_outer_iters'],
)
logger.dump_tabular(with_prefix=False)
report.new_row()
# append new goals to list of all goals (replay buffer): Not the low reward ones!!
filtered_raw_start = [
start for start, label in zip(starts, labels) if label[0] == 1
]
all_starts.append(filtered_raw_start)