Aprendizado por reforço com o Gymnasium: Um guia prático

Instalação do ginásio

O Gymnasium precisa de versões específicas (não as últimas versões) de vários programas de dependência, como o NumPy e o PyTorch. Portanto, recomendamos que você crie um novo ambiente Conda ou venv ou um novo notebook para instalar, usar o Gymnasium e executar os programas RL. 

Você pode Você pode usar essa pasta de trabalho do DataLab para acompanhar o tutorial.Você pode usar esta pasta de trabalho do DataLab para acompanhar o tutorial.

Instalação do ginásio

Para instalar o Gymnasium em um servidor ou máquina local, execute: 

$ pip install gymnasium 

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

!pip install gymnasium

O comando acima instala o Gymnasium e as versões corretas das dependências.

Explorando ambientes de ginásio

A partir de novembro de 2024, o Gymnasium inclui mais de 60 ambientes integrados. Para navegar pelos ambientes integrados disponíveis, use a função gym.envs.registry.all(), conforme ilustrado no exemplo abaixo :

import gymnasium as gym
for i in gym.envs.registry.keys():
	print(i)

Você também pode visitar a página inicial do Gymnasium. A coluna do lado esquerdo do sitetem links para todos os ambientes. A página da Web de cada ambiente inclui detalhes sobre ele, como ações, estados, etc. 

Os ambientes são organizadosem categorias como Classic Control, Box2D e muito mais. Abaixo, listo alguns dos ambientes comuns em cada grupo:

• Controle clássico: Esses são ambientes canônicos usados no desenvolvimento de RL; eles formam a base de muitos exemplos de livros didáticos. Eles oferecem a combinação certa de complexidade e simplicidade para testar e avaliar novos algoritmos de RL. Os ambientes de controle clássicos no Gymnasium incluem: 
• Acrobô
• Poste do carrinho
• Carro de montanha discreto
• Carro de montanha contínuo
• Pêndulo
• Box2D: O Box2D é um mecanismo de física 2D para jogos. Os ambientes baseados nesse mecanismo incluem jogos simples como:
• Lunar Lander
• Corrida de carros
• ToyText: Esses ambientes são pequenos e simples e costumam ser usados para depurar algoritmos de RL. Muitos desses ambientes são baseados no modelo de mundo de grade pequena e em jogos de cartas simples. Os exemplos incluem: 
• Blackjack
• Táxi
• Lago congelado
• MuJoCo: O MuJoCo (Multi-Joint dynamics with Contact) é um mecanismo de física de código aberto que simula ambientes para aplicativos como robótica, biomecânica, ML etc. Os ambientes do MuJoCo no Gymnasium incluem:
• Formiga
• Funil
• Humanoide
• Nadador
• E mais

Além dos ambientes integrados, o Gymnasium pode ser usado com muitos ambientes externos usando a mesma API. 

Neste tutorial, usaremos um dos ambientes canônicos do Classic Control. Para importar um ambiente específico, use o comando .make() e passe o nome do ambiente como argumento. Por exemplo, para criar um novo ambiente com base no CartPole (versão 1), use o comando abaixo: 

import gymnasium as gym
env = gym.make("CartPole-v1")

Compreensão dos conceitos de aprendizagem por reforço no ginásio

Em resumo, o Reinforcement Learning consiste em um agente (como um robô) que interage com seu ambiente. Uma política decide as ações do agente. Dependendo das ações do agente, o ambiente oferece uma recompensa (ou penalidade) a cada etapa do tempo. O agente usa a RL para descobrir a política ideal que maximiza as recompensas totais que o agente ganha. 

Componentes de um ambiente de RL

A seguir, você encontrará os principais componentes de um ambiente de RL: 

