Teorema do Gradiente de Política Explicado: Uma Introdução Prática

Por que usar métodos de gradiente de política?

Uma vantagem chave dos métodos de gradiente de política é sua capacidade de lidar com espaços de ação complexos, onde abordagens tradicionais baseadas em valor têm dificuldades.

Manipulando espaços de ação de alta dimensão.

Métodos baseados em valor, como o Q-learning, funcionam estimando a função de valor para todas as ações possíveis. Isso se torna difícil quando o espaço de ações do ambiente é contínuo ou discreto, mas grande.

Métodos de gradiente de política parametrizam a política e estimam o gradiente das recompensas cumulativas em relação aos parâmetros da política. Eles usam esse gradiente para otimizar diretamente a política, atualizando seus parâmetros. Assim, podem lidar de forma eficiente com espaços de ação de alta dimensão ou contínuos. Os gradientes de política também são a base dos métodos de Aprendizado por Reforço com Feedback Humano (RLHF).

Ao parametrizar a política e ajustar seus parâmetros com base nos gradientes, os gradientes de política podem lidar de forma eficiente com ações contínuas e de alta dimensão. Essa abordagem direta permite uma melhor generalização e uma exploração mais flexível, tornando-a bem adequada para tarefas como controle robótico e outros ambientes complexos.

Aprendendo políticas estocásticas

Dado um conjunto de observações:

• Uma política determinística especifica qual ação o agente toma.
• Uma política estocástica fornece um conjunto de ações e a probabilidade do agente escolher cada ação.

Ao seguir uma política estocástica, a mesma observação pode levar à escolha de diferentes ações em diferentes iterações. Isso promove a exploração do espaço de ações e impede que a política fique presa em ótimos locais. Por causa disso, políticas estocásticas são úteis em ambientes onde a exploração é essencial para descobrir o caminho que leva aos retornos máximos.

Nos métodos baseados em políticas, a saída da política é convertida em uma distribuição de probabilidade, com cada ação possível atribuída a uma probabilidade. O agente escolhe uma ação amostrando essa distribuição, tornando possível implementar uma política estocástica. Assim, os métodos de gradiente de política combinam exploração com exploração, úteis em ambientes com estruturas de recompensa complexas.

Derivação do Teorema do Gradiente da Política

Antes de mergulhar na derivação, é importante estabelecer a notação matemática e os conceitos-chave usados ao longo da prova.

Notação matemática e preliminares

Como mencionado em uma seção anterior, o teorema do gradiente de política afirma que a derivada do retorno esperado é a expectativa do produto do retorno e da derivada do logaritmo da política.

Antes de derivar o teorema do gradiente de política, introduzimos a notação:

• E[X] refere-se à expectativa probabilística de uma variável aleatória X.
• Matematicamente, a política é expressa como uma matriz de probabilidade que fornece a probabilidade de escolher diferentes ações com base em diferentes observações. Uma política é tipicamente modelada como uma função parametrizada, com os parâmetros representados como θ.
• π_θ refere-se a uma política parametrizada por θ. Na prática, esses parâmetros são os pesos da rede neural que modela a política.
• A trajetória, τ, refere-se a uma sequência de estados, geralmente começando a partir de um estado inicial randomizado até o passo de tempo atual ou o estado terminal.
• ∇_θf refere ao gradiente de uma função f em relação ao(s) parâmetro(s) θ.
• J(π_θ) refere-se ao retorno esperado alcançado pelo agente seguindo a política π_θ. Esta é também a função objetivo para a ascensão do gradiente.
• O ambiente fornece uma recompensa a cada passo de tempo, dependendo da ação do agente. O retorno refere-se às recompensas acumuladas desde o estado inicial até o passo de tempo atual.
• R(τ) refere-se ao retorno gerado ao longo da trajetória τ.

Passos de derivação

Mostramos como derivar e provar o teorema do gradiente de política a partir dos princípios básicos, começando com a expansão da função objetivo e usando o truque do logaritmo da derivada.

A função objetivo (Equação 1)

A função objetivo no método do gradiente de política é o retorno

J acumulado seguindo a trajetória com base na política π expressa em termos de parâmetros θ. Esta função objetivo é dada como:

Na equação acima:

