def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"local_dir": args.local_dir,
"trial_resources": (
args.trial_resources and
resources_to_json(args.trial_resources)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"repeat": args.repeat,
"upload_dir": args.upload_dir,
}
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
ray.init(redis_address=args.redis_address,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
run_experiments(experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials)
def run():
ModelCatalog.register_custom_model("my_vision_network", MyVisionNetwork)
config = {
"model": {
"custom_model": "my_vision_network",
"conv_filters": [[16, [5, 5], 4], [32, [3, 3], 1],
[256, [3, 3], 1]],
"custom_preprocessor": None
}
}
reb = RayExperimentBuilder(**config)
experiments, args, verbose = reb.get_experiment_definition()
ray.init(address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
run_experiments(experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
verbose=verbose,
concurrent=True)
def run(args, parser):
with open(args.config_file) as f:
experiments = yaml.load(f)
if hasattr(args, 'restore'):
key = list(experiments.keys())[0]
experiments[key]['restore'] = args.restore
key = list(experiments.keys())[0]
experiments[key]["config"]["callbacks"] = {
"on_episode_end": tune.function(on_episode_end)
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
ray.init(
redis_address=args.redis_address,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus,
#object_store_memory=20000 * (2**20), # 100000 #int(25*10**9) #30gb
#redis_max_memory=5000 * (2**20)
)
run_experiments(experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials)
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.safe_load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"keep_checkpoints_num": args.keep_checkpoints_num,
"checkpoint_score_attr": args.checkpoint_score_attr,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if args.eager:
exp["config"]["eager"] = True
if args.trace:
if not exp["config"].get("eager"):
raise ValueError("Must enable --eager to enable tracing.")
exp["config"]["eager_tracing"] = True
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(address=cluster.address)
else:
ray.init(address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
run_experiments(experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume)
def launch(self):
"""Actual entry point into the class instance where everything happens."""
self.register_env_creator()
self.register_algorithms_and_preprocessors()
experiment_config, args, verbose = self.get_experiment_config()
# All worker nodes will block at this step during training
ray_cluster_config = self.ray_init_config()
if not self.is_master_node:
return
ray_custom_cluster_config = {
"object_store_memory": args.ray_object_store_memory,
"memory": args.ray_memory,
"redis_max_memory": args.ray_redis_max_memory,
"num_cpus": args.ray_num_cpus,
"num_gpus": args.ray_num_gpus,
}
all_workers_host_names = self.get_all_host_names()[1:]
# Overwrite redis address for single instance job
if len(all_workers_host_names) == 0:
ray_custom_cluster_config.update({"address": args.ray_address})
ray_cluster_config.update(ray_custom_cluster_config)
# Start the driver on master node
ray.init(**ray_cluster_config)
# Spot instance is back
if os.path.exists(CHECKPOINTS_DIR) and os.listdir(CHECKPOINTS_DIR):
print("Instance is back. Local checkpoint path detected.")
checkpoint_file = self.find_checkpoint_file_for_spot(
CHECKPOINTS_DIR)
print("Setting checkpoint path to {}".format(checkpoint_file))
if checkpoint_file:
experiment_config["training"][
"restore"] = checkpoint_file # Overwrite
experiment_config = self.customize_experiment_config(experiment_config)
experiment_config = self.set_up_checkpoint(experiment_config)
experiment_config["training"]["sync_to_driver"] = custom_sync_func
run_experiments(
experiment_config,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
verbose=verbose,
concurrent=True,
)
# If distributed job, send TERMINATION_SIGNAL to all workers.
if len(all_workers_host_names) > 0:
self.sage_cluster_communicator.create_s3_signal(TERMINATION_SIGNAL)
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(
num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(redis_address=cluster.redis_address)
else:
ray.init(
redis_address=args.redis_address,
object_store_memory=args.ray_object_store_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
run_experiments(
experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume)
def make_custom_scheduler(args):
# if args.pbt:
# return get_pbt_scheduler()
# else:
return _make_scheduler(args)
def run(args, parser):
# create exps from configs
if args.config_file:
# load configs from yaml
with open(args.config_file) as f:
exps = yaml.safe_load(f)
else:
exps = create_exps(args=args, )
arena_exps = create_arena_exps(
exps=exps,
args=args,
parser=parser,
)
# config ray cluster
if args.ray_num_nodes:
cluster = Cluster()
for ray_node in range(args.ray_num_nodes):
cluster.add_node(
num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
)
ray.init(address=cluster.redis_address, )
else:
ray.init(
address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus,
)
if len(arena_exps.keys()) > 1:
logger.warning(
"There are multiple experiments scheduled, ray==0.7.4 will run them one by one, instead of cocurrently. "
"However, recent ray can run them cocurrently. But the recent ray has failed our test (the rllib is broken)"
"This is mainly due to there are grid search used in configs that is not supported by original rllib. "
)
if args.eval:
# evaluate policies
if len(arena_exps.keys()) < 1:
raise ValueError
elif len(arena_exps.keys()) >= 1:
if len(arena_exps.keys()) > 1:
arena_exp_key = inquire_select(
choices=list(arena_exps.keys()),
key="arena_exp_key",
)
else:
# if there is just one arena_exps
arena_exp_key = list(arena_exps.keys())[0]
logger.info("Evaluating arena_exp_key: {}".format(arena_exp_key, ))
arena_exp = arena_exps[arena_exp_key]
answers = prompt(
[{
'type': 'input',
'name': 'eval_log_path',
'message':
'Where do you want to log the results of this evaluation?',
'default': '../eval_log_path/'
}],
style=custom_style_2,
)
prepare_path(answers['eval_log_path'])
from ray.rllib.evaluation.rollout_worker import RolloutWorker
# worker = ArenaRolloutWorker(
# TODO: RolloutWorker does not support monitor for multi-agent envs
worker = RolloutWorker(
env_creator=lambda _: ArenaRllibEnv(
env=arena_exp["env"],
env_config=arena_exp["config"]["env_config"],
),
policy=arena_exp["config"]["multiagent"]["policies"],
policy_mapping_fn=arena_exp["config"]["multiagent"]
["policy_mapping_fn"],
batch_mode="complete_episodes",
batch_steps=500,
num_envs=1,
monitor_path=answers['eval_log_path'],
)
logger.info("Testing worker...")
sample_start = time.time()
worker.sample()
sample_time = time.time() - sample_start
logger.info("Finish testing worker.")
policy_ids = list(worker.policy_map.keys())
checkpoints = inquire_checkpoints(
local_dir=arena_exp["local_dir"],
policy_ids=policy_ids,
)
checkpoint_paths = checkpoints_2_checkpoint_paths(checkpoints)
num_checkpoint_paths = {}
for policy_id, checkpoint_paths_per_policy_id in checkpoint_paths.items(
):
num_checkpoint_paths[policy_id] = len(
checkpoint_paths_per_policy_id)
num_sampling = np.prod(list(num_checkpoint_paths.values()))
confirm = inquire_confirm(
"You have scheduled {} sampling, each sampling will take {} minutes, which means {} hours in total."
.format(
num_sampling,
sample_time / 60.0,
num_sampling * sample_time / 60.0 / 60.0,
))
if not confirm:
os.exit()
result_matrix = run_result_matrix(
checkpoint_paths=checkpoint_paths,
worker=worker,
)
result_matrix = np.asarray(result_matrix)
vis_result_matrix(
result_matrix=result_matrix,
log_path=answers['eval_log_path'],
)
else:
run_experiments(
arena_exps,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
)
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to /tmp/ray/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"local_dir": args.local_dir,
"resources": resources_to_json(args.resources),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"repeat": args.repeat,
"upload_dir": args.upload_dir,
}
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
run_experiments(experiments,
scheduler=_make_scheduler(args),
redis_address=args.redis_address,
num_cpus=args.num_cpus,
num_gpus=args.num_gpus)
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.safe_load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"env": "HuskyPickAndPlace-v1",
"checkpoint_freq": 100, # args.checkpoint_freq,
"keep_checkpoints_num": args.keep_checkpoints_num,
"checkpoint_score_attr": args.checkpoint_score_attr,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
# "stop": args.stop,
"stop": {"timesteps_total": 4000000}, # 10M "episode_reward_mean": 18.0
# "config": {dict(args.config, env=args.env)},
"config": {
"num_workers": 10,
"ignore_worker_failures": True,
# "seed": 789,
"callbacks": {
"on_episode_start": on_episode_start,
"on_episode_step": on_episode_step,
"on_episode_end": on_episode_end,
},
},
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
# verbose = 1
# for exp in experiments.values():
# if not exp.get("run"):
# parser.error("the following arguments are required: --run")
# if not exp.get("env") and not exp.get("config", {}).get("env"):
# parser.error("the following arguments are required: --env")
# if args.eager:
# exp["config"]["eager"] = True
# if args.v:
# exp["config"]["log_level"] = "INFO"
# verbose = 2
# if args.vv:
# exp["config"]["log_level"] = "DEBUG"
# verbose = 3
# if args.trace:
# if not exp["config"].get("eager"):
# raise ValueError("Must enable --eager to enable tracing.")
# exp["config"]["eager_tracing"] = True
# if args.ray_num_nodes:
# cluster = Cluster()
# for _ in range(args.ray_num_nodes):
# cluster.add_node(
# num_cpus=args.ray_num_cpus or 1,
# num_gpus=args.ray_num_gpus or 0,
# object_store_memory=args.ray_object_store_memory,
# memory=args.ray_memory,
# redis_max_memory=args.ray_redis_max_memory)
# ray.init(address=cluster.address)
# else:
ray.init(address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
run_experiments(
experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
verbose=2,
)
args = parser.parse_args(sys.argv[1:])
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"local_dir": args.local_dir,
"resources": resources_to_json(args.resources),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"repeat": args.repeat,
"upload_dir": args.upload_dir,
}
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
ray.init(
redis_address=args.redis_address,
num_cpus=args.num_cpus, num_gpus=args.num_gpus)
run_experiments(experiments, scheduler=_make_scheduler(args))
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.safe_load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"keep_checkpoints_num": args.keep_checkpoints_num,
"checkpoint_score_attr": args.checkpoint_score_attr,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
verbose = 1
webui_host = "localhost"
for exp in experiments.values():
# Bazel makes it hard to find files specified in `args` (and `data`).
# Look for them here.
# NOTE: Some of our yaml files don't have a `config` section.
if exp.get("config", {}).get("input"):
if not isinstance(exp.get("config", {}).get("input"),dict):
if not os.path.exists(exp["config"]["input"]):
# This script runs in the ray/rllib dir.
rllib_dir = Path(__file__).parent
input_file = rllib_dir.absolute().joinpath(exp["config"]["input"])
exp["config"]["input"] = str(input_file)
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if args.eager:
exp["config"]["eager"] = True
if args.torch:
exp["config"]["use_pytorch"] = True
if args.v:
exp["config"]["log_level"] = "INFO"
verbose = 2
if args.vv:
exp["config"]["log_level"] = "DEBUG"
verbose = 3
if args.trace:
if not exp["config"].get("eager"):
raise ValueError("Must enable --eager to enable tracing.")
exp["config"]["eager_tracing"] = True
if args.bind_all:
webui_host = "0.0.0.0"
if args.log_flatland_stats:
exp['config']['callbacks'] = {
'on_episode_end': on_episode_end,
}
if args.eval:
eval_configs = get_eval_config(exp['config'].get('env_config',\
{}).get('eval_generator',"default"))
eval_seed = eval_configs.get('evaluation_config',{}).get('env_config',{}).get('seed')
# add evaluation config to the current config
exp['config'] = merge_dicts(exp['config'],eval_configs)
if exp['config'].get('evaluation_config'):
exp['config']['evaluation_config']['env_config'] = exp['config'].get('env_config')
eval_env_config = exp['config']['evaluation_config'].get('env_config')
if eval_seed and eval_env_config:
# We override the env seed from the evaluation config
eval_env_config['seed'] = eval_seed
# Remove any wandb related configs
if eval_env_config:
if eval_env_config.get('wandb'):
del eval_env_config['wandb']
# Remove any wandb related configs
if exp['config']['evaluation_config'].get('wandb'):
del exp['config']['evaluation_config']['wandb']
if args.config_file:
# TODO should be in exp['config'] directly
exp['config']['env_config']['yaml_config'] = args.config_file
exp['loggers'] = [WandbLogger, TBXLogger]
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(
num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(address=cluster.address)
else:
ray.init(
address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus,
webui_host=webui_host)
run_experiments(
experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
verbose=verbose,
concurrent=True)
def run(self, experiments: dict, args=None):
verbose = 1
webui_host = "localhost"
for exp in experiments.values():
if exp.get("config", {}).get("input"):
if not isinstance(exp.get("config", {}).get("input"), dict):
if not os.path.exists(exp["config"]["input"]):
rllib_dir = Path(__file__).parent
input_file = rllib_dir.absolute().joinpath(exp["config"]["input"])
exp["config"]["input"] = str(input_file)
if exp["run"] in self.group_algorithms:
self.setup_grouping(exp.get("config"))
if exp["run"] == "contrib/MADDPG" or exp["config"].get("individual_policies", False):
self.setup_policy_map(exp.get("config"))
if exp["config"].get("individual_policies", False):
del exp["config"]["individual_policies"]
if exp["run"] == "contrib/MADDPG":
exp.get("config")["env_config"]["learning_starts"] = 100
exp.get("config")["env_config"]["actions_are_logits"] = True
if exp["env"] == "flatland_sparse_hierarchical":
self.setup_hierarchical_policies(exp.get("config"))
if args is not None:
experiments, verbose = self.apply_args(run_args=args, experiments=experiments)
if args.eval:
self.evaluate(exp)
if args.config_file:
# TODO should be in exp['config'] directly
exp['config']['env_config']['yaml_config'] = args.config_file
exp['loggers'] = [WandbLogger, TBXLogger]
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(
num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 1,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(address=cluster.address)
else:
import multiprocessing
n_cpu = multiprocessing.cpu_count()
import tensorflow as tf
n_gpu = len(tf.config.experimental.list_physical_devices('GPU'))
print("NUM_CPUS AVAILABLE: ", n_cpu)
print("NUM_GPUS AVAILABLE: ", n_gpu)
print("NUM_CPUS ARGS: ", args.ray_num_cpus)
print("NUM_GPUS ARGS: ", args.ray_num_gpus)
ray.init(
local_mode=True if args.local else False,
address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
num_cpus=args.ray_num_cpus if args.ray_num_cpus is not None else n_cpu,
num_gpus=args.ray_num_gpus if args.ray_num_gpus is not None else n_gpu)
run_experiments(
experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
verbose=verbose,
concurrent=True)
ray.shutdown()
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.safe_load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"checkpoint_at_end": args.checkpoint_at_end,
"keep_checkpoints_num": args.keep_checkpoints_num,
"checkpoint_score_attr": args.checkpoint_score_attr,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
verbose = 1
for exp in experiments.values():
# Bazel makes it hard to find files specified in `args` (and `data`).
# Look for them here.
# NOTE: Some of our yaml files don't have a `config` section.
if exp.get("config", {}).get("input") and \
not os.path.exists(exp["config"]["input"]):
# This script runs in the ray/rllib dir.
rllib_dir = Path(__file__).parent
input_file = rllib_dir.absolute().joinpath(exp["config"]["input"])
exp["config"]["input"] = str(input_file)
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if args.torch:
exp["config"]["framework"] = "torch"
elif args.eager:
exp["config"]["framework"] = "tfe"
if args.trace:
if exp["config"]["framework"] not in ["tf2", "tfe"]:
raise ValueError("Must enable --eager to enable tracing.")
exp["config"]["eager_tracing"] = True
if args.v:
exp["config"]["log_level"] = "INFO"
verbose = 2
if args.vv:
exp["config"]["log_level"] = "DEBUG"
verbose = 3
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory)
ray.init(address=cluster.address)
else:
ray.init(include_dashboard=not args.no_ray_ui,
address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus,
local_mode=args.local_mode)
if not args.queue_trials:
# TODO: this should be eventually removed as an arg
# because it is already autodetected on an autoscaling cluster.
os.environ["TUNE_DISABLE_QUEUE_TRIALS"] = "1"
run_experiments(experiments,
scheduler=_make_scheduler(args),
resume=args.resume,
verbose=verbose,
concurrent=True)
ray.shutdown()
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.safe_load(f)
# add callbacks for self-defined metric
# and save successful transitions from RL agents
experiment_name = next(iter(experiments))
experiments[experiment_name]["config"]["optimizer"]["robot_demo_path"] = dir_path
experiments[experiment_name]["config"]["callbacks"] = {
"on_episode_start": on_episode_start,
"on_episode_step": on_episode_step,
"on_episode_end": on_episode_end,
"on_sample_end": on_sample_end,
"on_train_result": on_train_result,
"on_postprocess_traj": on_postprocess_traj
}
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"keep_checkpoints_num": args.keep_checkpoints_num,
"checkpoint_score_attr": args.checkpoint_score_attr,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if args.eager:
exp["config"]["eager"] = True
if args.trace:
if not exp["config"].get("eager"):
raise ValueError("Must enable --eager to enable tracing.")
exp["config"]["eager_tracing"] = True
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(
num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(address=cluster.address) #, log_to_driver=False)
else:
ray.init(
address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
# log_to_driver=False) # disable the loggings
# https://github.com/ray-project/ray/issues/5048
run_experiments(
experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume)
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
# The default maximum number of bytes to allocate to the object store unless
# overridden by the user.
DEFAULT_OBJECT_STORE_MAX_MEMORY_BYTES = 20 * 10**9
# The smallest cap on the memory used by the object store that we allow.
OBJECT_STORE_MINIMUM_MEMORY_BYTES = 10**7
# The default maximum number of bytes that the non-primary Redis shards are
# allowed to use unless overridden by the user.
DEFAULT_REDIS_MAX_MEMORY_BYTES = 10**10
# The smallest cap on the memory used by Redis that we allow.
REDIS_MINIMUM_MEMORY_BYTES = 10**7
def on_episode_end(info):
episode = info["episode"]
env = info['env'].get_unwrapped()[0]
if hasattr(env, 'capital'):
capital_return = (env.capital -
env.initial_funds) / env.initial_funds
episode.custom_metrics['capital_return'] = capital_return
key = list(experiments.keys())[0]
experiments[key]["config"]["callbacks"] = {
"on_episode_end": tune.function(on_episode_end)
}
for exp in experiments.values():
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(resources={
"num_cpus": args.ray_num_cpus or 1,
"num_gpus": args.ray_num_gpus or 0,
},
object_store_memory=args.ray_object_store_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(redis_address=cluster.redis_address)
else:
print('init')
ray.init(redis_address=args.redis_address,
object_store_memory=int(0.5 * 10**9),
redis_max_memory=int(0.5 * 10**9),
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
run_experiments(experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume)
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
experiments = yaml.safe_load(f)
else:
# Note: keep this in sync with tune/config_parser.py
experiments = {
args.experiment_name: { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"keep_checkpoints_num": args.keep_checkpoints_num,
"checkpoint_score_attr": args.checkpoint_score_attr,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": dict(args.config, env=args.env),
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
}
verbose = 1
for exp in experiments.values():
# Bazel makes it hard to find files specified in `args` (and `data`).
# Look for them here.
# NOTE: Some of our yaml files don't have a `config` section.
if exp.get("config", {}).get("input") and \
not os.path.exists(exp["config"]["input"]):
# This script runs in the ray/rllib dir.
rllib_dir = Path(__file__).parent
input_file = rllib_dir.absolute().joinpath(exp["config"]["input"])
exp["config"]["input"] = str(input_file)
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if args.eager:
exp["config"]["eager"] = True
if args.torch:
exp["config"]["use_pytorch"] = True
if args.v:
exp["config"]["log_level"] = "INFO"
verbose = 2
if args.vv:
exp["config"]["log_level"] = "DEBUG"
verbose = 3
if args.trace:
if not exp["config"].get("eager"):
raise ValueError("Must enable --eager to enable tracing.")
exp["config"]["eager_tracing"] = True
### Add Custom Callbacks
exp["config"]["callbacks"] = CustomCallbacks
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(address=cluster.address)
else:
ray.init(address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus)
# NOTE: customs
for exp in experiments.values():
exp["loggers"] = make_loggers(args)
# launch training
run_experiments(experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
verbose=verbose,
concurrent=True)
def run(args, parser):
if args.config_file:
with open(args.config_file) as f:
config_experiments = yaml.safe_load(f)
experiments = config_experiments
else:
if args.algo is not None:
args.experiment = args.algo
if args.experiment:
config_file = os.path.join('config', f'{args.experiment}.yaml')
with open(config_file) as f:
config_dict = yaml.safe_load(f)
else:
config_dict = {args.name: {}}
if args.debug:
args.env = 'MineRLRandomDebug-v0'
experiments = {}
for experiment_name, experiment_settings in config_dict.items():
config = dict(args.config, env=args.env)
# TODO: implement
if args.mode == 'offline':
config.update(
dict(
explore=False,
input=args.data_path,
input_evaluation=['simulation'],
))
elif args.mode == 'mixed':
config.update(
dict(
input={
args.data_path: args.mixing_ratio,
'sample': (1 - args.mixing_ratio)
},
input_evaluation=['simulation'],
))
if 'time_total_s' not in args.stop:
# The MineRL competition training time limit is 4 days. Subtract an hour for evaluation.
args.stop['time_total_s'] = int(2 * 24 * 60 * 60 -
3600) # limit two day training
if 'info/num_steps_sampled' not in args.stop:
# The MineRL competition environment sample limit is 8 million steps.
args.stop['info/num_steps_sampled'] = 8000000
if args.checkpoint_freq is None:
args.checkpoint_freq = 1000
if args.checkpoint_at_end is None:
args.checkpoint_at_end = True
if args.checkpoint_score_attr is None:
args.checkpoint_score_attr = 'episode_reward_mean'
# Note: keep this in sync with tune/config_parser.py
settings_from_args = { # i.e. log to ~/ray_results/default
"run": args.run,
"checkpoint_freq": args.checkpoint_freq,
"checkpoint_at_end": args.checkpoint_at_end,
"keep_checkpoints_num": args.keep_checkpoints_num,
"checkpoint_score_attr": args.checkpoint_score_attr,
"local_dir": args.local_dir,
"resources_per_trial": (
args.resources_per_trial and
resources_to_json(args.resources_per_trial)),
"stop": args.stop,
"config": config,
"restore": args.restore,
"num_samples": args.num_samples,
"upload_dir": args.upload_dir,
}
# overwrite the settings from arguments with those in the experiment config file
settings = merge_dicts(settings_from_args, experiment_settings)
experiments.update({experiment_name: settings})
if any('MineRL' in setting['config']['env']
for setting in experiments.values()):
import envs
envs.register(discrete=args.discrete,
num_actions=args.num_actions,
data_dir=args.data_dir)
print('\nArguments:')
pprint.pprint(args)
print('\nExperiment config:')
pprint.pprint(experiments)
print()
verbose = 1
for exp in experiments.values():
# Bazel makes it hard to find files specified in `args` (and `data`).
# Look for them here.
# NOTE: Some of our yaml files don't have a `config` section.
if exp.get("config", {}).get("input") and \
not os.path.exists(exp["config"]["input"]):
# This script runs in the ray/rllib dir.
rllib_dir = Path(__file__).parent
input_file = rllib_dir.absolute().joinpath(exp["config"]["input"])
exp["config"]["input"] = str(input_file)
if not exp.get("run"):
parser.error("the following arguments are required: --run")
if not exp.get("env") and not exp.get("config", {}).get("env"):
parser.error("the following arguments are required: --env")
if 'framework' not in exp['config']:
if args.eager:
exp["config"]["framework"] = "tfe"
elif args.torch:
exp["config"]["framework"] = "torch"
else:
exp["config"]["framework"] = "tf"
if args.v:
exp["config"]["log_level"] = "INFO"
verbose = 2
if args.vv:
exp["config"]["log_level"] = "DEBUG"
verbose = 3
if args.trace:
if exp["config"]["framework"] != "tfe":
raise ValueError("Must enable --eager to enable tracing.")
exp["config"]["eager_tracing"] = True
if args.ray_num_nodes:
cluster = Cluster()
for _ in range(args.ray_num_nodes):
cluster.add_node(num_cpus=args.ray_num_cpus or 1,
num_gpus=args.ray_num_gpus or 0,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory)
ray.init(address=cluster.address)
else:
ray.init(include_dashboard=not args.no_ray_ui,
address=args.ray_address,
object_store_memory=args.ray_object_store_memory,
memory=args.ray_memory,
redis_max_memory=args.ray_redis_max_memory,
num_cpus=args.ray_num_cpus,
num_gpus=args.ray_num_gpus,
local_mode=args.local_mode)
run_experiments(experiments,
scheduler=_make_scheduler(args),
queue_trials=args.queue_trials,
resume=args.resume,
verbose=verbose,
concurrent=True)
ray.shutdown()
