Technical Tutorials

La création d'intelligence artificielle pour les jeux à agent unique est désormais un problème résolu pour de nombreux domaines, des échecs au Go. Cependant, créer une IA qui excelle dans les jeux de stratégie coopératifs complexes présente un défi considérablement plus élevé. Dans ces environnements, les agents doivent non seulement apprendre des politiques optimales pour eux-mêmes, mais aussi anticiper, communiquer et se synchroniser avec d'autres agents pour atteindre une récompense globale partagée. Cet article de blog explore les nuances architecturales de l'implémentation de l'apprentissage par renforcement multi-agents (MARL) pour les scénarios coopératifs, comblant le fossé entre les concepts théoriques et le code pratique.

Le défi central : La non-stationnarité

L'obstacle fondamental en MARL est la violation de l'hypothèse du processus de décision markovien (MDP). Dans le RL à agent unique, l'environnement est statique par rapport aux mises à jour de la politique de l'agent. Dans les systèmes multi-agents, chaque agent apprend et modifie simultanément son comportement. Cela signifie que l'environnement est effectivement non stationnaire du point de vue de tout agent unique. Une stratégie qui était optimale il y a quelques instants peut devenir sous-optimale parce que ses coéquipiers ont évolué. Pour remédier à cela, les développeurs utilisent souvent des techniques telles que l'entraînement centralisé avec exécution décentralisée (CTDE), où les agents s'entraînent avec accès aux informations d'état global mais exécutent des politiques basées uniquement sur des observations locales.

Configuration de l'environnement

Avant de plonger dans les algorithmes d'entraînement, nous avons besoin d'un environnement robuste. La bibliothèque PettingZoo est la norme de l'industrie pour l'apprentissage par renforcement multi-agents, offrant une interface unifiée pour divers environnements, y compris les scénarios populaires "simple_spread" ou "multi_jockey". Elle gère la synchronisation des environnements parallèles et gère les espaces d'observation/action pour plusieurs agents de manière transparente.

Examinons comment initialiser un environnement coopératif simple et traiter les observations pour un réseau neuronal.

import gymnasium as gym
import pettingzoo

# Initialiser un environnement coopératif simple
env = pettingzoo.mpe.simple_spread_v3.env()
env.reset(seed=42)

# Exemple d'extraction de l'observation pour un agent
agent_name = env.agents[0]
observation, info = env.observe(agent_name)

# L'observation contient généralement :
# 1. La position et la vitesse de l'agent lui-même
# 2. Les positions des autres agents (relatives à soi-même)
# 3. Les positions des objets à couvrir (relatives à soi-même)

print(f"Forme de l'observation pour {agent_name} : {observation.shape}")
print(f"Actions disponibles : {env.action_space(agent_name)}")

Conception de l'architecture : Actor-Critic avec poids partagés

Pour les tâches coopératives, le partage des poids entre les agents est souvent bénéfique. Il favorise la symétrie, courante dans les jeux symétriques, et réduit considérablement la complexité d'échantillonnage nécessaire à la convergence. Nous pouvons utiliser un réseau Actor-Critic partagé où l'entrée est l'observation concaténée de l'agent et de sa position relative par rapport aux coéquipiers.

Voici une implémentation simplifiée en PyTorch d'un réseau MLP partagé pour les têtes actor et critic.

import torch
import torch.nn as nn
import torch.nn.functional as F

class MultiAgentNetwork(nn.Module):
    def __init__(self, obs_dim, act_dim, hidden_dim=64):
        super(MultiAgentNetwork, self).__init__()
        
        # Extracteur de caractéristiques partagé
        self.shared_layers = nn.Sequential(
            nn.Linear(obs_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU()
        )
        
        # Tête Actor (politique)
        self.actor_head = nn.Linear(hidden_dim, act_dim)
        
        # Tête Critic (fonction de valeur)
        self.critic_head = nn.Linear(hidden_dim, 1)

    def forward(self, obs):
        features = self.shared_layers(obs)
        log_probs = self.actor_head(features)
        values = self.critic_head(features)
        return log_probs, values

Dynamique d'entraînement : Estimation de l'avantage

Dans les jeux coopératifs, la récompense est généralement rare et partagée. Le calcul de la fonction d'avantage est crucial pour un entraînement stable. Nous utilisons l'estimation généralisée de l'avantage (GAE) pour équilibrer biais et variance. L'extrait de code ci-dessous montre comment calculer le GAE pour un lot de trajectoires, garantissant que les agents apprennent non seulement la récompense qu'ils ont reçue, mais aussi dans quelle mesure cette action était meilleure que l'attente de base.

def compute_gae(rewards, values, next_values, dones, gamma=0.99, lam=0.95):
    advantages = torch.zeros_like(rewards)
    lastgaelam = 0
    for t in reversed(range(len(rewards))):
        if t == len(rewards) - 1:
            nextnonterminal = 1.0 - dones[t]
            nextvalues = next_values[t]
        else:
            nextnonterminal = 1.0 - dones[t]
            nextvalues = values[t + 1]
            
        delta = rewards[t] + gamma * nextvalues * nextnonterminal - values[t]
        advantages[t] = lastgaelam = delta + gamma * lam * nextnonterminal * lastgaelam
        
    returns = advantages + values
    return returns, advantages

Conclusion

L'implémentation de l'apprentissage par renforcement multi-agents pour les jeux de stratégie coopératifs nécessite une compréhension approfondie à la fois des architectures de réseaux de neurones et de la dynamique de l'environnement. En tirant parti des politiques partagées, de bibliothèques d'environnement robustes comme PettingZoo et de techniques avancées d'estimation de l'avantage, les développeurs peuvent créer des agents IA qui font preuve de comportement coopératif émergent. À mesure que le domaine progresse, nous verrons probablement davantage de canaux de communication sophistiqués et de structures hiérarchiques, permettant aux agents de résoudre des défis stratégiques encore plus complexes. Commencez petit, visualisez fréquemment les trajectoires de vos agents et itérez sur le façonnage de votre récompense pour guider votre IA vers une véritable coopération.