Explorer les techniques d'apprentissage par renforcement multi-agents (MARL), incluant la communication dynamique, la coordination, la décomposition des tâches et les protocoles d'entraînement décentralisés.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Explorer les techniques d'apprentissage par renforcement multi-agents (MARL), incluant la communication dynamique, la coordination, la décomposition des tâches et les protocoles d'entraînement décentralisés.
Apprentissage par Renforcement Multi-Agents (MARL)
Vue d'ensemble
L'apprentissage par renforcement multi-agents (MARL) étend le cadre classique du reinforcement learning à des environnements où plusieurs agents interagissent simultanément. Chaque agent observe l'état de l'environnement, prend des décisions, et reçoit des récompenses — mais la présence d'autres agents rend l'environnement non-stationnaire du point de vue de chaque apprenant.
Cette compétence couvre les aspects fondamentaux du MARL :
Formalisme : extension des MDP (Markov Decision Processes) aux jeux stochastiques.
Taxonomie des régimes : coopératif, compétitif, mixte.
Paradigmes d'entraînement : centralisé, décentralisé, CTDE (Centralized Training Decentralized Execution).
Communication entre agents : protocoles structurés, message passing, GNN.
Passage à l'échelle : factorisation de la fonction de valeur, mean-field MARL.
Quand utiliser cette compétence
Scénario
Pertinence
Coordination de flotte (drones, robots, véhicules autonomes)
Élevée
Optimisation de trafic urbain (feux, flux, itinéraires)
Élevée
Gestion de ressources partagées (énergie, bande passante, entrepôt)
Quand un autre agent met à jour sa politique, la distribution des transitions change du point de vue de l'agent $i$ — c'est la non-stationnarité, le défi central du MARL.
2. Paradigmes d'entraînement
2.1 Centralized Training Decentralized Execution (CTDE)
CTDE est le paradigme dominant : les agents sont entraînés avec accès à l'information globale (états et actions de tous), mais exécutent de manière décentralisée (chaque agent n'utilise que ses observations locales).
┌──────────────────┐
│ Entraînement │ ← Accès global (tous états × toutes actions)
│ Centralisé │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Exécution │ ← Chaque agent n'utilise que ses observations locales
│ Décentralisée │
└──────────────────┘
2.2 Implémentation : CTDE avec QMIX
QMIX factorise la fonction de valeur globale $Q_\text{tot}$ comme une combinaison monotone des fonctions de valeur individuelles $Q_i$ :
import torch
import torch.nn as nn
import torch.nn.functional as F
classReseauQMIX(nn.Module):
"""Réseau de mélange QMIX pour MARL coopératif."""def__init__(self, n_agents: int, dim_etat: int, dim_action: int, dim_embedding: int = 64):
super().__init__()
self.n_agents = n_agents
# Réseaux individuels (agents partagent les poids ou non)self.reseaux_agents = nn.ModuleList([
nn.Sequential(
nn.Linear(dim_etat, dim_embedding),
nn.ReLU(),
nn.Linear(dim_embedding, dim_embedding),
nn.ReLU(),
nn.Linear(dim_embedding, dim_action),
)
for _ inrange(n_agents)
])
# Hyper-réseaux pour les poids du mélangeurself.hyper_w1 = nn.Linear(dim_etat, dim_embedding * n_agents)
self.hyper_w2 = nn.Linear(dim_etat, dim_embedding)
self.hyper_b1 = nn.Linear(dim_etat, dim_embedding)
self.hyper_b2 = nn.Linear(dim_etat, 1)
defforward(self, etats: torch.Tensor) -> torch.Tensor:
"""Calcule Q_tot à partir des états et actions.
Args:
etats: Tenseur (batch, n_agents, dim_etat).
Returns:
Q_tot valeurs (batch, n_actions_tot).
"""
batch_size = etats.shape[0]
# Q_i pour chaque agent
q_i = torch.stack([
reseau(etats[:, i]) for i, reseau inenumerate(self.reseaux_agents)
], dim=1) # (batch, n_agents, n_actions)# État global (concaténation)
etat_global = etats.reshape(batch_size, -1)
# Poids du mélangeur
w1 = torch.abs(self.hyper_w1(etat_global)).reshape(
batch_size, self.n_agents, -1
)
b1 = self.hyper_b1(etat_global).reshape(batch_size, -1, 1)
w2 = torch.abs(self.hyper_w2(etat_global)).reshape(
batch_size, -1, 1
)
b2 = self.hyper_b2(etat_global)
# Q_tot = mélange monotone
q_hidden = F.elu(torch.bmm(q_i, w1) + b1)
q_tot = (torch.bmm(q_hidden, w2) + b2).squeeze(-1)
return q_tot
2.3 MARL complètement décentralisé (IQL)
Independent Q-Learning (IQL) traite chaque agent comme un apprenant RL indépendant, ignorant les autres agents :
Éviter les conflits d'actions (ex. deux robots vers le même objet)
Apprentissage accéléré
Transmission de politiques apprises (knowledge transfer)
3.2 Message Passing avec GNN
import torch.nn as nn
classCommunicateurGNN(nn.Module):
"""Couche de communication entre agents basée sur un GNN (message passing)."""def__init__(self, dim_etat: int, dim_message: int = 32):
super().__init__()
self.encoder_message = nn.Linear(dim_etat, dim_message)
self.aggregateur = nn.Linear(dim_message * 2, dim_message)
self.decodeur = nn.Linear(dim_message + dim_etat, dim_etat)
defforward(self, etats: torch.Tensor, matrice_adjacence: torch.Tensor) -> torch.Tensor:
"""Fait passer des messages entre agents connectés.
Args:
etats: Tenseur (n_agents, dim_etat).
matrice_adjacence: Tenseur booléen (n_agents, n_agents) — qui parle à qui.
Returns:
États mis à jour après communication (n_agents, dim_etat).
"""
n_agents = etats.shape[0]
messages = self.encoder_message(etats) # (n_agents, dim_message)# Agrégation des messages entrants
messages_aggreges = []
for i inrange(n_agents):
voisins = matrice_adjacence[i].nonzero(as_tuple=True)[0]
iflen(voisins) > 0:
msg_voisins = messages[voisins].mean(dim=0)
else:
msg_voisins = torch.zeros_like(messages[0])
messages_aggreges.append(msg_voisins)
messages_aggreges = torch.stack(messages_aggreges)
# Mise à jour des états avec les messages reçus
entrees = torch.cat([messages_aggreges, etats], dim=-1)
returnself.decodeur(entrees)
3.3 Apprentissage de protocoles de communication
Les agents peuvent apprendre quand et quoi communiquer :
classAgentAvecCommunication:
"""Agent MARL avec protocole de communication appris."""def__init__(self, dim_etat: int, dim_action: int, dim_message: int = 16):
# Politique de communication : génère un messageself.reseau_emission = nn.Sequential(
nn.Linear(dim_etat, 32),
nn.ReLU(),
nn.Linear(32, dim_message),
)
# Gating : décide si le message est envoyéself.gating = nn.Sequential(
nn.Linear(dim_etat, 1),
nn.Sigmoid(),
)
# Politique d'action : combine état et messages reçusself.reseau_action = nn.Sequential(
nn.Linear(dim_etat + dim_message, 64),
nn.ReLU(),
nn.Linear(64, dim_action),
)
defemettre_message(self, etat: torch.Tensor) -> tuple[torch.Tensor, float]:
"""Génère un message et décide s'il est envoyé.
Args:
etat: État local de l'agent.
Returns:
Tuple (message, probabilité d'envoi).
"""
message = self.reseau_emission(etat)
proba_envoi = self.gating(etat)
# Pendant l'entraînement, échantillonner depuis Bernoulli(proba_envoi)
envoyer = torch.bernoulli(proba_envoi) > 0.5return message if envoyer else torch.zeros_like(message), proba_envoi
defagir(self, etat: torch.Tensor, messages_recus: torch.Tensor) -> int:
"""Sélectionne une action basée sur l'état local et les messages reçus.
Args:
etat: État local de l'agent.
messages_recus: Messages reçus des autres agents (agrégés).
Returns:
Action sélectionnée.
"""
entrees = torch.cat([etat, messages_recus], dim=-1)
returnself.reseau_action(entrees).argmax().item()
4. Applications MARL
4.1 Coordination de drones
from marl_library.simulation import configure_agents, initialize_environment, train_agents
defentrainer_flotte_drones(n_drones: int = 5, n_epochs: int = 100) -> dict:
"""Entraîne une flotte de drones pour une mission de couverture coopérative.
Args:
n_drones: Nombre de drones dans la flotte.
n_epochs: Nombre d'épisodes d'entraînement.
Returns:
Métriques de performance (récompense moyenne, taux de couverture).
"""
environnement = initialize_environment("couverture_cooperative", n_agents=n_drones)
agents = configure_agents(n_agents=n_drones, algorithme="qmix")
resultats = train_agents(
agents=agents,
env=environnement,
n_episodes=n_epochs,
evaluer_tous=10, # Évaluer tous les 10 épisodes
)
return analyser_performance(resultats)
4.2 Gestion de trafic urbain
Agent
Action
Récompense
Feu de signalisation (intersection)
Durée du feu vert/rouge
Réduction du temps d'attente moyen
Véhicule autonome
Choix d'itinéraire
Temps de trajet individuel
Centre de régulation
Modification des priorités
Flux global maximisé
5. Pièges courants (Pitfalls)
5.1 Non-stationnarité ignorée
Problème : Traiter MARL comme N problèmes RL indépendants (IQL) ignore la non-stationnarité, conduisant à des politiques instables.
Solution : Utilisez le paradigme CTDE. Si IQL est nécessaire, stabilisez avec :
Hysteretic Q-learning : taux d'apprentissage asymétrique pour les récompenses positives/négatives.
Experience replay centralisé : stocke les transitions de tous les agents.
5.2 Crédit assignment dans les tâches coopératives
Problème : Quand la récompense est globale (tous les agents reçoivent la même récompense), comment attribuer le crédit à chaque agent ?
Solution : Utilisez des mécanismes de factorisation de la valeur :
QMIX : $Q_\text{tot} = f(Q_1, \dots, Q_N)$ avec contrainte de monotonie.
QTRAN : relaxation de la contrainte de monotonie.
5.3 Passage à l'échelle
Problème : Avec N agents, la dimension de l'espace d'actions conjoint est $|\mathcal{A}|^N$, explosive.
Solution : Utilisez des méthodes mean-field (approximation du champ moyen) où chaque agent interagit avec la distribution moyenne des autres agents plutôt qu'avec chaque agent individuellement.
5.4 Exploration inefficace
Problème : Dans les espaces d'états-actions conjoints, l'exploration aléatoire est extrêmement inefficace.
Solution : Implémentez une exploration structurée :
Exploration par curiosité : récompense intrinsèque pour les états inconnus.
Parameter space noise : bruit ajouté aux poids du réseau, pas aux actions.
6. Checklist de validation
Le régime MARL est-il correctement identifié (coopératif, compétitif, mixte) ?
Le paradigme d'entraînement choisi (CTDE, IQL, mean-field) est-il adapté au nombre d'agents ?
Un mécanisme de factorisation de la valeur est-il implémenté (VDN, QMIX, QTRAN) ?
La non-stationnarité est-elle traitée (pas de simples IQL pour N > 2) ?
Les agents peuvent-ils communiquer (message passing, protocole appris) ?
Le passage à l'échelle est-il assuré (mean-field, ou décomposition) ?