• Meio ambiente: O sistema, o mundo ou o contexto externo. O agente interage com o ambiente em uma série de etapas de tempo. Em cada intervalo de tempo, com base na ação do agente, o ambiente:
• Oferece uma recompensa (ou penalidade) 
• Decide o próximo estado 
• Estado: Uma representação matemática da configuração atual do ambiente. 
• Por exemplo, o estado de um ambiente de pêndulo pode incluir a posição e a velocidade angular do pêndulo em cada intervalo de tempo. 
• Estado do terminal: Um estado que não leva a novos/outros estados. 
• Agente: O algoritmo que observa o ambiente e executa várias ações com base nessa observação. O objetivo do agente é maximizar suas recompensas. 
• Por exemplo, o agente decide com que força e em que direção empurrar o pêndulo.  
• Observação: Uma representação matemática da visão que o agente tem do ambiente, adquirida, por exemplo, por meio de sensores. 
• Ação: A decisão tomada pelo agente antes de prosseguir para a próxima etapa. A ação afeta o próximo estado do ambiente e dá ao agente uma recompensa. 
• Recompensa: O feedback do ambiente para o agente. Ela pode ser positiva ou negativa, dependendo da ação e do estado do ambiente. 
• Retorno: O retorno cumulativo esperado em etapas de tempo futuras. As recompensas de etapas futuras podem ser descontadas usando um fator de desconto. 
• Política: A estratégia do agente sobre qual ação tomar em vários estados. Normalmente, ela é representada como uma matriz de probabilidade, P, que mapeia estados para ações.
• Dado um conjunto finito de m estados possíveis e n ações possíveis, o elemento Pmn na matriz denota a probabilidade de realizar a ação an no estado sm.
• Episódio: A série de passos de tempo desde o estado inicial (aleatório) até o agente atingir um estado terminal.

Espaço de observação e espaço de ação

A observação é a informação que o agente coleta sobre o ambiente. Um agente, por exemplo, um robô, pode coletar informações ambientais usando sensores. Idealmente, o agente deve ser capaz de observar o estado completo, que descreve todos os aspectos do ambiente. Na prática, o agente usa suas observações como um substituto para o estado. Assim, as observações decidem as ações do agente. 

Um espaço é análogo a um conjunto temático. O espaço de itens X inclui todas as instâncias possíveis de X. O espaço de X também define a estrutura (sintaxe e formato) de todos os itens do tipo X. Cada ambiente do Gymnasium tem dois espaços: o espaço de ação, action_space, e o espaço de observação, observation_space. Tanto o espaço de ação quanto o de observação derivam da superclasse gymnasium.spaces.Space .

Espaço de observação 

O espaço de observação é o espaço que inclui todas as observações possíveis. Ele também define o formato no qual as observações são armazenadas. O espaço de observação é normalmente representado como um objeto de dadospe Box. Trata-se de um ndarray que descreve os parâmetros das observações. A caixa especifica os limites de cada dimensão. Você pode visualizar o espaço de observação de um ambiente usando o método observation_space:

print("observation space: ", env.observation_space)

No caso do ambiente CartPole-v1, a saída é semelhante ao exemplo abaixo :

observation space:  Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32)

Neste exemplo, o espaço de observação do CartPole-v1 tem 4 dimensões. Os 4 elementos da matriz de observação são:

• Posição do carrinho - varia entre -4,8 e +4,8
• Velocidade do carrinho - varia entre - a +
• Ângulo do polo - varia entre -0,4189 e +0,4189
• A velocidade angular do polo - varia entre - a +

Para ver um exemplo de uma matriz de observação individual, use o comando .reset() .

observation, info = env.reset()
print("observation: ", observation)

No caso do ambiente CartPole-v1, a saída é semelhante ao exemplo abaixo :

[ 0.03481963 -0.0277232   0.01703267 -0.04870504]                                                                                                       

Os quatro elementos dessa matriz correspondem às quatro quantidades observadas (posição do carrinho, velocidade do carrinho, ângulo do polo, velocidade angular do polo), conforme explicado anteriormente. 

Espaço de ação

O espaço de ação inclui todas as ações possíveis que o agente pode realizar. O espaço de ação também define o formato no qual as ações são representadas. Você pode visualizar o espaço de ação de um ambiente usando o método action_space:

print("action space: ", env.action_space)

No caso do ambiente CartPole-v1, a saída é semelhante ao exemplo abaixo :

action space:  Discrete(2)

No caso do ambiente CartPole-v1, o espaço de ação é discreto. Há um total de duas ações que o agente pode realizar:

• 0: Empurre o carrinho para a esquerda
• 1: Empurre o carrinho para a direita

Criando seu primeiro agente de RL com o Gymnasium

Nas seções anteriores, exploramos os conceitos básicos de RL e Gymnasium. Esta seção mostra a você como usar o Gymnasium para criar um agente de RL. 

