Документация Engee

ReinforcementLearningCore.jl

# ReinforcementLearningCore.AbstractExplorer — Type

RLBase.plan!(p::AbstractExplorer, x[, mask])

Определяет, как выбирается действие в зависимости от значений действий.

# ReinforcementLearningCore.AbstractHook — Type

Обработчик вызывается на различных этапах выполнения run, что позволяет пользователям вводить настраиваемую логику времени выполнения. По умолчанию обработчик AbstractHook ничего не делает. Его поведение можно настроить, реализовав следующие методы:

  • Base.push!(hook::YourHook, ::PreActStage, agent, env)

  • Base.push!(hook::YourHook, ::PostActStage, agent, env)

  • Base.push!(hook::YourHook, ::PreEpisodeStage, agent, env)

  • Base.push!(hook::YourHook, ::PostEpisodeStage, agent, env)

  • Base.push!(hook::YourHook, ::PostExperimentStage, agent, env)

В соответствии с соглашением реализован метод Base.getindex(h::YourHook), извлекающий нужные метрики. Пользователи могут комбинировать различные обработчики AbstractHook с помощью оператора +.

# ReinforcementLearningCore.AbstractLearner — Type

AbstractLearner

Абстрактный тип для обучателя.

# ReinforcementLearningCore.ActorCritic — Type

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

Часть actor должна возвращать логиты (не используйте softmax в последнем слое!), а часть critic — значение состояния.

# ReinforcementLearningCore.Agent — Type

Agent(;policy, trajectory) <: AbstractPolicy

Оболочка для AbstractPolicy. По сути, ее единственная задача — надлежащим образом обновлять траекторию и политику на различных этапах. Агент является вызываемым объектом. Его метод вызова принимает аргументы с переменным количеством и именованные аргументы, которые должны быть переданы в политику.

# ReinforcementLearningCore.BatchExplorer — Type

BatchExplorer(explorer::AbstractExplorer)

# ReinforcementLearningCore.BatchStepsPerEpisode — Method

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

То же, что и StepsPerEpisode, но для сред, возвращающих вектор (Vector) наград (типичный случай для MultiThreadEnv).

# ReinforcementLearningCore.CategoricalNetwork — Type

CategoricalNetwork(model)([rng,] state::AbstractArray [, mask::AbstractArray{Bool}]; is_sampling::Bool=false, is_return_log_prob::Bool = false)

CategoricalNetwork инкапсулирует модель (как правило, нейронную сеть), которая принимает состояние state и выводит логиты для категориального распределения. Необязательный аргумент mask должен содержать массив значений типа Bool того же размера, что и state, кроме первого измерения, которое должно быть той же длины, что и вектор действий. Действия, сопоставленные по маске с false, имеют логит, равный -Inf, и (или) нулевую вероятность выборки.

  • rng::AbstractRNG=Random.default_rng()

  • is_sampling::Bool=false — производится ли выборка из полученного нормального категориального распределения (возвращает объект z типа Flux.OneHotArray).

  • is_return_log_prob::Bool=false — должны ли возвращаться логиты (то есть ненормализованные логарифмические вероятности) получения выбранных действий в указанном состоянии.

Действует только в том случае, если is_sampling имеет значение true, и возвращает z, logits.

Если is_sampling = false, возвращает только логиты, полученные в результате простого прямого прохода по модели model.

# ReinforcementLearningCore.CategoricalNetwork — Method

(model::CategoricalNetwork)([rng::AbstractRNG,] state::AbstractArray{<:Any, 3}, [mask::AbstractArray{Bool},] action_samples::Int)

Производит выборку action_samples действий из каждого состояния. Возвращает трехмерный тензор с измерениями (action_size x action_samples x batchsize). Всегда возвращает логиты каждого действия в тензоре с теми же измерениями. Необязательный аргумент mask должен содержать массив значений типа Bool того же размера, что и state, кроме первого измерения, которое должно быть той же длины, что и вектор действий. Действия, сопоставленные по маске с false, имеют логит, равный -Inf, и (или) нулевую вероятность выборки.

# ReinforcementLearningCore.CovGaussianNetwork — Type

CovGaussianNetwork(;pre=identity, μ, Σ)

При вызове возвращает μ и Σ, где μ — среднее значение, а Σ — ковариационная матрица. В отличие от GaussianNetwork, выходные данные трехмерные. μ имеет измерения (action_size x 1 x batchsize), а Σ — измерения (action_size x action_size x batchsize). Голова Σ сети CovGaussianNetwork должна возвращать не непосредственно квадратную матрицу, а вектор длиной action_size x (action_size + 1) ÷ 2. Этот вектор содержит элементы верхнетреугольного разложения Холецкого ковариационной матрицы, которая затем воссоздается из него. Производит выборку из MvNormal.(μ, Σ).

