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 numpyUm 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:
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:
Resultados Esperados:
Bora codar juntos um gerenciador de metas?
embarcar na missãoAgora, 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:
Resultados Esperados:
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.
Bora codar juntos um gerenciador de metas?
embarcar na missãoComo 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:
Resultados Esperados:
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:
