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–4 | Mi posición y velocidad |
| 5–8 | Posición y velocidad de la pelota |
| 9–12 | Posición y velocidad del rival |
| 13–16 | Pelota respecto a mí y al rival |
| 17–20 | Pelota respecto a la portería rival y a la mía |
| 21–22 | Mi distancia y la del rival a la pelota |
| 23–24 | ¿Puedo tirar ahora? ¿Y el rival? |
| 25 | Cuánto falta para que se libere el saque |
| 26–29 | Postes de la portería rival y línea de mi portería, desde mí |
| 30–33 | Distancia a las cuatro paredes |
| 34–35 | Distancia 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–39 | Velocidad 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érmino | Peso (etapa 3) | Por qué |
|---|---|---|
| Gol | +1 | El objetivo. Domina todo lo demás |
| Gol recibido | −1 | Con −0,8 apenas se esforzaba en defender |
| Mi velocidad hacia la pelota | 0,005 | Ayuda al principio a "encontrar" la pelota |
| Velocidad de la pelota hacia la portería rival | 0,015 | Premia llevar la pelota al lugar correcto |
| Toque que acelera la pelota hacia la portería | 0,02 × aceleración | Puede ser negativo: tocar hacia la propia portería cuesta |
| Invertir arriba ↔ abajo | −0,005 | Sin 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:
# 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 NoneEl currículo
| Etapa | Escenarios | Rival | Avanza con |
|---|---|---|---|
| 1 | 60% ataque (pelota en campo rival, IA cerca, casi siempre detrás de ella), 40% aleatorio; sin congelamiento inicial | Quieto, lejos (pegado a la pared de arriba) | 70% de goles en 400 jugadas |
| 2 | 40% saque, 30% aleatorio, 30% ataque | Quieto en el camino | 60% de goles |
| 3 | 40% 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:
--visao | Retraso sorteado | Proyección | Úsalo en la sala |
|---|---|---|---|
agora ("ahora", por defecto) | 0 (75%) o 1 decisión (25%) | no | Con los "ojos" (lagFrames: 0) |
atrasada | 1, 2 o 3 decisiones (10/60/30%) | 6 cuadros adelante | Solo el marcador + projectState |
Ver Poner la IA en tu sala para el lado de la sala.