Entrena la IA

Lo que ve la IA y cómo gana puntos

Observación, acciones, eje canónico, recompensas y currículo: las decisiones de diseño que más pesan en el resultado.

Tres decisiones definen lo que tu IA va a aprender: lo que ve (observación), lo que puede hacer (acciones) y por qué se la premia (recompensa). Esta página explica las decisiones del kit y por qué está cada una.

Eje canónico: la IA siempre ataca hacia la derecha

En lugar de aprender a jugar en los dos lados, la IA aprende uno. Cuando juega en rojo (que ataca hacia la izquierda), el kit refleja el campo antes de mostrárselo (x pasa a ser 2 × 33,18 − x, las velocidades en x cambian de signo) e intercambia izquierda y derecha en la tecla que elige. La mitad del trabajo, el doble de experiencia por situación.

La observación (39 números)

Todos los números quedan más o menos entre −1 y 1 (divididos por la mitad del campo o por la velocidad máxima) y se limitan a ±2. Las redes neuronales aprenden mucho mejor con números en ese rango.

#Qué
1–4Mi posición y velocidad
5–8Posición y velocidad de la pelota
9–12Posición y velocidad del rival
13–16Pelota respecto a mí y al rival
17–20Pelota respecto a la portería rival y a la mía
21–22Mi distancia y la del rival a la pelota
23–24¿Puedo tirar ahora? ¿Y el rival?
25Cuánto falta para que se libere el saque
26–29Postes de la portería rival y línea de mi portería, desde mí
30–33Distancia a las cuatro paredes
34–35Distancia de la pelota a las paredes de arriba y abajo (rebote)
36¿La pelota está entre yo y la portería rival? (puedo tirar)
37¿Estoy entre la pelota y mi portería? (estoy defendiendo)
38–39Velocidad de la pelota respecto a mí (para frenar y no pasarme de la pelota)

Los números 1 a 25 son la "versión 1" (los primeros modelos); los 26 a 39 se agregaron cuando notamos que la IA no "veía" paredes ni postes y se pasaba de la pelota. Ganancia clara.

Las acciones (18)

9 direcciones (quieta, ↑, ↗, →, ↘, ↓, ↙, ←, ↖) × {sin tiro, tiro}. Una decisión cada 3 cuadros (100 ms).

  • ¿Por qué no dejar que la IA pulse cualquier combinación de teclas? Porque muchas no tienen sentido (izquierda + derecha juntas) y solo hacen el aprendizaje más lento.
  • ¿Por qué 100 ms y no cada cuadro? Probamos decidir cada cuadro en la sala: la IA, entrenada a 100 ms, empezó a enviar teclas que duraban 1 cuadro y "se caía sin saber jugar". Decide en la sala al mismo ritmo que en el entrenamiento.

La recompensa

En cada decisión, la IA recibe una pequeña nota. Al final, PPO le enseña a maximizar la suma de las notas.

TérminoPeso (etapa 3)Por qué
Gol+1El objetivo. Domina todo lo demás
Gol recibido−1Con −0,8 apenas se esforzaba en defender
Mi velocidad hacia la pelota0,005Ayuda al principio a "encontrar" la pelota
Velocidad de la pelota hacia la portería rival0,015Premia llevar la pelota al lugar correcto
Toque que acelera la pelota hacia la portería0,02 × aceleraciónPuede ser negativo: tocar hacia la propia portería cuesta
Invertir arriba ↔ abajo−0,005Sin esto, andaba en zigzag

Las etapas 1 y 2 usan pesos mayores para "llegar a la pelota" y un bonus fijo por toque, para que la IA descubra lo básico rápido.

Trampas en las que caímos

El código completo:

python
# recompensas.py
"""Recompensa por decisión (10 por segundo), en el eje canónico (el agente siempre ataca hacia la derecha).

Este es el conjunto "clásico": el que entrenó a la IA que mejor jugó contra humanos en BonkTools.
  - términos de VELOCIDAD, no de posición: quedarse quieto da 0 (un bonus por "estar cerca de la pelota" enseña a estacionarse);
  - toque que acelera la pelota hacia la portería rival (puede ser negativo: pelota hacia la propia portería);
  - gol +1, gol recibido -1;
  - un pequeño costo por invertir arriba/abajo entre dos decisiones (sin él la IA anda en zigzag).
"""
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  # velocidad del agente hacia la pelota
    bola_gol: float  # velocidad de la pelota hacia la portería rival
    toque: float  # bonus fijo por toque (solo al principio: luego se vuelve "farm" de toquecitos)
    toque_gol: float  # toque ponderado por la aceleración que dio a la pelota hacia la portería
    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),  # portería vacía: aprender a llegar y empujar
    2: Pesos(jogador_bola=0.005, bola_gol=0.02, toque=0.02, toque_gol=0.05),  # rival quieto en el camino
    3: Pesos(jogador_bola=0.005, bola_gol=0.015, toque=0.0, toque_gol=0.02),  # juego de verdad: el gol domina
}

TOQUE_DV = 1.5  # cambio mínimo de velocidad de la pelota en un paso para contar como toque (solo la fricción da < 1)
TOQUE_INTERVALO = 5  # pasos entre bonus fijos de toque
TELEPORTE = 8.0  # en un paso nada se mueve más de ~1,5; más que eso es reposicionamiento (gol/reinicio)


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:
    """Si `eu` tocó la pelota entre `prev` y `curr`: aceleración de la pelota hacia la portería rival (-1..1). Si no, 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]:
        """Devuelve (recompensa, hubo 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

El currículo

EtapaEscenariosRivalAvanza con
160% ataque (pelota en campo rival, IA cerca, casi siempre detrás de ella), 40% aleatorio; sin congelamiento inicialQuieto, lejos (pegado a la pared de arriba)70% de goles en 400 jugadas
240% saque, 30% aleatorio, 30% ataqueQuieto en el camino60% de goles
340% saque, 30% aleatorio, 30% defensa (pelota yendo a la portería de la IA, rival detrás de ella)50% script (habilidad 0,4–1), 50% versión antigua de la propia IA—

Una jugada termina en el primer gol (de cualquier lado) o en el límite de tiempo (15, 30 y 45 s en las etapas 1, 2 y 3).

Los rivales con script

El Perseguidor del kit se pone detrás de la pelota, se alinea con la portería y tira. La "habilidad" controla cuántas veces se equivoca de decisión y cuánto tarda en reaccionar. Es importante al principio de la etapa 3, cuando las versiones antiguas de la IA todavía son demasiado débiles.

El retraso de la sala

En la sala, la IA no ve el juego exactamente "ahora": está el ritmo de 100 ms y, sin los "ojos", los 200 ms de retraso de la simulación del marcador. Si el entrenamiento muestra el juego perfecto y la sala muestra el juego atrasado, la IA juega mal sin ningún error visible (con 200 ms, un modelo entrenado sin retraso perdía todos los saques ante un delantero que tira de primera).

Por eso, en cada jugada, el entorno sortea cuántas decisiones atrás ve la IA:

--visaoRetraso sorteadoProyecciónÚsalo en la sala
agora ("ahora", por defecto)0 (75%) o 1 decisión (25%)noCon los "ojos" (lagFrames: 0)
atrasada1, 2 o 3 decisiones (10/60/30%)6 cuadros adelanteSolo el marcador + projectState

Ver Poner la IA en tu sala para el lado de la sala.