KI trainieren
Was die KI sieht und wie sie Punkte sammelt
Beobachtung, Aktionen, kanonische Achse, Belohnungen und Lehrplan: die Designentscheidungen, die das Ergebnis am stärksten prägen.
Drei Entscheidungen bestimmen, was deine KI lernt: was sie sieht (Beobachtung), was sie tun kann (Aktionen) und wofür sie belohnt wird (Belohnung). Diese Seite erklärt die Entscheidungen des Kits und warum es jede gibt.
Kanonische Achse: Die KI greift immer nach rechts an
Statt auf beiden Seiten spielen zu lernen, lernt die KI eine Seite. Spielt sie Rot (greift nach links an), spiegelt das Kit das Feld, bevor es ihr gezeigt wird (x wird zu 2 × 33,18 − x, die x-Geschwindigkeiten wechseln das Vorzeichen), und vertauscht links und rechts in der gewählten Taste. Halbe Arbeit, doppelte Erfahrung pro Situation.
Die Beobachtung (39 Zahlen)
Alle Zahlen liegen etwa zwischen −1 und 1 (geteilt durch die halbe Feldgröße oder die Höchstgeschwindigkeit) und werden auf ±2 begrenzt. Neuronale Netze lernen mit Zahlen in diesem Bereich viel besser.
| # | Was |
|---|---|
| 1–4 | Meine Position und Geschwindigkeit |
| 5–8 | Position und Geschwindigkeit des Balls |
| 9–12 | Position und Geschwindigkeit des Gegners |
| 13–16 | Ball relativ zu mir und zum Gegner |
| 17–20 | Ball relativ zum gegnerischen und zu meinem Tor |
| 21–22 | Mein Abstand und der des Gegners zum Ball |
| 23–24 | Kann ich jetzt schießen? Kann der Gegner? |
| 25 | Wie lange bis zur Freigabe des Anstoßes |
| 26–29 | Pfosten des gegnerischen Tors und meine Torlinie, von mir aus |
| 30–33 | Abstand zu den vier Wänden |
| 34–35 | Abstand des Balls zur oberen und unteren Wand (Abpraller) |
| 36 | Liegt der Ball zwischen mir und dem gegnerischen Tor? (ich kann schießen) |
| 37 | Stehe ich zwischen Ball und meinem Tor? (ich verteidige) |
| 38–39 | Ballgeschwindigkeit relativ zu mir (zum Bremsen, um nicht am Ball vorbeizulaufen) |
Die Zahlen 1 bis 25 sind „Version 1“ (die ersten Modelle); 26 bis 39 kamen hinzu, als wir merkten, dass die KI Wände und Pfosten nicht „sah“ und am Ball vorbeilief. Ein klarer Gewinn.
Die Aktionen (18)
9 Richtungen (stehen, ↑, ↗, →, ↘, ↓, ↙, ←, ↖) × {kein Schuss, Schuss}. Eine Entscheidung alle 3 Frames (100 ms).
- Warum darf die KI nicht jede Tastenkombination drücken? Weil viele keinen Sinn ergeben (links + rechts gleichzeitig) und das Lernen nur verlangsamen.
- Warum 100 ms und nicht jeder Frame? Wir haben im Raum Entscheidungen pro Frame getestet: Die KI, auf 100 ms trainiert, schickte plötzlich Tasten, die nur einen Frame dauerten, und „fiel um, ohne zu wissen, wie man spielt“. Entscheide im Raum im selben Takt wie im Training.
Die Belohnung
Bei jeder Entscheidung bekommt die KI eine kleine Note. Am Ende bringt PPO ihr bei, die Summe der Noten zu maximieren.
| Term | Gewicht (Stufe 3) | Warum |
|---|---|---|
| Tor | +1 | Das Ziel. Dominiert alles andere |
| Gegentor | −1 | Mit −0,8 strengte sie sich kaum an zu verteidigen |
| Meine Geschwindigkeit zum Ball | 0,005 | Hilft anfangs, den Ball zu „finden“ |
| Ballgeschwindigkeit zum gegnerischen Tor | 0,015 | Belohnt, den Ball an die richtige Stelle zu bringen |
| Berührung, die den Ball Richtung Tor beschleunigt | 0,02 × Beschleunigung | Kann negativ sein: Richtung eigenes Tor kostet |
| Wechsel oben ↔ unten | −0,005 | Ohne das lief sie Zickzack |
Die Stufen 1 und 2 nutzen höhere Gewichte für „zum Ball kommen“ und einen festen Bonus pro Berührung, damit die KI die Grundlagen schnell entdeckt.
Fallen, in die wir getappt sind
Der vollständige Code:
# recompensas.py
"""Belohnung pro Entscheidung (10 pro Sekunde), auf der kanonischen Achse (der Agent greift immer nach rechts an).
Das ist das "klassische" Set: Es trainierte die KI, die bei BonkTools am besten gegen Menschen spielte.
- GESCHWINDIGKEITS-Terme, keine Positions-Terme: Stillstehen bringt 0 (ein Bonus für "nah am Ball" bringt ihr Parken bei);
- Berührung, die den Ball Richtung gegnerisches Tor beschleunigt (kann negativ sein: Ball Richtung eigenes Tor);
- Tor +1, Gegentor -1;
- kleine Kosten für das Umkehren oben/unten zwischen zwei Entscheidungen (ohne sie läuft die KI im Zickzack).
"""
from __future__ import annotations
import math
from dataclasses import dataclass
from .features import (ACTION_TABLE, BALL_MAX_SPEED, CENTER_Y, DOWN, GOAL_X, KICK_REACH, PLAYER_MAX_SPEED, UP,
body, canon)
@dataclass(frozen=True)
class Pesos:
jogador_bola: float # Geschwindigkeit des Agenten zum Ball
bola_gol: float # Geschwindigkeit des Balls zum gegnerischen Tor
toque: float # fester Bonus pro Berührung (nur am Anfang: später wird daraus "Farming" kleiner Berührungen)
toque_gol: float # Berührung gewichtet nach der Beschleunigung des Balls Richtung Tor
gol: float = 1.0
sofrido: float = 1.0
inverter: float = 0.005
PESOS = {
1: Pesos(jogador_bola=0.01, bola_gol=0.02, toque=0.05, toque_gol=0.1), # leeres Tor: hinkommen und schieben lernen
2: Pesos(jogador_bola=0.005, bola_gol=0.02, toque=0.02, toque_gol=0.05), # stehender Gegner im Weg
3: Pesos(jogador_bola=0.005, bola_gol=0.015, toque=0.0, toque_gol=0.02), # echtes Spiel: das Tor dominiert
}
TOQUE_DV = 1.5 # minimale Änderung der Ballgeschwindigkeit in einem Schritt, um als Berührung zu zählen (Reibung allein ergibt < 1)
TOQUE_INTERVALO = 5 # Schritte zwischen festen Berührungs-Boni
TELEPORTE = 8.0 # in einem Schritt bewegt sich nichts mehr als ~1,5; mehr ist eine Neupositionierung (Tor/Neustart)
def _unit(dx: float, dy: float) -> tuple[float, float]:
n = math.hypot(dx, dy)
return (dx / n, dy / n) if n > 1e-6 else (0.0, 0.0)
def toque(prev: dict, curr: dict, eu: int, outro: int, espelho: bool) -> float | None:
"""Wenn `eu` den Ball zwischen `prev` und `curr` berührt hat: Beschleunigung des Balls Richtung gegnerisches Tor (-1..1). Sonst None."""
pbx, pby, pbxv, pbyv = canon(body(prev, "ball"), espelho)
bx, by, bxv, byv = canon(body(curr, "ball"), espelho)
dvx, dvy = bxv - pbxv, byv - pbyv
if math.hypot(dvx, dvy) < TOQUE_DV:
return None
sx, sy, _, _ = canon(body(curr, "discs", eu), espelho)
ox, oy, _, _ = canon(body(curr, "discs", outro), espelho)
d_eu, d_outro = math.hypot(bx - sx, by - sy), math.hypot(bx - ox, by - oy)
if d_eu > KICK_REACH + 1.0 or d_eu > d_outro:
return None
gx, gy = _unit(GOAL_X - pbx, CENTER_Y - pby)
return max(-1.0, min(1.0, (dvx * gx + dvy * gy) / BALL_MAX_SPEED))
def teleportou(prev: dict, curr: dict, ids: tuple[int, ...]) -> bool:
def andou(a: dict, b: dict) -> float:
return math.hypot(a["x"] - b["x"], a["y"] - b["y"])
if andou(body(prev, "ball"), body(curr, "ball")) > TELEPORTE:
return True
return any(andou(body(prev, "discs", i), body(curr, "discs", i)) > TELEPORTE for i in ids)
class Recompensa:
def __init__(self, pesos: Pesos):
self.p = pesos
self.reset()
def reset(self) -> None:
self._desde_toque = TOQUE_INTERVALO
self._vertical = 0
def passo(self, prev: dict, curr: dict, eu: int, outro: int, espelho: bool, marcou: bool, sofreu: bool,
acao: int) -> tuple[float, bool]:
"""Gibt (Belohnung, ob berührt wurde) zurück."""
p = self.p
r = 0.0
bits = ACTION_TABLE[int(acao)]
vertical = -1 if bits & UP else (1 if bits & DOWN else 0)
if vertical * self._vertical == -1:
r -= p.inverter
self._vertical = vertical
if marcou:
r += p.gol
if sofreu:
r -= p.sofrido
self._desde_toque += 1
if teleportou(prev, curr, (eu, outro)):
return r, False
sx, sy, sxv, syv = canon(body(curr, "discs", eu), espelho)
bx, by, bxv, byv = canon(body(curr, "ball"), espelho)
ux, uy = _unit(bx - sx, by - sy)
r += p.jogador_bola * (sxv * ux + syv * uy) / PLAYER_MAX_SPEED
gx, gy = _unit(GOAL_X - bx, CENTER_Y - by)
r += p.bola_gol * max(-1.0, min(1.0, (bxv * gx + byv * gy) / BALL_MAX_SPEED))
t = toque(prev, curr, eu, outro, espelho)
if t is not None:
r += p.toque_gol * t
if self._desde_toque >= TOQUE_INTERVALO:
r += p.toque
self._desde_toque = 0
return r, t is not NoneDer Lehrplan
| Stufe | Szenarien | Gegner | Aufstieg bei |
|---|---|---|---|
| 1 | 60 % Angriff (Ball in der gegnerischen Hälfte, KI nah, fast immer dahinter), 40 % zufällig; ohne Anfangssperre | Stehend, weit weg (an der oberen Wand) | 70 % Tore in 400 Spielzügen |
| 2 | 40 % Anstoß, 30 % zufällig, 30 % Angriff | Stehend, im Weg | 60 % Tore |
| 3 | 40 % Anstoß, 30 % zufällig, 30 % Verteidigung (Ball läuft aufs Tor der KI zu, Gegner dahinter) | 50 % Skript (Können 0,4–1), 50 % ältere Version der KI selbst | — |
Ein Spielzug endet beim ersten Tor (egal welche Seite) oder beim Zeitlimit (15, 30 und 45 s in den Stufen 1, 2 und 3).
Die Skript-Gegner
Der Perseguidor („Verfolger“) des Kits stellt sich hinter den Ball, richtet sich aufs Tor aus und schießt. Das „Können“ steuert, wie oft er falsch entscheidet und wie langsam er reagiert. Er ist am Anfang von Stufe 3 wichtig, wenn die älteren KI-Versionen noch zu schwach sind.
Die Verzögerung im Raum
Im Raum sieht die KI das Spiel nicht exakt „jetzt“: Es gibt den 100-ms-Takt und, ohne die „Augen“, die 200 ms Verzögerung der Spielstand-Simulation. Zeigt das Training das perfekte Spiel und der Raum ein verzögertes, spielt die KI schlecht, ohne sichtbaren Fehler (mit 200 ms verlor ein ohne Verzögerung trainiertes Modell jeden Anstoß gegen einen Stürmer, der direkt schießt).
Darum lost die Umgebung bei jedem Spielzug aus, wie viele Entscheidungen zurück die KI sieht:
--visao | Ausgeloste Verzögerung | Projektion | Im Raum nutzen |
|---|---|---|---|
agora („jetzt“, Standard) | 0 (75 %) oder 1 Entscheidung (25 %) | nein | Mit den „Augen“ (lagFrames: 0) |
atrasada („verzögert“) | 1, 2 oder 3 Entscheidungen (10/60/30 %) | 6 Frames voraus | Nur Spielstand + projectState |
Die Raumseite steht unter Die KI in deinen Raum bringen.