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–4Minha posição e velocidade
5–8Posição e velocidade da bola
9–12Posição e velocidade do adversário
13–16Bola em relação a mim e ao adversário
17–20Bola em relação ao golo adversário e ao meu golo
21–22Distância minha e do adversário até a bola
23–24Posso chutar agora? O adversário pode?
25Quanto falta para a saída de bola liberar
26–29Traves do golo adversário e linha do meu golo, a partir de mim
30–33Distância às quatro paredes
34–35Distância da bola às paredes de cima e de baixo (quique)
36A bola está entre mim e o golo adversário? (dá para chutar)
37Estou entre a bola e o meu golo? (estou defendendo)
38–39Velocidade 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.

TermoPeso (estágio 3)Por quê
Golo+1O objetivo. Domina todo o resto
Golo sofrido−1Com −0,8 ela pouco se esforçava para defender
Velocidade minha rumo à bola0,005Ajuda no começo a "achar" a bola
Velocidade da bola rumo ao golo adversário0,015Premia levar a bola para o lugar certo
Toque que acelera a bola rumo ao golo0,02 × aceleraçãoPode ser negativo: tocar para o próprio golo custa
Inverter cima ↔ baixo−0,005Sem 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:

python
# 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 None

O currículo

EstágioCenáriosAdversárioAvança com
160% ataque (bola no campo adversário, IA perto, quase sempre atrás dela), 40% aleatório; sem congelamento inicialParado, longe (encostado na parede de cima)70% de golos em 400 lances
240% saída de bola, 30% aleatório, 30% ataqueParado no caminho60% de golos
340% 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ê:

--visaoAtraso sorteadoProjeçãoUse na sala
agora (padrão)0 (75%) ou 1 decisão (25%)nãoCom os "olhos" (lagFrames: 0)
atrasada1, 2 ou 3 decisões (10/60/30%)6 quadros à frenteSó o marcador + projectState

Veja Colocar a IA na sua sala para o lado da sala.