Proximal Policy Optimization Agents

Proximal policy optimization (PPO) is a model-free, online, on-policy, policy gradient reinforcement learning method. This algorithm is a type of policy gradient training that alternates between sampling data through environmental interaction and optimizing a clipped surrogate objective function using stochastic gradient descent. The clipped surrogate objective function improves training stability by limiting the size of the policy change at each step [1].

For more information on the different types of reinforcement learning agents, see Reinforcement Learning Agents.

PPO agents can be trained in environments with the following observation and action spaces.

Observation Space	Action Space
Discrete or continuous	Discrete or continuous

During training, a PPO agent:

Estimates probabilities of taking each action in the action space and randomly selects actions based on the probability distribution.
Interacts with the environment for multiple steps using the current policy before using mini-batches to update the actor and critic properties over multiple epochs.

Actor and Critic Functions

To estimate the policy and value function, a PPO agent maintains two function approximators:

Actor μ(S) — The actor takes observation S and returns the probabilities of taking each action in the action space when in state S.
Critic V(S) — The critic takes observation S and returns the corresponding expectation of the discounted long-term reward.

When training is complete, the trained optimal policy is stored in actor μ(S).

For more information on creating actors and critics for function approximation, see Create Policy and Value Function Representations.

Agent Creation

You can create a PPO agent with default actor and critic representations based on the observation and action specifications from the environment. To do so, perform the following steps.

Create observation specifications for your environment. If you already have an environment interface object, you can obtain these specifications using getObservationInfo.
Create action specifications for your environment. If you already have an environment interface object, you can obtain these specifications using getActionInfo.
Specify agent options using an rlPPOAgentOptions object.
Create the agent using an rlPPOAgent object.

Alternatively, you can create actor and critic representations and use these representations to create your agent. In this case, ensure that the input and output dimensions of the actor and critic representations match the corresponding action and observation specifications of the environment.

Create an actor using an rlStochasticActorRepresentation object.
Create a critic using an rlValueRepresentation object.
If needed, specify the number of neurons in each learnable layer or whether to use an LSTM layer. To do so, create an agent initialization option object using rlAgentInitializationOptions.
If needed, specify agent options using an rlPPOAgentOptions object.
Create the agent using the rlPPOAgent function.

PPO agents support actors and critics that use recurrent deep neural networks as functions approximators.

For more information on creating actors and critics for function approximation, see Create Policy and Value Function Representations.

Training Algorithm

PPO agents use the following training algorithm. To configure the training algorithm, specify options using an rlPPOAgentOptions object.

Initialize the actor μ(S) with random parameter values θ_μ.
Initialize the critic V(S) with random parameter values θ_V.
Generate N experiences by following the current policy. The experience sequence is
$S_{t s}, A_{t s}, R_{t s + 1}, S_{t s + 1}, \dots, S_{t s + N - 1}, A_{t s + N - 1}, R_{t s + N}, S_{t s + N}$
Here, S_t is a state observation, A_t is an action taken from that state, S_t+1 is the next state, and R_t+1 is the reward received for moving from S_t to S_t+1.
When in state S_t, the agent computes the probability of taking each action in the action space using μ(S_t) and randomly selects action A_t based on the probability distribution.
ts is the starting time step of the current set of N experiences. At the beginning of the training episode, ts = 1. For each subsequent set of N experiences in the same training episode, ts ← ts + N.
For each experience sequence that does not contain a terminal state, N is equal to the ExperienceHorizon option value. Otherwise, N is less than ExperienceHorizon and S_N is the terminal state.
For each episode step t = ts+1, ts+2, …, ts+N, compute the return and advantage function using the method specified by the AdvantageEstimateMethod option.
- Finite Horizon (AdvantageEstimateMethod = "finite-horizon") — Compute the return G_t, which is the sum of the reward for that step and the discounted future reward [2].
  $G_{t} = \sum_{k = t}^{t s + N} (γ^{k - t} R_{k}) + b γ^{N - t + 1} V (S_{t s + N} | θ_{V})$
  Here, b is 0 if S_ts+N is a terminal state and 1 otherwise. That is, if S_ts+N is not a terminal state, the discounted future reward includes the discounted state value function, computed using the critic network V.
  Compute the advantage function D_t.
  $D_{t} = G_{t} - V (S_{t} | θ_{V})$
- Generalized Advantage Estimator (AdvantageEstimateMethod = "gae") — Compute the advantage function D_t, which is the discounted sum of temporal difference errors [3].
  $\begin{matrix} D_{t} = \sum_{k = t}^{t s + N - 1} {(γ λ)}^{k - t} δ_{k} \\ δ_{k} = R_{t} + b γ V (S_{t} | θ_{V}) \end{matrix}$
  Here, b is 0 if S_ts+N is a terminal state and 1 otherwise. λ is a smoothing factor specified using the GAEFactor option.
  Compute the return G_t.
  $G_{t} = D_{t} - V (S_{t} | θ_{V})$
To specify the discount factor γ for either method, use the DiscountFactor option.
Learn from mini-batches of experiences over K epochs. To specify K, use the NumEpoch option. For each learning epoch:
1. Sample a random mini-batch data set of size M from the current set of experiences. To specify M, use the MiniBatchSize option. Each element of the mini-batch data set contains a current experience and the corresponding return and advantage function values.
2. Update the critic parameters by minimizing the loss L_critic across all sampled mini-batch data.
  $L_{c r i t i c} (θ_{V}) = \frac{1}{M} \sum_{i = 1}^{M} {(G_{i} - V (S_{i} | θ_{V}))}^{2}$
3. Update the actor parameters by minimizing the loss L_actor across all sampled mini-batch data. If the EntropyLossWeight option is greater than zero, then additional entropy loss is added to L_actor, which encourages policy exploration.
  $\begin{matrix} L_{a c t o r} (θ_{μ}) = - \frac{1}{M} \sum_{i = 1}^{M} \min (r_{i} (θ_{μ}) * D_{i}, c_{i} (θ_{μ}) * D_{i}) \\ r_{i} (θ_{μ}) = \frac{μ_{A i} (S_{i} | θ_{μ})}{μ_{A i} (S_{i} | θ_{μ, o l d})} \\ c_{i} (θ_{μ}) = \max (\min (r_{i} (θ_{μ}), 1 + ε), 1 - ε) \end{matrix}$
  Here:
  - D_i and G_i are the advantage function and return value for the ith element of the mini-batch, respectively.
  - μ_i(S_i|θ_μ) is the probability of taking action A_i when in state S_i, given the updated policy parameters θ_μ.
  - μ_i(S_i|θ_μ,old) is the probability of taking action A_i when in state S_i, given the previous policy parameters (θ_μ,old) from before the current learning epoch.
  - ε is the clip factor specified using the ClipFactor option.
Repeat steps 3 through 5 until the training episode reaches a terminal state.

References

[1] Schulman, John, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. “Proximal Policy Optimization Algorithms.” ArXiv:1707.06347 [Cs], July 19, 2017. https://arxiv.org/abs/1707.06347.

[2] Mnih, Volodymyr, Adrià Puigdomènech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. “Asynchronous Methods for Deep Reinforcement Learning.” ArXiv:1602.01783 [Cs], February 4, 2016. https://arxiv.org/abs/1602.01783.

[3] Schulman, John, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. “High-Dimensional Continuous Control Using Generalized Advantage Estimation.” ArXiv:1506.02438 [Cs], October 20, 2018. https://arxiv.org/abs/1506.02438.

Documentation