c2c9dddf6d99bfa14b8ffb65b507a6be50b0ad6e,tensorforce/models/model.py,Model,create_observe_operations,#Model#Any#Any#,945

Before Change

    def create_observe_operations(self, terminal, reward):
        // Observation
        batched_size = tf.shape(input=terminal)[0]
        observation = self.fn_observe_timestep(
            states={name: tf.stop_gradient(input=state[:batched_size]) for name, state in self.current_states.items()},
            internals={name: tf.stop_gradient(input=internal[:batched_size]) for name, internal in self.current_internals.items()},
            actions={name: tf.stop_gradient(input=action[:batched_size]) for name, action in self.current_actions.items()},

After Change

        increment_episode = tf.assign_add(ref=self.episode, value=num_episodes)
        increment_global_episode = tf.assign_add(ref=self.global_episode, value=num_episodes)

        with tf.control_dependencies(control_inputs=(increment_episode, increment_global_episode)):
            // Stop gradients
            fn = (lambda x: tf.stop_gradient(input=x[:self.buffer_index]))
            states = util.map_tensors(fn=fn, tensors=self.states_buffer)
            internals = util.map_tensors(fn=fn, tensors=self.internals_buffer)
            actions = util.map_tensors(fn=fn, tensors=self.actions_buffer)
            terminal = tf.stop_gradient(input=terminal)
            reward = tf.stop_gradient(input=reward)

            // Observation
            observation = self.fn_observe_timestep(
                states=states,
                internals=internals,
                actions=actions,
                terminal=terminal,
                reward=reward
            )

        with tf.control_dependencies(control_inputs=(observation,)):
            // Reset index
            reset_index = tf.assign(ref=self.buffer_index, value=0)

Instances