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

ReinforcementLearningCore.jl

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

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

Обработчик вызывается на различных этапах выполнения 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 с помощью оператора +.

AbstractLearner

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

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

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

Agent(;policy, trajectory) <: AbstractPolicy

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

BatchExplorer(explorer::AbstractExplorer)
BatchStepsPerEpisode(batchsize::Int; tag = "TRAINING")

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

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.

(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, и (или) нулевую вероятность выборки.

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.(μ, Σ).

(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).

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

(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 соответственно.

(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 — следует ли вычислить условную вероятность получения действий в указанном состоянии.

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

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

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

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

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

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

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

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

DoOnExit(f)

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

DuelingNetwork(;base, val, adv)

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

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

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 
Experiment(policy::AbstractPolicy, env::AbstractEnv, stop_condition::AbstractStopCondition, hook::AbstractHook)

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

FluxApproximator(model, optimiser)

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

FluxApproximator(; model, optimiser, usegpu=false)

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

Аргументы

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

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

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

Возвращает

Объект FluxApproximator.

(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 каждого действия.

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

  • rng::AbstractRNG=Random.default_rng()

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

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

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

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

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

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

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

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

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

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

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

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

PlayerTuple

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

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

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

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

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

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

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

QBasedPolicy(;learner, explorer)

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

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

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

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

 
ResetAfterNSteps(n)

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

ResetIfEnvTerminated()

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

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

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

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

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

(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 каждого действия.

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

  • rng::AbstractRNG=Random.default_rng()

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

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

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

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

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

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

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

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

StopAfterNSeconds

Параметр:

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

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

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

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

StopAfterNoImprovement()

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

Параметры:

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

  1. () -> reward(env)

  2. () -> totalrewardper_episode.reward

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

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

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

AnyStopCondition(stop_conditions...)

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

StopIfEnvTerminated()

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

StopSignal()

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

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

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

Поля

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

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

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

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

TabularApproximator(table<:AbstractArray)

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

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

 
TabularQApproximator(; n_state, n_action, init = 0.0)

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

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.

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

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

Аргументы

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

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

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

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

Возвращает

Объект TargetNetwork.

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

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

TotalRewardPerEpisode(; is_display_on_exit = true)

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

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

Аргументы

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

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

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

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

VAE(;encoder, decoder, latent_dims)
WeightedExplorer(;is_normalized::Bool, rng=Random.default_rng())

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

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

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

WeightedSoftmaxExplorer(;rng=Random.default_rng())

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

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

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

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

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

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

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

 
Значения `NaN` отфильтровываются, если только не все они равны `NaN`. В этом случае возвращается случайное значение.
prob(p::AbstractExplorer, x, mask)

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

Пример

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
generalized_advantage_estimation(rewards::VectorOrMatrix, values::VectorOrMatrix, γ::Number, λ::Number;kwargs...)

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

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

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

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

Пример

logdetLorU(LorU::AbstractMatrix)

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

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

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

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

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

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

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

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

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

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

Преобразует вектор, содержащий ненулевые элементы нижней треугольной матрицы 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).