ReinforcementLearningCore.jl

ReinforcementLearningCore.jl (RLCore) provides some standard and reusable components defined by RLBase, hoping that they are useful for people to implement and experiment with different kinds of algorithms.

(app::AbstractApproximator)(env)

An approximator is a functional object for value estimation. It serves as a black box to provides an abstraction over different kinds of approximate methods (for example DNN provided by Flux or Knet).

(p::AbstractExplorer)(x)
(p::AbstractExplorer)(x, mask)

Define how to select an action based on action values.

A hook is called at different stage duiring a run to allow users to inject customized runtime logic. By default, a AbstractHook will do nothing. One can override the behavior by implementing the following methods:

• (hook::YourHook)(::PreActStage, agent, env, action), note that there's an extra argument of action.
• (hook::YourHook)(::PostActStage, agent, env)
• (hook::YourHook)(::PreEpisodeStage, agent, env)
• (hook::YourHook)(::PostEpisodeStage, agent, env)
• (hook::YourHook)(::PostExperimentStage, agent, env)

(learner::AbstractLearner)(env)

A learner is usually used to estimate state values, state-action values or distributional values based on experiences.

AbstractTrajectory

A trajectory is used to record some useful information during the interactions between agents and environments. It behaves similar to a NamedTuple except that we extend it with some optional methods.

Required Methods:

• Base.getindex
• Base.keys

Optional Methods:

• Base.length
• Base.isempty
• Base.empty!
• Base.haskey
• Base.push!
• Base.pop!

ActorCritic(;actor, critic, optimizer=ADAM())

The actor part must return logits (Do not use softmax in the last layer!), and the critic part must return a state value.

Agent(;kwargs...)

A wrapper of an AbstractPolicy. Generally speaking, it does nothing but to update the trajectory and policy appropriately in different stages.

Keywords & Fields

• policy::AbstractPolicy: the policy to use
• trajectory::AbstractTrajectory: used to store transitions between an agent and an environment

Here we extend the definition of (p::AbstractPolicy)(::AbstractEnv) in RLBase to accept an AbstractStage as the first argument. Algorithm designers may customize these behaviors respectively by implementing:

• (p::YourPolicy)(::AbstractStage, ::AbstractEnv)
• (p::YourPolicy)(::PreActStage, ::AbstractEnv, action)

The default behaviors for Agent are:

1. Update the inner trajectory given the context of policy, env, and stage.

2. By default we do nothing.

3. In PreActStage, we push! the current state and the action into the trajectory.

4. In PostActStage, we query the reward and is_terminated info from env and push them into trajectory.

5. In the PosEpisodeStage, we push the state at the end of an episode and a dummy action into the trajectory.

6. In the PreEpisodeStage, we pop out the latest state and action pair (which are dummy ones) from trajectory.

7. Update the inner policy given the context of trajectory, env, and stage.

8. By default, we only update! the policy in the PreActStage. And it's dispatched to update!(policy, trajectory, env, stage).

BatchExplorer(explorer::AbstractExplorer)

(x::BatchExplorer)(values::AbstractMatrix)

Apply inner explorer to each column of values.

BatchStepsPerEpisode(batch_size::Int; tag = "TRAINING")

Similar to StepsPerEpisode, but is specific to environments which return a Vector of rewards (a typical case with MultiThreadEnv).

CircularArraySARTTrajectory(;capacity::Int, kw...)

A specialized CircularArrayTrajectory with traces of SART. Note that the capacity of the :state and :action trace is one step longer than the capacity of the :reward and :terminal trace, so that we can reuse the same trace to represent the next state and next action in a typical transition in reinforcement learning.

Keyword arguments

• capacity::Int, the maximum number of transitions.
• state::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Int => (),
• action::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Int => (),
• reward::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Float32 => (),
• terminal::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Bool => (),

Example

julia> t = CircularArraySARTTrajectory(;
           capacity = 3,
           state = Vector{Int} => (4,),
           action = Int => (),
           reward = Float32 => (),
           terminal = Bool => (),
       )
Trajectory of 4 traces:
:state 4×0 CircularArrayBuffers.CircularArrayBuffer{Int64, 2}
:action 0-element CircularArrayBuffers.CircularVectorBuffer{Int64}
:reward 0-element CircularArrayBuffers.CircularVectorBuffer{Float32}
:terminal 0-element CircularArrayBuffers.CircularVectorBuffer{Bool}


