Conceitos de IA em Python

Aprendizado por reforço: value iteration e Q-learning em Python

No aprendizado por reforço, um agente age num ambiente e recebe recompensas. Ele aprende o quão bom é cada estado ou ação para escolher as ações que trazem mais recompensa ao longo do tempo.

O conceito em palavras simples

No aprendizado por reforço, um agente age num ambiente e recebe recompensas. Ele aprende o quão bom é cada estado ou ação para escolher as ações que trazem mais recompensa ao longo do tempo.

Ensine um agente a chegar a um objetivo: calcule os valores dos estados com value iteration e depois aprenda-os por tentativa e erro com Q-learning.

Ideias principais

O fator de desconto γ faz recompensas que chegam antes valerem mais.
A value iteration precisa de um modelo do ambiente; o Q-learning aprende com a experiência.
Q(s, a) é a recompensa total esperada ao tomar a ação a no estado s.
É preciso explorar (aqui, 20% de movimentos aleatórios) para o agente descobrir o objetivo.

Quando usar?

Entender o que acontece dentro das redes neurais e das bibliotecas de IA.
Aprender a ideia antes de implementá-la nos desafios correspondentes.
Se preparar para cursos de aprendizado de máquina, entrevistas e projetos.

Veja na prática

Clique em Executar à esquerda para espalhar os valores a partir do objetivo pela grade. À direita, veja o agente aprender o mesmo caminho por tentativa e erro.

Código de exemplo

Executar código →

main.py

import random

# A corridor of 5 cells: start in cell 0, reward +10 for reaching cell 4.
N, GOAL, GAMMA = 5, 4, 0.9

# Value iteration: a cell is worth its reward plus the discounted best neighbour.
values = [0.0] * N
for _ in range(50):
    values = [0.0 if s == GOAL else max((10 if n == GOAL else 0) + GAMMA * values[n]
              for n in (max(0, s - 1), min(N - 1, s + 1))) for s in range(N)]
print("state values:", [round(v, 2) for v in values])

# Q-learning learns the same thing from trial and error.
random.seed(0)
Q = [[0.0, 0.0] for _ in range(N)]   # actions: 0 = left, 1 = right
for episode in range(200):
    s = 0
    while s != GOAL:
        a = random.randrange(2) if random.random() < 0.2 else Q[s].index(max(Q[s]))
        n = max(0, s - 1) if a == 0 else min(N - 1, s + 1)
        reward = 10 if n == GOAL else 0
        target = reward + (0 if n == GOAL else GAMMA * max(Q[n]))
        Q[s][a] += 0.5 * (target - Q[s][a])   # move the estimate toward the target
        s = n
print("best action per cell:", ["right" if q[1] >= q[0] else "left" for q in Q[:GOAL]])
print("Q(0, right):", round(Q[0][1], 2))

Saída esperada

state values: [7.29, 8.1, 9.0, 10.0, 0.0]
best action per cell: ['right', 'right', 'right', 'right']
Q(0, right): 7.29

Como funciona

A value iteration repete a atualização de Bellman, em que o valor de uma célula é a melhor recompensa mais o valor descontado da célula seguinte; isso dá 10, 9, 8.1 e 7.29 à medida que se afasta do objetivo. O Q-learning não conhece as regras. Depois de cada passo, aproxima sua estimativa de reward + γ·max Q(next) e aprende a ir sempre para a direita.

Altere os valores e execute o programa no compilador Python online CodeUtility sem instalar Python.

Exercícios práticos

Altere as entradas e teste casos de borda antes de usar conjuntos de dados maiores.

Mude as entradas ou os pesos e preveja a saída antes de executar.
Imprima os valores intermediários para acompanhar cada passo do cálculo.
Resolva os desafios indicados abaixo para implementar a ideia você mesmo.

Executar no IDE Python →

Pratique com um desafio

Use o conteúdo desta lição para resolver um problema real. Cada desafio roda no navegador, com testes instantâneos e uma revisão por IA.

Todos os desafios