Python actor_loop示例

示例#1

def main(argv):
    if len(argv) > 1:
        raise app.UsageError('Too many command-line arguments.')
    if FLAGS.run_mode == 'actor':
        actor.actor_loop(env.create_environment)
    elif FLAGS.run_mode == 'learner':
        learner.learner_loop(env.create_environment, create_agent,
                             create_optimizer)
    else:
        raise ValueError('Unsupported run mode {}'.format(FLAGS.run_mode))

示例#2

def main(argv):
    fps_log = Logger('fps.log', level='info')
    if len(argv) > 1:
        raise app.UsageError('Too many command-line arguments.')
    if FLAGS.run_mode == 'actor':
        actor.actor_loop(create_atari_env)
    elif FLAGS.run_mode == 'learner':
        learner.learner_loop(create_atari_env, create_agent, create_optimizer,
                             fps_log)
    else:
        raise ValueError('Unsupported run mode {}'.format(FLAGS.run_mode))

示例#3

文件： vtrace_main.py 项目： zerocurve/seed_rl

def main(argv):
  create_environment = lambda task, config: env.create_environment(  
      env_name=config.env_name,
      discretization=config.discretization,
      n_actions_per_dim=config.n_actions_per_dim,
      action_ratio=config.action_ratio)

  if len(argv) > 1:
    raise app.UsageError('Too many command-line arguments.')
  if FLAGS.run_mode == 'actor':
    actor.actor_loop(create_environment)
  elif FLAGS.run_mode == 'learner':
    learner.learner_loop(create_environment,
                         create_agent,
                         create_optimizer)
  else:
    raise ValueError('Unsupported run mode {}'.format(FLAGS.run_mode))

示例#4

文件： vtrace_main.py 项目： do-not-be-hasty/seed_rl

def main(argv):
    if len(argv) > 1:
        raise app.UsageError('Too many command-line arguments.')
    if FLAGS.run_mode == 'actor':
        actor.actor_loop(env.create_environment)
    elif FLAGS.run_mode == 'learner':
        neptune.init('do-not-be-hasty/matrace')
        neptune.create_experiment(tags=[FLAGS.nonce])
        neptune_tensorboard.integrate_with_tensorflow()

        learner.learner_loop(env.create_environment, create_agent,
                             create_optimizer)
    elif FLAGS.run_mode == 'visualize':
        visualize.visualize(env.create_environment, create_agent,
                            create_optimizer)
    else:
        raise ValueError('Unsupported run mode {}'.format(FLAGS.run_mode))

示例#5

文件： ppo_main.py 项目： zerocurve/seed_rl

def main(unused_argv):
    # Save the string flags now as we modify them later.
    string_flags = FLAGS.flags_into_string()
    gin.parse_config_files_and_bindings(
        [FLAGS.gin_config] if FLAGS.gin_config else [],
        # Gin uses slashes to denote scopes but XM doesn't allow slashes in
        # parameter names so we use __ instead and convert it to slashes here.
        [s.replace('__', '/') for s in FLAGS.gin_bindings])
    gym_kwargs = {}
    if FLAGS.mujoco_model:
        local_mujoco_model = tempfile.mkstemp(prefix='mujoco_model',
                                              suffix='.xml')[1]
        logging.info('Copying remote model %s to local file %s',
                     FLAGS.mujoco_model, local_mujoco_model)
        tf.io.gfile.copy(FLAGS.mujoco_model,
                         local_mujoco_model,
                         overwrite=True)
        gym_kwargs['model_path'] = local_mujoco_model

    create_environment = lambda task, config: env.create_environment(
        env_name=config.env_name,
        discretization='none',
        n_actions_per_dim=11,
        action_ratio=30,
        gym_kwargs=gym_kwargs)

    if FLAGS.run_mode == 'actor':
        actor.actor_loop(create_environment)
    elif FLAGS.run_mode == 'learner':
        logdir = FLAGS.logdir
        settings = utils.init_learner_multi_host(FLAGS.num_training_tpus)
        learner.learner_loop(
            create_environment,
            create_agent,
            create_optimizer,
            learner_flags.training_config_from_flags(),
            settings,
            action_distribution_config=continuous_action_config())
        with tf.io.gfile.GFile(os.path.join(logdir, 'learner_flags.txt'),
                               'w') as f:
            f.write(string_flags)
        with tf.io.gfile.GFile(os.path.join(logdir, 'learner.gin'), 'w') as f:
            f.write(gin.operative_config_str())
    else:
        raise ValueError('Unsupported run mode {}'.format(FLAGS.run_mode))

示例#6

文件： vtrace_better_main.py 项目： do-not-be-hasty/seed_rl

def main(argv):
    if len(argv) > 1:
        raise app.UsageError('Too many command-line arguments.')
    if FLAGS.run_mode == 'actor':
        if not FLAGS.is_local:
            get_configuration(config_file=FLAGS.mrunner_config,
                              inject_parameters_to_FLAGS=True)
        actor.actor_loop(env.create_environment)
    elif FLAGS.run_mode == 'learner':
        if not FLAGS.is_local:
            get_configuration(config_file=FLAGS.mrunner_config,
                              print_diagnostics=True,
                              with_neptune=True,
                              inject_parameters_to_FLAGS=True)
            experiment = neptune.get_experiment()
            experiment.append_tag(tag=FLAGS.nonce)
            neptune_tensorboard.integrate_with_tensorflow()
        learner.learner_loop(env.create_environment, create_agent,
                             create_optimizer)
    elif FLAGS.run_mode == 'visualize':
        visualize.visualize(env.create_environment, create_agent,
                            create_optimizer)
    else:
        raise ValueError('Unsupported run mode {}'.format(FLAGS.run_mode))