julia> for i in 1:4
           push!(t;state=ones(Int, 4) .* i, action = i, reward=i/2, terminal=iseven(i))
       end

julia> push!(t;state=ones(Int,4) .* 5, action = 5)

julia> t[:state]
4×4 CircularArrayBuffers.CircularArrayBuffer{Int64, 2}:
 2  3  4  5
 2  3  4  5
 2  3  4  5
 2  3  4  5

julia> t[:action]
4-element CircularArrayBuffers.CircularVectorBuffer{Int64}:
 2
 3
 4
 5

julia> t[:reward]
3-element CircularArrayBuffers.CircularVectorBuffer{Float32}:
 1.0
 1.5
 2.0

julia> t[:terminal]
3-element CircularArrayBuffers.CircularVectorBuffer{Bool}:
 1
 0
 1

Similar to CircularArraySARTTrajectory with an extra legal_actions_mask trace.

Similar to CircularVectorSARTTrajectory with another two traces of (:next_state, :next_action)

CircularVectorSARTTrajectory(;capacity, kw::DataType...)

A specialized CircularVectorTrajectory with traces of SART. Note that the capacity of traces :state and :action are one step longer than the traces of :reward and :terminal, so that we can reuse the same underlying storage to represent the next state and next action in a typical transition in reinforcement learning.

Keyword arguments

• capacity::Int
• state = Int,
• action = Int,
• reward = Float32,
• terminal = Bool,

Example

julia> t = CircularVectorSARTTrajectory(;
           capacity = 3,
           state = Vector{Int},
           action = Int,
           reward = Float32,
           terminal = Bool,
       )
Trajectory of 4 traces:
:state 0-element CircularArrayBuffers.CircularVectorBuffer{Vector{Int64}}
:action 0-element CircularArrayBuffers.CircularVectorBuffer{Int64}
:reward 0-element CircularArrayBuffers.CircularVectorBuffer{Float32}
:terminal 0-element CircularArrayBuffers.CircularVectorBuffer{Bool}


julia> for i in 1:4
           push!(t;state=ones(Int, 4) .* i, action = i, reward=i/2, terminal=iseven(i))
       end

julia> push!(t;state=ones(Int,4) .* 5, action = 5)

julia> t[:state]
4-element CircularArrayBuffers.CircularVectorBuffer{Vector{Int64}}:
 [2, 2, 2, 2]
 [3, 3, 3, 3]
 [4, 4, 4, 4]
 [5, 5, 5, 5]

julia> t[:action]
4-element CircularArrayBuffers.CircularVectorBuffer{Int64}:
 2
 3
 4
 5

julia> t[:reward]
3-element CircularArrayBuffers.CircularVectorBuffer{Float32}:
 1.0
 1.5
 2.0

julia> t[:terminal]
3-element CircularArrayBuffers.CircularVectorBuffer{Bool}:
 1
 0
 1

ComposedHook(hooks::AbstractHook...)

Compose different hooks into a single hook.

ComposedStopCondition(stop_conditions...; reducer = any)

The result of stop_conditions is reduced by reducer.

DoEveryNEpisode(f; n=1, t=0)

Execute f(t, agent, env) every n episode. t is a counter of episodes.

DoEveryNStep(f; n=1, t=0)

Execute f(t, agent, env) every n step. t is a counter of steps.

DoOnExit(f)

Call the lambda function f at the end of an Experiment.

DuelingNetwork(;base, val, adv)

Dueling network automatically produces separate estimates of the state value function network and advantage function network. The expected output size of val is 1, and adv is the size of the action space.

ElasticSARTTrajectory(;kw...)

A specialized ElasticArrayTrajectory with traces of SART.

Keyword arguments

• state::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Int => (), by default it means the state is a scalar of Int.
• action::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Int => (),
• reward::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Float32 => (),
• terminal::Pair{<:DataType, <:Tuple{Vararg{Int}}} = Bool => (),

Example

julia> t = ElasticSARTTrajectory(;
           state = Vector{Int} => (4,),
           action = Int => (),
           reward = Float32 => (),
           terminal = Bool => (),
       )