• O lado esquerdo (LHS) é o retorno esperado alcançado ao seguir a política π_θ.
• O lado direito (RHS) é a expectativa (sobre a trajetória τ gerada ao seguir a política π_θ em cada passo) dos retornos R(τ) gerados ao longo da trajetória τ.  

A diferencial da função objetivo (Equação 2)

Diferenciando (em relação a θ) ambos os lados da equação acima, obtemos:

O gradiente da expectativa (Equação 3)

A expectativa (no RHS) pode ser expressa como uma integral sobre o produto de:

• A probabilidade de seguir uma trajetória τ
• Os retornos gerados ao longo da trajetória τ

Assim, o RHS da Equação 2 é reformulado como:

A integral do gradiente é igual à integral do gradiente. Portanto, na expressão acima, podemos trazer o gradiente ∇_θ sob o sinal de integral. Portanto, o RHS torna-se:

Assim, a Equação 2 pode ser reescrita como:

A probabilidade da trajetória (Equação 4)

Agora vamos dar uma olhada mais de perto em P(τ|θ), a probabilidade do agente seguir a trajetória τ dadas os parâmetros da política θ (e, portanto, a política π_θ). Uma trajetória consiste em um conjunto de passos. Assim:

• A probabilidade de obter a trajetória τ é o produto de:
• A probabilidade de seguir todos os passos individuais.

• No passo de tempo t, o agente passa do estado s para o estado s_t+1 seguindo a ação a_t. A probabilidade disso acontecer é dada pelo produto de:
• A probabilidade da política prever a ação a_t no estado s_t
• A probabilidade de terminar no estado st+1 dado a ação at e estado st

Dessa forma, partindo de um estado inicial s₀, a probabilidade do agente seguir a trajetória τ com base na política π_θ é dada por:

Para simplificar, queremos expressar o produto no RHS acima como uma soma. Portanto, tiramos o logaritmo de ambos os lados da equação acima:

A derivada da log-probabilidade (Equação 5) 

Agora tomamos a derivada (em relação a θ) da log probabilidade na equação acima. 

No RHS da equação acima: 

• O primeiro termo log ρ₀(s₀) é constante em relação ao θ. Portanto, sua derivada é 0.
• O primeiro termo dentro da soma P(s_t+1|s_t, a_t) também é independente de θ e sua derivada em relação a θ também é 0.

Removendo os termos zero acima da equação, ficamos com (Equação 5):

Lembre-se da Equação 2 que:

A Equação 5 avalia o logaritmo da primeira parte do RHS da Equação 2. Precisamos relacionar a derivada de um termo com seu logaritmo. Fazemos isso usando a regra da cadeia e o truque do logaritmo da derivada.

O truque do logaritmo da derivada

Fazemos um desvio e usamos as regras do cálculo para derivar um resultado, que usaremos para simplificar a equação anterior e torná-la adequada para métodos computacionais.

No cálculo, a derivada de um logaritmo pode ser expressa como:

Assim, rearranjando a equação acima, a derivada de x pode ser expressa em termos da derivada do logaritmo de x:

Isso às vezes é chamado de truque do logaritmo na derivada.

A regra da cadeia

De acordo com a regra da cadeia, dado z(y) como função de y, onde y é em si uma função de θ, y(θ), a derivada de z em relação a θ é dada por:

Neste caso, y(θ) representa P(θ) e z(y) representa log(y). Assim, 

Aplicando a regra da cadeia

Sabemos do cálculo que d(log(y)) / dy = 1/y. Use isso na primeira expressão do lado direito acima.

Mova y para o LHS e use a notação:

y representa P(θ). Portanto, a equação acima é equivalente a:

Aplicando o truque da derivada de log

O resultado acima fornece a primeira expressão do RHS da Equação 2 (mostrada abaixo).

Usando o resultado no RHS da Equação 2, obtemos:

Reorganizamos os termos sob a integral do RHS como abaixo:

Derivando o resultado final

Observe que a expressão acima contém a expansão integral de uma expectativa: ∫P(θ)∇logP(θ) = E[∇logP(θ)]

Assim, o RHS acima pode ser expresso como a expectativa:

Substituímos a derivada da probabilidade logarítmica na expressão da recompensa esperada:

Na equação acima, substitua o valor de ∇logP(θ) da Equação 5 para obter:

Esta é a expressão para o gradiente da função de recompensa de acordo com o teorema do gradiente de política.

