KI trainieren

Trainieren und exportieren

Starte das Training mit PPO und Self-Play, verfolge es mit Diagrammen, bewerte es und bring das Modell in deinen Raum.

Das Training starten

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

Was im Terminal erscheint (salvo = gespeichert, passos = Schritte, estágio = Stufe, currículo = Lehrplan):

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)
...
OptionStandardWas sie macht
--passos5 MillionenWie viele Schritte in dieser Runde trainiert werden
--envs4Parallele Simulationen (2, 4 oder 8 nutzen)
--visaoagoraWie die KI das Spiel sieht; muss zum Raum passen (warum)
--novo—Beginnt neu (der alte Checkpoint wird ignoriert, nicht gelöscht)
--salvar100 TausendAlle wie viele Schritte ein Checkpoint gespeichert wird
--rival-a-cada250 TausendAlle wie viele Schritte die aktuelle KI in die „Liga“ der Gegner kommt

Du kannst jederzeit mit Strg+C stoppen: Vorher wird gespeichert. Startest du python treinar.py erneut, geht es dort weiter, wo es aufgehört hat (die Lehrplanstufe steht in checkpoints/estado.json).

Wie lange es dauert

Gemessen auf einem normalen PC mit --envs 4 (~750 Schritte/s):

MeilensteinSchritteZeit
Verlässt Stufe 1 (findet den Ball und trifft ohne Torwart)~820 Tausend~18 min
Verlässt Stufe 2 (stehender Gegner im Weg)~870 Tausend~1 min später
Gegen das stärkste Skript: 78 Tore, 21 Gegentore in 100 Spielzügen2 Millionen~45 min
Veröffentlichtes Modell: 95 Tore, 2 Gegentore182 MillionenTage (unseres lief auf mehreren Maschinen)

Die Zahlen oben stammen aus einem echten Trainingslauf mit dem Kit auf einem normalen PC. Deiner kann etwas abweichen (das Glück der ersten Spielzüge ändert den Weg), aber die Größenordnung stimmt.

Mit Diagrammen verfolgen

bash
tensorboard --logdir checkpoints/tb

