def main():
args = parse_args()
if args['cores']:
cores = min(cpu_count(), args['cores'])
else:
cores = min(cpu_count(), 16)
print('Using {} cores.'.format(cores))
# Parameters
runs = range(16)
exp_name = "ddpg-exp2_two_stage"
tasks = {
'balancing_tf': 'cfg/leo_balancing_tf.yaml',
'balancing': 'cfg/leo_balancing.yaml',
'walking': 'cfg/leo_walking.yaml'
}
starting_task = 'balancing_tf'
misc = {'tasks': tasks, 'starting_task': starting_task, 'runs': runs}
mp_cfgs = []
# In this experiment we keep walking steps at 250000, but additionally do balancing steps of various durations
wsteps = 250000
for bsteps_mul in range(9):
name = "{}-mul{}".format(exp_name, bsteps_mul)
if bsteps_mul > 0:
bsteps = 25000 * bsteps_mul
args['rb_max_size'] = wsteps
options = {
'balancing_tf': '',
'balancing': '',
'walking': 'nnload_rbload'
}
mp_cfgs += do_steps_based(args,
cores,
name=name,
steps=(-1, bsteps, wsteps),
options=options,
**misc)
else:
options = {'balancing_tf': '', 'balancing': '', 'walking': ''}
mp_cfgs += do_steps_based(args,
cores,
name=name,
steps=(-1, -1, wsteps),
options=options,
**misc)
# DBG: export configuration
export_cfg(mp_cfgs)
# Run all scripts at once
random.shuffle(mp_cfgs)
prepare_multiprocessing()
do_multiprocessing_pool(cores, mp_cfgs)
def main():
args = parse_args()
if args['cores']:
cores = min(cpu_count(), args['cores'])
else:
cores = min(cpu_count(), 16)
print('Using {} cores.'.format(cores))
# Parameters
runs = range(16)
keep_samples = False
exp_name = "ddpg-exp1_two_stage"
tasks = {
'balancing_tf': 'cfg/leo_balancing_tf.yaml',
'balancing': 'cfg/leo_balancing.yaml',
'walking': 'cfg/leo_walking.yaml'
}
starting_task = 'balancing_tf'
misc = {'tasks':tasks, 'starting_task':starting_task, 'runs':runs}
mp_cfgs = []
steps = 300000
args['rb_max_size'] = steps
options = {'balancing_tf': '', 'balancing': '', 'walking': ''}
mp_cfgs += do_steps_based(args, cores, name=exp_name, steps=(-1, -1, steps), options=options, **misc)
bsteps = 50000
wsteps = steps - bsteps
args['rb_max_size'] = steps if keep_samples else wsteps
options = {'balancing_tf': '', 'balancing': '', 'walking': 'nnload'}
mp_cfgs += do_steps_based(args, cores, name=exp_name, steps=(-1, bsteps, wsteps), options=options, **misc)
options = {'balancing_tf': '', 'balancing': '', 'walking': 'nnload_rbload'}
mp_cfgs += do_steps_based(args, cores, name=exp_name, steps=(-1, bsteps, wsteps), options=options, **misc)
options = {'balancing_tf': '', 'balancing': '', 'walking': 'nnload_rbload_re_walking_300_-1.5'}
mp_cfgs += do_steps_based(args, cores, name=exp_name, steps=(-1, bsteps, wsteps), options=options, **misc)
options = {'balancing_tf': '', 'balancing': '', 'walking': 'rbload'}
mp_cfgs += do_steps_based(args, cores, name=exp_name, steps=(-1, bsteps, wsteps), options=options, **misc)
options = {'balancing_tf': '', 'balancing': '', 'walking': 'rbload_re_walking_300_-1.5'}
mp_cfgs += do_steps_based(args, cores, name=exp_name, steps=(-1, bsteps, wsteps), options=options, **misc)
# DBG: export configuration
export_cfg(mp_cfgs)
# Run all scripts at once
random.shuffle(mp_cfgs)
prepare_multiprocessing()
do_multiprocessing_pool(cores, mp_cfgs)
def main():
args = parse_args()
if args['cores']:
cores = min(cpu_count(), args['cores'])
else:
cores = min(cpu_count(), 16)
print('Using {} cores.'.format(cores))
# Parameters
runs = range(7, 16)
exp_name = "ddpg-exp1_two_stage"
starting_task = 'balancing_tf'
misc = {'starting_task': starting_task, 'runs': runs}
mp_cfgs = []
keep_samples = False
# Hopper
tasks = {
'balancing_tf': 'RoboschoolHopperBalancingGRL-v1',
'balancing': 'RoboschoolHopperBalancingGRL-v1',
'walking': 'RoboschoolHopperGRL-v1'
}
bsteps = 100000
steps = 600000
reassess_for = 'walking_3_-1.5'
args['rb_max_size'] = steps if keep_samples else steps - bsteps
mp_cfgs += create_tasks(args, cores, exp_name + '_hopper', bsteps, steps,
reassess_for, tasks, **misc)
# HalfCheetah
tasks = {
'balancing_tf': 'RoboschoolHalfCheetahBalancingGRL-v1',
'balancing': 'RoboschoolHalfCheetahBalancingGRL-v1',
'walking': 'RoboschoolHalfCheetahGRL-v1'
}
bsteps = 100000
steps = 600000
reassess_for = 'walking_3_-1.5'
args['rb_max_size'] = steps if keep_samples else steps - bsteps
mp_cfgs += create_tasks(args, cores, exp_name + '_halfcheetah', bsteps,
steps, reassess_for, tasks, **misc)
# Walker2d
tasks = {
'balancing_tf': 'RoboschoolWalker2dBalancingGRL-v1',
'balancing': 'RoboschoolWalker2dBalancingGRL-v1',
'walking': 'RoboschoolWalker2dGRL-v1'
}
bsteps = 200000
steps = 700000
reassess_for = 'walking_3_-1.5'
args['rb_max_size'] = steps if keep_samples else steps - bsteps
mp_cfgs += create_tasks(args, cores, exp_name + '_walker2d', bsteps, steps,
reassess_for, tasks, **misc)
# DBG: export configuration
export_cfg(mp_cfgs)
# Run all scripts at once
random.shuffle(mp_cfgs)
prepare_multiprocessing()
do_multiprocessing_pool(cores, mp_cfgs)
def main():
args = parse_args()
args[
"test_interval"] = -1 # this ensures that only learning trajectory is exported
if args['cores']:
cores = min(cpu_count(), args['cores'])
else:
cores = min(cpu_count(), 16)
print('Using {} cores.'.format(cores))
# Parameters
runs = range(6)
exp_name = "ddpg-exp1_two_stage"
starting_task = 'balancing_tf'
misc = {'starting_task': starting_task, 'runs': runs}
mp_cfgs = []
keep_samples = False
# Leo
tasks = {
'balancing_tf': 'cfg/leo_balancing_tf.yaml',
'balancing': 'cfg/leo_balancing.yaml',
'walking': 'cfg/leo_walking.yaml'
}
bsteps = 50000
steps = 300000
reassess_for = 'walking_300_-1.5'
args['rb_max_size'] = steps if keep_samples else steps - bsteps
args['env_timestep'] = 0.03
cl_options = {
'balancing_tf': '',
'balancing': '',
'walking': 'nnload_rbload'
}
mp_cfgs += create_tasks(args, cores, exp_name + '_leo', bsteps, steps,
reassess_for, tasks, cl_options, **misc)
# Hopper
tasks = {
'balancing_tf': 'RoboschoolHopperBalancingGRL-v1',
'balancing': 'RoboschoolHopperBalancingGRL-v1',
'walking': 'RoboschoolHopperGRL-v1'
}
bsteps = 100000
steps = 600000
reassess_for = 'walking_3_-1.5'
args['rb_max_size'] = steps if keep_samples else steps - bsteps
args['env_timestep'] = 0.0165
cl_options = {'balancing_tf': '', 'balancing': '', 'walking': 'nnload'}
mp_cfgs += create_tasks(args, cores, exp_name + '_hopper', bsteps, steps,
reassess_for, tasks, cl_options, **misc)
# HalfCheetah
tasks = {
'balancing_tf': 'RoboschoolHalfCheetahBalancingGRL-v1',
'balancing': 'RoboschoolHalfCheetahBalancingGRL-v1',
'walking': 'RoboschoolHalfCheetahGRL-v1'
}
bsteps = 100000
steps = 600000
reassess_for = 'walking_3_-1.5'
args['rb_max_size'] = steps if keep_samples else steps - bsteps
args['env_timestep'] = 0.0165
cl_options = {'balancing_tf': '', 'balancing': '', 'walking': 'nnload'}
mp_cfgs += create_tasks(args, cores, exp_name + '_halfcheetah', bsteps,
steps, reassess_for, tasks, cl_options, **misc)
# Walker2d
tasks = {
'balancing_tf': 'RoboschoolWalker2dBalancingGRL-v1',
'balancing': 'RoboschoolWalker2dBalancingGRL-v1',
'walking': 'RoboschoolWalker2dGRL-v1'
}
bsteps = 200000
steps = 700000
reassess_for = 'walking_3_-1.5'
args['rb_max_size'] = steps if keep_samples else steps - bsteps
args['env_timestep'] = 0.0165
cl_options = {'balancing_tf': '', 'balancing': '', 'walking': 'nnload'}
mp_cfgs += create_tasks(args, cores, exp_name + '_walker2d', bsteps, steps,
reassess_for, tasks, cl_options, **misc)
# DBG: export configuration
export_cfg(mp_cfgs)
# Run all scripts at once
random.shuffle(mp_cfgs)
prepare_multiprocessing()
do_multiprocessing_pool(cores, mp_cfgs)
def main():
args = parse_args()
if args['cores']:
cores = min(cpu_count(), args['cores'])
else:
cores = min(cpu_count(), 16)
print('Using {} cores.'.format(cores))
# for working with yaml files
_mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
yaml.add_representer(collections.OrderedDict, dict_representer)
yaml.add_constructor(_mapping_tag, dict_constructor)
# Parameters
runs = range(16)
args['cl_depth'] = 2
options = {
'balancing_tf': '',
'balancing': 'nnload_rbload',
'walking': 'nnload_rbload'
}
export_names = "eq_curriculum_network_depth_" + str(args['cl_depth'])
nn_params = (export_names, "{}_stat.pkl".format(export_names))
starting_task = 'balancing_tf'
mp_cfgs = []
# leo
tasks = {
'balancing_tf': 'cfg/leo_balancing_tf.yaml',
'balancing': 'cfg/leo_balancing.yaml',
'walking': 'cfg/leo_walking.yaml'
}
misc = {'tasks': tasks, 'starting_task': starting_task, 'runs': runs}
mp_cfgs += do_network_based_leo(args,
cores,
name='ddpg-leo',
nn_params=nn_params,
options=options,
**misc)
# leo_perturbed
tasks = {
'balancing_tf': 'cfg/leo_perturbed_balancing_tf.yaml',
'balancing': 'cfg/leo_perturbed_balancing.yaml',
'walking': 'cfg/leo_perturbed_walking.yaml'
}
misc = {'tasks': tasks, 'starting_task': starting_task, 'runs': runs}
mp_cfgs += do_network_based_leo(args,
cores,
name='ddpg-leo_perturbed',
nn_params=nn_params,
options=options,
**misc)
# walker2d
tasks = {
'balancing_tf': 'RoboschoolWalker2dBalancingGRL_TF-v1',
'balancing': 'RoboschoolWalker2dBalancingGRL-v1',
'walking': 'RoboschoolWalker2dGRL-v1'
}
misc = {'tasks': tasks, 'starting_task': starting_task, 'runs': runs}
mp_cfgs += do_network_based_mujoco(args,
cores,
name='ddpg-walker2d',
nn_params=nn_params,
options=options,
**misc)
# DBG: export configuration
export_cfg(mp_cfgs)
# Run all scripts at once
random.shuffle(mp_cfgs)
prepare_multiprocessing()
do_multiprocessing_pool(cores, mp_cfgs)
def main():
args = parse_args()
if args['cores']:
cores = min(cpu_count(), args['cores'])
else:
cores = min(cpu_count(), 16)
print('Using {} cores.'.format(cores))
# Parameters
runs = range(16)
tasks = {
'balancing_tf': 'cfg/leo_balancing_tf.yaml',
'balancing': 'cfg/leo_balancing.yaml',
'walking': 'cfg/leo_walking.yaml'
}
starting_task = 'balancing_tf'
misc = {'tasks': tasks, 'starting_task': starting_task, 'runs': runs}
args['cl_keep_samples'] = True
options = {
'balancing_tf': '',
'balancing': 'nnload',
'walking': 'nnload_rbload'
}
mp_cfgs = []
# # naive switching after achieving the balancing for n number of seconds happening once. 0 means not used
# args['reach_timeout_num'] = 1
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-three_stage-rb5', reach_timeout=(5.0, 5.0, 0.0), options=options, **misc)
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-two_stage-rb5', reach_timeout=(-1.0, 5.0, 0.0), options=options, **misc)
#
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-three_stage-rb20', reach_timeout=(20.0, 20.0, 0.0), options=options, **misc)
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-two_stage-rb20', reach_timeout=(-1.0, 20.0, 0.0), options=options, **misc)
#
#
# # naive switching after achieving the balancing for n number of seconds happening twice. 0 means not used
# args['reach_timeout_num'] = 2
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-three_stage-rb55', reach_timeout=(5.0, 5.0, 0.0), options=options, **misc)
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-two_stage-rb55', reach_timeout=(-1.0, 5.0, 0.0), options=options, **misc)
#
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-three_stage-rb2020', reach_timeout=(20.0, 20.0, 0.0), options=options, **misc)
# mp_cfgs += do_reach_timeout_based(args, cores, name='ddpg-exp3-two_stage-rb2020', reach_timeout=(-1.0, 20.0, 0.0), options=options, **misc)
args['reach_timeout_num'] = 5
mp_cfgs += do_reach_timeout_based(args,
cores,
name='ddpg-exp3-three_stage-rb55555',
reach_timeout=(5.0, 5.0, 0.0),
options=options,
**misc)
mp_cfgs += do_reach_timeout_based(args,
cores,
name='ddpg-exp3-two_stage-rb55555',
reach_timeout=(-1.0, 5.0, 0.0),
options=options,
**misc)
# DBG: export configuration
export_cfg(mp_cfgs)
# Run all scripts at once
random.shuffle(mp_cfgs)
prepare_multiprocessing()
do_multiprocessing_pool(cores, mp_cfgs)