Criação e redefinição do ambiente

A primeira etapa é criar uma instância do ambiente. Para criar novos ambientes, use o método .make(). 

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

As interações do agente alteram o estado do ambiente. O método .reset() redefine o ambiente para um estado inicial. Por padrão, o ambiente é inicializado em um estado aleatório. Você pode usar um parâmetro SEED com o método .reset() para inicializar o ambiente no mesmo estado sempre que o programa for executado. O código abaixo mostra como você pode fazer isso:

SEED = 1111
env.reset(seed=SEED)

A amostragem de ações também envolve aleatoriedade. Para controlar essa aleatoriedade e obter um caminho de treinamento totalmente reproduzível, podemos semear os geradores aleatórios do NumPy e do PyTorch:

np.random.seed(SEED)
torch.manual_seed(SEED)

Ações aleatórias versus ações inteligentes

Em cada etapa de um processo de Markov, o agente pode escolher aleatoriamente uma ação e explorar o ambiente até chegar a um estado terminal. Escolhendo ações aleatoriamente: 

• Você pode levar muito tempo para atingir o estado terminal.
• As recompensas cumulativas são muito menores do que poderiam ter sido.

Treinar o agente para otimizar a seleção de ações com base em experiências anteriores (de interação com o ambiente) é mais eficiente para maximizar as recompensas de longo prazo. 

O agente não treinado começa com ações aleatórias com base em uma política inicializada aleatoriamente. Normalmente, essa política é representada como uma rede neural. Durante o treinamento, o agente aprende a política ideal que maximiza as recompensas. Na RL, o processo de treinamento também é chamado de otimização de políticas. 

Há vários métodos de otimização de políticas. As equações de Bellman descrevem como calcular o valor das políticas de RL e determinar a política ideal. Neste tutorial, usaremos uma técnica simples chamada gradientes de política. Existem outros métodos, como o PPO (Proximal Policy Optimization). 

Implementação de um agente de gradiente de política simples

Para criar um agente de RL que usa gradientes de política, criamos uma rede neural para implementar a política, escrevemos funções para calcular os retornos e as perdas das recompensas em etapas e as probabilidades de ação e atualizamos iterativamente a política usando técnicas padrão de retropropagação. 

Configuração da rede de políticas

Usamos uma rede neural para implementar a política. Como o CartPole-v1 é um ambiente simples, usamos uma rede neural com o qual você pode se beneficiar:

• Dimensões de entrada iguais à dimensionalidade do espaço de observação do ambiente. 
• Uma única camada oculta com 64 neurônios. 
• Dimensões de saída iguais à dimensionalidade do espaço de ação do ambiente.

Assim, a função da rede de políticas é mapear os estados observados para as ações. Com base em uma observação de entrada, ele prevê a ação correta. O código abaixo implementa a rede de políticas:

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

Coleta de recompensas e o passe adiante

Conforme mencionado, em cada etapa do processo de Markov, o ambiente dá uma recompensa com base na ação e no estado do agente. O objetivo da RL é maximizar o retorno total. 

• O retorno em cada etapa de tempo é a soma cumulativa das recompensas obtidas desde o início até aquela etapa. 
• O retorno total em cada episódio é obtido pela acumulação de todas as recompensas por etapas desse episódio. Assim, o retorno total é o retorno no último intervalo de tempo (quando o agente atinge um estado terminal). 

Na prática, ao acumular recompensas, é comum que você: 

• Ajuste as recompensas futuras usando um fator de desconto. 
• Normalize a matriz de retornos por etapas para garantir um treinamento suave e estável. 

O código abaixo mostra como você pode 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

A passagem adiante consiste em executar o agente com base na política atual até que ele atinja um estado terminal e colete as recompensas e as probabilidades de ação em etapas. As etapas abaixo explicam como você pode implementar o passe para frente: 

