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 }, })