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+.

bash
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.py

Endet es mit OK — a ponte com a física funcionou. („die Brücke zur Physik funktioniert“), ist alles bereit.

2. Was im Kit steckt

DateiWas sie macht
sim_bridge/bridge.mjsDie Brücke: ein Node-Prozess, der die bonk.io-Physik ausführt und mit Python redet
bonk_ia/ambiente.pyDie Umgebung: macht aus dem Spiel eine Übung (Spielzug, Beobachtung, Punkte)
bonk_ia/features.pyWas die KI sieht (gleich wie features.ts im Raum)
bonk_ia/recompensas.pyWie die KI Punkte sammelt (Belohnungen)
bonk_ia/adversarios.pySkript-Gegner
bonk_ia/politica.pyExportiert nach policy.json und führt alte Modelle aus (Self-Play)
bonk_ia/decisao.pyDie Entscheidung Achse für Achse (gleich wie im Raum)
treinar.py, avaliar.py, testar_ponte.pyDie 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.

text
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":[]}────────────────────────────────
BefehlWas er macht
resetStartet 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}
stepDrückt die Tasten jedes Spielers ({"id": tasten}) und rückt frames Frames vor. Liefert den Zustand und die erzielten Tore
closeBeendet

Die ganze Brücke hat weniger als 90 Zeilen:

js
// 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

FeldInhalt
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“)
scoresSpielstand nach Team-ID (2 Rot, 3 Blau)
ftuFrames, 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:

bash
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.