Öffne die angezeigte Adresse (meist http://localhost:6006):

DiagrammWas zu erwarten ist
bonk/gols (Tore)Steigt bis zum Ziel und fällt, wenn die Stufe wechselt (die Übung wurde schwerer). Normal
bonk/sofridos (Gegentore)Sollte in Stufe 3 mit der Zeit sinken
bonk/estagio (Stufe)1 → 2 → 3
rollout/ep_rew_meanDie Durchschnittsnote pro Spielzug. Steigt langsam
train/entropy_lossWie sehr die KI noch „experimentiert“. Sinkt nach und nach; bricht er früh ein, hat sie aufgehört zu erkunden

Bewerten

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

Es spielt gegen das stärkste Skript und entscheidet genau wie der Raum (Achse für Achse, mit der gewählten Verzögerung). Zum Vergleich liefert das veröffentlichte Modell (gols = Tore, sofridos = Gegentore, saldo = Bilanz):

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

In den Raum bringen

Das Training schreibt bei jedem Checkpoint bereits checkpoints/policy.json. Kopier sie einfach in den Raumordner und nutze sie statt football-1x1.policy.json (oder lass IA_MODELO darauf zeigen). Denk daran, im Raum dasselbe --visao wie im Training zu nutzen.

Der Export nimmt nur den entscheidenden Teil des Netzes (das Value-Netz braucht man nur im Training) und speichert die Gewichte als float32 in Base64:

python
# politica.py
"""Exportiert das trainierte Netz nach `policy.json` (das Format, das der Raum in JavaScript ausführt) und führt es in NumPy wieder aus
(um alte Versionen als Self-Play-Gegner zu nutzen, ohne ein weiteres PyTorch zu laden)."""
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 von stable-baselines3) -> policy.json-Dict. Nur der entscheidende Teil (das Value-Netz bleibt zurück)."""
    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 in Base64: exakt und ~4x kleiner als Text
        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:
    """Führt eine policy.json in NumPy aus: tanh in den verborgenen Schichten, linear in der letzten (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:
        """Entscheidung Achse für Achse (wie im Raum), nicht das reine Argmax."""
        return decide(self.logits(obs), anterior)

Das vollständige Trainingsskript

python
# treinar.py
"""Trainiert die 1v1-Fußball-KI mit PPO (stable-baselines3) und Self-Play.

    python treinar.py                     # startet neu oder setzt von checkpoints/latest.zip fort
    python treinar.py --passos 20000000   # wie viele Schritte in dieser Runde trainiert werden
    python treinar.py --envs 4            # parallele Simulationen (je 1 Node-Prozess; 2, 4 oder 8 nutzen)
    python treinar.py --novo              # ignoriert den Checkpoint (löscht nichts)
    python treinar.py --visao atrasada    # für Räume OHNE die "Augen" (siehe Doku); Standard: agora
    tensorboard --logdir checkpoints/tb   # Diagramme

Alle --salvar Schritte schreibt es checkpoints/latest.zip, checkpoints/estado.json (Lehrplan-Stufe) und
checkpoints/policy.json (das fertige Modell für den Raum).
"""
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")
# Zum Aufstieg: Torquote in den letzten 400 Spielzügen.
META = {1: 0.7, 2: 0.6}

# Basierend auf dem RLGym-PPO-Guide: lr 2e-4, wenige Epochen, große Batches, Entropie 0,01. 256x256-Netz mit tanh.
PPO_ARGS = dict(
    learning_rate=2e-4,
    n_steps=1024,  # pro Umgebung
    batch_size=2048,
    n_epochs=4,
    gamma=0.99,  # bei 10 Entscheidungen/s etwa 10 s vorausschauend
    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):
    """Schickt den Schritt an ALLE Brücken, bevor die Antworten gelesen werden: Die Simulationen (Node-Prozesse) laufen gemeinsam,
    mit einem einzigen Python-Prozess (und einem einzigen PyTorch im Speicher)."""

    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):
    """Erhöht die Stufe nach Torquote, speichert Checkpoints und füttert die Self-Play-Liga."""

    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:
        # beim Fortsetzen ab den Schritten zählen, die das Modell schon hat
        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))  # die aktuelle Version wird Gegner der nächsten
        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()

Die Hyperparameter

ParameterWertWarum
learning_rate2e-4Standard aus dem PPO-Leitfaden für Rocket League (RLGym); höher wird instabil
n_steps × envs1024 × 4~4 Tausend Schritte (7 Minuten Spiel) pro Update
batch_size, n_epochs2048, 4Große Batches und wenige Durchläufe: stabil
gamma0,99Bei 10 Entscheidungen/s „sieht“ die KI ~10 s voraus
ent_coef0,01Hält die KI am Experimentieren
Netz256 × 256, tanhKlein genug für reines JS, groß genug für das Problem

Nächste Herausforderungen

Wenn die Grundlagen laufen, sind das die Verbesserungen, die uns am meisten gebracht haben (in dieser Reihenfolge):

  1. Szenarien aus echten Spielzügen. Zeichne Spiele deines Raums gegen Menschen auf (Rec) und starte Trainingsspielzüge aus den Situationen, in denen die KI ein Gegentor bekam. Das reset der Brücke akzeptiert overrides mit Positionen und Geschwindigkeiten.
  2. Ein „Erkunder“. Trainiere eine zweite KI, deren einziges Ziel es ist, die Haupt-KI zu schlagen, und nutze ihre Versionen als Gegner der Haupt-KI. Sie findet die Lücken vor den Spielern.
  3. Gegner, die Menschen nachahmen, etwa ein Stürmer, der beim Anstoß direkt schießt (die meisten menschlichen Anstoßtore entstehen so).