Математика алгоритма градиента политики объясняется реализацией PyTorch

Пошаговое объяснение алгоритма градиента политик RL и его реализации.

Оглавление

· Введение
· Метод градиента политики
∘ Вывод
∘ Оптимизация
∘ Алгоритм
· Реализация PyTorch
∘ Сети
∘ Цикл обучения (основной алгоритм)
∘ Результаты обучения< br /> · Заключение
· Литература

Введение

Обучение с подкреплением (RL) — это подобласть ИИ, цель которой — позволить машинам учиться и улучшать свое поведение, взаимодействуя с окружающей средой и получая обратную связь в виде сигналов вознаграждения. Эта среда математически сформулирована как марковский процесс принятия решений (MDP), где на каждом временном шаге известно, что агент находится в определенном состоянии (s ∈ S), где он может предпринять действие (a ∈ A). Это действие приводит к переходу из состояния s в новое состояние (s' ∈ S) с определенной вероятностью из функции динамики P(s, a, s') и получение скалярного вознаграждения r от функции вознаграждения R(s, a, s'). При этом MDP могут отображаться набором наборов (S, A, P, R,γ), в которых γ ∈ (0, 1] — коэффициент дисконтирования вознаграждений за будущие шаги.

Алгоритмы RL можно разделить на две группы: методы, основанные на значениях и на основе политик. Методы, основанные на значениях, направлены на оценку ожидаемого возврата состояний и выбор действия в этом состоянии, которое приводит к наибольшему ожидаемому значению, что является скорее косвенным способом оптимального поведения в среде MDP. Напротив, методы, основанные на политике, пытаются изучить и оптимизировать функцию политики, которая в основном представляет собой отображение состояний в действия. Метод Policy Gradient (PG) [1][2] — это популярный подход на основе политик в RL, который напрямую оптимизирует функцию политик, изменяя ее параметры с помощью градиентного восхождения. .

PG имеет некоторые преимущества перед методами, основанными на значениях, особенно при работе со средами с непрерывными пространствами действий или высокой стохастичностью. PG также может обрабатывать недифференцируемые политики, что делает его подходящим для сложных сценариев. Однако PG может страдать от некоторых проблем, таких как высокая дисперсия в оценках градиента, что может привести к более медленной сходимости и/или нестабильности.

В этом посте мы подробно расскажем о методе градиента политики, изучив его сильные стороны и ограничения. Мы обсудим интуицию, лежащую в основе PG, как она работает, а также предоставим кодовую реализацию алгоритма. Я постараюсь рассказать о различных модификациях и расширениях, которые были предложены для улучшения его производительности, в следующих постах.

Метод градиента политики

Как объяснялось выше, методы политик-градиентов (PG) — это алгоритмы, целью которых является изучение оптимальной функции политики непосредственно в настройках марковских процессов принятия решений (S, A, P, R,γ). В PG политикаπ представлена параметрической функцией (например, нейронной сетью), поэтому мы можем управлять ее выходными данными, изменяя ее параметры. Политикаπ сопоставляет состояние с действиями (или распределениями вероятностей по действиям).

Цель PG — разработать политику, которая максимизирует ожидаемое совокупное вознаграждение по траектории состояний и действий (т. н. доход). Давайте рассмотрим, как это достигается.

Вывод

Итак, учитывая, что у нас есть функция политикиπ, параметризованная набором параметров θ. Учитывая состояние в качестве входных данных, политика выводит распределение вероятностей по действиям в каждом состоянии. Зная это, во-первых, нам нужно придумать задачу/цель, чтобы мы хотели оптимизировать параметры нашей функции политики в отношении этой цели.

Обратите внимание, что эта функция политики может быть аппроксимирована любым методом аппроксимации функции. Однако в случае глубокого RL мы считаем, что эта функция аппроксимируется нейронной сетью (с набором параметров θ), которая принимает состояния (наблюдения) в качестве входных данных и выходных данных. распределение по действиям. Это может быть дискретное распределение для дискретных действий или непрерывное распределение для непрерывных действий.

Как правило, целью агента будет получение максимального совокупного вознаграждения за траекторию взаимодействий (последовательности состояний и действий). Итак, пустьτ обозначает такую траекторию, т. е. последовательность состояний-действий s₀, a₀, s₁, a₁, …, sₕ, aₕ, И R(τ) обозначает совокупное вознаграждение по этой траектории, также известное как возврат.

Очевидно, что эта траектория τ,является случайной величиной из-за ее стохастичности. Это делает R(τ) также стохастической функцией. Поскольку мы не можем максимизировать эту стохастическую функцию напрямую, мы хотели бы максимизировать ее математическое ожидание, то есть максимизировать его в среднем случае, предпринимая действия с политикой π: E[ R(τ); π].

И в качестве напоминания о вероятностях, вот как вычислить дискретное математическое ожидание функции случайной величины:

Таким образом, конечная целевая функция, которую мы хотели бы максимизировать, переписывается следующим образом. Кроме того, теперь мы будем называть эту целевую функцию Функция полезности (U).

где P(τ;θ) — вероятность того, что траектория τ реализуется по параметрам политики θ.

Обратите внимание, что эта функция полезности записывается как функция θ, набора параметров политики, потому что только политика управляет траекториями, поскольку динамическая среда фиксировано (и обычно неизвестно), и мы хотели бы оптимизировать эту утилиту, изменив и оптимизировав θ. Также обратите внимание, что серия вознаграждений R по траектории не зависит от политики. Следовательно, он не зависит от параметров θ, поскольку он основан на среде и представляет собой только испытанное скалярное значение.

Оптимизация

Теперь, когда у нас есть функция полезности U(θ), мы хотели бы оптимизировать ее с помощью алгоритма оптимизации на основе стохастического градиента, а именно Stochastic Gradient Ascent:

Чтобы иметь возможность выполнить обновление параметра, мы должны вычислить градиент утилиты по θ (∇U). Пытаясь сделать это, мы получаем:

Обратите внимание, что градиент по сумме равен сумме градиентов. Теперь продолжим, применив хитрость, умножив это выражение на P(τ;θ)/P(τ;θ), что равно1 . Помните из исчисления, что
∇f(x)/f(x) = ∇log(f(x)),поэтому мы получаем:

Мы делаем этот трюк, чтобы создать общую форму ожидания 'ΣP(x)f(x)'в градиенте,которую позже мы можем заменить и оценить ожиданиес средним значением по выборкам реальных данных о взаимодействии.

Поскольку мы не можем суммировать по ВСЕМ возможным траекториям, в стохастической ситуации мы оцениваем это выражение (∇U(θ)), генерируя «m»количество случайных траекторий, используя параметры политики θ и усредняя приведенные выше ожидание по этим mтраекториям для оценки градиента ∇U(θ):

Итак, теперь у нас есть способ оценить градиент с помощью образцов траектории, но здесь есть проблема. этот градиент заставляет параметры θ изменяться в направлении, при котором вероятность траекторий с более высокой доходностью R(τ)увеличивается больше всего. Однако у этого есть недостаток, заключающийся в том, что направление изменения вероятности траектории сильно зависит от того, как устроена функция вознаграждения R. Например, если все переходы приводят к положительному вознаграждению, вероятности всех траекторий будут увеличены, и ни одна траектория не будет оштрафована, и наоборот для случаев с отрицательным R.

Чтобы решить эту проблему, предлагается вычесть базовое значение (b)[1] из результата (т. е. изменить 'R(τ)' to'R(τ)-b'), где этот базовый показатель b должен оценить, какой доход будет в среднем. Это помогает централизовать доходность вокруг нуля, что увеличивает вероятность траектории, которая работает лучше, чем в среднем, а вероятность того, что нет, уменьшается. Существует несколько предложенных способов расчета базового уровня b, среди которых использование нейронной сети — тот, который мы будем использовать позже.

Кроме того, разложив вероятность траектории P(τ)на временные временные интервалы и записав ее как произведение вероятностей всех H временных шагов, а также зная, что динамика среды НЕ зависит от параметров θ, поэтому ее градиент по θ будет равен 1, мы можем переписать градиент траектории по отношению к Временные шаги и исключительно на основе функции политики π:

Кроме того, мы можем разложить доходность R(τ) как сумму вознаграждений за отдельные временные интервалы Σrₜ. И на каждом временном шаге t мы можем игнорироватьнаграды от предыдущих временных шагов 0, …, t-1, поскольку на них не влияет текущее действие aₜ (Удаление терминов, не зависящих от текущего действия, может снизить дисперсию). Вместе с включением базовой линии у нас будет следующий временной формат:

Таким образом, оценка градиента ‘g’ будет:

Наконец, в качестве правильного выбора для оценки базового уровня b(sₜ) мы можем использовать ожидаемый доход от состояния sₜ и далее, который также известен как Функция ценности этого состояния V(sₜ ). Мы будем использовать другую нейронную сеть с набором параметров ϕ, чтобы аппроксимировать эту функцию значений с целью Беллмана, используя либо метод Монте-Карло, либо метод обучения временных разностей на основе данных взаимодействия. окончательный вид будет следующим:

Кроме того, полезно знать, что разница между R(sₜ) и базовым уровнем b(sₜ) называется функцией преимущества A(sₜ). В некоторых реализациях, поскольку R(sₜ)эквивалентен значению состояния-действия, также известному как Q-функция Q(sₜ), преимущество записывается как A(sₜ) = Q(sₜ)-V(sₜ), где и Q, и V могут быть аппроксимированы с помощью нейронных сетей и, возможно, даже с общими весами.

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

Алгоритм

На основе полученного оценщика градиента g, аппроксимационной сети функции значения и правила обновления градиентного восхождения, общий алгоритм обучения агента с Алгоритм ванильного (простого) градиента политики выглядит следующим образом:

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

Реализация PyTorch

Для реализации VPG нам понадобятся следующие компоненты:

Policy Network с вероятностными выходными данными для выборки. (вывод Softmax для дискретного пространства действий или оценки параметров, такие как μ, σвывод для гауссового расстояния для непрерывных пространств действий)
Сеть создания ценности для оценки преимуществ.
Среда класса с интерфейсом тренажерный зал.
Цикл обучения

сети

Прежде всего, мы определяем Policy и Value Networks как классы модуля PyTorch. Для этой игрушечной задачи мы используем простые многослойные персептронные сети.

Импорт зависимостей

# import dependencies
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions import Categorical
import numpy as np
import gym
from collections import deque

Правила сети:

class PolicyNet(nn.Module):
    def __init__(self, state_dim, n_actions, n_hidden):
        super(PolicyNet, self).__init__()
        self.linear1 = nn.Linear(state_dim, n_hidden)
        self.linear2 = nn.Linear(n_hidden, n_actions)
        self.rewards, self.saved_actions = [], []

    def forward(self, x):
        out = F.relu(self.linear1(x))
        out = self.linear2(out)
        aprob = F.softmax(out, dim=1) # Softmax for categorical probabilities
        return aprob

Чистая стоимость:

class ValueNet(nn.Module):
    def __init__(self, state_dim, n_hidden):
        super(ValueNet, self).__init__()
        self.linear1 = nn.Linear(state_dim, n_hidden)
        self.linear2 = nn.Linear(n_hidden, 1)

    def forward(self, x):
        out = F.relu(self.linear1(x))
        V = self.linear2(out)
        return V

Цикл обучения (основной алгоритм)

Мы будем использовать простую среду Cartpole из библиотеки gym. Подробнее об этой среде, ее состояниях и пространствах действий можно прочитать здесь.

Полный алгоритм выглядит следующим образом:

## Vanilla Policy Gradient

# create environment
env = gym.make("CartPole-v1") # sample toy environment

# instantiate the policy and value networks
policy = PolicyNet(state_dim=env.observation_space.shape[0], n_actions=env.action_space.n, n_hidden=64)
value = ValueNet(state_dim=env.observation_space.shape[0], n_hidden=64)

# instantiate an optimizer
policy_optimizer = torch.optim.SGD(policy.parameters(), lr=2e-7)
value_optimizer = torch.optim.SGD(value.parameters(), lr=1e-7)

# initialize gamma and stats
gamma=0.99
num_episodes = 5000
returns_deq = deque(maxlen=100)
memory_buffer_deq = deque(maxlen=2000)

for n_ep in range(num_episodes):
    rewards = []
    actions = []
    states  = []
    # reset environment
    state = env.reset()
    done = False

    while not done:
        # recieve action probabilities from policy function
        probs = policy(torch.tensor(state).unsqueeze(0).float())

        # sample an action from the policy distribution
        policy_prob_dist = Categorical(probs)
        action = policy_prob_dist.sample()

        # take that action in the environment
        new_state, reward, done, info = env.step(action.item())

        # store state, action and reward
        states.append(state)
        actions.append(action)
        rewards.append(reward)

        memory_buffer_deq.append((state, reward, new_state))

        state = new_state

    ### UPDATE POLICY NET ###
    rewards = np.array(rewards)
    # calculate rewards-to-go
    R = torch.tensor([np.sum(rewards[i:]*(gamma**np.array(range(i, len(rewards))))) for i in range(len(rewards))])

    # cast states and actions to tensors
    states = torch.tensor(states).float()
    actions = torch.tensor(actions)

    # calculate baseline V(s)
    with torch.no_grad():
        baseline = value(states)

    # calculate utility func
    probs = policy(states)
    sampler = Categorical(probs)
    log_probs = - sampler.log_prob(actions)   # "-" is because we are doing gradient ascent
    utility = torch.sum(log_probs * (R-baseline)) # loss that when differentiated with autograd gives the gradient of J(θ)
    
    # update policy weights
    policy_optimizer.zero_grad()
    utility.backward()
    policy_optimizer.step()
    
    ########################
    ### UPDATE VALUE NET ###

    # getting batch experience data 
    batch_experience = random.sample(list(memory_buffer_deq), min(256, len(memory_buffer_deq)))
    state_batch = torch.tensor([exp[0] for exp in batch_experience])
    reward_batch = torch.tensor([exp[1] for exp in batch_experience]).view(-1,1)
    new_state_batch = torch.tensor([exp[2] for exp in batch_experience])


    with torch.no_grad():
        target = reward_batch + gamma*value(new_state_batch)
    current_state_value = value(new_state_batch)

    value_loss = torch.nn.functional.mse_loss(current_state_value, target)
    # update value weights
    value_optimizer.zero_grad()
    value_loss.backward()
    value_optimizer.step()

    ########################

    # calculate average return and print it out
    returns_deq.append(np.sum(rewards))
    print("Episode: {:6d}\tAvg. Return: {:6.2f}".format(n_ep, np.mean(returns_deq)))

# close environment
env.close()

Результаты обучения

После обучения агента с VPG на 4000 эпизодов получаем следующие результаты:

Стоит отметить, что у vanilla PG есть два основных ограничения:

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

Вторая проблема решается в некоторых дополнительных вариантах алгоритма PG, которые я постараюсь осветить в следующих постах.

Здесь показана иллюстрация полностью обученного агента, управляющего средой Cartpole:

Полный код этой реализации доступен в этом репозитории GitHub.

GitHub — ebrahimpichka/vanilla-pg: простая реализация PyTorch градиента политики Vanilla…
Вы не можете выполнить это действие в настоящее время. Вы вошли в другую вкладку или окно. Вы вышли на другой вкладке или…github.com

Заключение

В заключение мы изучили алгоритм градиента политики (PG), мощный подход в обучении с подкреплением (RL), который непосредственно изучает оптимальную политику. В этом сообщении блога мы предоставили пошаговое объяснение алгоритма PG и его реализации. Мы начали с понимания фундаментальной концепции RL и разницы между методами, основанными на ценностях, и методами, основанными на политике. Затем мы углубились в детали PG, выделив ее цель максимизировать ожидаемое совокупное вознаграждение путем обновления параметров политики с использованием градиентного восхождения. Мы обсудили алгоритм Vanilla PG как обычную реализацию PG, где мы вычисляем градиент логарифмической вероятности действий и обновляем политику, используя градиенты политик. Кроме того, мы изучили метод «актор-критик», который сочетает в себе сеть политик и функцию ценности для улучшения конвергенции. Хотя PG предлагает преимущества в обработке непрерывных пространств действий и недифференцируемых политик, он может страдать от высокой дисперсии. Тем не менее, для решения этих проблем можно использовать такие методы, как базовые уровни и методы уменьшения дисперсии. Поняв тонкости PG, вы теперь вооружены ценным инструментом для решения проблем RL и разработки интеллектуальных систем, которые обучаются и адаптируются посредством взаимодействия с окружающей средой.