Construindo um Ambiente Personalizado para Aprendizado de Reforço Profundo com OpenAI Gym e Python

Tabela de Conteúdos

1. Introdução
2. Ambiente de Aprendizado por Reforço Personalizado 2.1. O que é o OpenAI Gym? 2.2. Criando um ambiente personalizado
3. Treinando um modelo DQN 3.1. Bibliotecas necessárias 3.2. Definindo as ações e estados 3.3. Definindo o modelo de aprendizado 3.4. Treinando o modelo
4. Testando o modelo 4.1. Avaliando as recompensas 4.2. Ajustando o ambiente
5. Conclusão
6. Recursos adicionais

Introdução

Olá pessoal, meu nome é Nicholas Turner e neste artigo vamos dar uma olhada em como você pode construir seu próprio ambiente personalizado de aprendizado por reforço usando o OpenAI Gym. Vamos explorar passo a passo como criar esse ambiente, treinar um modelo DQN nele e, em seguida, testar seu desempenho. Então vamos lá!

Ambiente de Aprendizado por Reforço Personalizado

2.1 O que é o OpenAI Gym?

O OpenAI Gym é uma biblioteca de código aberto que fornece uma ampla coleção de ambientes e ferramentas para desenvolver e comparar algoritmos de aprendizado por reforço. Ele oferece uma interface consistente para trabalhar com diferentes ambientes e facilita o desenvolvimento de ambientes personalizados.

2.2 Criando um ambiente personalizado

Vamos começar baixando algum código inicial para aprendizado por reforço. Esse código será a base do nosso ambiente personalizado. Acesse o repositório abaixo para obter o código necessário: https://github.com/nick-nack-attack/tensorflow-keras-reinforcement-learning

Após clonar o repositório em seu ambiente de desenvolvimento, abra o arquivo reinforcement_learning_tutorial.ipynb no Jupyter Notebook. Este notebook contém um Tutorial completo sobre aprendizado por reforço usando o OpenAI Gym.

Agora, vamos começar a construir nosso ambiente personalizado. Abra uma célula de código no notebook e vamos importar as bibliotecas necessárias:

import gym
from gym import spaces
import numpy as np
import random

Em seguida, criaremos uma classe chamada ShowerEnv, que será o nosso ambiente personalizado. Essa classe será uma subclasse da classe gym.Env do OpenAI Gym. Vamos definir os métodos necessários para nosso ambiente:

class ShowerEnv(gym.Env):
    def __init__(self):
        super(ShowerEnv, self).__init__()
        self.action_space = spaces.Discrete(3)
        low = np.array([0])
        high = np.array([100])
        self.observation_space = spaces.Box(low, high, dtype=np.float32)
        self.state = None
        self.shower_length = 60

    def step(self, action):
      # Lógica para calcular a próxima etapa do ambiente
      ...

    def reset(self):
      # Lógica para redefinir o ambiente
      ...

O método __init__ é responsável pela inicialização do ambiente. Nele, configuramos o espaço de ação como um espaço discreto com 3 ações possíveis (0, 1 e 2) e o espaço de observação como um espaço contínuo entre 0 e 100 (representando a temperatura da água do chuveiro).

O método step é chamado a cada passo do ambiente e recebe uma ação como parâmetro. É neste método que a lógica para calcular a próxima etapa do ambiente é implementada.

O método reset é responsável por redefinir o ambiente para um estado inicial. Será útil quando formos treinar nosso modelo.

Agora que temos a estrutura básica do ambiente personalizado, vamos preencher os métodos com a lógica necessária. Vou descrever a lógica em detalhes no próximo trecho do artigo.

Treinando um modelo DQN

3.1 Bibliotecas necessárias

Antes de começarmos, vamos importar as bibliotecas necessárias para treinar o modelo DQN:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from rl.agents import DQNAgent
from rl.policy import EpsilonGreedyPolicy
from rl.memory import SequentialMemory

3.2 Definindo as ações e estados

Em nosso ambiente personalizado, as ações possíveis são representadas pelos números 0, 1 e 2. O número 0 significa diminuir a temperatura do chuveiro, o número 1 significa manter a temperatura atual e o número 2 significa aumentar a temperatura.

