Aprendizado por reforço: agente, ambiente, ação e estado
O aprendizado por reforço é um tipo de machine learning. Ele ensina um agente a tomar decisões. O agente aprende por tentativa e erro. Ele recebe recompensas ou punições. Esse método inspira-se na psicologia comportamental. Portanto, as pessoas usam muito este método em robótica e jogos.
Os quatro elementos fundamentais
Primeiramente, o agente é quem aprende e age. Ele observa o ambiente ao redor. O ambiente compreende tudo com que o agente interage. Por exemplo, uma ação representa uma escolha possível do agente. Mover para esquerda ou direita seria um exemplo disso. O estado descreve a situação atual. Consequentemente, a cada ação, o estado muda. Além disso, o ambiente fornece uma recompensa numérica. Assim, o objetivo do agente é maximizar a soma das recompensas. Dessa forma, o agente melhora continuamente seu comportamento.
Os pesquisadores modelam esses quatro elementos matematicamente. A política π define a estratégia do agente. Ela mapeia estados para ações. A função valor V(s) estima a recompensa futura. Os especialistas denotam isso frequentemente por \( V(s) = \mathbb{E} \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right] \). O fator γ é um hiperparâmetro entre 0 e 1. Ele desconta recompensas distantes. Portanto, valores baixos de γ priorizam ganhos imediatos.
Hiperparâmetros e arquitetura comum
A taxa de aprendizado α controla a velocidade de atualização. O fator de desconto γ foi mencionado antes. A taxa de exploração ε usa a estratégia ε-greedy. Em cada passo, o agente escolhe ação aleatória com probabilidade ε. Caso contrário, ele escolhe a melhor ação conhecida. Essa abordagem equilibra exploração e explotação. Os engenheiros usam redes neurais profundas frequentemente. Essas redes aproximam a função valor ou política. Essa arquitetura chama-se DQN (Deep Q-Network). Consequentemente, os profissionais resolvem problemas complexos com essa técnica.
A equação de Bellman ocupa lugar central no aprendizado. Nós a escrevemos como \( Q(s,a) = r + \gamma \max_{a’} Q(s’, a’) \). Aqui Q(s,a) é o valor de agir em um estado. O erro temporal (TD error) é calculado assim: \( \delta = r + \gamma \max_{a’} Q(s’, a’) – Q(s,a) \). A atualização do Q-valor segue a fórmula \( Q(s,a) \leftarrow Q(s,a) + \alpha \delta \). Essas fórmulas constituem a base de muitos algoritmos. Além disso, elas permitem aprendizado online eficiente.
Exemplo clássico: o labirinto do rato faminto
Considere um rato em um labirinto 4×4. O rato (agente) quer encontrar o queijo. A recompensa do queijo é +10. Ele pode mover-se para cima, baixo, esquerda ou direita. Porém, paredes bloqueiam certos movimentos. Buracos dão recompensa -5. Eles também terminam o episódio. O estado representa a posição (linha, coluna). O ambiente compreende a grade com paredes e buracos. Portanto, o objetivo do agente é aprender a política ótima. O código abaixo resolve esse problema com Q-learning.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 |
import numpy as np import matplotlib.pyplot as plt # Ambiente: grade 4x4 # 0 = caminho, 1 = parede, 2 = queijo, 3 = buraco grid = np.array([ [0, 0, 0, 0], [0, 1, 0, 3], [0, 1, 0, 0], [0, 0, 2, 0] ]) # Mapeamento ações: 0=cima, 1=baixo, 2=esquerda, 3=direita acoes = [(-1,0), (1,0), (0,-1), (0,1)] num_acoes = 4 num_estados = 16 # 4x4 # Hiperparâmetros alpha = 0.1 # taxa aprendizado gamma = 0.95 # fator desconto epsilon = 0.2 # exploração episodios = 500 # Inicializa tabela Q Q = np.zeros((num_estados, num_acoes)) def estado_para_idx(linha, coluna): return linha * 4 + coluna def idx_para_estado(idx): return (idx // 4, idx % 4) def obter_recompensa(linha, coluna): if grid[linha, coluna] == 2: # queijo return 10, True elif grid[linha, coluna] == 3: # buraco return -5, True return -0.1, False # pequena penalidade por tempo def escolher_acao(estado_idx, epsilon): if np.random.rand() < epsilon: return np.random.randint(num_acoes) return np.argmax(Q[estado_idx]) # Treinamento recompensas_por_episodio = [] for ep in range(episodios): linha, coluna = 0, 0 # estado inicial estado_idx = estado_para_idx(linha, coluna) total_recompensa = 0 feito = False while not feito: acao = escolher_acao(estado_idx, epsilon) dlinha, dcoluna = acoes[acao] nova_linha = linha + dlinha nova_coluna = coluna + dcoluna # Verifica limites e paredes if (nova_linha < 0 or nova_linha >= 4 or nova_coluna < 0 or nova_coluna >= 4 or grid[nova_linha, nova_coluna] == 1): nova_linha, nova_coluna = linha, coluna # não move recompensa, feito = obter_recompensa(nova_linha, nova_coluna) novo_estado_idx = estado_para_idx(nova_linha, nova_coluna) # Atualização Q-learning melhor_futuro = np.max(Q[novo_estado_idx]) Q[estado_idx, acao] += alpha * (recompensa + gamma * melhor_futuro - Q[estado_idx, acao]) linha, coluna = nova_linha, nova_coluna estado_idx = novo_estado_idx total_recompensa += recompensa if feito: break recompensas_por_episodio.append(total_recompensa) # Gráfico 1: Evolução das recompensas plt.figure(figsize=(12,4)) plt.subplot(1,2,1) plt.plot(recompensas_por_episodio, alpha=0.7) plt.xlabel('Episódio') plt.ylabel('Recompensa total') plt.title('Aprendizado do rato') plt.grid(True) # Gráfico 2: Política aprendida (setas) plt.subplot(1,2,2) política = np.argmax(Q, axis=1) setas = ['↑', '↓', '←', '→'] grade_pol = np.empty((4,4), dtype=str) for i in range(4): for j in range(4): if grid[i,j] == 2: grade_pol[i,j] = '🧀' elif grid[i,j] == 3: grade_pol[i,j] = '💀' elif grid[i,j] == 1: grade_pol[i,j] = '█' else: acao = política[estado_para_idx(i,j)] grade_pol[i,j] = setas[acao] plt.text(0.1, 0.5, str(grade_pol), fontsize=14, family='monospace') plt.axis('off') plt.title('Política ótima aprendida') plt.tight_layout() plt.show() print("Política final (setas):") for linha in grade_pol: print(' '.join(linha)) |
O código implementa Q-learning clássico. O rato explora o labirinto por 500 episódios. A recompensa total cresce gradualmente. A política final mostra o caminho para o queijo. Este exemplo oferece uma introdução poderosa. Assim, você entende os fundamentos do aprendizado por reforço.