Entraîner l'IA

Ce que voit l'IA et comment elle gagne des points

Observation, actions, axe canonique, récompenses et curriculum : les choix de conception qui pèsent le plus sur le résultat.

Trois choix définissent ce que votre IA va apprendre : ce qu'elle voit (observation), ce qu'elle peut faire (actions) et ce pour quoi elle est récompensée (récompense). Cette page explique les choix du kit et la raison de chacun.

Axe canonique : l'IA attaque toujours vers la droite

Au lieu d'apprendre à jouer des deux côtés, l'IA en apprend un. Quand elle joue en rouge (qui attaque vers la gauche), le kit inverse le terrain avant de le lui montrer (x devient 2 × 33,18 − x, les vitesses en x changent de signe) et échange gauche et droite dans la touche qu'elle choisit. Moitié moins de travail, deux fois plus d'expérience par situation.

L'observation (39 nombres)

Tous les nombres restent à peu près entre −1 et 1 (divisés par la moitié du terrain ou par la vitesse maximale) et sont limités à ±2. Les réseaux de neurones apprennent bien mieux avec des nombres dans cette plage.

#Quoi
1–4Ma position et ma vitesse
5–8Position et vitesse du ballon
9–12Position et vitesse de l'adversaire
13–16Ballon par rapport à moi et à l'adversaire
17–20Ballon par rapport au but adverse et au mien
21–22Ma distance et celle de l'adversaire au ballon
23–24Puis-je tirer maintenant ? Et l'adversaire ?
25Temps avant que l'engagement soit libéré
26–29Poteaux du but adverse et ligne de mon but, depuis moi
30–33Distance aux quatre murs
34–35Distance du ballon aux murs du haut et du bas (rebond)
36Le ballon est-il entre moi et le but adverse ? (je peux tirer)
37Suis-je entre le ballon et mon but ? (je défends)
38–39Vitesse du ballon par rapport à moi (pour freiner et ne pas dépasser le ballon)

Les nombres 1 à 25 sont la « version 1 » (les premiers modèles) ; les 26 à 39 ont été ajoutés quand nous avons remarqué que l'IA ne « voyait » ni murs ni poteaux et dépassait le ballon. Gain net.

Les actions (18)

9 directions (immobile, ↑, ↗, →, ↘, ↓, ↙, ←, ↖) × {sans tir, tir}. Une décision toutes les 3 images (100 ms).

  • Pourquoi ne pas laisser l'IA presser n'importe quelle combinaison de touches ? Parce que beaucoup n'ont pas de sens (gauche + droite ensemble) et ne font que ralentir l'apprentissage.
  • Pourquoi 100 ms et pas à chaque image ? Nous avons testé une décision à chaque image dans le salon : l'IA, entraînée à 100 ms, s'est mise à envoyer des touches d'une seule image et « tombait sans savoir jouer ». Décidez dans le salon au même rythme qu'à l'entraînement.

La récompense

À chaque décision, l'IA reçoit une petite note. Au bout du compte, PPO lui apprend à maximiser la somme des notes.

TermePoids (étape 3)Pourquoi
But+1L'objectif. Domine tout le reste
But encaissé−1Avec −0,8 elle faisait à peine l'effort de défendre
Ma vitesse vers le ballon0,005Aide au début à « trouver » le ballon
Vitesse du ballon vers le but adverse0,015Récompense le fait d'amener le ballon au bon endroit
Touche qui accélère le ballon vers le but0,02 × accélérationPeut être négative : toucher vers son propre but coûte
Inverser haut ↔ bas−0,005Sans ça, elle zigzaguait

Les étapes 1 et 2 utilisent des poids plus forts pour « atteindre le ballon » et un bonus fixe par touche, pour que l'IA découvre vite les bases.

Les pièges où nous sommes tombés

Le code complet :

python
# recompensas.py
"""Récompense par décision (10 par seconde), sur l'axe canonique (l'agent attaque toujours vers la droite).

C'est l'ensemble "classique" : celui qui a entraîné l'IA qui a le mieux joué contre des humains chez BonkTools.
  - termes de VITESSE, pas de position : rester immobile rapporte 0 (un bonus pour "être près du ballon" apprend à se garer) ;
  - touche qui accélère le ballon vers le but adverse (peut être négative : ballon vers son propre but) ;
  - but +1, but encaissé -1 ;
  - un petit coût pour inverser haut/bas entre deux décisions (sans lui l'IA zigzague).
"""
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  # vitesse de l'agent vers le ballon
    bola_gol: float  # vitesse du ballon vers le but adverse
    toque: float  # bonus fixe par touche (seulement au début : ensuite ça devient du "farm" de petites touches)
    toque_gol: float  # touche pondérée par l'accélération donnée au ballon vers le but
    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),  # but vide : apprendre à arriver et pousser
    2: Pesos(jogador_bola=0.005, bola_gol=0.02, toque=0.02, toque_gol=0.05),  # adversaire immobile sur le chemin
    3: Pesos(jogador_bola=0.005, bola_gol=0.015, toque=0.0, toque_gol=0.02),  # vrai match : le but domine
}

TOQUE_DV = 1.5  # variation minimale de vitesse du ballon en un pas pour compter comme touche (la friction seule donne < 1)
TOQUE_INTERVALO = 5  # pas entre deux bonus fixes de touche
TELEPORTE = 8.0  # en un pas rien ne bouge de plus de ~1,5 ; au-delà c'est un repositionnement (but/reprise)


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:
    """Si `eu` a touché le ballon entre `prev` et `curr` : accélération du ballon vers le but adverse (-1..1). Sinon 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]:
        """Renvoie (récompense, s'il y a eu une touche)."""
        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

Le curriculum

ÉtapeScénariosAdversaireAvance à
160 % attaque (ballon dans le camp adverse, IA proche, presque toujours derrière lui), 40 % aléatoire ; sans gel initialImmobile, loin (contre le mur du haut)70 % de buts sur 400 actions
240 % engagement, 30 % aléatoire, 30 % attaqueImmobile, sur le chemin60 % de buts
340 % engagement, 30 % aléatoire, 30 % défense (ballon allant vers le but de l'IA, adversaire derrière lui)50 % script (habileté 0,4–1), 50 % ancienne version de l'IA elle-même—

Une action se termine au premier but (des deux côtés) ou à la limite de temps (15, 30 et 45 s aux étapes 1, 2 et 3).

Les adversaires scriptés

Le Perseguidor (« poursuivant ») du kit se place derrière le ballon, s'aligne avec le but et tire. L'« habileté » règle la fréquence de ses mauvaises décisions et sa lenteur de réaction. Il est important au début de l'étape 3, quand les anciennes versions de l'IA sont encore trop faibles.

Le retard du salon

Dans le salon, l'IA ne voit pas le jeu exactement « maintenant » : il y a le rythme de 100 ms et, sans les « yeux », les 200 ms de retard de la simulation du score. Si l'entraînement montre le jeu parfait et le salon un jeu retardé, l'IA joue mal sans aucune erreur visible (avec 200 ms, un modèle entraîné sans retard perdait tous les engagements contre un attaquant qui tire en première intention).

C'est pourquoi, à chaque action, l'environnement tire au sort combien de décisions en arrière l'IA voit :

--visaoRetard tiréProjectionÀ utiliser dans le salon
agora (« maintenant », par défaut)0 (75 %) ou 1 décision (25 %)nonAvec les « yeux » (lagFrames: 0)
atrasada (« retardée »)1, 2 ou 3 décisions (10/60/30 %)6 images en avantSeulement le score + projectState

Voir Mettre l'IA dans votre salon pour le côté salon.