A intuição por trás do gradiente de política

Os métodos de gradiente de política convertem a saída da política em uma distribuição de probabilidade. O agente amostra essa distribuição para escolher uma ação. Os métodos de gradiente de política ajustam os parâmetros da política. Isso leva a atualizar essa distribuição de probabilidade em cada iteração. A distribuição de probabilidade atualizada tem uma maior probabilidade de escolher ações que levam a recompensas mais altas.

O algoritmo de gradiente de política calcula o gradiente do retorno esperado em relação aos parâmetros da política. Movendo os parâmetros da política na direção desse gradiente, o agente aumenta a probabilidade de escolher ações que resultam em recompensas mais altas durante o treinamento.

Essencialmente, ações que levaram a melhores resultados se tornam mais propensas a serem escolhidas no futuro, melhorando gradualmente a política para maximizar as recompensas a longo prazo.

Implementando Gradientes de Política em Python

Ao discutir os princípios fundamentais dos gradientes de políticas, mostramos como implementá-los usando PyTorch e Gymnasium.

Configurando o ambiente

Como primeiro passo, precisamos instalar gymnasium e algumas bibliotecas de suporte como NumPy e PyTorch.

Para instalar gymnasium e suas dependências em um servidor ou máquina local, execute:

$ pip install gymnasium 

Para instalar usando um Notebook como Google Colab ou DataLab, use:

!pip install gymnasium

Você importa esses pacotes dentro do ambiente Python:

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torch.distributions as distributions
import numpy as np
import gymnasium as gym  

Codificando um agente simples de gradiente de política

Crie uma instância do ambiente usando o método .make().

env = gym.make('CartPole-v1')

Assim como em outros métodos de aprendizado de máquina, usamos uma rede neural para implementar o agente de política de gradiente. 

O CartPole-v1 é um ambiente simples, então projetamos uma rede simples com 1 camada oculta com 64 neurônios. A dimensão da camada de entrada é igual às dimensões do espaço de observação. A dimensão da camada de saída é igual ao tamanho do espaço de ação do ambiente. Assim, a rede de política mapeia estados observados para ações. Dada uma observação como entrada, a rede gera a ação prevista de acordo com a política. 

O código abaixo implementa a rede de política: 

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()

        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

Treinando o agente

O ambiente fornece uma recompensa em cada passo de tempo dependendo do estado e ação do agente. A abordagem de política de gradiente consiste em executar a descida do gradiente nas recompensas acumuladas (retorno). O objetivo é maximizar o retorno total. 

Para calcular o retorno em um episódio, você acumula (com um fator de desconto) as recompensas de todos os passos de tempo nesse episódio. Além disso, normalizar os retornos é útil para garantir um treinamento suave e estável. O código abaixo mostra como fazer isso:

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0

    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returns

Em cada iteração da passagem direta, fazemos os seguintes passos: 

• Executar o agente com base na política atual usando a .step() função. A política prevê a probabilidade de realizar a ação escolhida em cada etapa de tempo.
• Receber a recompensa do ambiente com base na ação do agente.
• Acumular recompensas passo a passo e as probabilidades logarítmicas das ações até que o agente alcance um estado terminal.

O código abaixo implementa a passagem direta:

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0

    policy.train()
    observation, info = env.reset()

    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)

        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated

        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward

    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)

    return episode_return, stepwise_returns, log_prob_actions

Usando retropropagação e subida de gradiente para atualizar a política

Em aprendizado de máquina tradicional:

• Perda refere-se à diferença entre a saída prevista e a real. 
• Minimizamos a perda usando descida de gradiente.

Em RL:

• A perda é um proxy para a quantidade sobre a qual o descida (ou subida) do gradiente deve ser aplicada. 
• Maximizamos o retorno (recompensas acumuladas) usando ascensão do gradiente.
• O valor de retorno esperado é usado como um proxy para a perda na descida do gradiente. O valor de retorno esperado é o produto de:
• Os retornos esperados de cada etapa com 
• A probabilidade de escolher a ação amostrada em cada etapa. 
• Para aplicar ascensão do gradiente usando retropropagação, usamos o negativo da perda. 

O código abaixo calcula a perda:

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return loss

