KI trainieren
Die Trainingsumgebung vorbereiten
Installiere das Kit, verstehe die Brücke zwischen Python und der echten bonk.io-Physik und prüfe, dass alles verbunden ist.
In diesem Pfad trainierst du deine eigene Fußball-KI. Du brauchst weder Grafikkarte noch einen bezahlten Dienst: nur einen Rechner mit Node.js und Python. Mit 4 parallelen Simulationen schafft ein normaler PC etwa 750 Schritte pro Sekunde (jeder Schritt = 100 ms Spiel).
1. Kit herunterladen und installieren
ia-kit.zip herunterladen und entpacken. Du brauchst Node.js 20.18+ und 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.pyEndet es mit OK — a ponte com a física funcionou. („die Brücke zur Physik funktioniert“), ist alles bereit.
2. Was im Kit steckt
| Datei | Was sie macht |
|---|---|
sim_bridge/bridge.mjs | Die Brücke: ein Node-Prozess, der die bonk.io-Physik ausführt und mit Python redet |
bonk_ia/ambiente.py | Die Umgebung: macht aus dem Spiel eine Übung (Spielzug, Beobachtung, Punkte) |
bonk_ia/features.py | Was die KI sieht (gleich wie features.ts im Raum) |
bonk_ia/recompensas.py | Wie die KI Punkte sammelt (Belohnungen) |
bonk_ia/adversarios.py | Skript-Gegner |
bonk_ia/politica.py | Exportiert nach policy.json und führt alte Modelle aus (Self-Play) |
bonk_ia/decisao.py | Die Entscheidung Achse für Achse (gleich wie im Raum) |
treinar.py, avaliar.py, testar_ponte.py | Die Befehle, die du ausführst: trainieren, bewerten, Brücke testen |
3. Die Brücke: Python spricht mit der Physik
Das Training läuft in Python (dort sind die KI-Bibliotheken), aber die bonk.io-Physik ist JavaScript. Die Brücke löst das: Python öffnet einen Node-Prozess, und beide tauschen eine JSON-Zeile nach der anderen aus.
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":[]}────────────────────────────────| Befehl | Was er macht |
|---|---|
reset | Startet einen Spielzug. players ist die Aufstellung (Index = ID). overrides (optional) setzt Ball und Spieler, wohin du willst: {"ball":{"x":..,"y":..,"xv":0,"yv":0},"discs":{"1":{"x":..,"y":..}},"ftu":0} |
step | Drückt die Tasten jedes Spielers ({"id": tasten}) und rückt frames Frames vor. Liefert den Zustand und die erzielten Tore |
close | Beendet |
Die ganze Brücke hat weniger als 90 Zeilen:
// bridge.mjs
// Brücke zwischen dem Physiksimulator (Node, `PhysicsSimulator` aus `bonktools`) und der
// Gymnasium-Umgebung (Python, `bonk_ia/ambiente.py`). Protokoll: eine JSON-Anfrage pro Zeile auf stdin, eine
// JSON-Antwort pro Zeile auf stdout. Strikt Anfrage/Antwort — der Aufrufer wartet auf die Antwort
// auf jede Zeile, bevor er die nächste sendet (kein Pipelining mehrerer gleichzeitiger Anfragen).
//
// Befehle:
// {"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}} (optional)
// {"cmd":"step","actions":{"1":2,"2":0},"frames":3} (frames optional, Standard 1)
// -> {"ok":true,"state":{...},"frame":N,"goals":[...]}
// {"cmd":"close"}
// -> {"ok":true} (der Prozess beendet sich danach)
// Fehler: {"ok":false,"error":"Meldung"}
import readline from 'node:readline';
import { PhysicsSimulator } from 'bonktools';
const sim = new PhysicsSimulator();
let started = false;
// Nur die Felder, die die Python-Umgebung nutzt — der vollständige Spielzustand ist viel größer, und ihn
// bei jedem Schritt komplett zu serialisieren/parsen war ein großer Teil der Kosten pro Schritt.
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` feuert 'line' für jede bereits gepufferte Zeile, ohne auf den vorherigen Handler zu warten
// — ohne Serialisierung hier würde ein 'close', das direkt nach einem langsamen 'reset' kommt,
// den Prozess beenden (process.exit), bevor die 'reset'-Antwort geschrieben ist. Eine Warteschlange aus
// Promises stellt sicher, dass jede Zeile erst verarbeitet wird, nachdem die Antwort der vorherigen
// gesendet wurde — so bleibt das Anfrage/Antwort-Protokoll erhalten, auch wenn stdin auf einmal ankommt.
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) });
}
}Der Spielzustand
| Feld | Inhalt |
|---|---|
ball | {x, y, xv, yv}: Position und Geschwindigkeit des Balls |
discs[id] | {x, y, xv, yv, team, kickReady}: jeder Spieler (sein physischer Körper ist eine „Scheibe“) |
scores | Spielstand nach Team-ID (2 Rot, 3 Blau) |
ftu | Frames, bis der Anstoß freigegeben wird (~120 = 4 s; Tasten werden vorher ignoriert) |
Das Feld misst etwa 66 × 45 Einheiten: Spieler bewegen sich in x von 1 bis 65,4 und in y von 1 bis 44,5 (y wächst nach unten), das rechte Tor liegt bei x ≈ 64 und die Mitte bei (33,18; 22,73). Ein Spieler läuft bis zu ~11,7 Einheiten/s, ein Schuss geht mit ~24 ab.
4. Schneller: mehrere Simulationen gleichzeitig
Jede Umgebung hat ihre eigene Brücke (einen Node-Prozess). treinar.py schickt den Schritt an alle, bevor es die Antworten liest, sodass die Simulationen mit einem einzigen Python parallel laufen:
python treinar.py --envs 4 # 4 Brücken: nimm 2, 4 oder 8 (sie teilen den PPO-Batch glatt)Faustregel: eine Umgebung pro Prozessorkern.
Nächster Schritt
Verstehe was die KI sieht und wie sie Punkte sammelt, bevor du etwas änderst, und geh dann zu Trainieren und exportieren.