def test_ddpg_trainer(self):
environment = GridworldContinuous()
samples = environment.generate_samples(500000, 0.25)
trainer = DDPGTrainer(
self.get_ddpg_parameters(),
environment.normalization,
environment.normalization_action,
environment.min_action_range,
environment.max_action_range,
)
evaluator = GridworldDDPGEvaluator(environment, True, DISCOUNT, False,
samples)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
critic_predictor = trainer.predictor(actor=False)
evaluator.evaluate_critic(critic_predictor)
for tdp in tdps:
tdp.rewards = tdp.rewards.flatten()
tdp.not_terminals = tdp.not_terminals.flatten()
trainer.train(tdp)
# Make sure actor predictor works
actor = trainer.predictor(actor=True)
evaluator.evaluate_actor(actor)
# Evaluate critic predicor for correctness
critic_predictor = trainer.predictor(actor=False)
error = evaluator.evaluate_critic(critic_predictor)
print("gridworld MAE: {0:.3f}".format(error))
def test_ddpg_trainer(self):
environment = GridworldContinuous()
samples = environment.generate_samples(200000, 1.0)
epochs = 3
trainer = DDPGTrainer(
self.get_ddpg_parameters(),
environment.normalization,
environment.normalization_action,
)
evaluator = GridworldDDPGEvaluator(environment, True)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for epoch in range(epochs):
print("On epoch {} of {}".format(epoch + 1, epochs))
critic_predictor = trainer.predictor()
evaluator.evaluate_critic(critic_predictor)
for tdp in tdps:
training_samples = [
tdp.states,
tdp.actions,
tdp.rewards.flatten(),
tdp.next_states,
None,
1 - tdp.not_terminals.flatten(), # done
None,
None,
[1 for i in range(len(tdp.states))], # time diff
]
trainer.train(training_samples)
critic_predictor = trainer.predictor()
error = evaluator.evaluate_critic(critic_predictor)
print("gridworld MAE: {0:.3f}".format(error))
def test_trainer_sarsa(self):
environment = GridworldContinuous()
states, actions, rewards, next_states, next_actions, is_terminal,\
possible_next_actions, reward_timelines = \
environment.generate_samples(100000, 1.0)
trainer = self.get_sarsa_trainer(environment)
predictor = trainer.predictor()
evaluator = GridworldContinuousEvaluator(environment, False)
tdps = environment.preprocess_samples(
states,
actions,
rewards,
next_states,
next_actions,
is_terminal,
possible_next_actions,
reward_timelines,
self.minibatch_size,
)
self.assertGreater(evaluator.evaluate(predictor), 0.15)
for tdp in tdps:
trainer.train_numpy(tdp, None)
evaluator.evaluate(predictor)
self.assertLess(evaluator.evaluate(predictor), 0.05)
def test_evaluator_ground_truth(self):
environment = GridworldContinuous()
states, actions, rewards, next_states, next_actions, is_terminal,\
possible_next_actions, _ = environment.generate_samples(100000, 1.0)
true_values = environment.true_values_for_sample(
states, actions, False)
# Hijack the reward timeline to insert the ground truth
reward_timelines = []
for tv in true_values:
reward_timelines.append({0: tv})
trainer = self.get_sarsa_trainer(environment)
evaluator = Evaluator(trainer, DISCOUNT)
tdps = environment.preprocess_samples(
states,
actions,
rewards,
next_states,
next_actions,
is_terminal,
possible_next_actions,
reward_timelines,
self.minibatch_size,
)
for tdp in tdps:
trainer.train_numpy(tdp, evaluator)
self.assertLess(evaluator.td_loss[-1], 0.05)
self.assertLess(evaluator.mc_loss[-1], 0.12)
def test_trainer_maxq(self):
environment = GridworldContinuous()
rl_parameters = self.get_sarsa_parameters()
new_rl_parameters = ContinuousActionModelParameters(
rl=RLParameters(
gamma=DISCOUNT,
target_update_rate=0.5,
reward_burnin=10,
maxq_learning=True,
),
training=rl_parameters.training,
knn=rl_parameters.knn,
)
maxq_trainer = ContinuousActionDQNTrainer(
new_rl_parameters,
environment.normalization,
environment.normalization_action,
)
samples = environment.generate_samples(100000, 1.0)
predictor = maxq_trainer.predictor()
tdps = environment.preprocess_samples(samples, self.minibatch_size)
evaluator = GridworldContinuousEvaluator(environment, True)
self.assertGreater(evaluator.evaluate(predictor), 0.2)
for _ in range(2):
for tdp in tdps:
maxq_trainer.train_numpy(tdp, None)
evaluator.evaluate(predictor)
self.assertLess(evaluator.evaluate(predictor), 0.15)
def test_evaluator_timeline(self):
environment = GridworldContinuous()
samples = environment.generate_samples(100000, 1.0)
trainer = self.get_sarsa_trainer(environment)
evaluator = Evaluator(1)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for tdp in tdps:
trainer.train_numpy(tdp, evaluator)
self.assertLess(evaluator.td_loss[-1], 0.2)
self.assertLess(evaluator.mc_loss[-1], 0.2)
def test_trainer_sarsa(self):
environment = GridworldContinuous()
samples = environment.generate_samples(100000, 1.0)
trainer = self.get_sarsa_trainer(environment)
predictor = trainer.predictor()
evaluator = GridworldContinuousEvaluator(environment, False, DISCOUNT,
False, samples)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for tdp in tdps:
trainer.train_numpy(tdp, None)
evaluator.evaluate(predictor)
self.assertLess(evaluator.evaluate(predictor), 0.15)
def test_evaluator_ground_truth(self):
environment = GridworldContinuous()
samples = environment.generate_samples(500000, 1.0, DISCOUNT)
# Hijack the reward timeline to insert the ground truth
samples.episode_values = environment.true_values_for_sample(
samples.states, samples.actions, False)
trainer = self.get_sarsa_trainer(environment)
evaluator = Evaluator(None, 10, DISCOUNT, None, None)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for tdp in tdps:
trainer.train(tdp, evaluator)
self.assertLess(evaluator.mc_loss[-1], 0.15)
def test_trainer_sarsa_factorized(self):
environment = GridworldContinuous()
samples = environment.generate_samples(500000, 1.0, DISCOUNT)
trainer = self.get_sarsa_trainer(
environment, self.get_sarsa_parameters_factorized())
predictor = trainer.predictor()
evaluator = GridworldContinuousEvaluator(environment, False, DISCOUNT,
False, samples)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for tdp in tdps:
trainer.train(tdp)
predictor = trainer.predictor()
evaluator.evaluate(predictor)
self.assertLess(evaluator.evaluate(predictor), 0.15)
def test_evaluator_ground_truth(self):
environment = GridworldContinuous()
samples = environment.generate_samples(100000, 1.0)
true_values = environment.true_values_for_sample(
samples.states, samples.actions, False)
# Hijack the reward timeline to insert the ground truth
samples.reward_timelines = []
for tv in true_values:
samples.reward_timelines.append({0: tv})
trainer = self.get_sarsa_trainer(environment)
evaluator = Evaluator(1)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for tdp in tdps:
trainer.train_numpy(tdp, evaluator)
self.assertLess(evaluator.td_loss[-1], 0.05)
self.assertLess(evaluator.mc_loss[-1], 0.12)
def test_trainer_sarsa(self):
environment = GridworldContinuous()
samples = environment.generate_samples(150000, 1.0)
trainer = self.get_sarsa_trainer(environment)
predictor = trainer.predictor()
evaluator = GridworldContinuousEvaluator(environment, False, DISCOUNT,
False, samples)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for tdp in tdps:
tdp.rewards = tdp.rewards.flatten()
tdp.not_terminals = tdp.not_terminals.flatten()
trainer.train(tdp)
predictor = trainer.predictor()
evaluator.evaluate(predictor)
self.assertLess(evaluator.evaluate(predictor), 0.15)
def test_evaluator_ground_truth(self):
environment = GridworldContinuous()
samples = environment.generate_samples(200000, 1.0)
true_values = environment.true_values_for_sample(
samples.states, samples.actions, False)
# Hijack the reward timeline to insert the ground truth
samples.reward_timelines = []
for tv in true_values:
samples.reward_timelines.append({0: tv})
trainer = self.get_sarsa_trainer(environment)
evaluator = Evaluator(None, 10, DISCOUNT)
tdps = environment.preprocess_samples(samples, self.minibatch_size)
for tdp in tdps:
tdp.rewards = tdp.rewards.flatten()
tdp.not_terminals = tdp.not_terminals.flatten()
trainer.train(tdp, evaluator)
self.assertLess(evaluator.mc_loss[-1], 0.15)
def preprocess_samples(
self,
states: List[Dict[str, float]],
actions: List[Dict[str, float]],
rewards: List[float],
next_states: List[Dict[str, float]],
next_actions: List[Dict[str, float]],
is_terminals: List[bool],
possible_next_actions: List[List[Dict[str, float]]],
reward_timelines: List[Dict[int, float]],
) -> TrainingDataPage:
tdp = GridworldContinuous.preprocess_samples(
self, states, actions, rewards, next_states, next_actions,
is_terminals, possible_next_actions, reward_timelines)
tdp.states = np.where(tdp.states == 1.0)[1].reshape(-1, 1).astype(
np.float32)
tdp.next_states = np.where(tdp.next_states == 1.0)[1].reshape(
-1, 1).astype(np.float32)
return tdp
def test_trainer_maxq(self):
environment = GridworldContinuous()
rl_parameters = self.get_sarsa_parameters()
new_rl_parameters = ContinuousActionModelParameters(
rl=RLParameters(
gamma=DISCOUNT,
target_update_rate=0.5,
reward_burnin=10,
maxq_learning=True,
),
training=rl_parameters.training,
knn=rl_parameters.knn)
maxq_trainer = ContinuousActionDQNTrainer(
new_rl_parameters,
environment.normalization,
environment.normalization_action,
)
states, actions, rewards, next_states, next_actions, is_terminal,\
possible_next_actions, reward_timelines = \
environment.generate_samples(100000, 1.0)
predictor = maxq_trainer.predictor()
tdps = environment.preprocess_samples(
states,
actions,
rewards,
next_states,
next_actions,
is_terminal,
possible_next_actions,
reward_timelines,
self.minibatch_size,
)
evaluator = GridworldContinuousEvaluator(environment, True)
self.assertGreater(evaluator.evaluate(predictor), 0.4)
for _ in range(2):
for tdp in tdps:
maxq_trainer.stream_tdp(tdp)
evaluator.evaluate(predictor)
self.assertLess(evaluator.evaluate(predictor), 0.1)
def test_evaluator_timeline(self):
environment = GridworldContinuous()
states, actions, rewards, next_states, next_actions, is_terminal,\
possible_next_actions, reward_timelines = \
environment.generate_samples(100000, 1.0)
trainer = self.get_sarsa_trainer(environment)
evaluator = Evaluator(trainer, DISCOUNT)
tdps = environment.preprocess_samples(
states,
actions,
rewards,
next_states,
next_actions,
is_terminal,
possible_next_actions,
reward_timelines,
self.minibatch_size,
)
for tdp in tdps:
trainer.train_numpy(tdp, evaluator)
self.assertLess(evaluator.td_loss[-1], 0.2)
self.assertLess(evaluator.mc_loss[-1], 0.2)