Trust Region Policy Optimization (TRPO) Agent

Trust region policy optimization (TRPO) is an on-policy, policy gradient reinforcement learning method for environments with a discrete or continuous action space. It directly estimates a stochastic policy and uses a value function critic to estimate the value of the policy. The KL-divergence between the old policy and the new policy is used as a constraint during optimization. As a result, this algorithm prevents significant performance drops compared to standard policy gradient methods by keeping the updated policy within a trust region close to the current policy [1]. For continuous action spaces, this agent does not enforce constraints set in the action specification; therefore, if you need to enforce action constraints, you must do so within the environment.

In Reinforcement Learning Toolbox™, a TRPO agent is implemented by an rlPPOAgent object.

Note

For TRPO agents, you can only use actors or critics with deep network that support calculating higher order derivatives. Actors and critics that use recurrent networks, custom basis functions, or tables are not supported.

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 PPO agents, see Proximal Policy Optimization (PPO) Agent. For more information on the different types of reinforcement learning agents, see Reinforcement Learning Agents.

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

Observation Space	Action Space
Discrete or continuous	Discrete or continuous

TRPO agents use the following actor and critic.

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

During training, a TRPO 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.

This option affects only simulation and deployment; it does not affect training.

Actor and Critic Function Approximators

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

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 — The probability of taking each discrete action. The sum of these probabilities across all actions is 1.
- Continuous action space — The mean and standard deviation of the Gaussian probability distribution for each continuous action.
Critic V(S;ϕ) — The critic, with parameters ϕ, takes observation S and returns the corresponding expectation of the discounted long-term reward.

For more information on creating actors and critics for function approximation, see Create Policies and Value Functions.

During training, the agent tunes the parameter values in θ. After training, the parameters remain at their tuned value and the trained actor function approximator is stored in π(A|S).

Agent Creation

You can create and train TRPO 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 TRPO agent with default actor and critic 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 object, you can obtain these specifications using getObservationInfo.
Create action specifications for your environment. If you already have an environment object, you can obtain these specifications using getActionInfo.
If needed, specify the number of neurons in each learnable layer. To do so, create an agent initialization options object using rlAgentInitializationOptions.
Specify agent options using an rlTRPOAgentOptions object (alternatively, you can skip this step and then modify the agent options later using dot notation).
Create the agent using an rlTRPOAgent object.

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.

Create an actor using rlDiscreteCategoricalActor object (for discrete action spaces) or rlContinuousGaussianActor object (for continuous action spaces).
Create a critic using an rlValueFunction object.
If needed, specify agent options using an rlTRPOAgentOptions object.
Create the agent using the rlTRPOAgent function.

TRPO agents do not support actors and critics that use recurrent deep neural networks as function approximators. TRPO agents also do not support deep neural networks that use a quadraticLayer.

For more information on creating actors and critics for function approximation, see Create Policies and Value Functions.

Trust Region Policy Optimization

Trust region policy optimization finds the actor parameters that minimize the following actor loss function.

$L_{a c t o r} (θ) = - \frac{1}{M} \sum_{i = 1}^{M} (\frac{π (A_{i} | S_{i}; θ)}{π (A_{i} | S_{i}; θ_{o l d})} D_{i} + w ℋ_{i} (θ, S_{i}))$

Here:

M is the mini-batch size.
D_i is an advantage function.
π_i(A_i|S_i;θ) is the probability of taking action A_i following the current policy. This value is a specific value of the probability (discrete action) or of the probability density function (continuous action).
π(A_i|S_i;θ_old) is the probability of taking action A_i following the old policy.
wℋ_i(θ,S_i) is an entropy loss term, where w is the entropy loss weight and ℋ_i(θ,S_i) is the entropy. For more information, see Entropy Loss.

This minimization is subject to the following constraint.

$\frac{1}{M} \sum_{i = 1}^{M} D_{K L} (θ_{o l d}, θ, S_{i}) \leq δ$

Here:

D_KL(θ_old,θ,S_i) is the Kullback-Leibler (KL) divergence between the old policy π(A|S_i;θ_old) and current policy π(A|S_i;θ). D_KL measures how much the probability distributions of the old and new policies differ. D_KL is zero when the two distributions are identical.
δ is the limit for D_KL and controls how much the new policy can deviate from the old policy.

For agents with discrete action spaces, D_KL is computed as follows, where P is the number of actions.

$D_{K L} (θ_{o l d}, θ, S_{i}) = \sum_{k = 1}^{P} π (A_{k} | S_{i}; θ_{o l d}) \ln (\frac{π (A_{k} | S_{i}; θ_{o l d})}{π (A_{k} | S_{i}; θ)})$

For agents with continuous action spaces, D_KL is computed as follows.

$D_{K L} (θ_{o l d}, θ, S_{i}) = \frac{1}{P} \sum_{k = 1}^{P} (\ln (σ_{θ, k}) - \ln (σ_{θ o l d, k}) + \frac{σ_{θ o l d, k}^{2} + {(μ_{θ o l d, k} - μ_{θ, k})}^{2}}{2 σ_{θ, k}^{2}} - 0.5)$

Here:

μ_θ,k and σ_θ,k are the mean and standard deviation for the kth action output by the current actor policy π(A_k|S_i;θ).
μ_θold,k and σ_θold,k are the mean and standard deviation for the kth action output by the old policy π(A_k|S_i;θ_old).