Trajectory of 4 traces:
:state 4×0 ElasticArrays.ElasticMatrix{Int64, Vector{Int64}}
:action 0-element ElasticArrays.ElasticVector{Int64, Vector{Int64}}
:reward 0-element ElasticArrays.ElasticVector{Float32, Vector{Float32}}
:terminal 0-element ElasticArrays.ElasticVector{Bool, Vector{Bool}}


julia> for i in 1:4
           push!(t;state=ones(Int, 4) .* i, action = i, reward=i/2, terminal=iseven(i))
       end

julia> push!(t;state=ones(Int,4) .* 5, action = 5)

julia> t
Trajectory of 4 traces:
:state 4×5 ElasticArrays.ElasticMatrix{Int64, Vector{Int64}}
:action 5-element ElasticArrays.ElasticVector{Int64, Vector{Int64}}
:reward 4-element ElasticArrays.ElasticVector{Float32, Vector{Float32}}
:terminal 4-element ElasticArrays.ElasticVector{Bool, Vector{Bool}}

julia> t[:state]
4×5 ElasticArrays.ElasticMatrix{Int64, Vector{Int64}}:
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

julia> t[:action]
5-element ElasticArrays.ElasticVector{Int64, Vector{Int64}}:
 1
 2
 3
 4
 5

julia> t[:reward]
4-element ElasticArrays.ElasticVector{Float32, Vector{Float32}}:
 0.5
 1.0
 1.5
 2.0

julia> t[:terminal]
4-element ElasticArrays.ElasticVector{Bool, Vector{Bool}}:
 0
 1
 0
 1

julia> empty!(t)

julia> t
Trajectory of 4 traces:
:state 4×0 ElasticArrays.ElasticMatrix{Int64, Vector{Int64}}
:action 0-element ElasticArrays.ElasticVector{Int64, Vector{Int64}}
:reward 0-element ElasticArrays.ElasticVector{Float32, Vector{Float32}}
:terminal 0-element ElasticArrays.ElasticVector{Bool, Vector{Bool}}

Do nothing

EpsilonGreedyExplorer{T}(;kwargs...)
EpsilonGreedyExplorer(ϵ) -> EpsilonGreedyExplorer{:linear}(; ϵ_stable = ϵ)

Epsilon-greedy strategy: The best lever is selected for a proportion 1 - epsilon of the trials, and a lever is selected at random (with uniform probability) for a proportion epsilon . Multi-armed_bandit

Two kinds of epsilon-decreasing strategy are implemented here (linear and exp).

Epsilon-decreasing strategy: Similar to the epsilon-greedy strategy, except that the value of epsilon decreases as the experiment progresses, resulting in highly explorative behaviour at the start and highly exploitative behaviour at the finish. - Multi-armed_bandit

Keywords

• T::Symbol: defines how to calculate the epsilon in the warmup steps. Supported values are linear and exp.
• step::Int = 1: record the current step.
• ϵ_init::Float64 = 1.0: initial epsilon.
• warmup_steps::Int=0: the number of steps to use ϵ_init.
• decay_steps::Int=0: the number of steps for epsilon to decay from ϵ_init to ϵ_stable.
• ϵ_stable::Float64: the epsilon after warmup_steps + decay_steps.
• is_break_tie=false: randomly select an action of the same maximum values if set to true.
• rng=Random.GLOBAL_RNG: set the internal RNG.
• is_training=true, in training mode, step will not be updated. And the ϵ will be set to 0.

Example

s = EpsilonGreedyExplorer{:linear}(ϵ_init=0.9, ϵ_stable=0.1, warmup_steps=100, decay_steps=100)
plot([RL.get_ϵ(s, i) for i in 1:500], label="linear epsilon")

s = EpsilonGreedyExplorer{:exp}(ϵ_init=0.9, ϵ_stable=0.1, warmup_steps=100, decay_steps=100)
plot([RL.get_ϵ(s, i) for i in 1:500], label="exp epsilon")

(s::EpsilonGreedyExplorer)(values; step) where T

Experiment(policy, env, stop_condition, hook, description)

These are the four essential components in a typical reinforcement learning experiment:

• policy, generates an action during the interaction with the env. It may update its strategy in the meanwhile.
• env, the environment we're going to experiment with.
• stop_condition, defines the when the experiment terminates.
• hook, collects some intermediate data during the experiment.
• description, displays some useful information for logging.