• Redefinir o ambiente para um estado inicial. 
• Inicialize os buffers para armazenar as probabilidades de ação, as recompensas e o retorno acumulado
• Use a função .step() para executar iterativamente o agente no ambiente até que ele termine:
• Obtenha a observação do estado do ambiente.
• Obtenha a ação prevista pela política com base na observação.
• Use a função Softmax para estimar a probabilidade de você realizar a ação prevista.
• Simule uma distribuição de probabilidade categórica com base nessas probabilidades estimadas.
• Faça uma amostragem dessa distribuição para obter a ação do agente.
• Estimar a probabilidade logarítmica da ação amostrada a partir da distribuição simulada. 
• Anexe a probabilidade de log das ações e as recompensas de cada etapa aos seus respectivos buffers. 
• Estime os valores normalizados e descontados dos retornos em cada etapa com base nas recompensas. 

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

Atualização da política com base em recompensas

A perda representa a quantidade na qual aplicamos a descida do gradiente. O objetivo na RL é maximizar os retornos. Portanto, usamos o valor de retorno esperado como um substituto para a perda. O valor de retorno esperado é calculado como o produto dos retornos esperados em etapas e a probabilidade logarítmica das ações em etapas. O código abaixo calcula a perda:

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

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, ele executa a retropropagação nessa perda para atualizar os parâmetros da política, ou seja, os pesos do modelo da rede de políticas.

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

A atualização da política com base no gradiente dos retornos é chamada de método de gradiente de política. 

Treinamento da política

Agora temos todos os componentes necessários para treinar e avaliar a política. Implementamos o loop de treinamento conforme explicado nas etapas a seguir:  

Antes de começar, declaramos os hiperparâmetros, instanciamos uma política e criamos um otimizador:

• Declare os hiperparâmetros como constantes Python:
• MAX_EPOCHS é o número máximo de iterações que estamos dispostos a executar para treinar a política. 
• DISCOUNT_FACTOR decide a importância relativa das recompensas de etapas de tempo futuras. Um fator de desconto de 1 significa que todas as recompensas são igualmente importantes, enquanto um valor de 0 significa que somente a recompensa da etapa de tempo atual é importante. 
• N_TRIALS é o número de episódios sobre os quais calculamos a média dos retornos para avaliar o desempenho do agente. Decidimos que o treinamento foi bem-sucedido se o retorno médio em N_TRIALS episódios estiver acima do limite .
• REWARD_THRESHOLD: Se a política conseguir obter um retorno maior que o limite, ela será considerada bem-sucedida. 
• DROPOUT decide a fração dos pesos que deve ser zerada aleatoriamente. A função de abandono define aleatoriamente uma fração dos pesos do modelo como zero. Isso reduz a dependência de neurônios específicos e evita o ajuste excessivo, tornando a rede mais robusta.
• LEARNING_RATE decide o quanto os parâmetros da política podem ser modificados em cada etapa. A atualização dos parâmetros em cada iteração é o produto do gradiente e da taxa de aprendizado. 
• Defina a política como uma instância da classe PolicyNetwork (implementada anteriormente). 
• Crie um otimizador usando o algoritmo Adam e a taxa de aprendizado. 

Para treinar a política, executamos iterativamente as etapas de treinamento até que o retorno médio (em N_TRIALS ) seja maior que o limite de recompensa:

• Para cada episódio, execute a passagem para frente uma vez. Colete a probabilidade logarítmica das ações, os retornos por etapas e o retorno total desse episódio. Acumule os retornos episódicos em uma matriz. 
• Calcule a perda usando as probabilidades de registro e os retornos por etapas. Execute o backpropagation na perda. Use o otimizador para atualizar os parâmetros da política. 
• Verifique se o retorno médio em N_TRIALS excede o limite de recompensa .

O código abaixo implementa essas etapas:

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

Por fim, invoque a função main() para treinar a política:

main()

UUse esta pasta de trabalho do DataLab para executar o algoritmo acima diretamente e resolver o ambiente CartPole usando RL.o algoritmo acima diretamente e resolver o ambiente CartPole usando RL.

Técnicas avançadas de ginástica

Depois de demonstrar como implementar um algoritmo de RL, discutiremos agora algumas técnicas avançadas comumente usadas na prática. 

Uso de arquiteturas pré-construídas

A implementação de algoritmos de RL do zero é um processo longo e difícil, especialmente para ambientes complexos e políticas de última geração. 

Uma alternativa mais prática é usar um softwarecomo o Stable Baselines3. Ele vem com implementações testadas e comprovadas de algoritmos de RL. Ele inclui agentes pré-treinados, scripts de treinamento, ferramentas de avaliação e módulos para plotar gráficos e gravar vídeos. 

