Exemple #1
0
 def testCreateRunner(self, mock_create_agent, mock_runner_constructor):
     base_dir = '/tmp'
     run_experiment.create_runner(base_dir)
     self.assertEqual(1, mock_runner_constructor.call_count)
     mock_args, _ = mock_runner_constructor.call_args
     self.assertEqual(base_dir, mock_args[0])
     self.assertEqual(mock_create_agent, mock_args[1])
Exemple #2
0
 def testCreateTrainRunner(self, mock_create_agent,
                           mock_runner_constructor):
     base_dir = '/tmp'
     run_experiment.create_runner(base_dir, schedule='continuous_train')
     self.assertEqual(1, mock_runner_constructor.call_count)
     mock_args, _ = mock_runner_constructor.call_args
     self.assertEqual(base_dir, mock_args[0])
     self.assertEqual(mock_create_agent, mock_args[1])
Exemple #3
0
def main(unused_argv):
  """Main method.

  Args:
    unused_argv: Arguments (unused).
  """
  tf.logging.set_verbosity(tf.logging.INFO)
  run_experiment.load_gin_configs(FLAGS.gin_files, FLAGS.gin_bindings)
  runner = run_experiment.create_runner(FLAGS.base_dir)
  runner.run_experiment()
Exemple #4
0
def main(unused_argv):
    """Main method.

  Args:
    unused_argv: Arguments (unused).
  """
    logging.set_verbosity(logging.INFO)
    tf.compat.v1.disable_v2_behavior()

    run_experiment.load_gin_configs(FLAGS.gin_files, FLAGS.gin_bindings)
    runner = run_experiment.create_runner(FLAGS.base_dir)
    runner.run_experiment()
Exemple #5
0
def main(unused_argv):
    """Main method.

  Args:
    unused_argv: Arguments (unused).
  """
    tf.logging.set_verbosity(tf.logging.INFO)
    print("levin: test ok")

    run_experiment.load_gin_configs(FLAGS.gin_files, FLAGS.gin_bindings)
    FLAGS.base_dir = FLAGS.base_dir + '-' + str(int(time.time()))
    runner = run_experiment.create_runner(FLAGS.base_dir)
    runner.run_experiment()
Exemple #6
0
RainbowAgent.epsilon_train = 0.01
RainbowAgent.epsilon_eval = 0.001
RainbowAgent.epsilon_decay_period = 250000  # agent steps
# IQN currently does not support prioritized replay.
RainbowAgent.replay_scheme = 'uniform'
RainbowAgent.tf_device = '/gpu:0'  # '/cpu:*' use for non-GPU version
RainbowAgent.optimizer = @tf.train.AdamOptimizer()

tf.train.AdamOptimizer.learning_rate = 0.00005
tf.train.AdamOptimizer.epsilon = 0.0003125

atari_lib.create_atari_environment.game_name = 'Pong'
# Sticky actions with probability 0.25, as suggested by (Machado et al., 2017).
atari_lib.create_atari_environment.sticky_actions = True
create_agent.agent_name = 'implicit_quantile'
Runner.num_iterations = 50
Runner.training_steps = 1000
Runner.evaluation_steps = 1000
Runner.max_steps_per_episode = 200  # Default max episode length.

WrappedPrioritizedReplayBuffer.replay_capacity = 50000
WrappedPrioritizedReplayBuffer.batch_size = 128
"""
gin.parse_config(iqn_config, skip_unknown=False)

# @title Train IQN
iqn_runner = run_experiment.create_runner(IQN_PATH,
                                          schedule='continuous_train')
print('Will train IQN agent, please be patient, may be a while...')
iqn_runner.run_experiment()
print('Done training!')
Exemple #7
0
 def testCreateRunnerUnknown(self):
     base_dir = '/tmp'
     with self.assertRaisesRegexp(ValueError, 'Unknown schedule'):
         run_experiment.create_runner(base_dir, 'Unknown schedule')
Exemple #8
0
#TrainRunner.create_environment_fn = @gym_lib.create_gym_environment
Runner.num_iterations = 100
Runner.training_steps = 1000
Runner.evaluation_steps = 1000
Runner.max_steps_per_episode = 1000  # Default max episode length.

WrappedReplayBuffer.replay_capacity = 100000
WrappedReplayBuffer.batch_size = 64
"""
gin.parse_config(dqn_config, skip_unknown=False)

for run in range(10):
    DQN_PATH = os.path.join(BASE_PATH,
                            'llv2_standard_eval_decay/run_' + str(run))

    dqn_runner = run_experiment.create_runner(
        DQN_PATH, schedule='continuous_train_and_eval')
    print('Will train DQN agent, please be patient, may be a while...')
    dqn_runner.run_experiment()
    print('Done training!')

    data = colab_utils.read_experiment(
        DQN_PATH,
        verbose=True,
        summary_keys=[
            'train_episode_returns', 'train_episode_actual_returns',
            'train_episode_lengths', 'eval_episode_returns',
            'eval_episode_actual_returns', 'eval_episode_lengths'
        ])
    data['agent'] = 'DQN'
    data['run'] = run
Exemple #9
0
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from dopamine.discrete_domains import run_experiment

import tensorflow as tf

gin_files = ['./my_tests/fourier_pong.gin']
base_dir = './tmp/fourier/'
gin_bindings = []

tf.logging.set_verbosity(tf.logging.INFO)
run_experiment.load_gin_configs(gin_files, gin_bindings)
runner = run_experiment.create_runner(base_dir)
runner.run_experiment()