Similar aos algoritmos de aprendizado de máquina padrão, para atualizar a política, você executa retropropagação em relação à função de perda. O método atualizar_politica() abaixo invoca o método calcular_perda(). Em seguida, ele executa retropropagação nesta perda para atualizar os parâmetros da política, ou seja, os pesos do modelo da rede de política.

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    return loss.item()

O loop de treinamento

Usamos as funções definidas anteriormente para treinar a política. Antes de iniciar o treinamento, precisamos: 

• Uma política não treinada inicializada como uma instância aleatória da classe PolicyNetwork. 
• Um otimizador que utiliza o algoritmo Adam. 
• Hiperparâmetros para o fator de desconto, taxa de aprendizado, taxa de dropout, limiar de recompensa e o número máximo de épocas de treinamento. 

Iteramos pelo loop de treinamento até que o retorno médio exceda o limiar de recompensa. Em cada iteração, executamos os seguintes passos: 

• Para cada episódio, execute a passagem para frente uma vez. Colete a probabilidade logarítmica das ações, os retornos passo a passo e o retorno total daquele episódio. Acumule os retornos episódicos em um array. 
• Calcule a perda usando as probabilidades logarítmicas e os retornos passo a passo. Execute a retropropagação sobre a perda. Use o otimizador para atualizar os parâmetros da política. 
• Verifique se o retorno médio em N_TRIALS excede o limiar de recompensa. 

O código abaixo implementa esses passos:

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5

    episode_returns = []

    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)

    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)

    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)

        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])

        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')

        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break

Execute o programa de treinamento chamando a função main().

main()

Este workbook do DataLab contém a implementação acima do algoritmo de gradiente de política. Você pode executá-lo diretamente ou usá-lo como ponto de partida para modificar o algoritmo.

Vantagens e Desafios dos Métodos de Gradiente de Política

Os métodos de gradiente de política oferecem várias vantagens, tais como:

• Manipulação de espaços de ação contínuos: Métodos baseados em valor (como o Q-learning) são ineficientes com espaços de ação contínuos porque precisam estimar valores em todo o espaço de ação. Métodos de gradiente de política podem otimizar diretamente a política usando o gradiente dos retornos esperados. Essa abordagem funciona bem com distribuições de ação contínua. Assim, os métodos de gradiente de política são adequados para tarefas como controle robótico que são baseadas em espaços de ação contínuos.
• Políticas estocásticas: Métodos de gradiente de política podem aprender políticas estocásticas – que fornecem uma probabilidade de selecionar cada ação possível. Isso permite que o agente experimente uma variedade de ações e reduz o risco de ficar preso em ótimos locais. Isso ajuda em ambientes complexos em que o agente precisa explorar o espaço de ação para encontrar a política ótima. A natureza estocástica ajuda a equilibrar a exploração (experimentar novas ações) e a exploração (escolher as ações mais conhecidas), o que é crucial para ambientes com incerteza ou recompensas esparsas.
• Otimização direta de políticas: Os gradientes de políticas otimizam a política diretamente em vez de usar funções de valor. Em espaços de ação contínuos ou de alta dimensão, a aproximação de valores para cada ação pode se tornar computacionalmente cara. Portanto, métodos baseados em políticas se saem bem em tais ambientes. 

Apesar de suas muitas vantagens, os métodos de gradiente de política têm alguns desafios inerentes:

• Alta variância nas estimativas de gradiente: Métodos de gradiente de política selecionam ações amostrando uma distribuição de probabilidade. Na prática, eles amostram a trajetória para estimar o retorno esperado. Como o processo de amostragem é inerentemente aleatório, os retornos estimados em iterações subsequentes podem ter alta variância. Isso pode dificultar a aprendizagem eficiente do agente, pois as atualizações na política podem flutuar significativamente entre as iterações. 
• Instabilidade durante o treinamento: 
• Os métodos de gradiente de política são sensíveis a hiperparâmetros como o. Se a taxa de aprendizado for muito alta, as atualizações nos parâmetros da política podem ser muito grandes, fazendo com que o treinamento não atinja os parâmetros ideais. Por outro lado, se a taxa de aprendizado for muito pequena, a convergência pode ser lenta. 
• Métodos de gradiente de política precisam equilibrar exploração e exploração. Se o agente não explorar o suficiente, pode não alcançar a vizinhança da política ótima. Por outro lado, se explorar demais, não convergirá para a política ótima e oscilará em torno do espaço de ação.
• Ineficiência amostral: Métodos de gradiente de política estimam o retorno seguindo cada política até a terminação e acumulando as recompensas de cada passo. Assim, eles precisam de muitas interações com o ambiente para gerar um grande número de trajetórias amostrais. Isso é ineficiente e caro para ambientes com grandes espaços de estado ou ação.

