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 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 acumuladas em relação aos parâmetros da política. Eles usam esse gradiente para otimizar diretamente a política, atualizando seus parâmetros. Portanto, eles 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 de Aprendizado por Reforço com Feedback Humano (RLHF) métodos.

Ao parametrizar a política e ajustar seus parâmetros com base nos gradientes, os gradientes de política podem lidar eficientemente 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

Dada um conjunto de observações:

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

Ao seguir uma política estocástica, a mesma observação pode levar a escolher ações diferentes em iterações diferentes. 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 ao máximo retorno.

Em 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, métodos de gradiente de política combinam exploração com exploração, sendo ú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 utilizados 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 de um estado inicial aleatório até o passo de tempo atual ou o estado terminal.
• ∇_θf refere-se 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 πθ. Este é também a função objetivo para o aumento do gradiente.
• O ambiente oferece uma recompensa a cada passo de tempo, dependendo da ação do agente. O retorno refere-se às recompensas cumulativas do 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 utilizando o truque do logaritmo derivado. 

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 baseada 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 resulta em:

O gradiente da expectativa (Equação 3)

A expectativa (no LHS) 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 lado direito da Equação 2 é reescrito como:

O gradiente de uma integral é igual à integral do gradiente. Assim, 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 analisamos mais de perto P(τ|θ), a probabilidade de o agente seguir a trajetória τ dada os parâmetros de política θ (e, portanto, a política π_θ). Uma trajetória consiste em um conjunto de etapas. 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 vai 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 s_t+1 dado a ação a_t e o estado s_t

Assim, 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 lado direito da equação como uma soma. Assim, aplicamos o logaritmo em 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 lado direito da equação acima: 

• O primeiro termo log ρ₀(s₀) é constante em relação a θ. 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, restamos 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, ao reorganizar 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 da log-derivada.

A regra da cadeia

De acordo com a regra da cadeia, dado z(y) como uma função de y, onde y é 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 da RHS acima. 

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

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

Aplicando o truque do logaritmo-derivativo

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

Usando o resultado na parte direita da Equação 2, obtemos: 

Reorganizamos os termos sob a integral da parte direita conforme 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:

No 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 da política.

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

Métodos de gradiente da 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 da política ajustam os parâmetros da política. Isso leva à atualização dessa 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 da política calcula o gradiente do retorno esperado em relação aos parâmetros da política. Ao mover 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

Após discutir os princípios fundamentais dos gradientes de política, 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 gradiente de política.

O CartPole-v1 é um ambiente simples, então projetamos uma rede simples com 1 camada oculta contendo 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ções 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 concede uma recompensa em cada passo de tempo, dependendo do estado e da ação do agente. A abordagem de gradiente de política consiste em executar descida de gradiente sobre as recompensas acumuladas (retorno). O objetivo é maximizar o retorno total.

Para calcular o retorno em um episódio, você acumula (com um fator de desconto) 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 função .step() . A política prevê a probabilidade de realizar a ação escolhida em cada instante 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 ascensão de gradiente para atualizar a política

Em aprendizado de máquina tradicional :

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

Em RL:

• A perda é um proxy para a quantidade na qual descida (ou subida) de gradiente deve ser aplicada.
• Maximizamos o retorno (recompensas cumulativas) usando subida de gradiente.
• O valor esperado de retorno é usado como um proxy para a perda na descida de gradiente. O valor esperado de retorno é o produto de:
• Os retornos esperados de cada passo com
• A probabilidade de escolher a ação amostrada em cada passo.
• Para aplicar a subida de 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

Semelhante aos algoritmos padrão de aprendizado de máquina, para atualizar a política, você executa a retropropagação em relação à função de perda. O método update_policy() abaixo invoca o método calculate_loss(). Em seguida, executa a retropropagação nessa 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 randomizada da classe PolicyNetwork.
• Um otimizador que utilize o algoritmo Adam.
• Hiperparâmetros para o fator de desconto, taxa de aprendizado, taxa de abandono, 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, executamos o forward pass uma vez. Coletamos a probabilidade logarítmica das ações, os retornos passo a passo e o retorno total daquele episódio. Acumulamos os retornos episódicos em um array.
• Calculamos a perda usando as probabilidades logarítmicas e os retornos passo a passo. Executamos a retropropagação na perda. Utilizamos o otimizador para atualizar os parâmetros da política.
• Verificamos 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 DataLab contém a implementação acima do algoritmo de gradiente de políticas. 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íticas