GaussianNetwork(;pre=identity, μ, logσ, min_σ=0f0, max_σ=Inf32)

Returns μ and logσ when called. Create a distribution to sample from using Normal.(μ, exp.(logσ)). min_σ and max_σ are used to clip the output from logσ.

This function is compatible with a multidimensional action space. When outputting an action, it uses tanh to normalize it.

• rng::AbstractRNG=Random.GLOBAL_RNG
• is_sampling::Bool=false, whether to sample from the obtained normal distribution.
• is_return_log_prob::Bool=false, whether to calculate the conditional probability of getting actions in the given state.

MultiAgentHook(player=>hook...)

MultiAgentManager(player => policy...)

This is the simplest form of multiagent system. At each step they observe the environment from their own perspective and get updated independently. For environments of SEQUENTIAL style, agents which are not the current player will observe a dummy action of NO_OP in the PreActStage. For environments of SIMULTANEOUS style, please wrap it with SequentialEnv first.

NamedPolicy(name=>policy)

A policy wrapper to provide a name. Mostly used in multi-agent environments.

NeuralNetworkApproximator(;kwargs)

Use a DNN model for value estimation.

Keyword arguments

• model, a Flux based DNN model.
• optimizer=nothing

Represent no-operation if it's not the agent's turn.

This function accepts state and action, and then outputs actions after disturbance.

QBasedPolicy(;learner::Q, explorer::S)

Use a Q-learner to generate estimations of action values. Then an explorer is applied on the estimations to select an action.

RandomPolicy(action_space=nothing; rng=Random.GLOBAL_RNG)

If action_space is nothing, then it will use the legal_action_space at runtime to randomly select an action. Otherwise, a random element within action_space is selected.

RewardsPerEpisode(; rewards = Vector{Vector{Float64}}())

Store each reward of each step in every episode in the field of rewards.

StackFrames(::Type{T}=Float32, d::Int...)