Soluções para estabilidade

Como a instabilidade é um problema relativamente comum em métodos de gradiente de política, os desenvolvedores adotaram várias soluções para estabilizar o processo de treinamento. Abaixo, apresentamos soluções comuns para estabilizar o treinamento usando gradientes de política:

Usando funções de base

Devido à amostragem ineficiente, os gradientes dos retornos estimados durante as iterações de treinamento podem ter alta variância, tornando o treinamento instável e lento. Uma abordagem comum para reduzir a variância é usar funções de base, como o método Advantage Actor-Critic (A2C). A ideia é usar um proxy (a função de vantagem) em vez do retorno estimado para a função objetivo.

A vantagem é calculada como a diferença entre o retorno real da trajetória amostrada e o retorno esperado dado o estado inicial. Essa abordagem envolve o uso da função de valor como o valor esperado de estados e pares estado-ação. Ao representar a perda como a diferença entre o retorno real e o retorno esperado em vez de como os retornos sozinhos, o A2C reduz a variância na função de perda e, portanto, nos gradientes, tornando o treinamento mais estável.

Usando regularização de entropia

Em certos ambientes, como aqueles com recompensas esparsas (apenas muito poucos estados dão uma recompensa), a política rapidamente adota uma abordagem determinística. Ela também adota uma abordagem gananciosa e explora os caminhos que já foram explorados. Isso impede uma exploração adicional e muitas vezes leva à convergência para ótimos locais e políticas subótimas.

A solução é incentivar a exploração sobre penalizar a política quando ela se torna muito determinística. Isso é feito adicionando um termo baseado em entropia à função objetiva. A entropia mede a quantidade de aleatoriedade na política. Quanto maior a entropia, mais aleatoriedade nas ações escolhidas pelo agente. Esse termo baseado em entropia é o produto do coeficiente de entropia e da entropia da política atual.

Tornar a entropia parte da função objetiva ajuda a alcançar um equilíbrio entre exploração e exploração.

Extensões de Gradiente de Política

Entre as várias extensões dos métodos de gradiente de política, uma das mais fundamentais é o algoritmo REINFORCE. Ele fornece uma implementação direta do teorema do gradiente de política e é a base para técnicas mais avançadas.

Algoritmo REINFORCE

O algoritmo REINFORCE, também conhecido como Monte Carlo Reinforce, é uma das implementações básicas do teorema do gradiente de política. Ele utiliza métodos Monte Carlo para estimar retornos e gradientes de política. Ao seguir o algoritmo REINFORCE, o agente amostra diretamente todas as ações (do estado inicial ao estado terminal) do ambiente. Isso contrasta com outros métodos como TD-Learning e Programação Dinâmica, que inicializam suas ações com base em estimativas de função de valor.

Abaixo, apresentamos os passos básicos do algoritmo REINFORCE:

• Inicialize a política com parâmetros aleatórios
• Repita vários episódios de treinamento. Para cada episódio:
• Gere cada etapa do episódio inteiro da seguinte forma:
• Passe o estado para a função de política.
• A função de política gera probabilidades para cada ação possível.
• Amostra aleatoriamente uma ação desta distribuição de probabilidade.
• Para cada estado no episódio, estime os retornos (recompensas cumulativas descontadas) até a etapa.
• Estime o gradiente da função objetivo (de acordo com o teorema do gradiente de política), expresso como o produto dos retornos passo a passo e as probabilidades de ação para cada passo.
• Atualize os parâmetros da política aplicando os gradientes

Para cada política, você pode amostrar uma única trajetória para estimar o gradiente (como mostrado acima) ou calcular a média do gradiente ao longo de várias trajetórias amostradas sob a mesma política.

Métodos ator-crítico

Os métodos ator-crítico combinam métodos de gradiente de política (como REINFORCE) com funções de valor.