To approximate this optimization problem, the TRPO agent uses a linear approximation of L_actor(θ) and a quadratic approximation of D_KL(θ_old,θ,S_i). The approximations are computed by taking the Taylor series expansion around θ.

$\begin{array}{l} \min_{θ} L_{a c t o r} (θ) \approx {g (θ - θ_{o l d}) = \nabla_{θ} L_{a c t o r} (θ) |}_{θ = θ_{o l d}} \cdot (θ - θ_{o l d}) \\ s u b j e c t t o \frac{1}{2} {(θ_{o l d} - θ)}^{T} H (θ_{o l d} - θ) \leq δ \\ w h e r e H = \nabla_{θ}^{2} {\frac{1}{M} \sum_{i = 1}^{M} D_{K L} (θ_{o l d}, θ, S_{i}) |}_{θ = θ_{o l d}} \end{array}$

The analytical solution to this approximate optimization problem is as follows.

$θ = θ_{o l d} + α \sqrt{\frac{2 δ}{x^{T} H^{- 1} x}} x$

Here, x=H^-1g and α is a coefficient for ensuring that the policy improves and satisfies the constraint.

Training Algorithm

TRPO agents use the following training algorithm. To configure the training algorithm, specify options using an rlTRPOAgentOptions object.

Initialize the actor π(A|S;θ) with random parameter values θ.
Initialize the critic V(S;ϕ) with random parameter values ϕ.
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 π(A|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, ts+1, …, ts+N-1, 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 + 1}^{t s + N} (γ^{k - t - 1} R_{k}) + b γ^{t s + N - t} V (S_{t s + N}; ϕ)$
  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}; ϕ)$
- 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_{k + 1} + b γ V (S_{k + 1}; ϕ) - V (S_{k}; ϕ) \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}; ϕ)$
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} (ϕ) = \frac{1}{2 M} \sum_{i = 1}^{M} {(G_{i} - V (S_{i}; ϕ))}^{2}$
3. Normalize the advantage values D_i based on recent unnormalized advantage values.
  - If the NormalizedAdvantageMethod option is 'none', do not normalize the advantage values.
    ${\hat{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.
    ${\hat{D}}_{i} \leftarrow \frac{D_{i} - m e a n (D_{1}, D_{2}, \dots, D_{M})}{s t d (D_{1}, D_{2}, \dots, D_{M})}$
  - 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.
    ${\hat{D}}_{i} \leftarrow \frac{D_{i} - m e a n (D_{1}, D_{2}, \dots, D_{N})}{s t d (D_{1}, D_{2}, \dots, D_{N})}$
4. Update the actor parameters by solving the constrained optimization problem.
  1. Compute the policy gradient.
    $g = \nabla_{θ} L_{a c t o r} (θ) = \nabla_{θ} - \frac{1}{M} \sum_{i = 1}^{M} (\frac{π (A_{i} | S_{i}; θ)}{π (A_{i} | S_{i}; θ_{o l d})} {\hat{D}}_{i} + w ℋ_{i} (θ, S_{i}))$
  2. Apply the conjugate gradient (CG) method to find an approximate solution to the following equation, where H is the Hessian of the KL-divergence between the old and new policies.
    $x \approx H^{- 1} g$
    To configure the termination conditions for the CG algorithm, use the NumIterationsConjugateGradient and ConjugateGradientResidualTolerance options. To stabilize the numerical computation for the CG algorithm, use the ConjugateGradientDamping option.
  3. Using a line search algorithm, find the largest α that satisfies the following constraints.
    $\begin{array}{l} θ = θ_{o l d} + α \sqrt{\frac{2 δ}{x^{T} H^{- 1} x}} x \\ L_{a c t o r} (θ) - L_{a c t o r} (θ_{o l d}) < 0 \\ \frac{1}{M} \sum_{i = 1}^{M} D_{K L} (θ_{o l d}, θ, S_{i}) \leq δ \\ α \in {1, \frac{1}{2}, \frac{1}{2^{2}}, \dots, \frac{1}{2^{n - 1}}} \end{array}$
    Here, δ is the KL-divergence limit, which you set using the KLDivergenceLimit option. n is the number of line search iterations, which you set using the NumIterationsLineSearch option.
  4. If a valid value of α exists, update the parameters of the actor network to θ. If a valid value of α does not exist, do not update the actor parameters.
Repeat steps 3 through 5 until the training episode reaches a terminal state.

Entropy Loss

To promote agent exploration, you can add an entropy loss term wℋ_i(θ,S_i) to 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 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.

$ℋ_{i} (θ, S_{i}) = - \sum_{k = 1}^{P} π (A_{k} | S_{i}; θ) \ln π (A_{k} | S_{i}; θ)$

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.

$ℋ_{i} (θ, S_{i}) = \frac{1}{2} \sum_{k = 1}^{C} \ln (2 π \cdot e \cdot σ_{k, i}^{2})$

Here:

C is the number of continuous actions output by the actor.
σ_k,i is the standard deviation for action k when in state S_i following the current policy.

References

[1] Schulman, John, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. "Trust Region Policy Optimization." Proceedings of the 32nd International Conference on Machine Learning, pp. 1889-1897. 2015.

[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.

Related Examples

Train Reinforcement Learning Agents

Trust Region Policy Optimization (TRPO) Agent

Actor and Critic Function Approximators

Agent Creation

Trust Region Policy Optimization

Training Algorithm

Entropy Loss

References

See Also

Objects

Related Examples

More About