O estado do ambiente é representado pela temperatura atual do chuveiro. Vamos manter a temperatura inicial em 38 graus Celsius e permitir que ela varie entre 37 e 39 graus.

3.3 Definindo o modelo de aprendizado

Agora é hora de definir o modelo de aprendizado. Usaremos uma rede neural simples com uma camada densa. O modelo será treinado usando o algoritmo de aprendizado por reforço Deep Q-Network (DQN).

Segue o código para definir o modelo:

def build_model(states, actions):
    model = Sequential()
    model.add(Dense(64, activation='relu', input_shape=(states,)))
    model.add(Dense(actions, activation='linear'))
    return model

states = 1
actions = 3

model = build_model(states, actions)

No código acima, estamos criando uma rede neural com uma camada densa de 64 neurônios e função de ativação ReLU. A camada de saída possui tantos neurônios quanto a quantidade de ações possíveis (3 no nosso caso) e usa uma função de ativação linear.

3.4 Treinando o modelo

Agora que temos nosso ambiente personalizado e nosso modelo DQN, podemos começar o treinamento.

Vamos configurar alguns hiperparâmetros e criar um objeto DQNAgent para realizar o treinamento:

# Definindo alguns hiperparâmetros
batch_size = 32
gamma = 0.99
exploration_policy = EpsilonGreedyPolicy(epsilon=0.1)

# Criando a memória de replay
memory = SequentialMemory(limit=50000, window_length=1)

# Criando o agente
agent = DQNAgent(model=model, memory=memory, policy=exploration_policy,
                 nb_actions=actions, nb_steps_warmup=10, target_model_update=1e-2)

# Compilando o modelo
agent.compile(Adam(lr=1e-3), metrics=['mae'])

# Treinando o modelo
history = agent.fit(env, nb_steps=10000, visualize=False,
                    verbose=2, batch_size=batch_size)

# Salvando o modelo treinado
agent.save_weights('shower_dqn_weights.h5', overwrite=True)

No código acima, estamos definindo alguns hiperparâmetros, como o tamanho do batch e o fator de desconto gamma. Em seguida, criamos uma política de exploração epsilon-greedy para o nosso agente.

Também criamos um objeto SequentialMemory para armazenar as experiências passadas do agente, permitindo que ele aprenda com elas.

Em seguida, criamos o objeto DQNAgent, passando nosso modelo, a Memória, a política de exploração e o número de ações possíveis. Compilamos o modelo usando o otimizador Adam com uma taxa de aprendizado de 1e-3.

Finalmente, treinamos o modelo chamando o método fit do agente. Salvamos os pesos do modelo treinado para uso posterior.

Testando o modelo

4.1 Avaliando as recompensas

Para avaliar o desempenho do nosso modelo treinado, vamos executá-lo em nosso ambiente personalizado e registrar as recompensas alcançadas. Podemos fazer isso da seguinte forma:

# Testando o modelo treinado
scores = []
for _ in range(10):
    score = agent.test(env, nb_episodes=1, visualize=False)
    scores.append(score.history['episode_reward'][0])

average_reward = np.mean(scores)
print("Average reward:", average_reward)

No código acima, estamos executando 10 episódios do nosso ambiente e registrando as recompensas obtidas em cada episódio. Em seguida, calculamos a média das recompensas para obter uma medida do desempenho médio do nosso modelo treinado.

4.2 Ajustando o ambiente

Depois de testar o modelo, você pode experimentar ajustar os parâmetros do ambiente e executar novamente o treinamento para ver se consegue melhorar o desempenho. Por exemplo, você pode ajustar a faixa de temperatura ideal ou modificar a quantidade de ruído que é adicionada à temperatura do chuveiro.

Conclusão

Neste artigo, exploramos como criar um ambiente personalizado de aprendizado por reforço usando o OpenAI Gym. Também treinamos um modelo DQN nesse ambiente e testamos seu desempenho. Espero que você tenha achado este tutorial útil e possa aplicar esses conceitos para desenvolver seus próprios ambientes de aprendizado por reforço personalizados. Divirta-se experimentando e boa sorte em seus projetos de IA!

Recursos adicionais

• Repositório GitHub com o código completo
• Documentação do OpenAI Gym
• Artigo do Deep Q-Network (DQN)