• O funcionamento do ator é semelhante aos métodos de gradiente de política. O ator implementa a política, selecionando ações em cada passo com base na política. Ele atualiza a política seguindo o gradiente do retorno esperado.
• O crítico implementa a função de valor, que é usada como uma linha de base (discutida na seção anterior). Isso ajuda a tornar o treinamento mais eficiente e estável.

Métodos de gradiente de política como REINFORCE estimam os gradientes ao longo de cada trajetória usando o retorno bruto. Como um processo de amostragem gera essas trajetórias, isso pode levar a grandes variâncias nos retornos e gradientes. Usar uma função de vantagem em vez dos retornos brutos resolve esse problema. A função de vantagem é a diferença entre os retornos reais e os esperados (ou seja, a função de valor). Métodos de ator-crítico são uma classe de algoritmos. Quando o crítico é implementado usando a função de vantagem (a abordagem mais comum), também é chamado de ator-crítico de vantagem (A2C).

Otimização Proximal de Política (PPO)

Em ambientes complexos, métodos de ator-crítico como A2C sozinhos não são suficientes para controlar a variância nos retornos e gradientes. Nesses casos, restringir artificialmente a quantidade pela qual a política pode mudar em cada iteração ajuda. Isso força a política atualizada (após a ascensão do gradiente) a permanecer na vizinhança da política antiga.

Métodos como Otimização Proximal de Política fazem duas modificações nos gradientes de política:

• Use uma função de vantagem. Tipicamente, essa função de vantagem utiliza a função de valor como base. Nisso, são semelhantes aos métodos A2C.
• Restrinja a quantidade pela qual os parâmetros da política podem mudar em cada iteração. Isso é feito usando uma função objetivo de substituição limitada. O algoritmo especifica um intervalo no qual a razão da nova política para a antiga política deve estar. Quando a razão (após a atualização do gradiente) excede esses valores predeterminados, ela é limitada a estar dentro do intervalo.

Assim, o PPO melhora significativamente os métodos de gradiente de política vanilla, o que melhora a estabilidade em ambientes complexos. A função objetivo recortada evita grandes variâncias nos retornos e gradientes que poderiam desestabilizar as atualizações da política. Para alcançar um equilíbrio entre exploração e exploração, também é possível modificar o PPO para usar regularização de entropia. Isso é feito adicionando um termo de entropia (um parâmetro de escala multiplicado pela entropia da política) à função objetivo.

Avanços recentes

Os gradientes de política estão entre os primeiros métodos usados para resolver problemas de RL. Após o advento das GPUs rápidas, várias novas abordagens foram propostas para aplicar técnicas modernas de ML aos gradientes de política.

Aprendizado por Reforço Aumentado por Gradiente

Nos últimos anos, progressos têm sido feitos na aplicação de métodos como gradient boosting em algoritmos de RL. O gradient boosting combina as previsões de vários modelos fracos para gerar um único modelo forte. Isso é referido como Gradient-Boosted Reinforcement Learning (GBRL). GBRL é um pacote Python similar ao XGBoost que implementa essas técnicas para algoritmos de RL.

Transfer Reinforcement Learning 

Transfer learning (TL) é uma técnica onde o conhecimento adquirido por um modelo é aplicado para melhorar o desempenho de outro modelo. Transfer learning é útil porque treinar modelos de aprendizado de máquina do zero é caro. Abordagens de TL têm sido usadas com gradientes de política para melhorar o desempenho de modelos de RL. Essa abordagem é chamada de Transfer Reinforcement Learning (TRL).

Conclusão

Os gradientes de política estão entre as abordagens mais fundamentais para resolver problemas de RL.

 Neste artigo, apresentamos os primeiros princípios dos gradientes de política e mostramos como derivar o teorema do gradiente de política. Também demonstramos como implementar um algoritmo simples baseado em gradientes usando PyTorch em um ambiente de Gymnasium. Por fim, discutimos desafios práticos e extensões comuns ao algoritmo básico de gradiente de política.

Se você deseja aprofundar seu entendimento em aprendizado por reforço e aprendizado profundo com PyTorch, confira estes cursos:

• Trilha de Aprendizado por Reforço – Aprenda os fundamentos do RL, desde métodos baseados em valor até técnicas de otimização de política.
• Introdução ao Aprendizado Profundo com PyTorch – Tenha experiência prática com PyTorch e construa modelos de aprendizado profundo do zero.