# ReinforcementLearningCore.CovGaussianNetwork — Method

(model::CovGaussianNetwork)(state::AbstractArray, action::AbstractArray)

Возвращает logpdf действия action, выбранного из модели в состоянии state. Состояние должно быть трехмерным тензором с измерениями (state_size x 1 x batchsize). Для каждого состояния может выбираться несколько действий, при этом action должно иметь измерения (action_size x action_samples_per_state x batchsize). Возвращает трехмерный тензор с измерениями (1 x action_samples_per_state x batchsize).

# ReinforcementLearningCore.CovGaussianNetwork — Method

Если на вход подаются двухмерные матрицы, возвращает двухмерную матрицу значений logpdf. Состояния и действия составляются в пары по столбцам, по одному действию на состояние.

# ReinforcementLearningCore.CovGaussianNetwork — Method

(model::CovGaussianNetwork)(rng::AbstractRNG, state::AbstractArray{<:Any, 3}, action_samples::Int)

Производит выборку action_samples действий из каждого состояния в state и возвращает actions, logpdf(actions). Эта функция совместима с многомерным пространством действий. Выходные данные представляют собой трехмерные тензоры с измерениями (action_size x action_samples x batchsize) и (1 x action_samples x batchsize) для actions и logdpf соответственно.

# ReinforcementLearningCore.CovGaussianNetwork — Method

(model::CovGaussianNetwork)(rng::AbstractRNG, state::AbstractArray{<:Any, 3}; is_sampling::Bool=false, is_return_log_prob::Bool=false)

