Guia Técnico: Desenvolvendo Agentes de IA com Python
Os agentes de IA (Inteligência Artificial) são entidades autônomas que percebem seu ambiente, processam informações e executam ações para alcançar objetivos específicos. Eles são amplamente utilizados em diversas áreas, como assistentes virtuais, veículos autônomos, robótica, jogos e aplicações financeiras. Esses agentes podem variar em complexidade, desde simples sistemas baseados em regras até sofisticados modelos de aprendizado de máquina que se adaptam com base em experiências passadas.
Neste guia técnico, você aprenderá a desenvolver agentes de IA utilizando Python, começando com conceitos básicos e evoluindo para a implementação de agentes que utilizam técnicas de aprendizado por reforço. Em cada etapa, avaliaremos o desempenho do agente para observar as melhorias obtidas.
Antes de tudo você precisa intalas as ferramentas:
!pip install gym numpy
Passo 1: Compreendendo o Ambiente
Um agente de IA interage com um ambiente definido por estados, ações e recompensas. Vamos utilizar o OpenAI Gym, uma biblioteca que fornece uma variedade de ambientes prontos para treinamento de agentes. Neste exemplo, usaremos o ambiente
CartPole-v1, onde o objetivo do agente é equilibrar um pêndulo em cima de um carrinho em movimento.import gym # Criando o ambiente env = gym.make('CartPole-v1') state = env.reset() print("Estado inicial:", state)
O que esse código faz:
- Importa a biblioteca
gym.
- Cria o ambiente
CartPole-v1, onde o agente tentará manter o pêndulo equilibrado.
- Reseta o ambiente para o estado inicial e imprime esse estado.
Passo 2: Implementando um Agente Aleatório
Começamos criando um agente básico que executa ações aleatórias, sem qualquer inteligência. Esse agente servirá como ponto de referência para as melhorias subsequentes.
# Avaliação do agente aleatório total_rewards = [] for episode in range(100): state = env.reset() total_reward = 0 for _ in range(1000): action = env.action_space.sample() # Ação aleatória state, reward, done, info = env.step(action) total_reward += reward if done: break total_rewards.append(total_reward) average_reward = np.mean(total_rewards) print(f"Recompensa média do agente aleatório: {average_reward}") env.close()
O que esse código faz:
- O agente executa ações aleatórias em 100 episódios.
- Calcula e imprime a recompensa média do agente aleatório.
Resultados Esperados:
- A recompensa média do agente aleatório será baixa, refletindo a falta de inteligência no processo de tomada de decisões.
Acesse e teste o código aqui 👉 Agente Simples Aleatório
Passo 3: Agora vamos criar um Agente baseado em regras
Agora, vamos implementar um agente que usa uma política simples: mover o carrinho para a esquerda se o pêndulo inclinar para a esquerda, e para a direita se inclinar para a direita. Essa abordagem é chamada de política baseada em regras.
def basic_policy(state): angle = state[2] # O terceiro valor do estado é o ângulo do pêndulo return 0 if angle < 0 else 1 # Retorna 0 (esquerda) se o ângulo for negativo, caso contrário, 1 (direita) # Avaliação do agente baseado em regras total_rewards = [] for episode in range(100): state = env.reset() total_reward = 0 for _ in range(1000): action = basic_policy(state) # Política baseada em regras state, reward, done, info = env.step(action) total_reward += reward if done: break total_rewards.append(total_reward) average_reward = np.mean(total_rewards) print(f"Recompensa média do agente baseado em regras: {average_reward}") env.close()
O que esse código faz:
- Define uma política simples onde o agente se move para a direção oposta da inclinação do pêndulo.
- Avalia o agente ao longo de 100 episódios e imprime a recompensa média.
Resultados Esperados:
- A recompensa média deve ser maior do que a do agente aleatório, mostrando que decisões simples baseadas em regras podem melhorar o desempenho.
Acesse e teste o código aqui 👉 Agente baseado em regras
Passo 4: Desenvolvendo um Agente inteligente com Q-Learning
Finalmente, vamos implementar um agente que aprende usando Q-Learning, uma técnica de aprendizado
Q-Learning é uma técnica de aprendizado por reforço onde o agente aprende a tomar decisões baseadas na maximização da recompensa a longo prazo. Diferente do agente baseado em regras, um agente com Q-Learning não segue regras fixas, mas sim aprende uma política de ações com base em experiências passadas.
Conceitos Fundamentais de Q-Learning
- Q-Table: É uma tabela onde cada linha representa um estado e cada coluna uma ação. O valor na interseção entre um estado e uma ação (valor Q) representa a recompensa esperada se a ação for tomada naquele estado.
- Atualização da Q-Table: Após cada ação, a Q-Table é atualizada com base na recompensa recebida e na estimativa da recompensa futura.
Como o espaço de estados no
CartPole-v1 é contínuo, precisamos discretizar esses estados para aplicar Q-Learning.import numpy as np # Configurações do ambiente e Q-Learning env = gym.make('CartPole-v1') n_actions = env.action_space.n # Discretização dos espaços de estado state_bins = [ np.linspace(-4.8, 4.8, 10), # bins para a posição do carrinho np.linspace(-4, 4, 10), # bins para a velocidade do carrinho np.linspace(-0.418, 0.418, 10), # bins para o ângulo do pêndulo np.linspace(-4, 4, 10) # bins para a velocidade angular do pêndulo ] # Inicializando a Q-table q_table = np.zeros([10, 10, 10, 10, n_actions]) # Hiperparâmetros alpha = 0.1 # Taxa de aprendizado gamma = 0.99 # Fator de desconto epsilon = 0.1 # Fator de exploração def discretize_state(state, state_bins): """Converte um estado contínuo em um índice discreto.""" state_idx = [] for i in range(len(state)): state_idx.append(np.digitize(state[i], state_bins[i]) - 1) return tuple(state_idx) # Treinando o agente usando Q-Learning for episode in range(100): state = discretize_state(env.reset(), state_bins) total_reward = 0 for _ in range(1000): if np.random.rand() < epsilon: action = env.action_space.sample() # Escolhe ação aleatória (exploração) else: action = np.argmax(q_table[state]) # Escolhe ação com melhor valor Q (exploração) next_state, reward, done, info = env.step(action) next_state = discretize_state(next_state, state_bins) # Atualização da Q-table q_value = q_table[state][action] max_q_value_next = np.max(q_table[next_state]) new_q_value = q_value + alpha * (reward + gamma * max_q_value_next - q_value) q_table[state][action] = new_q_value state = next_state total_reward += reward if done: break print(f"Episódio {episode + 1}: Recompensa Total = {total_reward}") env.close() # Avaliação do agente treinado com Q-Learning total_rewards = [] for episode in range(100): state = discretize_state(env.reset(), state_bins) total_reward = 0 for _ in range(1000): action = np.argmax(q_table[state]) next_state, reward, done, info = env.step(action) state = discretize_state(next_state, state_bins) total_reward += reward if done: break total_rewards.append(total_reward) average_reward = np.mean(total_rewards) print(f"Recompensa média do agente treinado com Q-Learning: {average_reward}") env.close()
O que esse código faz:
- Discretiza o espaço de estados contínuos em bins.
- Treina o agente utilizando Q-Learning, atualizando a Q-table ao longo dos episódios.
- Avalia o agente treinado ao longo de 100 episódios e imprime a recompensa média.
Resultados Esperados:
- O agente treinado com Q-Learning deve apresentar uma recompensa média significativamente maior, indicando que ele aprendeu a maximizar as recompensas ao longo do tempo.
Acesse e teste o código aqui 👉 Agente Q-Learning
Conclusão
Neste artigo, você viu a evolução de um agente de IA, desde um simples agente aleatório até um agente treinado usando Q-Learning.
Cada passo foi acompanhado de uma avaliação para medir o desempenho e as melhorias obtidas com as técnicas aplicadas.
Resumo das Avaliações:
- Agente Aleatório: Recompensa média baixa, sem inteligência nas ações.
- Agente Baseado em Regras: Recompensa média melhorada, mostrando que políticas simples podem fazer diferença.
- Agente com Q-Learning: Melhor desempenho geral, aprendendo a maximizar a recompensa ao longo do tempo.