O Ray RLib é outra ferramenta popular para RL. O RLib foi projetado como uma solução dimensionável, facilitando a implementação de algoritmos de RL em sistemas com várias GPUs. Ele também oferece suporte à RL multiagente, o que abre novas possibilidades, como, por exemplo, a de que você possa usar o sistema de forma mais eficiente:

• Aprendizagem independente de vários agentes: Cada agente trata os outros agentes como parte do ambiente.
• Treinamento colaborativo de vários agentes: Um grupo de agentes compartilha a mesma política e funções de valor e aprende com as experiências uns dos outros em paralelo. 
• Treinamento contraditório: Os agentes (ou grupos de agentes) competem entre si em ambientes competitivos semelhantes a jogos. 

Com o RLib e o Stable Baselines3, você pode importar e usar ambientes do OpenAI Gymnasium. 

Ambientes personalizados

Os ambientes com o Gymnasium são a escolha certa para testar novas estratégias de RL e políticas de treinamento. No entanto, para a maioria das aplicações práticas, você precisa criar e usar um ambiente que reflita com precisão o problema que deseja resolver. Você pode usar o Gymnasium para criar um ambiente personalizado. A vantagem de usar os ambientes personalizados do Gymnasium é que muitas ferramentas externas, como RLib e Stable Baselines3 , já estão configuradas para trabalhar com a estrutura da API do Gymnasium. 

Para criar um ambiente personalizado no Gymnasium, você precisa definir: 

• O espaço de observação.
• As condições do terminal.
• O conjunto de ações que o agente pode escolher.
• Como inicializar o ambiente (quando a função reset() é chamada) .
• Como o ambiente decide o próximo estado com base nas ações do agente (quando a função step() é chamada) .

Para saber mais, siga o guiado Gymnasium sobre como criar ambientes personalizados. 

Práticas recomendadas para o uso do Gymnasium

Faça experiências com diferentes ambientes

O código deste tutorial mostrou como implementar o algoritmo de gradiente de política no ambiente CartPole. Esse é um ambiente simples com um espaço de ação discreto. Para entender melhor a RL, recomendamos que você aplique o mesmo algoritmo de gradiente de política (e outrosalgoritmos, como o PPO) em outros ambientes .

Por exemplo, o ambiente Pendulum tem um espaço de ação contínuo. Ele consiste em uma única entrada representada como uma variável contínua - o torque (magnitude e direção do) aplicado ao pêndulo em qualquer estado. Esse torque pode assumir qualquer valor entre -2 e +2.

Experimentar diferentes algoritmos em vários ambientes ajuda você a entender melhor os diferentes tipos de soluções de RL e seus desafios. 

Monitorar o progresso do treinamento

Os ambientes de RL geralmente consistem em robôs, pêndulos, carros de montanha, videogames etc. A visualização das ações do agente no ambiente proporciona uma melhor compreensão intuitiva do desempenho da política. 

No Gymnasium, o método env.render() visualiza as interações do agente com o ambiente. Ele exibe graficamente o estado atual do ambiente - telas do jogo, a posição do pêndulo ou do poste do carrinho, etc. O feedback visual das ações do agente e as respostas do ambiente ajudam a monitorar o desempenho e o progresso do agente durante o processo de treinamento. 

Há quatro modos de renderização: "human", "rgb_array", "ansi" e "rgb_array_list". Para visualizar o desempenho do agente, use o modo de renderização "humano". O modo de renderização é especificado quando o ambiente é inicializado. Por exemplo:

env = gym.make(‘CartPole-v1’, render_mode=’human’)

Para executar a renderização, envolva o método .render() após cada ação executada pelo agente (por meio da chamada do método .step() ). O pseudocódigo abaixo ilustra como você pode fazer isso:

while not done:
    …
   step, reward, terminated, truncated, info = env.step(action.item())
   env.render()
    …

Solução de problemas de erros comuns

O Gymnasium facilita a interface com ambientes RL complexos. No entanto, é um software atualizado continuamente com muitas dependências. Portanto, é essencial que você fique atento a alguns tipos comuns de erros.

Incompatibilidades de versões

