Proximal Policy Optimization (PPO) Agent

Proximal policy optimization (PPO) is an on-policy, policy gradient reinforcement learning method for environments with a discrete, continuous or hybrid action space. It directly estimates a stochastic policy and uses a value function critic to estimate the value of the policy. This algorithm 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 continuous action spaces and with custom networks, this agent does not automatically enforce the constraints set by the action specification. In this case, you must enforce action space constraints within the environment. The default agent for continuous action spaces automatically enforces constraints on the action.

PPO is a simplified version of TRPO. Specifically, PPO has less hyperparameters and therefore is easier to tune, and less computationally expensive than TRPO. For more information on TRPO agents, see Trust Region Policy Optimization (TRPO) Agent. For more information on the different types of reinforcement learning agents, see Reinforcement Learning Agents.

In Reinforcement Learning Toolbox™, a proximal policy optimization agent is implemented by an rlPPOAgent object.

Proximal policy optimization agents can be trained in environments with the following observation and action spaces.

Observation Space	Action Space
Discrete, continuous, or hybrid.	Discrete, continuous, or hybrid.

Proximal policy optimization agents use the following actor and critics. In the most general case, for hybrid action spaces, the action A has a discrete part A^d and a continuous part A^c.

Critic	Actor
Value function critic V(S), which you create using rlValueFunction	Stochastic policy actor π(A|S), which you create using rlDiscreteCategoricalActor (for discrete action spaces), rlContinuousGaussianActor (for continuous action spaces) or rlHybridStochasticActor for hybrid action spaces

During training, a Proximal policy optimization 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.

If the UseExplorationPolicy option of the agent is set to false the action with maximum likelihood is always used in sim and generatePolicyFunction. As a result, the simulated agent and generated policy behave deterministically.

If the UseExplorationPolicy is set to true the agent selects its actions by sampling its probability distribution. As a result the policy is stochastic and the agent explores its observation space.

Note

The UseExplorationPolicy option affects only simulation and deployment; it does not affect training. When you train an agent using train, the agent always uses its exploration policy independently of the value of this property.

Actor and Critic Used by the PPO Agent

To estimate the policy and value function, a proximal policy optimization agent maintains two function approximators.

• Stochastic actor π(A|S;θ) — The actor, with parameters θ, outputs the conditional probability of taking each action A when in state S as one of the following:

  • Discrete action space — A vector containing the probability of taking each discrete action. The sum of these probabilities across all actions is 1.

  • Continuous action space — Two vectors containing the means and standard deviations, respectively, of the Gaussian distribution for each continuous action.

  • Hybrid action space — A vector of probabilities for each discrete action, and two vectors representing mean and standard deviation for each continuous action.

  The agent samples these probability distributions to obtain the action vector.

• Critic V(S;ϕ) — The critic, with parameters ϕ, takes observation S and returns the corresponding expectation of the discounted long-term reward.

During training, the actor tunes the parameter values in θ to improve the policy. Similarly, during training, the critic tunes the parameter values in ϕ to improve its value function estimation. After training, the parameters remain at their tuned values in the actor and critic internal to the trained agent.

For more information on actors and critics, see Create Actors, Critics, and Policy Objects.

PPO Agent Creation

You can create and train proximal policy optimization agents at the MATLAB^® command line or using the Reinforcement Learning Designer app. For more information on creating agents using Reinforcement Learning Designer, see Create Agents Using Reinforcement Learning Designer.

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

1. Create observation specifications for your environment. If you already have an environment object, you can obtain these specifications using getObservationInfo.

2. Create action specifications for your environment. If you already have an environment object, you can obtain these specifications using getActionInfo.

3. If needed, specify the number of neurons in each learnable layer of the default network or whether to use an LSTM layer. To do so, create an agent initialization option object using rlAgentInitializationOptions.

4. Specify agent options using an rlPPOAgentOptions object. Alternatively, you can skip this step and modify the agent options later using dot notation.

5. Create the agent using rlPPOAgent.

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

1. Create observation specifications for your environment. If you already have an environment object, you can obtain these specifications using getObservationInfo.

2. Create action specifications for your environment. If you already have an environment object, you can obtain these specifications using getActionInfo.

3. Create an approximation model for your actor. For continuous action spaces, this model must be a neural network object. For discrete action spaces, you also have the option of using a custom basis function with initial parameter values.

4. Create a stochastic actor using rlContinuousGaussianActor (for continuous action spaces), rlDiscreteCategoricalActor (for discrete action spaces), or rlHybridStochasticActor (for hybrid action spaces). Use the model you created in the previous step as a first input argument.

5. Create an approximation model for your critic using either a custom basis function with initial parameter values or a neural network object.

