def test_reward_decreases_vail(demo_to_buffer: Any, use_actions: bool, behavior_spec: BehaviorSpec, seed: int) -> None: np.random.seed(seed) torch.manual_seed(seed) buffer_expert = create_agent_buffer(behavior_spec, 1000) buffer_policy = create_agent_buffer(behavior_spec, 1000) demo_to_buffer.return_value = None, buffer_expert gail_settings = GAILSettings(demo_path="", learning_rate=0.005, use_vail=True, use_actions=use_actions) DiscriminatorNetwork.initial_beta = 0.0 # we must set the initial value of beta to 0 for testing # If we do not, the kl-loss will dominate early and will block the estimator gail_rp = create_reward_provider(RewardSignalType.GAIL, behavior_spec, gail_settings) for _ in range(300): gail_rp.update(buffer_policy) reward_expert = gail_rp.evaluate(buffer_expert)[0] reward_policy = gail_rp.evaluate(buffer_policy)[0] assert reward_expert >= 0 # GAIL / VAIL reward always positive assert reward_policy >= 0 reward_expert = gail_rp.evaluate(buffer_expert)[0] reward_policy = gail_rp.evaluate(buffer_policy)[0] assert reward_expert > reward_policy # Expert reward greater than non-expert reward
def test_reward_decreases(demo_to_buffer: Any, use_actions: bool, behavior_spec: BehaviorSpec, seed: int) -> None: np.random.seed(seed) torch.manual_seed(seed) buffer_expert = create_agent_buffer(behavior_spec, 1000) buffer_policy = create_agent_buffer(behavior_spec, 1000) demo_to_buffer.return_value = None, buffer_expert gail_settings = GAILSettings(demo_path="", learning_rate=0.005, use_vail=False, use_actions=use_actions) gail_rp = create_reward_provider(RewardSignalType.GAIL, behavior_spec, gail_settings) init_reward_expert = gail_rp.evaluate(buffer_expert)[0] init_reward_policy = gail_rp.evaluate(buffer_policy)[0] for _ in range(10): gail_rp.update(buffer_policy) reward_expert = gail_rp.evaluate(buffer_expert)[0] reward_policy = gail_rp.evaluate(buffer_policy)[0] assert reward_expert >= 0 # GAIL / VAIL reward always positive assert reward_policy >= 0 reward_expert = gail_rp.evaluate(buffer_expert)[0] reward_policy = gail_rp.evaluate(buffer_policy)[0] assert reward_expert > reward_policy # Expert reward greater than non-expert reward assert (reward_expert > init_reward_expert ) # Expert reward getting better as network trains assert (reward_policy < init_reward_policy ) # Non-expert reward getting worse as network trains
def test_reward_provider_save(tmp_path, optimizer): OptimizerClass, HyperparametersClass = optimizer trainer_settings = TrainerSettings() trainer_settings.hyperparameters = HyperparametersClass() trainer_settings.reward_signals = { RewardSignalType.CURIOSITY: CuriositySettings(), RewardSignalType.GAIL: GAILSettings(demo_path=DEMO_PATH), RewardSignalType.RND: RNDSettings(), } policy = create_policy_mock(trainer_settings, use_discrete=False) optimizer = OptimizerClass(policy, trainer_settings) # save at path 1 path1 = os.path.join(tmp_path, "runid1") model_saver = TorchModelSaver(trainer_settings, path1) model_saver.register(policy) model_saver.register(optimizer) model_saver.initialize_or_load() policy.set_step(2000) model_saver.save_checkpoint("MockBrain", 2000) # create a new optimizer and policy optimizer2 = OptimizerClass(policy, trainer_settings) policy2 = create_policy_mock(trainer_settings, use_discrete=False) # load weights model_saver2 = TorchModelSaver(trainer_settings, path1, load=True) model_saver2.register(policy2) model_saver2.register(optimizer2) model_saver2.initialize_or_load() # This is to load the optimizers # assert the models have the same weights module_dict_1 = optimizer.get_modules() module_dict_2 = optimizer2.get_modules() assert "Module:GAIL" in module_dict_1 assert "Module:GAIL" in module_dict_2 assert "Module:Curiosity" in module_dict_1 assert "Module:Curiosity" in module_dict_2 assert "Module:RND-pred" in module_dict_1 assert "Module:RND-pred" in module_dict_2 assert "Module:RND-target" in module_dict_1 assert "Module:RND-target" in module_dict_2 for name, module1 in module_dict_1.items(): assert name in module_dict_2 module2 = module_dict_2[name] if hasattr(module1, "parameters"): for param1, param2 in zip(module1.parameters(), module2.parameters()): assert param1.data.ne(param2.data).sum() == 0 # Run some rewards data = create_agent_buffer(policy.behavior_spec, 1) for reward_name in optimizer.reward_signals.keys(): rp_1 = optimizer.reward_signals[reward_name] rp_2 = optimizer2.reward_signals[reward_name] assert np.array_equal(rp_1.evaluate(data), rp_2.evaluate(data))
def test_reward_decreases(behavior_spec: BehaviorSpec, seed: int) -> None: np.random.seed(seed) torch.manual_seed(seed) rnd_settings = RNDSettings(32, 0.01) rnd_rp = RNDRewardProvider(behavior_spec, rnd_settings) buffer = create_agent_buffer(behavior_spec, 5) rnd_rp.update(buffer) reward_old = rnd_rp.evaluate(buffer)[0] for _ in range(100): rnd_rp.update(buffer) reward_new = rnd_rp.evaluate(buffer)[0] assert reward_new < reward_old
def test_continuous_action_prediction(behavior_spec: BehaviorSpec, seed: int) -> None: np.random.seed(seed) torch.manual_seed(seed) curiosity_settings = CuriositySettings(32, 0.1) curiosity_rp = CuriosityRewardProvider(behavior_spec, curiosity_settings) buffer = create_agent_buffer(behavior_spec, 5) for _ in range(200): curiosity_rp.update(buffer) prediction = curiosity_rp._network.predict_action(buffer)[0] target = torch.tensor(buffer["actions"][0]) error = torch.mean((prediction - target) ** 2).item() assert error < 0.001
def test_next_state_prediction(behavior_spec: BehaviorSpec, seed: int) -> None: np.random.seed(seed) torch.manual_seed(seed) curiosity_settings = CuriositySettings(32, 0.1) curiosity_rp = CuriosityRewardProvider(behavior_spec, curiosity_settings) buffer = create_agent_buffer(behavior_spec, 5) for _ in range(100): curiosity_rp.update(buffer) prediction = curiosity_rp._network.predict_next_state(buffer)[0] target = curiosity_rp._network.get_next_state(buffer)[0] error = float(ModelUtils.to_numpy(torch.mean((prediction - target) ** 2))) assert error < 0.001
def test_reward_decreases(behavior_spec: BehaviorSpec, seed: int) -> None: np.random.seed(seed) torch.manual_seed(seed) curiosity_settings = CuriositySettings(32, 0.01) curiosity_rp = CuriosityRewardProvider(behavior_spec, curiosity_settings) buffer = create_agent_buffer(behavior_spec, 5) curiosity_rp.update(buffer) reward_old = curiosity_rp.evaluate(buffer)[0] for _ in range(20): curiosity_rp.update(buffer) reward_new = curiosity_rp.evaluate(buffer)[0] assert reward_new < reward_old
def test_reward(behavior_spec: BehaviorSpec, reward: float) -> None: buffer = create_agent_buffer(behavior_spec, 1000, reward) settings = RewardSignalSettings() extrinsic_rp = ExtrinsicRewardProvider(behavior_spec, settings) generated_rewards = extrinsic_rp.evaluate(buffer) assert (generated_rewards == reward).all() # Test group rewards. Rewards should be double of the environment rewards, but shouldn't count # the groupmate rewards. buffer[BufferKey.GROUP_REWARD] = buffer[BufferKey.ENVIRONMENT_REWARDS] # 2 agents with identical rewards buffer[BufferKey.GROUPMATE_REWARDS].set( [np.ones(1, dtype=np.float32) * reward] * 2 for _ in range(buffer.num_experiences)) generated_rewards = extrinsic_rp.evaluate(buffer) assert (generated_rewards == 2 * reward).all() # Test groupmate rewards. Total reward should be indiv_reward + 2 * teammate_reward + group_reward extrinsic_rp = ExtrinsicRewardProvider(behavior_spec, settings) extrinsic_rp.add_groupmate_rewards = True generated_rewards = extrinsic_rp.evaluate(buffer) assert (generated_rewards == 4 * reward).all()
def test_reward(behavior_spec: BehaviorSpec, reward: float) -> None: buffer = create_agent_buffer(behavior_spec, 1000, reward) settings = RewardSignalSettings() extrinsic_rp = ExtrinsicRewardProvider(behavior_spec, settings) generated_rewards = extrinsic_rp.evaluate(buffer) assert (generated_rewards == reward).all()