Entraîner l'IA

Entraîner et exporter

Lancez l'entraînement avec PPO et self-play, suivez-le avec des graphiques, évaluez et emmenez le modèle dans votre salon.

Lancer l'entraînement

bash
python treinar.py --passos 5000000 --envs 4

Ce qui s'affiche dans le terminal (salvo = enregistré, passos = pas, estágio = étape, currículo = curriculum) :

text
[salvo] 100000 passos, estágio 1
[currículo] passou para o estágio 2 (822320 passos)
[currículo] passou para o estágio 3 (870212 passos)
...
OptionPar défautCe qu'elle fait
--passos5 millionsCombien de pas entraîner cette fois
--envs4Simulations en parallèle (utilisez 2, 4 ou 8)
--visaoagoraComment l'IA voit le jeu ; doit correspondre au salon (pourquoi)
--novo—Repart de zéro (l'ancien checkpoint est ignoré, pas supprimé)
--salvar100 milleTous les combien de pas il enregistre un checkpoint
--rival-a-cada250 milleTous les combien de pas l'IA actuelle entre dans la « ligue » d'adversaires

Vous pouvez l'arrêter avec Ctrl+C quand vous voulez : il enregistre avant de quitter. En relançant python treinar.py, il reprend là où il s'était arrêté (l'étape du curriculum est gardée dans checkpoints/estado.json).

Combien de temps ça prend

Mesuré sur un PC ordinaire avec --envs 4 (~750 pas/s) :

Étape franchiePasTemps
Sort de l'étape 1 (trouve le ballon et marque sans gardien)~820 mille~18 min
Sort de l'étape 2 (adversaire immobile sur le chemin)~870 mille~1 min plus tard
Contre le script le plus fort : 78 buts, 21 encaissés en 100 actions2 millions~45 min
Modèle publié : 95 buts, 2 encaissés182 millionsdes jours (le nôtre a tourné sur plusieurs machines)

Ces chiffres viennent d'un vrai entraînement avec le kit, sur un PC ordinaire. Le vôtre peut varier un peu (la chance des premières actions change le parcours), mais l'ordre de grandeur est celui-là.

Suivre avec des graphiques

bash
tensorboard --logdir checkpoints/tb

Ouvrez l'adresse affichée (en général http://localhost:6006) :

GraphiqueÀ quoi s'attendre
bonk/gols (buts)Monte jusqu'à l'objectif et chute quand l'étape change (l'exercice est devenu plus dur). Normal
bonk/sofridos (encaissés)À l'étape 3, doit baisser avec le temps
bonk/estagio (étape)1 → 2 → 3
rollout/ep_rew_meanLa note moyenne par action. Monte lentement
train/entropy_lossÀ quel point l'IA « expérimente » encore. Diminue ; si ça s'effondre tôt, elle a arrêté d'explorer

Évaluer

bash
python avaliar.py checkpoints/policy.json --lances 200

Il joue contre le script le plus fort, en décidant exactement comme le salon (axe par axe, avec le retard choisi). Pour référence, le modèle publié donne (gols = buts, sofridos = encaissés, saldo = solde) :

text
$ python avaliar.py football-1x1.policy.json --lances 100
100 lances: 95 gols, 2 sofridos, 3 sem gol (saldo +0.93 por lance)

L'emmener dans le salon

L'entraînement écrit déjà checkpoints/policy.json à chaque checkpoint. Copiez-le simplement dans le dossier du salon et utilisez-le à la place de football-1x1.policy.json (ou pointez IA_MODELO dessus). Pensez à utiliser dans le salon le même --visao qu'à l'entraînement.

L'export ne prend que la partie du réseau qui décide (le réseau de valeur ne sert qu'à l'entraînement) et stocke les poids en float32 en base64 :

python
# politica.py
"""Exporte le réseau entraîné vers `policy.json` (le format que le salon exécute en JavaScript) et le réexécute en NumPy
(pour utiliser d'anciennes versions comme adversaires en self-play sans charger un autre PyTorch)."""
from __future__ import annotations

import base64
import time

import numpy as np

from .decisao import decide
from .features import ACTION_TABLE, N_ACTIONS, version_for_size

FORMATO = "bonktools-rl-policy/1"


def exportar(model) -> dict:
    """PPO (MlpPolicy de stable-baselines3) -> dict du policy.json. Seulement la partie qui décide (le réseau de valeur reste)."""
    import torch

    p = model.policy
    lineares = [m for m in p.mlp_extractor.policy_net if isinstance(m, torch.nn.Linear)] + [p.action_net]
    ativacoes = {type(m).__name__ for m in p.mlp_extractor.policy_net if not isinstance(m, torch.nn.Linear)}
    if ativacoes != {"Tanh"}:
        raise ValueError(f"ativação inesperada: {ativacoes} (o formato só conhece Tanh)")

    def b64(t) -> str:  # float32 little-endian en base64 : exact et ~4x plus petit que du texte
        return base64.b64encode(t.detach().cpu().numpy().astype("<f4").tobytes()).decode("ascii")

    camadas = [{"in": l.in_features, "out": l.out_features, "w": b64(l.weight), "b": b64(l.bias)} for l in lineares]
    return {
        "format": FORMATO,
        "obsSize": camadas[0]["in"],
        "obsVersion": version_for_size(camadas[0]["in"]),
        "actionTable": ACTION_TABLE,
        "activation": "tanh",
        "layers": camadas,
        "timesteps": int(model.num_timesteps),
        "exportedAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
    }


class PoliticaNP:
    """Exécute un policy.json en NumPy : tanh dans les couches cachées, linéaire dans la dernière (18 logits)."""

    def __init__(self, data: dict):
        if data.get("format") != FORMATO:
            raise ValueError(f"formato desconhecido: {data.get('format')}")
        self.obs_version = int(data["obsVersion"])
        self.timesteps = int(data.get("timesteps", 0))
        self.camadas = []
        for c in data["layers"]:
            w = np.frombuffer(base64.b64decode(c["w"]), dtype="<f4").reshape(c["out"], c["in"])
            b = np.frombuffer(base64.b64decode(c["b"]), dtype="<f4")
            self.camadas.append((w.astype(np.float64), b.astype(np.float64)))
        if self.camadas[-1][0].shape[0] != N_ACTIONS:
            raise ValueError("a rede não termina em 18 ações")

    def logits(self, obs: np.ndarray) -> np.ndarray:
        x = np.asarray(obs, dtype=np.float64)
        for i, (w, b) in enumerate(self.camadas):
            x = w @ x + b
            if i < len(self.camadas) - 1:
                x = np.tanh(x)
        return x

    def agir(self, obs: np.ndarray, anterior: int | None = None) -> int:
        """Décision axe par axe (la même que le salon), pas l'argmax brut."""
        return decide(self.logits(obs), anterior)

Le script d'entraînement complet

python
# treinar.py
"""Entraîne l'IA de football 1v1 avec PPO (stable-baselines3) et self-play.

    python treinar.py                     # part de zéro ou reprend depuis checkpoints/latest.zip
    python treinar.py --passos 20000000   # combien de pas entraîner cette fois
    python treinar.py --envs 4            # simulations en parallèle (1 processus Node chacune ; utilisez 2, 4 ou 8)
    python treinar.py --novo              # ignore le checkpoint (ne supprime rien)
    python treinar.py --visao atrasada    # pour les salons SANS les "yeux" (voir la doc) ; par défaut : agora
    tensorboard --logdir checkpoints/tb   # graphiques

Tous les --salvar pas, il écrit checkpoints/latest.zip, checkpoints/estado.json (étape du curriculum) et
checkpoints/policy.json (le modèle prêt pour le salon).
"""
from __future__ import annotations

import argparse
import json
from collections import deque
from pathlib import Path

import numpy as np
from stable_baselines3 import PPO
from stable_baselines3.common.callbacks import BaseCallback
from stable_baselines3.common.vec_env import DummyVecEnv

from bonk_ia.ambiente import BonkFootballEnv, Liga
from bonk_ia.politica import exportar

PASTA = Path("checkpoints")
# Pour passer d'étape : taux de buts sur les 400 dernières actions.
META = {1: 0.7, 2: 0.6}

# Basé sur le RLGym-PPO-Guide : lr 2e-4, peu d'époques, gros lots, entropie 0,01. Réseau 256x256 avec tanh.
PPO_ARGS = dict(
    learning_rate=2e-4,
    n_steps=1024,  # par environnement
    batch_size=2048,
    n_epochs=4,
    gamma=0.99,  # à 10 décisions/s, regarde ~10 s devant
    gae_lambda=0.95,
    clip_range=0.2,
    ent_coef=0.01,
    policy_kwargs=dict(net_arch=dict(pi=[256, 256], vf=[256, 256])),
)


class VecEmParalelo(DummyVecEnv):
    """Envoie le pas à TOUS les ponts avant de lire les réponses : les simulations (processus Node) avancent ensemble,
    avec un seul processus Python (et un seul PyTorch en mémoire)."""

    def step_wait(self):
        for env, acao in zip(self.envs, self.actions):
            env.step_send(acao)
        for i, env in enumerate(self.envs):
            obs, r, terminou, cortou, info = env.step_recv()
            self.buf_rews[i] = r
            self.buf_dones[i] = terminou or cortou
            info = dict(info)
            info["TimeLimit.truncated"] = cortou and not terminou
            if self.buf_dones[i]:
                info["terminal_observation"] = obs
                obs, self.reset_infos[i] = env.reset()
            self.buf_infos[i] = info
            self._save_obs(i, obs)
        return self._obs_from_buf(), np.copy(self.buf_rews), np.copy(self.buf_dones), list(self.buf_infos)


class Curriculo(BaseCallback):
    """Fait avancer l'étape selon le taux de buts, enregistre les checkpoints et alimente la ligue du self-play."""

    def __init__(self, estagio: int, liga: Liga, salvar: int, rival_a_cada: int):
        super().__init__()
        self.estagio = estagio
        self.liga = liga
        self.salvar_a_cada = salvar
        self.rival_a_cada = rival_a_cada
        self.janela: deque[int] = deque(maxlen=400)
        self.prox_salvar = 0
        self.prox_rival = 0

    def _on_training_start(self) -> None:
        # en reprenant un entraînement, compte à partir des pas déjà faits par le modèle
        self.prox_salvar = self.num_timesteps + self.salvar_a_cada
        self.prox_rival = self.num_timesteps + self.rival_a_cada

    def _on_step(self) -> bool:
        for info in self.locals["infos"]:
            if "gol" in info and info.get("estagio") == self.estagio:
                self.janela.append(info["gol"])
        if len(self.janela) == self.janela.maxlen:
            gols = sum(g == 1 for g in self.janela) / len(self.janela)
            sofridos = sum(g == -1 for g in self.janela) / len(self.janela)
            self.logger.record("bonk/gols", gols)
            self.logger.record("bonk/sofridos", sofridos)
            self.logger.record("bonk/estagio", self.estagio)
            if self.estagio in META and gols >= META[self.estagio]:
                self.estagio += 1
                self.janela.clear()
                self.training_env.env_method("set_estagio", self.estagio)
                print(f"[currículo] passou para o estágio {self.estagio} ({self.num_timesteps} passos)")
        if self.estagio == 3 and self.num_timesteps >= self.prox_rival:
            self.prox_rival = self.num_timesteps + self.rival_a_cada
            self.liga.adicionar(exportar(self.model))  # la version actuelle devient l'adversaire des suivantes
        if self.num_timesteps >= self.prox_salvar:
            self.prox_salvar = self.num_timesteps + self.salvar_a_cada
            self.salvar()
        return True

    def salvar(self) -> None:
        PASTA.mkdir(exist_ok=True)
        self.model.save(PASTA / "latest.zip")
        (PASTA / "estado.json").write_text(json.dumps({"estagio": self.estagio, "passos": self.num_timesteps}))
        (PASTA / "policy.json").write_text(json.dumps(exportar(self.model), separators=(",", ":")))
        print(f"[salvo] {self.num_timesteps} passos, estágio {self.estagio}")


def main() -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("--passos", type=int, default=5_000_000)
    ap.add_argument("--envs", type=int, default=4)
    ap.add_argument("--novo", action="store_true")
    ap.add_argument("--salvar", type=int, default=100_000)
    ap.add_argument("--rival-a-cada", type=int, default=250_000)
    ap.add_argument("--visao", choices=["agora", "atrasada"], default="agora")
    a = ap.parse_args()

    continuar = (PASTA / "latest.zip").exists() and not a.novo
    estagio = json.loads((PASTA / "estado.json").read_text())["estagio"] if continuar else 1
    liga = Liga()
    venv = VecEmParalelo([lambda i=i: BonkFootballEnv(estagio=estagio, liga=liga, seed=1000 + i, visao=a.visao) for i in range(a.envs)])
    if continuar:
        model = PPO.load(PASTA / "latest.zip", env=venv, device="cpu")
        print(f"continuando de {model.num_timesteps} passos (estágio {estagio})")
    else:
        model = PPO("MlpPolicy", venv, device="cpu", tensorboard_log=str(PASTA / "tb"), verbose=0, **PPO_ARGS)
    cb = Curriculo(estagio, liga, a.salvar, a.rival_a_cada)
    try:
        model.learn(total_timesteps=a.passos, callback=cb, reset_num_timesteps=not continuar, progress_bar=False)
    finally:
        cb.salvar()
        venv.close()


if __name__ == "__main__":
    main()

Les hyperparamètres

ParamètreValeurPourquoi
learning_rate2e-4Valeur standard du guide PPO pour Rocket League (RLGym) ; plus haut devient instable
n_steps × envs1024 × 4~4 mille pas (7 minutes de jeu) par mise à jour
batch_size, n_epochs2048, 4Gros lots et peu de passes : stable
gamma0,99À 10 décisions/s, l'IA « voit » ~10 s en avant
ent_coef0,01Garde l'IA en train d'expérimenter
Réseau256 × 256, tanhAssez petit pour tourner en JS pur, assez grand pour le problème

Prochains défis

Une fois l'essentiel en marche, voici les améliorations qui ont le plus payé chez nous (dans l'ordre) :

  1. Scénarios tirés d'actions réelles. Enregistrez les matchs de votre salon contre des humains (rec) et démarrez des actions d'entraînement depuis les situations où l'IA a encaissé. Le reset du pont accepte des overrides avec positions et vitesses.
  2. Un « explorateur ». Entraînez une seconde IA dont le seul objectif est de battre la principale, et utilisez ses versions comme adversaires de la principale. Elle trouve les failles avant les joueurs.
  3. Des adversaires qui imitent les humains, comme un attaquant qui tire en première intention à l'engagement (la plupart des buts humains sur engagement viennent de là).