def run_trial_single_instance(config, kwargs):
# Connect to ray, no specific redis address
ray.init(load_code_from_local=False, webui_host="0.0.0.0")
config["dist_url"] = f"tcp://127.0.0.1:{get_free_port()}"
kwargs["config"] = config
tune.run(**kwargs)
print("**** Trial ended")
def main():
arg_params = parse_args()
register_env("malmo", create_malmo)
config = {
'mission': arg_params.mission,
'port': arg_params.port,
'server': arg_params.server,
'port2': arg_params.port2,
'server2': arg_params.server2,
'episodes': arg_params.episodes,
'episode': arg_params.episode,
'role': arg_params.role,
'episodemaxsteps': arg_params.episodemaxsteps,
'saveimagesteps': arg_params.saveimagesteps,
'resync': arg_params.resync,
'experimentUniqueId': arg_params.experimentUniqueId
}
env = create_malmo(config)
ray.init(num_cpus=20)
tune.run("IMPALA",
stop={
"timesteps_total": 10000,
},
config={
"env_config": config,
"env": "malmo",
"num_workers": 1,
"num_gpus": 0
})
ray.shutdown()
def run(config):
if config.get("single_instance", False):
return run_single_instance(config)
# Connect to ray
local_mode = config.get("local_mode", False)
if local_mode:
address = None
else:
address = os.environ.get("REDIS_ADDRESS", config.get("redis_address"))
ray.init(address=address, local_mode=local_mode)
# Register serializer and deserializer - needed when logging arrays and tensors.
if not config.get("local_mode", False):
register_torch_serializers()
# Get ray.tune kwargs for the given config.
kwargs = get_tune_kwargs(config)
# Queue trials until the cluster scales up
kwargs.update(queue_trials=True)
pprint(kwargs)
result = tune.run(**kwargs)
ray.shutdown()
return result
def _fit_resume(self, trainable) -> ExperimentAnalysis:
"""Fitting for a restored Tuner."""
analysis = run(
trainable,
resume=True,
mode=self._tune_config.mode,
metric=self._tune_config.metric,
callbacks=self._run_config.callbacks,
_experiment_checkpoint_dir=self._experiment_checkpoint_dir,
raise_on_failed_trial=False,
)
return analysis
def main():
register_env("malmo", create_malmo)
env = create_malmo(env_config={
"env": "malmo",
"num_workers": 1,
"num_gpus": 0
})
ray.init(num_cpus=20)
tune.run("IMPALA",
stop={
"timesteps_total": 10000,
},
config={
"env": "malmo",
"num_workers": 1,
"num_gpus": 0
})
ray.shutdown()
def _fit_resume(self, trainable) -> ExperimentAnalysis:
"""Fitting for a restored Tuner."""
args = {
**self._get_tune_run_arguments(trainable),
**dict(
run_or_experiment=trainable,
resume=True,
),
**self._tuner_kwargs,
}
analysis = run(**args)
return analysis
def run(config):
# Connect to ray
address = os.environ.get("REDIS_ADDRESS", config.get("redis_address"))
ray.init(address=address)
# Build kwargs for `tune.run` function using merged config and command line dict
kwargs_names = tune.run.__code__.co_varnames[:tune.run.__code__.co_argcount]
if "sigopt_config" in config:
kwargs = dict(zip(kwargs_names, [SigOptImagenetTrainable,
*tune.run.__defaults__]))
else:
kwargs = dict(zip(kwargs_names, [ImagenetTrainable, *tune.run.__defaults__]))
# Update`tune.run` kwargs with config
kwargs.update(config)
kwargs["config"] = config
# Update tune stop criteria with config epochs
stop = kwargs.get("stop", {}) or dict()
epochs = config.get("epochs", 1)
stop.update(training_iteration=epochs)
kwargs["stop"] = stop
# Make sure to only select`tune.run` function arguments
kwargs = dict(filter(lambda x: x[0] in kwargs_names, kwargs.items()))
# Queue trials until the cluster scales up
kwargs.update(queue_trials=True)
# Group trial into nodes as much as possible
# kwargs.update(trial_executor=AffinityExecutor(
# queue_trials=kwargs.get("queue_trials", True),
# reuse_actors=kwargs.get("reuse_actors", False),
# ray_auto_init=kwargs.get("ray_auto_init", True)
# ))
pprint(kwargs)
tune.run(**kwargs)
ray.shutdown()
def run(config):
# Connect to ray
address = os.environ.get("REDIS_ADDRESS", config.get("redis_address"))
ray.init(address=address, local_mode=config.get("local_mode", False))
# Build kwargs for `tune.run` function using merged config and command line dict
kwargs_names = tune.run.__code__.co_varnames[:tune.run.__code__.
co_argcount]
if "sigopt_config" in config:
kwargs = dict(
zip(kwargs_names,
[SigOptImagenetTrainable, *tune.run.__defaults__]))
else:
imagenet_trainable = config.get("imagenet_trainable",
ImagenetTrainable)
assert issubclass(imagenet_trainable, ImagenetTrainable)
kwargs = dict(
zip(kwargs_names, [imagenet_trainable, *tune.run.__defaults__]))
# Check if restoring experiment from last known checkpoint
if config.pop("restore", False):
result_dir = os.path.join(config["local_dir"], config["name"])
checkpoint_file = get_last_checkpoint(result_dir)
config["checkpoint_file"] = checkpoint_file
# Update`tune.run` kwargs with config
kwargs.update(config)
kwargs["config"] = config
# Make sure to only select`tune.run` function arguments
kwargs = dict(filter(lambda x: x[0] in kwargs_names, kwargs.items()))
# Queue trials until the cluster scales up
kwargs.update(queue_trials=True)
pprint(kwargs)
tune.run(**kwargs)
ray.shutdown()
def main(args):
if args.name is None:
parser.print_help()
exit(1)
else:
address = os.environ.get("REDIS_ADDRESS", args.redis_address)
ray.init(address=address)
# Get configuration values
config = copy.deepcopy(CONFIGS[args.name])
# Merge configuration with command line arguments
config.update(vars(args))
# Build kwargs for `tune.run` function using merged config and command line dict
kwargs_names = tune.run.__code__.co_varnames[:tune.run.__code__.
co_argcount]
kwargs = dict(
zip(kwargs_names, [ImagenetTrainable, *tune.run.__defaults__]))
# Update`tune.run` kwargs with config
kwargs.update(config)
kwargs["config"] = config
# Update tune stop criteria with config epochs
epochs = config.get("epochs", 1)
kwargs["stop"].update(training_iteration=epochs)
# Make sure to only select`tune.run` function arguments
kwargs = dict(filter(lambda x: x[0] in kwargs_names, kwargs.items()))
# Queue trials until the cluster scales up
kwargs.update(queue_trials=True)
pprint(kwargs)
tune.run(**kwargs)
ray.shutdown()
def _fit_internal(self, trainable, param_space) -> ExperimentAnalysis:
"""Fitting for a fresh Tuner."""
analysis = run(
trainable,
config={**param_space},
mode=self._tune_config.mode,
metric=self._tune_config.metric,
num_samples=self._tune_config.num_samples,
search_alg=self._tune_config.search_alg,
scheduler=self._tune_config.scheduler,
name=self._run_config.name,
callbacks=self._run_config.callbacks,
_experiment_checkpoint_dir=self._experiment_checkpoint_dir,
raise_on_failed_trial=False,
)
return analysis
def _fit_internal(self, trainable, param_space) -> ExperimentAnalysis:
"""Fitting for a fresh Tuner."""
args = {
**self._get_tune_run_arguments(),
**dict(
run_or_experiment=trainable,
config={**param_space},
num_samples=self._tune_config.num_samples,
search_alg=self._tune_config.search_alg,
scheduler=self._tune_config.scheduler,
name=self._run_config.name,
),
**self._tuner_kwargs,
}
analysis = run(**args, )
return analysis
def _fit_resume(self, trainable) -> ExperimentAnalysis:
"""Fitting for a restored Tuner."""
analysis = run(
trainable,
resume=True,
mode=self._tune_config.mode,
metric=self._tune_config.metric,
callbacks=self._run_config.callbacks,
sync_config=self._run_config.sync_config,
stop=self._run_config.stop,
max_failures=(self._run_config.failure.max_failures
if self._run_config.failure else 0),
_experiment_checkpoint_dir=self._experiment_checkpoint_dir,
raise_on_failed_trial=False,
**self._tuner_kwargs,
)
return analysis
def _fit_internal(self, trainable, param_space) -> ExperimentAnalysis:
"""Fitting for a fresh Tuner."""
analysis = run(
trainable,
config={**param_space},
mode=self._tune_config.mode,
metric=self._tune_config.metric,
num_samples=self._tune_config.num_samples,
search_alg=self._tune_config.search_alg,
scheduler=self._tune_config.scheduler,
name=self._run_config.name,
callbacks=self._run_config.callbacks,
sync_config=self._run_config.sync_config,
stop=self._run_config.stop,
max_failures=(self._run_config.failure.max_failures
if self._run_config.failure else 0),
_experiment_checkpoint_dir=self._experiment_checkpoint_dir,
raise_on_failed_trial=False,
verbose=self._run_config.verbose,
**self._tuner_kwargs,
)
return analysis
def run_single_instance(config):
# get number of GPUs
config["num_gpus"] = torch.cuda.device_count()
config["workers"] = 4
config["log_level"] = "INFO"
config["reuse_actors"] = False
config["dist_port"] = get_free_port()
# Build kwargs for `tune.run` function using merged config and command line dict
kwargs_names = tune.run.__code__.co_varnames[:tune.run.__code__.
co_argcount]
kwargs = dict(
zip(kwargs_names, [ImagenetTrainable, *tune.run.__defaults__]))
# Update`tune.run` kwargs with config
kwargs.update(config)
kwargs["config"] = config
# Update tune stop criteria with config epochs
stop = kwargs.get("stop", {}) or dict()
epochs = config.get("epochs", 1)
stop.update(training_iteration=epochs)
kwargs["stop"] = stop
# Make sure to only select`tune.run` function arguments
kwargs = dict(filter(lambda x: x[0] in kwargs_names, kwargs.items()))
# pprint(kwargs)
# current torch distributed approach requires num_samples to be 1
num_samples = 1
if "num_samples" in kwargs:
num_samples = kwargs["num_samples"]
kwargs["num_samples"] = 1
trials = TrialsCollection(kwargs["config"], num_samples, restore=True)
t_init = time.time()
for config in trials.retrieve():
t0 = time.time()
trials.report_progress()
# Connect to ray, no specific redis address
ray.init(load_code_from_local=True, webui_host="0.0.0.0")
config["dist_url"] = f"tcp://127.0.0.1:{get_free_port()}"
kwargs["config"] = config
tune.run(**kwargs)
print("**** ended training")
# report time elapsed
t1 = time.time()
print(f"***** Time elapsed last trial: {t1-t0:.0f} seconds")
print(f"***** Time elapsed total: {t1-t_init:.0f} seconds")
ray.shutdown()
# save trials for later retrieval
trials.mark_completed(config, save=True)
# sleep to avoid interference between runs
time.sleep(2)
# error message when experiment ends
print(f"***** Experiment {trials.name} finished: {len(trials.completed)}"
" trials completed")
from ray.experimental.client import ray
from ray.tune import tune
ray.connect("localhost:50051")
tune.run("PG", config={"env": "CartPole-v0"})
server=config["server"],
server2=config["server2"], port2=config["port2"],
role=config["role"],
exp_uid=config["experimentUniqueId"],
episode=config["episode"], resync=config["resync"])
return env
register_env("malmo", create_malmo)
register_env("marlo", create_marlo)
ray.init(num_cpus=4)
tune.run("IMPALA",
stop={
"timesteps_total": 10000,
},
config={"env": "marlo",
# "model": {
# "conv_filters": [224,224,224],
# "fcnet_hiddens": [1024,1024],
# "framestack": False,
# "grayscale": False,
# "fcnet_activation":"relu"
# },
"num_workers": 1,
"num_gpus": 0}
)
ray.shutdown()
[90, 128])), # there are 3 other hardcoded layers after this one
"batch_size": tune.sample_from(list([64, 256, 512, 1024])),
"dropout": tune.sample_from(list([0.2, 0.5])),
"optimizer_name": tune.sample_from(list(["adam", "ranger", "sgd"])),
"lr": tune.sample_from(list([0.001, 0.1])),
"data": tune.sample_from(list(["default", "rus", "smte"]))
}
num_samples = 4
ray.shutdown() # Restart Ray defensively in case the ray connection is lost.
ray.init(num_cpus=8, memory=10000000000, log_to_driver=False)
# We clean out the logs before running for a clean visualization later.
# ! rm -rf ~/ray_results/tune_iris
analysis = tune.run(create_model_tune_cofig,
verbose=1,
config=hyperparameter_space,
num_samples=num_samples)
# HPARAM-----------------------------------------------------------------------------
# from tensorboard.plugins.hparams import api as hp
# import os
# from datetime import datetime
#
# METRICS = [
# tf.keras.metrics.TruePositives(name='tp'),
# tf.metrics.FalsePositives(name='fp'),
# tf.metrics.TrueNegatives(name='tn'),
# tf.metrics.FalseNegatives(name='fn'),
# tf.metrics.BinaryAccuracy(name='accuracy'),
# tf.metrics.Precision(name='precision'),
# tf.metrics.Recall(name='recall'),
import argparse
from pathlib import Path
import ray
from ray.tune import tune
import yaml
from scripts.models import custom_eval_fn
from scripts.trainer import MyTrainer
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--config', type=Path, default='./config')
args = parser.parse_args()
with open(args.config, 'r') as f:
config = yaml.load(f)
config['custom_eval_function'] = custom_eval_fn
ray.init()
tune.run(
MyTrainer,
stop={"episode_reward_mean": 20000},
config=config,
checkpoint_freq=1,
local_dir="results",
)
def run_experiment(args, parser):
# args.ray_object_store_memory = int(1e10)
args.ray_redis_max_memory = int(2e9)
if args.config_file:
with open(args.config_file) as f:
exp = yaml.load(f)
else:
raise Exception('No config file!')
exp = merge_dicts(exp, args.config)
log.info('Num workers: %d, num_envs_per_worker: %d',
exp['config']['num_workers'],
exp['config']['num_envs_per_worker'])
if args.cfg_mixins is not None:
for cfg_mixin_file in args.cfg_mixins:
with open(cfg_mixin_file, 'r') as f:
override_cfg = yaml.load(f)
log.info('Overriding parameters from %s: %r', cfg_mixin_file,
override_cfg)
exp = merge_dicts(exp, override_cfg)
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,
local_mode=args.local_mode)
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,
local_mode=args.local_mode,
)
exp = Experiment.from_json(args.experiment_name, exp)
exp.spec['checkpoint_freq'] = 20
if args.pbt:
exp.spec['checkpoint_freq'] = 3
exp.spec['checkpoint_at_end'] = True
# exp.spec['checkpoint_score_attr'] = 'episode_reward_mean'
exp.spec['keep_checkpoints_num'] = 5
if args.stop_seconds > 0:
exp.spec['stop'] = {'time_total_s': args.stop_seconds}
# if 'multiagent' in exp.spec['config']:
# # noinspection PyProtectedMember
# make_env = ray.tune.registry._global_registry.get(ENV_CREATOR, exp.spec['config']['env'])
# temp_env = make_env(None)
# obs_space, action_space = temp_env.observation_space, temp_env.action_space
# temp_env.close()
# del temp_env
#
# policies = dict(
# main=(None, obs_space, action_space, {}),
# dummy=(None, obs_space, action_space, {}),
# )
#
# exp.spec['config']['multiagent'] = {
# 'policies': policies,
# 'policy_mapping_fn': function(lambda agent_id: 'main'),
# 'policies_to_train': ['main'],
# }
#
# if args.dbg:
# exp.spec['config']['num_workers'] = 1
# exp.spec['config']['num_gpus'] = 1
# exp.spec['config']['num_envs_per_worker'] = 1
#
# if 'callbacks' not in exp.spec['config']:
# exp.spec['config']['callbacks'] = {}
#
# fps_helper = FpsHelper()
#
# def on_train_result(info):
# if 'APPO' in exp.spec['run']:
# samples = info['result']['info']['num_steps_sampled']
# else:
# samples = info['trainer'].optimizer.num_steps_trained
#
# fps_helper.record(samples)
# fps = fps_helper.get_fps()
# info['result']['custom_metrics']['fps'] = fps
#
# # remove this as currently
# skip_frames = exp.spec['config']['env_config']['skip_frames']
# info['result']['custom_metrics']['fps_frameskip'] = fps * skip_frames
#
# exp.spec['config']['callbacks']['on_train_result'] = function(on_train_result)
#
# def on_episode_end(info):
# episode = info['episode']
# stats = {
# 'DEATHCOUNT': 0,
# 'FRAGCOUNT': 0,
# 'HITCOUNT': 0,
# 'DAMAGECOUNT': 0,
# 'KDR': 0,
# 'FINAL_PLACE': 0,
# 'LEADER_GAP': 0,
# 'PLAYER_COUNT': 0,
# 'BOT_DIFFICULTY': 0,
# }
#
# # noinspection PyProtectedMember
# agent_to_last_info = episode._agent_to_last_info
# for agent in agent_to_last_info.keys():
# agent_info = agent_to_last_info[agent]
# for stats_key in stats.keys():
# stats[stats_key] += agent_info.get(stats_key, 0.0)
#
# for stats_key in stats.keys():
# stats[stats_key] /= len(agent_to_last_info.keys())
#
# episode.custom_metrics.update(stats)
#
# exp.spec['config']['callbacks']['on_episode_end'] = function(on_episode_end)
extra_kwargs = {}
if args.pbt:
extra_kwargs['reuse_actors'] = False
run(exp,
name=args.experiment_name,
scheduler=make_custom_scheduler(args),
resume=args.resume,
queue_trials=args.queue_trials,
**extra_kwargs)
tune.run(
DQNTrainer,
checkpoint_at_end=True,
stop={"timesteps_total": 2000},
config={
"num_gpus": 0,
"num_workers": 1,
"env": "MultiAgentSimEnv-v0",
"framework": "torch",
# "sample_batch_size": 50,
"lr": 4e-3,
# "lr": tune.grid_search([5e-3, 2e-3, 1e-3, 5e-4]),
"gamma": 0.985,
# "gamma": tune.grid_search([0.983, 0.985, 0.986, 0.987, 0.988, 0.989]),
"epsilon": 1,
"epsilon_decay": 0.99998,
"epsilon_min": 0.01,
"buffer_size": 20000,
"batch_size": 2000,
"dqn_model": {
"custom_model": "DQNModel",
"custom_model_config": {
# "network_size": [32, 64, 32],
},
# extra options to pass to your model
},
"multiagent": {
"policy_mapping_fn": policy_mapping_fn,
"policies": policies,
"policies_to_train": policies
},
})
