Entraîner l'IA
Préparer l'environnement d'entraînement
Installez le kit, comprenez le pont entre Python et la vraie physique de bonk.io et vérifiez que tout est branché.
Dans ce parcours, vous entraînez votre propre IA de football. Pas besoin de carte graphique ni de service payant : juste un ordinateur avec Node.js et Python. Avec 4 simulations en parallèle, un PC ordinaire entraîne environ 750 pas par seconde (chaque pas = 100 ms de jeu).
1. Téléchargez et installez le kit
Télécharger ia-kit.zip et décompressez-le. Il vous faut Node.js 20.18+ et Python 3.10+.
cd ia-kit
cd sim_bridge && npm install && cd ..
python -m venv .venv
# Windows: .venv\Scripts\activate
# Linux/mac: source .venv/bin/activate
pip install -r requirements.txt # gymnasium, stable-baselines3, torch (CPU), numpy, tensorboard
python testar_ponte.pyS'il se termine par OK — a ponte com a física funcionou. (« le pont avec la physique fonctionne »), tout est prêt.
2. Contenu du kit
| Fichier | Ce qu'il fait |
|---|---|
sim_bridge/bridge.mjs | Le pont : un processus Node qui exécute la physique de bonk.io et parle à Python |
bonk_ia/ambiente.py | L'environnement : transforme le jeu en exercice (action, observation, points) |
bonk_ia/features.py | Ce que l'IA voit (identique au features.ts du salon) |
bonk_ia/recompensas.py | Comment l'IA gagne des points (récompenses) |
bonk_ia/adversarios.py | Adversaires scriptés |
bonk_ia/politica.py | Exporte vers policy.json et fait tourner d'anciens modèles (self-play) |
bonk_ia/decisao.py | La décision axe par axe (identique à celle du salon) |
treinar.py, avaliar.py, testar_ponte.py | Les commandes que vous lancez : entraîner, évaluer, tester le pont |
3. Le pont : Python qui parle à la physique
L'entraînement est en Python (c'est là que sont les bibliothèques d'IA), mais la physique de bonk.io est en JavaScript. Le pont règle ça : Python ouvre un processus Node et les deux échangent une ligne de JSON à la fois.
Python ──{"cmd":"reset","players":[null,{"id":1,"team":3},{"id":2,"team":2}],"seed":42}──► Node
◄──{"ok":true,"state":{"ball":{...},"discs":[null,{...},{...}],"ftu":120}}───────────
──{"cmd":"step","actions":{"1":18,"2":0},"frames":3}─────────────────────────────►
◄──{"ok":true,"state":{...},"frame":3,"goals":[]}────────────────────────────────| Commande | Ce qu'elle fait |
|---|---|
reset | Démarre une action. players est la composition (indice = id). overrides (optionnel) place le ballon et les joueurs où vous voulez : {"ball":{"x":..,"y":..,"xv":0,"yv":0},"discs":{"1":{"x":..,"y":..}},"ftu":0} |
step | Presse les touches de chaque joueur ({"id": touches}) et avance de frames images. Renvoie l'état et les buts marqués |
close | Ferme |
Le pont entier fait moins de 90 lignes :
// bridge.mjs
// Pont entre le simulateur physique (Node, `PhysicsSimulator` de `bonktools`) et l'environnement
// Gymnasium (Python, `bonk_ia/ambiente.py`). Protocole : une requête JSON par ligne sur stdin, une
// réponse JSON par ligne sur stdout. Strictement requête/réponse — l'appelant attend la réponse
// à chaque ligne avant d'envoyer la suivante (pas de pipeline de plusieurs requêtes en vol).
//
// Commandes :
// {"cmd":"reset","players":[null,{"id":1,"team":3},{"id":2,"team":2}],"seed":123}
// -> {"ok":true,"state":{...}}
// {"cmd":"reset",...,"overrides":{"ball":{"x":..,"y":..,"xv":..,"yv":..},"discs":{"1":{...}},"ftu":0}} (optionnel)
// {"cmd":"step","actions":{"1":2,"2":0},"frames":3} (frames optionnel, 1 par défaut)
// -> {"ok":true,"state":{...},"frame":N,"goals":[...]}
// {"cmd":"close"}
// -> {"ok":true} (le processus se termine ensuite)
// Erreurs : {"ok":false,"error":"message"}
import readline from 'node:readline';
import { PhysicsSimulator } from 'bonktools';
const sim = new PhysicsSimulator();
let started = false;
// Seulement les champs utilisés par l'environnement Python — l'état complet du jeu est bien plus gros, et sérialiser/parser
// tout à chaque pas représentait une bonne part du coût par pas.
function compact(state) {
if (!state) return state;
const body = (b) => (b ? { x: b.x, y: b.y, xv: b.xv, yv: b.yv } : null);
return {
ball: body(state.ball),
discs: (state.discs || []).map((d) => (d ? { ...body(d), team: d.team, kickReady: d.kickReady } : null)),
scores: state.scores,
ftu: state.ftu,
};
}
function send(obj) {
process.stdout.write(JSON.stringify(obj) + '\n');
}
const rl = readline.createInterface({ input: process.stdin, terminal: false });
// `readline` déclenche 'line' pour chaque ligne déjà en tampon sans attendre que le handler précédent
// se termine — si on ne sérialisait pas ici, un 'close' arrivant juste après un 'reset' lent
// tuerait le processus (process.exit) avant que la réponse du 'reset' soit écrite. Une file de
// promesses garantit que chaque ligne n'est traitée qu'après l'envoi de la réponse précédente
// , respectant le protocole requête/réponse même si stdin arrive d'un seul coup.
let queue = Promise.resolve();
rl.on('line', (line) => {
queue = queue.then(() => handleLine(line));
});
async function handleLine(line) {
const trimmed = line.trim();
if (!trimmed) return;
let req;
try {
req = JSON.parse(trimmed);
} catch {
send({ ok: false, error: 'linha não é JSON válido' });
return;
}
try {
if (req.cmd === 'reset') {
if (!started) {
await sim.start();
started = true;
}
const state = await sim.reset(req.players, req.seed, undefined, req.overrides);
send({ ok: true, state: compact(state) });
} else if (req.cmd === 'step') {
const result = await sim.step(req.actions, req.frames || 1);
send({ ok: true, state: compact(result.state), frame: result.frame, goals: result.goals });
} else if (req.cmd === 'close') {
sim.close();
send({ ok: true });
process.exit(0);
} else {
send({ ok: false, error: `comando desconhecido: ${String(req.cmd)}` });
}
} catch (err) {
send({ ok: false, error: err instanceof Error ? err.message : String(err) });
}
}L'état du jeu
| Champ | Contenu |
|---|---|
ball | {x, y, xv, yv} : position et vitesse du ballon |
discs[id] | {x, y, xv, yv, team, kickReady} : chaque joueur (son corps physique est un « disque ») |
scores | score par id d'équipe (2 rouge, 3 bleu) |
ftu | images avant que l'engagement soit libéré (~120 = 4 s ; les touches sont ignorées avant) |
Le terrain mesure environ 66 × 45 unités : le joueur se déplace en x de 1 à 65,4 et en y de 1 à 44,5 (y augmente vers le bas), le but de droite est en x ≈ 64 et le centre en (33,18 ; 22,73). Un joueur court jusqu'à ~11,7 unités/s et un tir part à ~24.
4. Plus vite : plusieurs simulations à la fois
Chaque environnement a son propre pont (un processus Node). treinar.py envoie le pas à tous avant de lire les réponses, ainsi les simulations avancent en parallèle avec un seul Python :
python treinar.py --envs 4 # 4 ponts : utilisez 2, 4 ou 8 (ils divisent exactement le lot du PPO)Règle pratique : un environnement par cœur du processeur.
Étape suivante
Comprenez ce que voit l'IA et comment elle gagne des points avant de changer quoi que ce soit, puis passez à Entraîner et exporter.