• Incompatibilidade de versão do ginásio: O pacote de software Gymnasium da Farama foi derivado do Gym da OpenAI a partir da versão 0.26.2. Houve algumas mudanças significativas entre as versões anteriores do Gym e as novas versões do Gymnasium. Muitas implementações disponíveis publicamente são baseadas em versões mais antigas do Gym e podem não funcionar diretamente com a versão mais recente. Nesses casos, é necessário reverter a instalação para uma versão mais antiga ou adaptar o código para funcionar com a versão mais recente. 
• Incompatibilidade de versão de ambiente: Muitos ambientes do Gymnasium têm versões diferentes. Por exemplo, há dois ambientes CartPole - CartPole-v1 e CartPole-v0. Embora o comportamento do ambiente seja o mesmo em ambas as versões, alguns dos parâmetros, como a duração do episódio, o limite de recompensa, etc., podem ser diferentes. Uma política treinada em uma versão pode não funcionar tão bem em outra versão do mesmo ambiente. Você precisa atualizar os parâmetros de treinamento e treinar novamente a política para cada versão do ambiente. 
• Incompatibilidade de versão das dependências: O Gymnasium depende de dependências como NumPy e PyTorch. Em dezembro de 2024, as versões mais recentes dessas dependências eram numpy 2.1.3 e torch 2.5.1. No entanto, o Gymnasium funciona melhor com torch 1.13.0 e numpy 1.23.3. Você pode encontrar problemas se instalar o Gymnasium em um ambiente com essas dependências pré-instaladas. Recomendamos que você instale e trabalhe com o Gymnasium em um ambiente Conda novo. 

Problemas de convergência

• Hiperparâmetros: Como outros algoritmos de aprendizado de máquina, as políticas de RL são sensíveis a hiperparâmetros como taxa de aprendizado, fator de desconto, etc. Recomendamos que você experimente e ajuste os hiperparâmetros manualmente ou use técnicas automatizadas, como pesquisa em grade e pesquisa aleatória. 
• Exploração versus exploração: Para algumas classes de políticas (como PPO), o agente adota uma estratégia dupla: explora o ambiente para descobrir novos caminhos e adota uma abordagem gananciosa para maximizar as recompensas com base nos caminhos conhecidos até o momento. Se você explorar demais, a política não convergirá. Por outro lado, ele nunca tenta o caminho ideal se não explorar o suficiente. Portanto, é essencial encontrar o equilíbrio certo entre exploração e aproveitamento. Também é comum priorizar a exploração nos primeiros episódios e o aproveitamento nos últimos episódios durante o treinamento. 

Instabilidade de treinamento

• Grandes taxas de aprendizado: Se a taxa de aprendizado for muito alta, os parâmetros da política sofrerão grandes atualizações em cada etapa. Isso pode fazer com que você perca o conjunto ideal de valores. Uma solução comum é diminuir gradualmente a taxa de aprendizado, garantindo atualizações menores e mais estáveis à medida que o treinamento converge. 
• Exploração excessiva: O excesso de aleatoriedade (entropia) na seleção de ações impede a convergência e leva a grandes variações na função de perda entre as etapas subsequentes. Para ter um processo de treinamento estável e convergente, equilibre a exploração com o aproveitamento. 
• Escolha errada do algoritmo: Algoritmos simples, como o gradiente de política, podem levar a um treinamento instável em ambientes complexos com grandes espaços de ação e estado. Nesses casos, recomendamos que você use algoritmos mais robustos, como PPO e TRPO (Trust Region Policy Optimization). Esses algoritmos evitam grandes atualizações de política em cada etapa e podem ser mais estáveis.
• Aleatoriedade: Os algoritmos de RL são notoriamente sensíveis aos estados iniciais e à aleatoriedade inerente à seleção de ações. Quando uma execução de treinamento é instável, às vezes ela pode ser estabilizada usando uma semente aleatória diferente ou reinicializando a política.

Conclusão

Neste tutorial, exploramos os princípios básicos da RL, discutimos o Gymnasium como um pacote de software com uma API limpa para interagir com vários ambientes de RL e mostramos como escrever um programa Python para implementar um algoritmo simples de RL e aplicá-lo em um ambiente Gymnasium.

Depois de entender os conceitos básicos deste tutorial, recomendo que você use os ambientes do Gymnasium para aplicar os conceitos de RL na solução de problemas práticos, como otimização de rotas de táxi e simulações de negociação de ações.