Os métodos de gradiente de políticas 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, pois precisam estimar valores sobre 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. Esta abordagem funciona bem com distribuições de ação contínuas. Assim, métodos de gradiente de política são adequados para tarefas como controle robótico que se baseiam 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 dão uma probabilidade de selecionar cada ação possível. Isso permite que o agente experimente uma variedade de ações e reduza o risco de ficar preso em ótimos locais. Isso ajuda em ambientes complexos nos quais 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 (tentando novas ações) e a exploração (escolhendo as melhores ações conhecidas), o que é crucial para ambientes com incerteza ou recompensas esparsas.
• Optimização direta da política: Os gradientes de política 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. Assim, os 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 gradientes: Os métodos de gradiente de política selecionam ações por amostragem de 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 tornar difícil para o agente aprender eficientemente, pois as atualizações da 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 dos 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 baixa, a convergência pode ser lenta.
• Os métodos de gradiente de política precisam equilibrar a exploração e a exploração. Se o agente não explorar o suficiente, ele pode não alcançar o bairro da política ótima. Por outro lado, se ele explorar demais, não convergirá na política ótima e oscilará em torno do espaço de ação.
• Ineficiência da amostra: Os 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 desenhar um grande número de trajetórias de amostra. 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 nos 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 linha 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 apenas os retornos, 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 escassas (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á foi explorada. 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 penalizando a política quando ela se torna muito determinística. Isso é feito adicionando um termo baseado em entropia à função objetivo. A entropia mede a quantidade de aleatoriedade na política. Quanto maior a entropia, mais aleatoriedade nas ações escolhidas pelo agente. Este termo baseado em entropia é o produto do coeficiente de entropia e a entropia da política atual.

Fazer da entropia uma parte da função objetivo ajuda a alcançar um equilíbrio entre exploração e exploração.

Extensões do 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 de 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 da função de valor.

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

• Inicialize a política com parâmetros aleatórios
• Repita múltiplos episódios de treinamento. Para cada episódio:
• Gere cada passo 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 etapa.
• 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 múltiplas 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 o REINFORCE, estimam os gradientes ao longo de cada trajetória usando o retorno bruto. Como um processo de amostragem desenha essas trajetórias, pode levar a grandes variações 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 esperados (ou seja, a função de valor). Métodos 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 de Política Próxima (PPO)

Em ambientes complexos, métodos ator-crítico como o A2C sozinhos não são suficientes para controlar a variância nos retornos e gradientes. Em tais 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 estar no entorno da política antiga.

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

• Usar uma função de vantagem. Geralmente, essa função de vantagem usa a função de valor como referência. Nisso, elas são semelhantes aos métodos A2C.
• Restringir a quantidade pela qual os parâmetros de política podem mudar em cada iteração. Isso é feito usando uma função de objetivo substituta limitada. O algoritmo especifica um intervalo no qual a razão da nova política para a antiga política deve se situar. Quando a razão (após a atualização do gradiente) excede esses valores predeterminados, ela é limitada a se situar dentro do intervalo.

Assim, o PPO melhora significativamente os métodos de gradiente de política simples, o que melhora a estabilidade em ambientes complexos. A função objetivo cortada evita grandes variações nos retornos e gradientes de desestabilizar as atualizações de 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 surgimento de GPUs rápidas, várias novas abordagens foram propostas para aplicar técnicas modernas de ML aos gradientes de política.

Aprendizado de Reforço Impulsionado por Gradiente

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

Transferência de Aprendizado por Reforço

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 ML do zero é caro. As 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 princípios fundamentais 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 o 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 sua compreensão sobre aprendizado por reforço e aprendizado profundo com PyTorch, confira estes cursos:

• Trilha de Aprendizado por Reforço – Aprenda os fundamentos de 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.