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
python treinar.py --passos 5000000 --envs 4Was im Terminal erscheint (salvo = gespeichert, passos = Schritte, estágio = Stufe, currículo = Lehrplan):
[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 | Standard | Was sie macht |
|---|---|---|
--passos | 5 Millionen | Wie viele Schritte in dieser Runde trainiert werden |
--envs | 4 | Parallele Simulationen (2, 4 oder 8 nutzen) |
--visao | agora | Wie die KI das Spiel sieht; muss zum Raum passen (warum) |
--novo | — | Beginnt neu (der alte Checkpoint wird ignoriert, nicht gelöscht) |
--salvar | 100 Tausend | Alle wie viele Schritte ein Checkpoint gespeichert wird |
--rival-a-cada | 250 Tausend | Alle 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):
| Meilenstein | Schritte | Zeit |
|---|---|---|
| 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ügen | 2 Millionen | ~45 min |
| Veröffentlichtes Modell: 95 Tore, 2 Gegentore | 182 Millionen | Tage (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
tensorboard --logdir checkpoints/tbÖffne die angezeigte Adresse (meist http://localhost:6006):
| Diagramm | Was 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_mean | Die Durchschnittsnote pro Spielzug. Steigt langsam |
train/entropy_loss | Wie sehr die KI noch „experimentiert“. Sinkt nach und nach; bricht er früh ein, hat sie aufgehört zu erkunden |
Bewerten
python avaliar.py checkpoints/policy.json --lances 200Es 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):
$ 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:
# 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
# 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
| Parameter | Wert | Warum |
|---|---|---|
learning_rate | 2e-4 | Standard aus dem PPO-Leitfaden für Rocket League (RLGym); höher wird instabil |
n_steps × envs | 1024 × 4 | ~4 Tausend Schritte (7 Minuten Spiel) pro Update |
batch_size, n_epochs | 2048, 4 | Große Batches und wenige Durchläufe: stabil |
gamma | 0,99 | Bei 10 Entscheidungen/s „sieht“ die KI ~10 s voraus |
ent_coef | 0,01 | Hält die KI am Experimentieren |
| Netz | 256 × 256, tanh | Klein 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):
- 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
resetder Brücke akzeptiertoverridesmit Positionen und Geschwindigkeiten. - 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.
- Gegner, die Menschen nachahmen, etwa ein Stürmer, der beim Anstoß direkt schießt (die meisten menschlichen Anstoßtore entstehen so).