Use a pre-initialized CircularArrayBuffer to store the latest several states specified by d. Before processing any observation, the buffer is filled with `zero{T} by default.

StepsPerEpisode(; steps = Int[], count = 0)

Store steps of each episode in the field of steps.

StopAfterEpisode(episode; cur = 0, is_show_progress = true)

Return true after being called episode. If is_show_progress is true, the ProgressMeter will be used to show progress.

StopAfterNSeconds

parameter:

1. time badget

stop training after N seconds

StopAfterNoImprovement()

Stop training when a monitored metric has stopped improving.

Parameters:

fn: a closure, return a scalar value, which indicates the performance of the policy (the higher the better) e.g.

1. () -> reward(env)
2. () -> totalrewardper_episode.reward

patience: Number of epochs with no improvement after which training will be stopped.

δ: Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute change of less than min_delta, will count as no improvement.

Return true after the monitored metric has stopped improving.

StopAfterStep(step; cur = 1, is_show_progress = true)

Return true after being called step times.

StopSignal()

Create a stop signal initialized with a value of false. You can manually set it to true by s[] = true to stop the running loop at any time.

StopWhenDone()

Return true if the environment is terminated.

SumTree(capacity::Int)

Efficiently sample and update weights. For more details, see the post at here. Here we use a vector to represent the binary tree. Suppose we will have capacity leaves at most. Every time we push! new node into the tree, only the recent capacity node and their sum will be updated! [––––––Parent nodes––––––][––––leaves––––] [size: 2^ceil(Int, log2(capacity))-1 ][ size: capacity ]

Example

julia> t = SumTree(8)
0-element SumTree
julia> for i in 1:16
       push!(t, i)
       end
julia> t
8-element SumTree:
  9.0
 10.0
 11.0
 12.0
 13.0
 14.0
 15.0
 16.0
julia> sample(t)
(2, 10.0)
julia> sample(t)
(1, 9.0)
julia> inds, ps = sample(t,100000)
([8, 4, 8, 1, 5, 2, 2, 7, 6, 6  …  1, 1, 7, 1, 6, 1, 5, 7, 2, 7], [16.0, 12.0, 16.0, 9.0, 13.0, 10.0, 10.0, 15.0, 14.0, 14.0  …  9.0, 9.0, 15.0, 9.0, 14.0, 9.0, 13.0, 15.0, 10.0, 15.0])
julia> countmap(inds)
Dict{Int64,Int64} with 8 entries:
  7 => 14991
  4 => 12019
  2 => 10003
  3 => 11027
  5 => 12971
  8 => 16052
  6 => 13952
  1 => 8985
julia> countmap(ps)
Dict{Float64,Int64} with 8 entries:
  9.0  => 8985
  13.0 => 12971
  10.0 => 10003
  14.0 => 13952
  16.0 => 16052
  11.0 => 11027
  15.0 => 14991
  12.0 => 12019

TabularApproximator(table<:AbstractArray, opt)

For table of 1-d, it will serve as a state value approximator. For table of 2-d, it will serve as a state-action value approximator.

TabularRandomPolicy(;table=Dict{Int, Float32}(), rng=Random.GLOBAL_RNG)

Use a Dict to store action distribution.

TimePerStep(;max_steps=100)
TimePerStep(times::CircularArrayBuffer{Float64}, t::UInt64)

Store time cost of the latest max_steps in the times field.

TotalBatchRewardPerEpisode(batch_size::Int; is_display_on_exit=true)

Similar to TotalRewardPerEpisode, but is specific to environments which return a Vector of rewards (a typical case with MultiThreadEnv). If is_display_on_exit is set to true, a ribbon plot will be shown to reflect the mean and std of rewards.

TotalRewardPerEpisode(; rewards = Float64[], reward = 0.0, is_display_on_exit = true)

Store the total reward of each episode in the field of rewards. If is_display_on_exit is set to true, a unicode plot will be shown at the PostExperimentStage.

Trajectory(;[trace_name=trace_container]...)

A simple wrapper of NamedTuple. Define our own type here to avoid type piracy with NamedTuple

UCBExplorer(na; c=2.0, ϵ=1e-10, step=1, seed=nothing)

Arguments

• na is the number of actions used to create a internal counter.
• t is used to store current time step.
• c is used to control the degree of exploration.
• seed, set the seed of inner RNG.
• is_training=true, in training mode, time step and counter will not be updated.

UploadTrajectoryEveryNStep(;mailbox, n, sealer=deepcopy)

VAE(;encoder, decoder, latent_dims)

VBasedPolicy(;learner, mapping=default_value_action_mapping)

The learner must be a value learner. The mapping is a function which returns an action given env and the learner. By default we iterate through all the valid actions and select the best one which lead to the maximum state value.

VectorSARTTrajectory(;kw...)

A specialized [VectorTrajectory] with traces of SART.

Keyword arguments

• state::DataType = Int
• action::DataType = Int
• reward::DataType = Float32
• terminal::DataType = Bool

VectorSATrajectory(;kw...)

A specialized [VectorTrajectory] with traces of (:state, :action).

Keyword arguments

• state::DataType = Int
• action::DataType = Int

WeightedExplorer(;is_normalized::Bool, rng=Random.GLOBAL_RNG)

is_normalized is used to indicate if the fed action values are already normalized to have a sum of 1.0.

See also: WeightedSoftmaxExplorer

WeightedSoftmaxExplorer(;rng=Random.GLOBAL_RNG)

See also: WeightedExplorer

When pushing a StackFrames into a CircularArrayBuffer of the same dimension, only the latest frame is pushed. If the StackFrames is one dimension lower, then it is treated as a general AbstractArray and is pushed in as a frame.

device(model)

Detect the suitable running device for the model. Return Val(:cpu) by default.

get_priority(p::AbstractLearner, experience)

prob(p::AbstractExplorer, x, mask)

Similar to prob(p::AbstractExplorer, x), but here only the masked elements are considered.

prob(p::AbstractExplorer, x) -> AbstractDistribution

Get the action distribution given action values.

prob(s::EpsilonGreedyExplorer, values) ->Categorical
prob(s::EpsilonGreedyExplorer, values, mask) ->Categorical

Return the probability of selecting each action given the estimated values of each action.

update!(a::AbstractApproximator, correction)

Usually the correction is the gradient of inner parameters.

update!(p::TabularRandomPolicy, state => value)

You should manually check value sum to 1.0.

Used to detect what an AbstractApproximator is approximating.

CircularArrayTrajectory(; capacity::Int, kw::Pair{<:DataType, <:Tuple{Vararg{Int}}}...)

A specialized Trajectory which uses CircularArrayBuffer as the underlying storage. kw specifies the name, the element type and the size of each trace. capacity is used to define the maximum length of the underlying buffer.

See also CircularArraySARTTrajectory, CircularArraySLARTTrajectory, CircularArrayPSARTTrajectory.

CircularVectorTrajectory(;capacity, kw::DataType)

Similar to CircularArrayTrajectory, except that the underlying storage is CircularVectorBuffer.

See also CircularVectorSARTTrajectory, CircularVectorSARTSATrajectory.

ElasticArrayTrajectory(;[trace_name::Pair{<:DataType, <:Tuple{Vararg{Int}}}]...)

A specialized Trajectory which uses ElasticArray as the underlying storage. See also ElasticSARTTrajectory.

VectorTrajectory(;[trace_name::DataType]...)

A Trajectory with each trace using a Vector as the storage.

assuming rewards and new_rewards are Vector

assuming rewards and advantages are Vector

Inject some customized checkings here by overwriting this function

consecutive_view(x::AbstractArray, inds; n_stack = nothing, n_horizon = nothing)

By default, it behaves the same with select_last_dim(x, inds). If n_stack is set to an int, then for each frame specified by inds, the previous n_stack frames (including the current one) are concatenated as a new dimension. If n_horizon is set to an int, then for each frame specified by inds, the next n_horizon frames (including the current one) are concatenated as a new dimension.

Example

julia> x = collect(1:5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

julia> consecutive_view(x, [2,4])  # just the same with `select_last_dim(x, [2,4])`
2-element view(::Array{Int64,1}, [2, 4]) with eltype Int64:
 2
 4

julia> consecutive_view(x, [2,4];n_stack = 2)
2×2 view(::Array{Int64,1}, [1 3; 2 4]) with eltype Int64:
 1  3
 2  4

julia> consecutive_view(x, [2,4];n_horizon = 2)
2×2 view(::Array{Int64,1}, [2 4; 3 5]) with eltype Int64:
 2  4
 3  5

julia> consecutive_view(x, [2,4];n_horizon = 2, n_stack=2)  # note the order here, first we stack, then we apply the horizon
2×2×2 view(::Array{Int64,1}, [1 2; 2 3]

[3 4; 4 5]) with eltype Int64:
[:, :, 1] =
 1  2
 2  3

[:, :, 2] =
 3  4
 4  5

See also Frame Skipping and Preprocessing for Deep Q networks to gain a better understanding of state stacking and n-step learning.

discount_rewards(rewards::VectorOrMatrix, γ::Number;kwargs...)

Calculate the gain started from the current step with discount rate of γ. rewards can be a matrix.

Keyword arguments

• dims=:, if rewards is a Matrix, then dims can only be 1 or 2.
• terminal=nothing, specify if each reward follows by a terminal. nothing means the game is not terminated yet. If terminal is provided, then the size must be the same with rewards.
• init=nothing, init can be used to provide the the reward estimation of the last state.

Example

flatten_batch(x::AbstractArray)

Merge the last two dimension.

Example

julia> x = reshape(1:12, 2, 2, 3)
2×2×3 reshape(::UnitRange{Int64}, 2, 2, 3) with eltype Int64:
[:, :, 1] =
 1  3
 2  4

[:, :, 2] =
 5  7
 6  8

[:, :, 3] =
  9  11
 10  12

julia> flatten_batch(x)
2×6 reshape(::UnitRange{Int64}, 2, 6) with eltype Int64:
 1  3  5  7   9  11
 2  4  6  8  10  12

generalized_advantage_estimation(rewards::VectorOrMatrix, values::VectorOrMatrix, γ::Number, λ::Number;kwargs...)

Calculate the generalized advantage estimate started from the current step with discount rate of γ and a lambda for GAE-Lambda of 'λ'. rewards and 'values' can be a matrix.

Keyword arguments

• dims=:, if rewards is a Matrix, then dims can only be 1 or 2.
• terminal=nothing, specify if each reward follows by a terminal. nothing means the game is not terminated yet. If terminal is provided, then the size must be the same with rewards.

Example

GPU automatic differentiable version for the logpdf function of normal distributions. Adding an epsilon value to guarantee numeric stability if sigma is exactly zero (e.g. if relu is used in output layer).

sample([rng=Random.GLOBAL_RNG], trajectory, sampler, [traces=Val(keys(trajectory))])