Эта функция совместима с многомерным пространством действий. Для работы с ковариационными матрицами выходные данные представляют собой трехмерные тензоры. При выборке возвращает тензор действий с измерениями (action_size x action_samples x batchsize) и тензор logp_π с измерениями (1 x action_samples x batchsize). Если выборка не производится, возвращает μ с измерениями (action_size x 1 x batchsize) и L, нижний треугольник разложения Холецкого ковариационной матрицы, с измерениями (action_size x action_size x batchsize). Ковариационные матрицы можно получить так: Σ = stack(map(l -> l*l', eachslice(L, dims=3)); dims=3).

  • rng::AbstractRNG=Random.default_rng()

  • is_sampling::Bool=false — производится ли выборка из полученного нормального распределения.

  • is_return_log_prob::Bool=false — следует ли вычислить условную вероятность получения действий в указанном состоянии.

# ReinforcementLearningCore.CovGaussianNetwork — Method

(model::CovGaussianNetwork)(rng::AbstractRNG, state::AbstractMatrix; is_sampling::Bool=false, is_return_log_prob::Bool=false)

Для переданной матрицы состояний возвращает действия, μ и logpdf в матричном формате. Пакет Σ остается трехмерным тензором.

# ReinforcementLearningCore.CurrentPlayerIterator — Type

CurrentPlayerIterator(env::E) where {E<:AbstractEnv}

CurrentPlayerIterator— это итератор, перебирающий игроков в среде и возвращающийcurrentplayerна каждой итерации. Требуется только для сред в стиле`MultiAgent`. После каждой итерации вызывается`RLBase.next*player!для смены`current*player`на следующего игрока. При условии что методRLBase.nextplayer!определен для среды, этот итератор будет правильно работать в функцииBase.run` функции.

# ReinforcementLearningCore.DoEveryNEpisodes — Type

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

Выполняет функцию f(t, agent, env) каждые n эпизодов. t — это счетчик эпизодов.

# ReinforcementLearningCore.DoEveryNSteps — Type

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

Выполняет функцию f(t, agent, env) каждые n шагов. t — это счетчик шагов.

# ReinforcementLearningCore.DoOnExit — Type

DoOnExit(f)

Вызывает лямбда-функцию f в конце эксперимента (Experiment).

# ReinforcementLearningCore.DuelingNetwork — Type

DuelingNetwork(;base, val, adv)

Состязательная сеть автоматически выдает отдельные оценки для сети с функцией значений состояний и сети с функцией преимуществ. Ожидаемый выходной размер val равен 1, а adv — это размер пространства действий.

# ReinforcementLearningCore.EmptyHook — Type

Просто заполнитель.

# ReinforcementLearningCore.EpsilonGreedyExplorer — Type

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

Эпсилон-жадная стратегия: для доли 1 - epsilon попыток выбирается лучшая рука, а для доли попыток epsilon рука выбирается случайно (с равномерно распределенной вероятностью). Многорукий бандит

Здесь реализованы два вида эпсилон-понижающей стратегии (linear и exp).

Эпсилон-понижающая стратегия: похожа на эпсилон-жадную стратегию за тем исключением, что значение epsilon в ходе эксперимента уменьшается, что приводит к существенному смещению в сторону исследования в начале и в сторону использования в конце. Многорукий бандит

Именованные аргументы

  • T::Symbol: определяет способ вычисления epsilon на шагах разогрева. Поддерживаемые значения — linear и exp.

  • step::Int = 1: регистрирует текущий шаг.

  • ϵ_init::Float64 = 1.0: начальное значение epsilon.

  • warmup_steps::Int=0: количество шагов, на которых используется значение ϵ_init.

  • decay_steps::Int=0: количество шагов, в течение которых значение epsilon снижается с ϵ_init до ϵ_stable.

  • ϵ_stable::Float64: значение epsilon после warmup_steps + decay_steps шагов.

  • is_break_tie=false: если задано значение true, случайно выбирается действие с теми же максимальными значениями.

  • rng=Random.default_rng(): задает внутренний генератор случайных чисел.

Пример

s_lin = EpsilonGreedyExplorer(kind=:linear, ϵ_init=0.9, ϵ_stable=0.1, warmup_steps=100, decay_steps=100)
plot([RLCore.get_ϵ(s_lin, i) for i in 1:500], label="linear epsilon")
s_exp = EpsilonGreedyExplorer(kind=:exp, ϵ_init=0.9, ϵ_stable=0.1, warmup_steps=100, decay_steps=100)
plot!([RLCore.get_ϵ(s_exp, i) for i in 1:500], label="exp epsilon")
epsilon greedy selector

# ReinforcementLearningCore.Experiment — Type

Experiment(policy::AbstractPolicy, env::AbstractEnv, stop_condition::AbstractStopCondition, hook::AbstractHook)

Структура для хранения информации об эксперименте. Используется для проведения эксперимента с указанными политикой, средой, конечным условием и обработчиком.

# ReinforcementLearningCore.FluxApproximator — Type

FluxApproximator(model, optimiser)

Инкапсулирует обучаемую модель Flux и реализует интерфейс RLBase.optimise!(::FluxApproximator, ::Gradient) . Дополнительные сведения о правильном использовании см. в документации по RLCore.

# ReinforcementLearningCore.FluxApproximator — Method

FluxApproximator(; model, optimiser, usegpu=false)

Создает объект FluxApproximator для обучения с подкреплением.

Аргументы

  • model: модель, используемая для аппроксимации.

  • optimiser: оптимизатор, используемый для обновления модели.

  • usegpu: логическое значение, указывающее, следует ли использовать GPU для вычислений. Значение по умолчанию — false.

Возвращает

Объект FluxApproximator.

# ReinforcementLearningCore.GaussianNetwork — Method

(model::GaussianNetwork)(rng::AbstractRNG, state::AbstractArray{<:Any, 3}, action_samples::Int)

Производит выборку action_samples действий из каждого состояния. Возвращает трехмерный тензор с измерениями (action_size x action_samples x batchsize). state должно быть трехмерным тензором с измерениями (state_size x 1 x batchsize). Всегда возвращает logpdf каждого действия.

# ReinforcementLearningCore.GaussianNetwork — Method

Эта функция совместима с многомерным пространством действий.

  • rng::AbstractRNG=Random.default_rng()

  • is_sampling::Bool=false — производится ли выборка из полученного нормального распределения.

  • is_return_log_prob::Bool=false — следует ли вычислить условную вероятность получения действий в указанном состоянии.

# ReinforcementLearningCore.MultiAgentHook — Type

MultiAgentHook(hooks::NT) where {NT<: NamedTuple}

MultiAgentHook — это структура перехватчика, которая содержит структуры <:AbstractHook, индексируемые по символу игрока.

# ReinforcementLearningCore.MultiAgentPolicy — Type

MultiAgentPolicy(agents::NT) where {NT<: NamedTuple}

MultiAgentPolicy — это структура политики, которая содержит структуры <:AbstractPolicy, индексируемые по символу игрока.

# ReinforcementLearningCore.OfflineAgent — Type

OfflineAgent(policy::AbstractPolicy, trajectory::Trajectory, offline_behavior::OfflineBehavior = OfflineBehavior()) <: AbstractAgent

OfflineAgent — это объект AbstractAgent, который, в отличие от обычного потокового объекта Agent, не взаимодействует со средой во время обучения с целью сбора данных. Как и Agent, он содержит политику AbstractPolicy, которая должна обучаться на траектории Trajectory, содержащей обучающие данные. Отличие в том, что траектория заполняется перед обучением и не обновляется. При необходимости можно передать объект OfflineBehavior, представляющий собой второй «поведенческий агент», который генерирует обучающие данные на этапе PreExperimentStage. По умолчанию ничего не делает.

# ReinforcementLearningCore.OfflineBehavior — Type

OfflineBehavior(; agent:: Union{<:Agent, Nothing}, steps::Int, reset_condition)

Служит для предоставления объекта OfflineAgent с «поведенческим агентом», генерирующим обучающие данные на этапе PreExperimentStage. Если agent имеет значение nothing (по умолчанию), ничего не делает. Траектория trajectory агента должна совпадать с траекторией родительского агента OfflineAgent. steps — это количество генерируемых элементов данных; по умолчанию равно емкости траектории. reset_condition — это условие сброса эпизода для генерирования данных (по умолчанию ResetIfEnvTerminated()).

Поведенческий агент взаимодействует с главной средой эксперимента для генерирования данных.

# ReinforcementLearningCore.PerturbationNetwork — Method

Эта функция принимает аргументы state и action и возвращает действия после возмущения.

# ReinforcementLearningCore.PlayerTuple — Type

PlayerTuple

Объект NamedTuple, сопоставляющий игроков и соответствующие значения.

# ReinforcementLearningCore.PostActStage — Type

Этап, выполняемый после действия агента Agent.

# ReinforcementLearningCore.PostEpisodeStage — Type

Этап, выполняемый после завершения эпизода Episode.

# ReinforcementLearningCore.PostExperimentStage — Type

Этап, выполняемый после завершения эксперимента Experiment.

# ReinforcementLearningCore.PreActStage — Type

Этап, выполняемый перед действием агента Agent.

# ReinforcementLearningCore.PreEpisodeStage — Type

Этап, выполняемый перед началом эпизода Episode.

# ReinforcementLearningCore.PreExperimentStage — Type

Этап, выполняемый перед началом эксперимента Experiment.

# ReinforcementLearningCore.QBasedPolicy — Type

QBasedPolicy(;learner, explorer)

Инкапсулирует обучатель и исследователь. Обучатель — это структура, которая должна прогнозировать Q-значение каждого допустимого действия в среде в текущем состоянии. Обычно это таблица или нейронная сеть. Действие можно запросить у QBasedPolicy с помощью RLBase.plan!; исследователь повлияет на выбор действия соответствующим образом.

# ReinforcementLearningCore.RandomPolicy — Type

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

Если action_space имеет значение nothing, во время выполнения используется legal_action_space для выбора действия случайным образом. В противном случае выбирается случайный элемент из action_space.

Всегда устанавливайте значение action_space=nothing при работе со средами стиля FULL_ACTION_SET.

# ReinforcementLearningCore.ResetAfterNSteps — Type

ResetAfterNSteps(n)

Условие сброса, сбрасывающее среду после n шагов.

# ReinforcementLearningCore.ResetIfEnvTerminated — Type

ResetIfEnvTerminated()

Условие сброса, сбрасывающее среду, если is_terminated(env) имеет значение true.

# ReinforcementLearningCore.RewardsPerEpisode — Type

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

Сохраняет все награды за каждый шаг каждого эпизода в поле rewards.

# ReinforcementLearningCore.SoftGaussianNetwork — Type

SoftGaussianNetwork(;pre=identity, μ, σ, min_σ=0f0, max_σ=Inf32, squash = tanh)

То же, что и GaussianNetwork, но с возможностью дифференцируемой перепараметризации. Используется в основном для SAC. При вызове возвращает μ и σ. Создает распределение, из которого будет производиться выборка, с помощью Normal.(μ, σ). Аргументы min_σ и max_σ используются для усечения выходных данных σ. pre — это общее тело перед двумя головами нейронной сети. Значение σ должно быть больше 0. Сделать так, чтобы это требование выполнялось, можно посредством активации выхода softplus. Действия приводятся на tanh, и к logpdf применяется поправка.

# ReinforcementLearningCore.SoftGaussianNetwork — Method

(model::SoftGaussianNetwork)(rng::AbstractRNG, state::AbstractArray{<:Any, 3}, action_samples::Int)

Производит выборку action_samples действий из каждого состояния. Возвращает трехмерный тензор с измерениями (action_size x action_samples x batchsize). state должно быть трехмерным тензором с измерениями (state_size x 1 x batchsize). Всегда возвращает logpdf каждого действия.

# ReinforcementLearningCore.SoftGaussianNetwork — Method

Эта функция совместима с многомерным пространством действий.

  • rng::AbstractRNG=Random.default_rng()

  • is_sampling::Bool=false — производится ли выборка из полученного нормального распределения.

  • is_return_log_prob::Bool=false — следует ли вычислить условную вероятность получения действий в указанном состоянии.

# ReinforcementLearningCore.StackFrames — Type

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

Использует предварительно инициализированный объект CircularArrayBuffer для сохранения нескольких последних состояний, определяемых аргументом d. Перед обработкой какого-либо наблюдения буфер по умолчанию заполняется значениями zero{T} .

# ReinforcementLearningCore.StepsPerEpisode — Type

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

Сохраняет шаги каждого эпизода в поле steps.

# ReinforcementLearningCore.StopAfterNEpisodes — Type

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

Возвращает значение true после вызова episode раз. Если is_show_progress имеет значение true, для отображения хода выполнения используется ProgressMeter.

# ReinforcementLearningCore.StopAfterNSeconds — Type

StopAfterNSeconds

Параметр:

  1. Временной бюджет

Завершает обучение по истечении N секунд.

# ReinforcementLearningCore.StopAfterNSteps — Type

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

Возвращает значение true после вызова step раз.

# ReinforcementLearningCore.StopAfterNoImprovement — Type

StopAfterNoImprovement()

Завершает обучение, когда отслеживаемая метрика перестает улучшаться.

Параметры:

fn: замыкание; возвращает скалярное значение, указывающее производительность политики (чем выше, тем лучше), например:

  1. () -> reward(env)

  2. () -> totalrewardper_episode.reward

patience: количество эпох без улучшения, после которых обучение прекращается.

δ: минимальное изменение отслеживаемого количества, расцениваемое как улучшение, то есть абсолютное изменение меньше min_delta не считается улучшением.

Возвращает значение true после того, как отслеживаемая метрика перестала улучшаться.

# ReinforcementLearningCore.StopIfAny — Type

AnyStopCondition(stop_conditions...)

Результат stop_conditions уменьшается на any.

# ReinforcementLearningCore.StopIfEnvTerminated — Type

StopIfEnvTerminated()

Возвращает значение true, если выполнение среды завершилось.

# ReinforcementLearningCore.StopSignal — Type

StopSignal()

Создает сигнал остановки, инициализируемый со значением false. Ему можно вручную присвоить значение true с помощью выражения s[] = true, чтобы в любой момент остановить цикл выполнения.

# ReinforcementLearningCore.TDLearner — Type

TDLearner(;approximator, method, γ=1.0, α=0.01, n=0)

Использует метод временных разностей для оценки значения состояния или значения «состояние-действие».

Поля

  • approximator: объект <:TabularApproximator.

  • γ=1.0: норма скидки.

  • method: пока поддерживается только :SARS (Q-обучение).

  • n=0: количество использованных временных шагов минус 1.

# ReinforcementLearningCore.TabularApproximator — Method

TabularApproximator(table<:AbstractArray)

Для одномерной таблицы table служит аппроксиматором значения состояния. Для двухмерной таблицы table служит аппроксиматором значения «состояние-действие».

В двухмерной таблице table первым измерением являются действия, а вторым — состояния.

# ReinforcementLearningCore.TabularQApproximator — Method

TabularQApproximator(; n_state, n_action, init = 0.0)

Создает объект TabularQApproximator с n_state состояниями и n_action действиями.

# ReinforcementLearningCore.TargetNetwork — Type

TargetNetwork(network::FluxApproximator; sync_freq::Int = 1, ρ::Float32 = 0f0)

Инкапсулирует FluxApproximator для хранения целевой сети, которая обновляется в сторону сближения с моделью аппроксиматора.

  • sync_freq — это количество обновлений network между двумя обновлениями target.

  • ρ (ро) — это доля целевой модели, которая сохраняется при ее обновлении.

Два основных варианта использования TargetNetwork:

  • При значении ρ = 0 target полностью заменяется на network каждые sync_freq обновлений.

  • При значении ρ < 1 (но близком к единице) и значении sync_freq = 1 целевая модель согласуется с network посредством усреднения Поляка.

Реализует интерфейс RLBase.optimise!(::TargetNetwork, ::Gradient) для обновления модели с использованием градиента и обновления целевой модели с использованием замены весов или усреднения Поляка.

Примечание для разработчиков: model(::TargetNetwork) возвращает обучаемую модель Flux, target(::TargetNetwork) — целевую модель, а target(::FluxApproximator) — необучаемую модель Flux. См. документацию по RLCore.

# ReinforcementLearningCore.TargetNetwork — Method

TargetNetwork(network; sync_freq = 1, ρ = 0f0, use_gpu = false)

Создает целевую сеть для обучения с подкреплением.

Аргументы

  • network: главная сеть, используемая для обучения.

  • sync_freq: частота (в виде количества вызовов optimise!), с которой целевая сеть синхронизируется с главной сетью. Значение по умолчанию — 1.

  • ρ: коэффициент интерполяции, используемый для обновления целевой сети. Должен быть в диапазоне [0, 1]. Значение по умолчанию — 0 (старые веса полностью заменяются новыми).

  • use_gpu: указывает, следует ли использовать GPU для целевой сети. Значение по умолчанию — false.

Возвращает

Объект TargetNetwork.

# ReinforcementLearningCore.TimePerStep — Type

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

Сохраняет временные затраты (в секундах) на последние max_steps шагов в поле times.

# ReinforcementLearningCore.TotalRewardPerEpisode — Type

TotalRewardPerEpisode(; is_display_on_exit = true)

Сохраняет суммарную награду за каждый эпизод в поле rewards. Если is_display_on_exit имеет значение true, на этапе PostExperimentStage выводится график из символов Юникода.

# ReinforcementLearningCore.UCBExplorer — Method

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

Аргументы

  • na: количество действий, используемых при создании внутреннего счетчика.

  • t: служит для хранения текущего временного шага.

  • c: служит для управления степенью исследования.

  • seed: задает начальное значение для внутреннего генератора случайных чисел.

# ReinforcementLearningCore.VAE — Type

VAE(;encoder, decoder, latent_dims)

# ReinforcementLearningCore.WeightedExplorer — Type

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

is_normalized: указывает, были ли переданные значения действий нормализованы к сумме 1.0.

Предполагается, что значения элементов >=0.

См. также описание WeightedSoftmaxExplorer.

# ReinforcementLearningCore.WeightedSoftmaxExplorer — Type

WeightedSoftmaxExplorer(;rng=Random.default_rng())

См. также описание WeightedExplorer.

# Base.push! — Method

При отправке StackFrames в буфер CircularArrayBuffer той же размерности передается только последний фрейм. Если у объекта StackFrames на одно измерение меньше, он считается обычным массивом AbstractArray и передается как фрейм.

# Base.run — Method

Base.run(
    multiagent_policy::MultiAgentPolicy,
    env::E,
    stop_condition,
    hook::MultiAgentHook,
    reset_condition,
) where {E<:AbstractEnv, H<:AbstractHook}

Эта функция выполнения диспетчеризует игры с помощью MultiAgentPolicy и MultiAgentHook в соответствующую функцию run в зависимости от стиля Sequential или Simultaneous среды.

# Base.run — Method

Base.run(
    multiagent_policy::MultiAgentPolicy,
    env::E,
    ::Sequential,
    stop_condition,
    hook::MultiAgentHook,
    reset_condition,
) where {E<:AbstractEnv, H<:AbstractHook}

Эта функция обрабатывает игры MultiAgent со стилем Sequential. Она выполняет итерацию по current_player для каждого хода в среде и полностью выполняет цикл run, как и в случае с SingleAgent. Если выполняется условие stop_condition, функция выходит из цикла и снова вызывает optimise! для политики. Наконец, она вызывает optimise! для политики еще один раз и возвращает MultiAgentHook.

# Base.run — Method

Base.run(
    multiagent_policy::MultiAgentPolicy,
    env::E,
    ::Simultaneous,
    stop_condition,
    hook::MultiAgentHook,
    reset_condition,
) where {E<:AbstractEnv, H<:AbstractHook}

Эта функция обрабатывает игры MultiAgent со стилем Simultaneous. Она выполняет итерацию по игрокам в среде и для каждого из них выбирает подходящую политику из MultiAgentPolicy. Перед обновлением среды собираются все действия агентов. После того как каждый игрок выполнил действие, функция вызывает optimise! для политики. Если выполняется условие stop_condition, функция выходит из цикла и снова вызывает optimise! для политики. Наконец, она вызывает optimise! для политики еще один раз и возвращает MultiAgentHook.

# ReinforcementLearningBase.plan! — Method

RLBase.plan!(x::BatchExplorer, values::AbstractMatrix)

Применяет внутренний исследователь к каждому столбцу в values.

# ReinforcementLearningBase.plan! — Method

RLBase.plan!(s::EpsilonGreedyExplorer, values; step) where T

Если найдено несколько значений с одинаковым максимальным значением, то при is_break_tie==true возвращается случайное значение.

 
Значения `NaN` отфильтровываются, если только не все они равны `NaN`. В этом случае возвращается случайное значение.

# ReinforcementLearningBase.prob — Method

prob(p::AbstractExplorer, x, mask)

То же, что и prob(p::AbstractExplorer, x), но учитываются только маскированные (mask) элементы.

# ReinforcementLearningBase.prob — Method

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

Возвращает распределение действий исходя из значений действий.

# ReinforcementLearningBase.prob — Method

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

Возвращает вероятность выбора каждого действия исходя из его оценочных значений values.

# ReinforcementLearningCore._discount_rewards! — _Method

Предполагается, что rewards и new_rewards — это вектор.

# ReinforcementLearningCore._generalized_advantage_estimation! — _Method

Предполагается, что rewards и advantages — это вектор.

# ReinforcementLearningCore.bellman_update! — Method

bellman_update!(app::TabularApproximator, s::Int, s_plus_one::Int, a::Int, α::Float64, π_::Float64, γ::Float64)

Обновляет Q-значение указанной пары «состояние-действие».

# ReinforcementLearningCore.check — Method

Переписав эту функцию, можно добавить пользовательские проверки.

# ReinforcementLearningCore.cholesky_matrix_to_vector_index — Method

cholesky_matrix_to_vector_index(i, j)

Возвращает позицию в векторе cholesky_vec (длиной da), которую занимает элемент нижней треугольной матрицы с координатами (i,j).

Например, если cholesky_vec = [1,2,3,4,5,6], соответствующая нижняя треугольная матрица имеет следующий вид:

L = [1 0 0
     2 4 0
     3 5 6]

и cholesky_matrix_to_vector_index(3, 2) == 5.

# ReinforcementLearningCore.diagnormkldivergence — Method

diagnormkldivergence(μ1, σ1, μ2, σ2)

Дифференцируемая на GPU реализация расстояния Кульбака-Лейблера между двумя многомерными гауссовыми распределениями с векторами средних значений μ1, μ2 соответственно и диагональными среднеквадратичными отклонениями σ1, σ2. Аргументы должны быть векторами или массивами векторов столбцов.

# ReinforcementLearningCore.diagnormlogpdf — Method

diagnormlogpdf(μ, σ, x; ϵ = 1.0f-8)

Совместимая с GPU и автоматически дифференцируемая версия функции logpdf нормальных распределений с диагональной ковариацией. Добавляет значение epsilon для обеспечения численной устойчивости, если значение sigma равно нулю (например, если в выходном слое используется ReLU). Принимает аргументы одинаковой формы: векторы, матрицы или трехмерные массивы (второе измерение которых имеет размер 1).

# ReinforcementLearningCore.discount_rewards — Method

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

Вычисляет выигрыш начиная с текущего шага с нормой скидки γ. rewards может быть матрицей.

Именованные аргументы

  • dims=:: если rewards — это объект Matrix, значением dims может быть только 1 или 2.

  • terminal=nothing: происходит ли после получения каждой награды окончание. nothing означает, что игра еще не окончена. Если аргумент terminal указан, его размер должен быть таким же, как у rewards.

  • init=nothing: с помощью аргумента init можно указать оценку награды в последнем состоянии.

Пример

# ReinforcementLearningCore.flatten_batch — Method

flatten_batch(x::AbstractArray)

Объединяет два последних измерения.

Пример

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

# ReinforcementLearningCore.generalized_advantage_estimation — Method

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

Вычисляет общую оценку преимущества начиная с текущего шага с нормой скидки γ и лямбдой λ для GAE-лямбда. rewards и values могут быть матрицами.

Именованные аргументы

  • dims=:: если rewards — это объект Matrix, значением dims может быть только 1 или 2.

  • terminal=nothing: происходит ли после получения каждой награды окончание. nothing означает, что игра еще не окончена. Если аргумент terminal указан, его размер должен быть таким же, как у rewards.

Пример

# ReinforcementLearningCore.logdetLorU — Method

logdetLorU(LorU::AbstractMatrix)

Логарифм определителя положительно полуопределенной матрицы A = L*U (нижний и верхний треугольники Холецкого) для заданного L или U. Для матриц, не являющихся положительно полуопределенными, имеет знаковую неопределенность.

# ReinforcementLearningCore.mvnormkldivergence — Method

mvnormkldivergence(μ1, L1, μ2, L2)

Дифференцируемая на GPU реализация расстояния Кульбака-Лейблера между двумя многомерными гауссовыми распределениями с векторами средних значений μ1, μ2 соответственно и с разложением Холецкого ковариационных матриц L1, L2.

# ReinforcementLearningCore.mvnormlogpdf — Method

mvnormlogpdf(μ::AbstractVecOrMat, L::AbstractMatrix, x::AbstractVecOrMat)

Совместимая с GPU и автоматически дифференцируемая версия функции logpdf многомерных нормальных распределений. В качестве входных значений принимает mu (вектор средних значений), L (нижнюю треугольную матрицу разложения Холецкого ковариационной матрицы) и x (матрицу выборок, каждый столбец которой представляет собой выборку). Возвращает вектор, содержащий logpdf каждого столбца x для MvNormal с параметризацией по μ и Σ = L*L'.

# ReinforcementLearningCore.mvnormlogpdf — Method

mvnormlogpdf(μ::A, LorU::A, x::A; ϵ = 1f-8) where A <: AbstractArray

Пакетная версия, принимающая в качестве входных данных трехмерные тензоры, каждый срез которых по третьему измерению — это пакетная выборка. μ — это матрица размером (actionsize x 1 x batchsize). L имеет размер (actionsize x actionsize x batchsize), а x — размер (actionsize x actionsamples x batchsize). Возвращает трехмерную матрицу размером (1 x actionsamples x batchsize).

# ReinforcementLearningCore.normkldivergence — Method

normkldivergence(μ1, σ1, μ2, σ2)

Дифференцируемая на GPU реализация расстояния Кульбака-Лейблера между двумя одномерными гауссовыми распределениями со средними значениями μ1, μ2 и среднеквадратичными отклонениями σ1, σ2 соответственно.

# ReinforcementLearningCore.normlogpdf — Method

 normlogpdf(μ, σ, x; ϵ = 1.0f-8)

Совместимая с GPU и автоматически дифференцируемая версия функции logpdf одномерного нормального распределения. Добавляет значение epsilon для обеспечения численной устойчивости, если значение sigma равно нулю (например, если в выходном слое используется ReLU).

# ReinforcementLearningCore.vec_to_tril — Method

Преобразует вектор, содержащий ненулевые элементы нижней треугольной матрицы da x da в эту матрицу.

Помимо цикла выполнения, RLCore содержит коллекцию готовых компонентов, которые часто используются в обучении с подкреплением.

QBasedPolicy

QBasedPolicy — это подтип AbstractPolicy, в котором инкапсулируются обучатель (табличный или аппроксимируемый) и исследователь Q-значения. С помощью этой оболочки можно реализовать политику, которая напрямую использует функцию Q-значения для выбора следующего действия. В этом случае вместо создания подтипа AbstractPolicy для алгоритма определите подтип AbstractLearner и специализируйте интерфейс RLBase.optimise!(::YourLearnerType, ::Stage, ::Trajectory). Таким образом, вам не придется самостоятельно программировать взаимодействие между политикой и исследователем. RLCore предоставляет наиболее распространенные стратегии исследования (такие как эпсилон-жадная, UCB и т. д.). Множество примеров политик QBasedPolicy можно найти в разделе DQN документации по RLZoo.

Параметрические аппроксиматоры

Аппроксиматор

Если в вашем алгоритме применяется нейронная сеть или линейный аппроксиматор для аппроксимации функции, обученной с помощью Flux.jl, используйте объект Approximator. Он инкапсулирует модель Flux и объект Optimiser (например, Adam или SGD). Действие вашей функции optimise!(::PolicyOrLearner, batch), вероятно, будет заключаться в вычислении градиента и последующем вызове RLBase.optimise!(app::Approximator, gradient::Flux.Grads).

Approximator реализует интерфейсы model(::Approximator) и target(::Approximator). Оба они возвращают базовую модель Flux. Преимущество этих интерфейсов объясняется в разделе TargetNetwork ниже.

TargetNetwork

Целевые сети часто применяются в обучении с подкреплением на основе состояний или значений действий. Принцип работы такой сети заключается в том, что в ней хранится копия главного аппроксиматора, который обучается с помощью градиента, и еще одна его копия, которая обновляется лишь частично или просто реже. Объект TargetNetwork создается путем инкапсуляции объекта Approximator. Присвойте именованному аргументу sync_freq значение больше единицы, чтобы главная модель копировалась в целевую каждые sync_freq обновлений, либо присвойте параметру \rho значение больше нуля (обычно 0.99f0), чтобы целевая модель частично обновлялась в сторону сближения с главной моделью при каждом обновлении. Интерфейс RLBase.optimise!(tn::TargetNetwork, gradient::Flux.Grads) отвечает за автоматическое обновление целевой модели.

Еще одним преимуществом TargetNetwork является то, что благодаря множественной диспетчеризации в Julia работа алгоритма не зависит от наличия или отсутствия целевой сети. Например, DQNLearner в RLZoo имеет поле approximator типа Union{Approximator, TargetNetwork}. При вычислении погрешности временной разности обучатель вызывает Q = model(learner.approximator) и Qt = target(learner.approximator). Если learner.approximator — это объект Approximator, то целевая сеть не используется, так как оба вызова указывают на одну и ту же нейронную сеть, а если это объект TargetNetwork, то возвращается автоматически управляемая целевая модель.

Архитектуры

Предоставляются также стандартные архитектуры моделей, например GaussianNetwork для непрерывных политик с диагональными многомерными политиками и CovGaussianNetwork для полной ковариации (пока с очень низкой скоростью выполнения на GPU).