Treine a IA
O que a IA vê e como ela ganha pontos
Observação, ações, eixo canônico, recompensas e currículo: as decisões de projeto que mais pesam no resultado.
Três escolhas definem o que a sua IA vai aprender: o que ela vê (observação), o que ela pode fazer (ações) e pelo que ela é premiada (recompensa). Esta página explica as escolhas do kit e por que cada uma está lá.
Eixo canônico: a IA sempre ataca para a direita
Em vez de aprender a jogar dos dois lados, a IA aprende um lado. Quando ela joga de vermelho (que ataca para a esquerda), o kit espelha o campo antes de mostrar a ela (x vira 2 × 33,18 − x, as velocidades em x trocam de sinal) e troca esquerda e direita na tecla que ela escolhe. Metade do trabalho, o dobro de experiência por situação.
A observação (39 números)
Todos os números ficam mais ou menos entre −1 e 1 (divididos pela metade do campo ou pela velocidade máxima) e são cortados em ±2. Redes neurais aprendem muito melhor com números nessa faixa.
| # | O quê |
|---|---|
| 1–4 | Minha posição e velocidade |
| 5–8 | Posição e velocidade da bola |
| 9–12 | Posição e velocidade do adversário |
| 13–16 | Bola em relação a mim e ao adversário |
| 17–20 | Bola em relação ao golo adversário e ao meu golo |
| 21–22 | Distância minha e do adversário até a bola |
| 23–24 | Posso chutar agora? O adversário pode? |
| 25 | Quanto falta para a saída de bola liberar |
| 26–29 | Traves do golo adversário e linha do meu golo, a partir de mim |
| 30–33 | Distância às quatro paredes |
| 34–35 | Distância da bola às paredes de cima e de baixo (quique) |
| 36 | A bola está entre mim e o golo adversário? (dá para chutar) |
| 37 | Estou entre a bola e o meu golo? (estou defendendo) |
| 38–39 | Velocidade da bola em relação a mim (para frear e não passar da bola) |
Os números 1 a 25 são a "versão 1" (os primeiros modelos); os 26 a 39 foram acrescentados depois que percebemos que a IA não "enxergava" paredes e traves e passava da bola. Ganho claro.
As ações (18)
9 direções (parado, ↑, ↗, →, ↘, ↓, ↙, ←, ↖) × {sem chute, chute}. Uma decisão a cada 3 quadros (100 ms).
- Por que não deixar a IA apertar qualquer combinação de teclas? Porque muitas não fazem sentido (esquerda + direita juntas) e só deixam o aprendizado mais lento.
- Por que 100 ms e não a cada quadro? Já testamos decidir a cada quadro na sala: a IA, treinada a 100 ms, passou a mandar teclas que duravam 1 quadro e "caía sem saber jogar". Decida na sala no mesmo ritmo do treino.
A recompensa
A cada decisão, a IA recebe uma pequena nota. No fim, o PPO a ensina a maximizar a soma das notas.
| Termo | Peso (estágio 3) | Por quê |
|---|---|---|
| Golo | +1 | O objetivo. Domina todo o resto |
| Golo sofrido | −1 | Com −0,8 ela pouco se esforçava para defender |
| Velocidade minha rumo à bola | 0,005 | Ajuda no começo a "achar" a bola |
| Velocidade da bola rumo ao golo adversário | 0,015 | Premia levar a bola para o lugar certo |
| Toque que acelera a bola rumo ao golo | 0,02 × aceleração | Pode ser negativo: tocar para o próprio golo custa |
| Inverter cima ↔ baixo | −0,005 | Sem isso, ela andava em zigue-zague |
Os estágios 1 e 2 usam pesos maiores de "chegar na bola" e um bônus fixo por toque, para a IA descobrir o básico rápido.
Armadilhas que já pegaram a gente
O código completo:
# recompensas.py
"""Recompensa por decisão (10 por segundo), no eixo canônico (o agente sempre ataca para a direita).
Este é o conjunto "clássico": o que treinou a IA que melhor jogou contra humanos na BonkTools.
- termos de VELOCIDADE, não de posição: ficar parado rende 0 (bônus por "estar perto da bola" ensina a estacionar);
- toque que acelera a bola rumo ao gol adversário (pode ser negativo: bola pro próprio gol);
- gol +1, gol sofrido -1;
- um custinho por inverter cima/baixo entre duas decisões (sem ele a IA anda em zigue-zague).
"""
from __future__ import annotations
import math
from dataclasses import dataclass
from .features import (ACTION_TABLE, BALL_MAX_SPEED, CENTER_Y, DOWN, GOAL_X, KICK_REACH, PLAYER_MAX_SPEED, UP,
body, canon)
@dataclass(frozen=True)
class Pesos:
jogador_bola: float # velocidade do agente em direção à bola
bola_gol: float # velocidade da bola em direção ao gol adversário
toque: float # bônus fixo por toque (só no começo: depois vira "farm" de toquinhos)
toque_gol: float # toque ponderado pela aceleração que deu à bola rumo ao gol
gol: float = 1.0
sofrido: float = 1.0
inverter: float = 0.005
PESOS = {
1: Pesos(jogador_bola=0.01, bola_gol=0.02, toque=0.05, toque_gol=0.1), # gol vazio: aprender a chegar e empurrar
2: Pesos(jogador_bola=0.005, bola_gol=0.02, toque=0.02, toque_gol=0.05), # adversário parado no caminho
3: Pesos(jogador_bola=0.005, bola_gol=0.015, toque=0.0, toque_gol=0.02), # jogo de verdade: o gol domina
}
TOQUE_DV = 1.5 # mudança mínima de velocidade da bola num passo para contar como toque (só o atrito dá < 1)
TOQUE_INTERVALO = 5 # passos entre bônus fixos de toque
TELEPORTE = 8.0 # num passo nada anda mais que ~1,5; mais que isso é reposicionamento (gol/reinício)
def _unit(dx: float, dy: float) -> tuple[float, float]:
n = math.hypot(dx, dy)
return (dx / n, dy / n) if n > 1e-6 else (0.0, 0.0)
def toque(prev: dict, curr: dict, eu: int, outro: int, espelho: bool) -> float | None:
"""Se `eu` tocou a bola entre `prev` e `curr`: aceleração da bola rumo ao gol adversário (-1..1). Senão None."""
pbx, pby, pbxv, pbyv = canon(body(prev, "ball"), espelho)
bx, by, bxv, byv = canon(body(curr, "ball"), espelho)
dvx, dvy = bxv - pbxv, byv - pbyv
if math.hypot(dvx, dvy) < TOQUE_DV:
return None
sx, sy, _, _ = canon(body(curr, "discs", eu), espelho)
ox, oy, _, _ = canon(body(curr, "discs", outro), espelho)
d_eu, d_outro = math.hypot(bx - sx, by - sy), math.hypot(bx - ox, by - oy)
if d_eu > KICK_REACH + 1.0 or d_eu > d_outro:
return None
gx, gy = _unit(GOAL_X - pbx, CENTER_Y - pby)
return max(-1.0, min(1.0, (dvx * gx + dvy * gy) / BALL_MAX_SPEED))
def teleportou(prev: dict, curr: dict, ids: tuple[int, ...]) -> bool:
def andou(a: dict, b: dict) -> float:
return math.hypot(a["x"] - b["x"], a["y"] - b["y"])
if andou(body(prev, "ball"), body(curr, "ball")) > TELEPORTE:
return True
return any(andou(body(prev, "discs", i), body(curr, "discs", i)) > TELEPORTE for i in ids)
class Recompensa:
def __init__(self, pesos: Pesos):
self.p = pesos
self.reset()
def reset(self) -> None:
self._desde_toque = TOQUE_INTERVALO
self._vertical = 0
def passo(self, prev: dict, curr: dict, eu: int, outro: int, espelho: bool, marcou: bool, sofreu: bool,
acao: int) -> tuple[float, bool]:
"""Devolve (recompensa, houve toque)."""
p = self.p
r = 0.0
bits = ACTION_TABLE[int(acao)]
vertical = -1 if bits & UP else (1 if bits & DOWN else 0)
if vertical * self._vertical == -1:
r -= p.inverter
self._vertical = vertical
if marcou:
r += p.gol
if sofreu:
r -= p.sofrido
self._desde_toque += 1
if teleportou(prev, curr, (eu, outro)):
return r, False
sx, sy, sxv, syv = canon(body(curr, "discs", eu), espelho)
bx, by, bxv, byv = canon(body(curr, "ball"), espelho)
ux, uy = _unit(bx - sx, by - sy)
r += p.jogador_bola * (sxv * ux + syv * uy) / PLAYER_MAX_SPEED
gx, gy = _unit(GOAL_X - bx, CENTER_Y - by)
r += p.bola_gol * max(-1.0, min(1.0, (bxv * gx + byv * gy) / BALL_MAX_SPEED))
t = toque(prev, curr, eu, outro, espelho)
if t is not None:
r += p.toque_gol * t
if self._desde_toque >= TOQUE_INTERVALO:
r += p.toque
self._desde_toque = 0
return r, t is not NoneO currículo
| Estágio | Cenários | Adversário | Avança com |
|---|---|---|---|
| 1 | 60% ataque (bola no campo adversário, IA perto, quase sempre atrás dela), 40% aleatório; sem congelamento inicial | Parado, longe (encostado na parede de cima) | 70% de golos em 400 lances |
| 2 | 40% saída de bola, 30% aleatório, 30% ataque | Parado no caminho | 60% de golos |
| 3 | 40% saída de bola, 30% aleatório, 30% defesa (bola indo para o golo da IA, adversário atrás dela) | 50% script (habilidade 0,4–1), 50% versão antiga da própria IA | — |
Um lance termina no primeiro golo (de qualquer lado) ou no limite de tempo (15, 30 e 45 s nos estágios 1, 2 e 3).
Os adversários com script
O Perseguidor do kit vai para trás da bola, alinha com o golo e chuta. A "habilidade" controla quantas vezes ele erra a decisão e quanto demora para reagir. Ele é importante no começo do estágio 3, quando as versões antigas da IA ainda são fracas demais.
O atraso da sala
Na sala, a IA não vê o jogo exatamente "agora": há o ritmo de 100 ms e, sem os "olhos", 200 ms de atraso da simulação do marcador. Se o treino mostrar o jogo perfeito e a sala mostrar o jogo atrasado, a IA joga mal sem nenhum erro aparente (com 200 ms, um modelo treinado sem atraso perdia todas as saídas de bola para um atacante que chuta de primeira).
Por isso o ambiente sorteia, a cada lance, quantas decisões atrás a IA vê:
--visao | Atraso sorteado | Projeção | Use na sala |
|---|---|---|---|
agora (padrão) | 0 (75%) ou 1 decisão (25%) | não | Com os "olhos" (lagFrames: 0) |
atrasada | 1, 2 ou 3 decisões (10/60/30%) | 6 quadros à frente | Só o marcador + projectState |
Veja Colocar a IA na sua sala para o lado da sala.