6. Create a critic using rlValueFunction. Use the model you created in the previous step as a first input argument.

7. If needed, specify agent options using an rlPPOAgentOptions object. Alternatively, you can skip this step and modify the agent options later using dot notation.

8. Create the agent using rlPPOAgent.

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

For more information on creating actors and critics for function approximation, see Create Actors, Critics, and Policy Objects.

PPO Agent Initialization

When you create a PPO agent, the actor and critic initialize as follows.

• The actor π(A|S;θ) uses random parameter values in θ.

• The critic V(S;ϕ) uses parameter values in ϕ.

The agent uses this initial actor and critic parameters at the beginning of the first training session. For each subsequent training session, the actor and critic retain the parameters from the previous session.

PPO Training Algorithm

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

1. Generate E experiences (possibly running multiple episodes) by following the current policy. Specifically:

   1. At the beginning of each episode, get the initial observation from the environment.

   2. For the current observation S, select the action A using the policy in π(A|S;θ).

   3. Execute action A. Observe the reward R and the next observation S'.

   4. Store the experience (S,A,R,S').

   To specify E use the LearningFrequency option.

2. Divide the E experiences into sequences each having N experiences, numbered from t_s to t_s+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.

3. For each step t = ts, ts+1, …, ts+N-1, of each sequence, 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={\displaystyle \sum _{k=t+1}^{ts+N}\left({\gamma }^{k-t-1}{R}_k\right)}+b{\gamma }^{ts+N-t}V\left(S_{ts+N};\varphi \right)$$

     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 approximator V.

     Compute the advantage function D_t.

     $$D_t=G_t-V\left(S_t;\varphi \right)$$

   • Generalized Advantage Estimator (AdvantageEstimateMethod = "gae") — Compute the advantage function D_t, which is the discounted sum of temporal difference errors [3].

     $$\begin{array}{c}{D}_t={\displaystyle \sum _{k=t}^{ts+N-1}{\left(\gamma \lambda \right)}^{k-t}{\delta }_k}\\ {\delta }_k=R_{k+1}+b\gamma V\left(S_{k+1};\varphi \right)-V\left(S_k;\varphi \right)\end{array}$$

     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\left(S_t;\varphi \right)$$

   To specify the discount factor γ for either method, use the DiscountFactor option.

4. Perform the following two operations for NumEpoch times:

   1. Using all the collected experiences, create a maximum of B different mini-batches. To specify B, use the MaxMiniBatchPerEpoch option. Each mini-batch contains M different (typically nonconsecutive) experiences (S_i,A_i,R_i,S'_i) that are randomly sampled from the experience buffer (each experience can only be part of one mini-batch). To specify M, use the MiniBatchSize option.

      If the agent contains recurrent neural networks, each mini-batch contains M different sequences. Each sequence contains K consecutive experiences (starting from a randomly sampled experience). To specify K, use the SequenceLength option.

   2. For each (randomly selected) mini-batch, perform the learning operations described in Mini-Batch Learning Operations.

Mini-Batch Learning Operations

Operations performed for each mini-batch.

1. Update the critic parameters by minimizing the loss L_critic across all sampled mini-batch data.

   $$L_{critic}\left(\varphi \right)=\frac{1}{2M}{\displaystyle \sum _{i=1}^M{\left(G_i-V\left(S_i;\varphi \right)\right)}^2}$$

2. Normalize the advantage values D_i based on recent unnormalized advantage values.

   • If the NormalizedAdvantageMethod option is "none", do not normalize the advantage values.

     $${\widehat{D}}_i\leftarrow D_i$$

   • If the NormalizedAdvantageMethod option is "current", normalize the advantage values based on the unnormalized advantages in the current mini-batch.

     $${\widehat{D}}_i\leftarrow \frac{D_i-mean\left(D_1,D_2,\dots ,D_M\right)}{std\left(D_1,D_2,\dots ,D_M\right)}$$

   • If the NormalizedAdvantageMethod option is "moving", normalize the advantage values based on the unnormalized advantages for the N most recent advantages, including the current advantage value. To specify the window size N, use the AdvantageNormalizingWindow option.

     $${\widehat{D}}_i\leftarrow \frac{D_i-mean\left(D_1,D_2,\dots ,D_N\right)}{std\left(D_1,D_2,\dots ,D_N\right)}$$

3. Update the actor parameters by minimizing the actor loss function L_actor across all sampled mini-batch data.

   $$\begin{array}{c}{L}_{actor}\left(\theta \right)=\frac{1}{M}{\displaystyle \sum _{i=1}^M\left(-\min \left(r_i\left(\theta \right)\cdot {\widehat{D}}_i,c_i\left(\theta \right)\cdot {\widehat{D}}_i\right)-w{\mathscr{H}}_i\left(\theta ,S_i\right)\right)}\\ r_i\left(\theta \right)=\frac{\pi \left(A_i|S_i;\theta \right)}{\pi \left(A_i|S_i;{\theta }_{old}\right)}\\ c_i\left(\theta \right)=\max \left(\min \left(r_i\left(\theta \right),1+\epsilon \right),1-\epsilon \right)\end{array}$$

   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 entropy loss and w is the entropy loss weight factor, specified using the EntropyLossWeight option. For more information on entropy loss, see Entropy Loss.

   • π(A_i|S_i;θ) indicates one of the following quantities:

     • For a discrete action space — The probability of taking the discrete action A_i, given observation S_i, and parameters θ.

     • For a continuous action space — The value of the joint probability density function of the action, calculated for the action vector A_i and the observation S_i, given parameters θ:

       $$\pi \left(A_i|S;\theta \right)={\displaystyle \prod _{j=1}^N{f}_j}\left(A_{j,i}|S_i;\theta \right)$$

       Here, f_j is the probability density function for the dimension j of the action vector, and A_i,j is the jth element of A_i, which has dimension N.

     • For a Hybrid action space — The value of the joint probability density function of both the discrete and continuous actions, calculated for the action vector A_i and the observation S_i, given parameters θ:

       $$\pi \left(A_i|S_i;\theta \right)=p(A_i^d|S_i;\theta ){\displaystyle \prod _{j=1}^{N_C}{f}_{j,i}}\left(A_{j,i}^c|S_i;\theta \right)$$

       Here, p(A^d_i| S_i;θ) is the probability of taking the discrete action A^d_i, given observation S_i and parameters θ, f_j,i is the probability density function for the dimension j of the continuous part of the action vector A^c_i, and A^c_j,i is the jth element of A^c_i, which has dimension N_C.

   • π(A_i|S_i;θ_old) is the same as π(A_i|S_i;θ_old), except that the previous policy parameters θ_old from before the current learning epoch are used instead of the current parameters θ.

   • ε is the clip factor specified using the ClipFactor option.

Entropy Loss

To promote agent exploration, you can subtract an entropy loss term wℋ_i(θ,S_i) from the actor loss function, where w is the entropy loss weight and ℋ_i(θ,S_i) is the entropy.

The entropy value is higher when the agent is more uncertain about which action to take next. Therefore, maximizing the entropy loss term (minimizing the negative entropy loss) increases the agent uncertainty, thus encouraging exploration. To promote additional exploration, which can help the agent move out of local optima, you can specify a larger entropy loss weight. For more information on entropy weights, see the EntropyLossWeight property in rlPPOAgentOptions.

For a discrete action space, the agent uses the following entropy value. In this case, the actor outputs the probability of taking each possible discrete action.

$${\mathscr{H}}_i\left(\theta ,S_i\right)={\mathscr{H}}_i^d\left(\theta ,S_i\right)=-{\displaystyle \sum _{k=1}^P\pi \left(A_k|S_i;\theta \right)\ln \pi \left(A_k|S_i;\theta \right)}$$

Here:

• P is the number of possible discrete actions.

• π(A_k|S_i;θ) is the probability of taking action A_k when in state S_i following the current policy.

For a continuous action space, the agent uses the following entropy value. In this case, the actor outputs the mean and standard deviation of the Gaussian distribution for each continuous action.

$${\mathscr{H}}_i\left(\theta ,S_i\right)={\mathscr{H}}_i^c\left(\theta ,S_i\right)=\frac{1}{2}{\displaystyle \sum _{k=1}^{N_C}\ln \left(2\pi \cdot e\cdot {\sigma }_{k,i}^2\right)}$$

Here:

• N_C is the dimension of the continuous part of the action vector.

• σ_k,i is the standard deviation for action k when in state S_i following the current policy.

For an hybrid action space, the entropy is a two-element column vector containing both the discrete and a continuous entropy values, respectively.

$${\mathscr{H}}_i\left(\theta ,S_i\right)=\left[\begin{array}{c}{\mathscr{H}}_i^d\left(\theta ,S_i\right)\\ {\mathscr{H}}_i^c\left(\theta ,S_i\right)\end{array}\right]$$

In this case, the entropy weight is a row vector containing weights for the discrete and continuous entropy values, respectively.

References

[1] Schulman, John, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. “Proximal Policy Optimization Algorithms.” arXiv, August 28, 2017. https://doi.org/10.48550/arXiv.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, June 16, 2016. https://doi.org/10.48550/arXiv.1602.01783.

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