text stringlengths 0 4.99k |
|---|
import time |
Functions and class |
def discounted_cumulative_sums(x, discount): |
# Discounted cumulative sums of vectors for computing rewards-to-go and advantage estimates |
return scipy.signal.lfilter([1], [1, float(-discount)], x[::-1], axis=0)[::-1] |
class Buffer: |
# Buffer for storing trajectories |
def __init__(self, observation_dimensions, size, gamma=0.99, lam=0.95): |
# Buffer initialization |
self.observation_buffer = np.zeros( |
(size, observation_dimensions), dtype=np.float32 |
) |
self.action_buffer = np.zeros(size, dtype=np.int32) |
self.advantage_buffer = np.zeros(size, dtype=np.float32) |
self.reward_buffer = np.zeros(size, dtype=np.float32) |
self.return_buffer = np.zeros(size, dtype=np.float32) |
self.value_buffer = np.zeros(size, dtype=np.float32) |
self.logprobability_buffer = np.zeros(size, dtype=np.float32) |
self.gamma, self.lam = gamma, lam |
self.pointer, self.trajectory_start_index = 0, 0 |
def store(self, observation, action, reward, value, logprobability): |
# Append one step of agent-environment interaction |
self.observation_buffer[self.pointer] = observation |
self.action_buffer[self.pointer] = action |
self.reward_buffer[self.pointer] = reward |
self.value_buffer[self.pointer] = value |
self.logprobability_buffer[self.pointer] = logprobability |
self.pointer += 1 |
def finish_trajectory(self, last_value=0): |
# Finish the trajectory by computing advantage estimates and rewards-to-go |
path_slice = slice(self.trajectory_start_index, self.pointer) |
rewards = np.append(self.reward_buffer[path_slice], last_value) |
values = np.append(self.value_buffer[path_slice], last_value) |
deltas = rewards[:-1] + self.gamma * values[1:] - values[:-1] |
self.advantage_buffer[path_slice] = discounted_cumulative_sums( |
deltas, self.gamma * self.lam |
) |
self.return_buffer[path_slice] = discounted_cumulative_sums( |
rewards, self.gamma |
)[:-1] |
self.trajectory_start_index = self.pointer |
def get(self): |
# Get all data of the buffer and normalize the advantages |
self.pointer, self.trajectory_start_index = 0, 0 |
advantage_mean, advantage_std = ( |
np.mean(self.advantage_buffer), |
np.std(self.advantage_buffer), |
) |
self.advantage_buffer = (self.advantage_buffer - advantage_mean) / advantage_std |
return ( |
self.observation_buffer, |
self.action_buffer, |
self.advantage_buffer, |
self.return_buffer, |
self.logprobability_buffer, |
) |
def mlp(x, sizes, activation=tf.tanh, output_activation=None): |
# Build a feedforward neural network |
for size in sizes[:-1]: |
x = layers.Dense(units=size, activation=activation)(x) |
return layers.Dense(units=sizes[-1], activation=output_activation)(x) |
def logprobabilities(logits, a): |
# Compute the log-probabilities of taking actions a by using the logits (i.e. the output of the actor) |
logprobabilities_all = tf.nn.log_softmax(logits) |
logprobability = tf.reduce_sum( |
tf.one_hot(a, num_actions) * logprobabilities_all, axis=1 |
) |
return logprobability |
# Sample action from actor |
@tf.function |
def sample_action(observation): |
logits = actor(observation) |
action = tf.squeeze(tf.random.categorical(logits, 1), axis=1) |
return logits, action |
# Train the policy by maxizing the PPO-Clip objective |
@tf.function |
def train_policy( |
observation_buffer, action_buffer, logprobability_buffer, advantage_buffer |
): |
with tf.GradientTape() as tape: # Record operations for automatic differentiation. |
ratio = tf.exp( |
logprobabilities(actor(observation_buffer), action_buffer) |
- logprobability_buffer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.