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–4Meine Position und Geschwindigkeit
5–8Position und Geschwindigkeit des Balls
9–12Position und Geschwindigkeit des Gegners
13–16Ball relativ zu mir und zum Gegner
17–20Ball relativ zum gegnerischen und zu meinem Tor
21–22Mein Abstand und der des Gegners zum Ball
23–24Kann ich jetzt schießen? Kann der Gegner?
25Wie lange bis zur Freigabe des Anstoßes
26–29Pfosten des gegnerischen Tors und meine Torlinie, von mir aus
30–33Abstand zu den vier Wänden
34–35Abstand des Balls zur oberen und unteren Wand (Abpraller)
36Liegt der Ball zwischen mir und dem gegnerischen Tor? (ich kann schießen)
37Stehe ich zwischen Ball und meinem Tor? (ich verteidige)
38–39Ballgeschwindigkeit 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.

TermGewicht (Stufe 3)Warum
Tor+1Das Ziel. Dominiert alles andere
Gegentor−1Mit −0,8 strengte sie sich kaum an zu verteidigen
Meine Geschwindigkeit zum Ball0,005Hilft anfangs, den Ball zu „finden“
Ballgeschwindigkeit zum gegnerischen Tor0,015Belohnt, den Ball an die richtige Stelle zu bringen
Berührung, die den Ball Richtung Tor beschleunigt0,02 × BeschleunigungKann negativ sein: Richtung eigenes Tor kostet
Wechsel oben ↔ unten−0,005Ohne 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:

python
# 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 None

Der Lehrplan

StufeSzenarienGegnerAufstieg bei
160 % Angriff (Ball in der gegnerischen Hälfte, KI nah, fast immer dahinter), 40 % zufällig; ohne AnfangssperreStehend, weit weg (an der oberen Wand)70 % Tore in 400 Spielzügen
240 % Anstoß, 30 % zufällig, 30 % AngriffStehend, im Weg60 % Tore
340 % 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:

--visaoAusgeloste VerzögerungProjektionIm Raum nutzen
agora („jetzt“, Standard)0 (75 %) oder 1 Entscheidung (25 %)neinMit den „Augen“ (lagFrames: 0)
atrasada („verzögert“)1, 2 oder 3 Entscheidungen (10/60/30 %)6 Frames vorausNur Spielstand + projectState

Die Raumseite steht unter Die KI in deinen Raum bringen.