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
python treinar.py --passos 5000000 --envs 4Ce qui s'affiche dans le terminal (salvo = enregistré, passos = pas, estágio = étape, currículo = curriculum) :
[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)
...| Option | Par défaut | Ce qu'elle fait |
|---|---|---|
--passos | 5 millions | Combien de pas entraîner cette fois |
--envs | 4 | Simulations en parallèle (utilisez 2, 4 ou 8) |
--visao | agora | Comment l'IA voit le jeu ; doit correspondre au salon (pourquoi) |
--novo | — | Repart de zéro (l'ancien checkpoint est ignoré, pas supprimé) |
--salvar | 100 mille | Tous les combien de pas il enregistre un checkpoint |
--rival-a-cada | 250 mille | Tous 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 franchie | Pas | Temps |
|---|---|---|
| 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 actions | 2 millions | ~45 min |
| Modèle publié : 95 buts, 2 encaissés | 182 millions | des 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
tensorboard --logdir checkpoints/tbOuvrez 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_mean | La 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
python avaliar.py checkpoints/policy.json --lances 200Il 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) :
$ 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 :
# 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
# 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ètre | Valeur | Pourquoi |
|---|---|---|
learning_rate | 2e-4 | Valeur standard du guide PPO pour Rocket League (RLGym) ; plus haut devient instable |
n_steps × envs | 1024 × 4 | ~4 mille pas (7 minutes de jeu) par mise à jour |
batch_size, n_epochs | 2048, 4 | Gros lots et peu de passes : stable |
gamma | 0,99 | À 10 décisions/s, l'IA « voit » ~10 s en avant |
ent_coef | 0,01 | Garde l'IA en train d'expérimenter |
| Réseau | 256 × 256, tanh | Assez 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) :
- 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
resetdu pont accepte desoverridesavec positions et vitesses. - 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.
- 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à).