Phase 09 - Lesson 10

RL Multiagente

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

O RL de agente único assume que o ambiente é estacionário. Coloque dois agentes de aprendizado no mesmo mundo e essa suposição se desfaz: cada agente faz parte do ambiente do outro, e ambos estão mudando. O RL multiagente é o conjunto de truques para fazer o aprendizado convergir quando a suposição de Markov não é mais válida.

Tipo: Build Idiomas: Python Pré-requisitos: Phase 9 · 04 (Q-learning), Phase 9 · 06 (REINFORCE), Phase 9 · 07 (Actor-Critic) Tempo: ~45 minutos

O Problema

Um robô aprendendo a navegar em uma sala é um problema de RL de agente único. Um time de futebol não é. AlphaStar vs oponentes de StarCraft não é. Um mercado de agentes de lances não é. Dois carros negociando um cruzamento de quatro vias não é. Muitos problemas do mundo real de muitos para muitos não são.

Em todo cenário multiagente, sob a perspectiva de qualquer agente individual, os outros agentes são parte do ambiente. Conforme eles aprendem e mudam seu comportamento, o ambiente se torna não estacionário. A propriedade de Markov — "o próximo estado depende apenas do estado atual e da minha ação" — é violada porque o próximo estado também depende do que os outros agentes escolheram, e suas políticas são alvos móveis.

Isso quebra as provas de convergência tabulares (a garantia do Q-learning assume um ambiente estacionário). Também quebra o RL profundo ingênuo: os agentes perseguem uns aos outros em loops, nunca convergindo para uma política estável. Você precisa de técnicas específicas para multiagentes: treinamento centralizado / execução descentralizada, baselines contrafatuais, league play, self-play.

Aplicações em 2026: enxames de robôs, roteamento de tráfego, frotas de veículos autônomos, simuladores de mercado, sistemas de LLM multiagentes (Phase 16) e qualquer jogo com mais de um jogador inteligente.

O Conceito

Formalism: Markov Game. Uma generalização de MDP: estados S, uma ação conjunta a = (a_1, …, a_n), transição P(s' | s, a) e recompensas por agente R_i(s, a, s'). Cada agente i maximiza seu próprio retorno sob sua própria política π_i. Se as recompensas forem idênticas, é totalmente cooperativo. Se for de soma zero, é adversário. Se for misto, é de soma geral.

Desafios principais:

• Não estacionariedade. A transição P(s' | s, a_i) sob a perspectiva do agente i depende de π_{-i}, que está mudando.
• Atribuição de crédito. Com uma recompensa compartilhada, qual agente a causou?
• Coordenação da exploração. Os agentes devem explorar estratégias complementares, em vez de explorar redundantemente o mesmo estado.
• Escalabilidade. O espaço de ação conjunta cresce exponencialmente em n.
• Observabilidade parcial. Cada agente vê apenas sua própria observação; o estado global fica oculto.

Quatro regimes dominantes:

1. Q-learning independente / PPO independente (IQL, IPPO). Cada agente aprende seu próprio Q ou política, tratando os outros como parte do ambiente. Simples, às vezes funciona (especialmente com experience replay atuando como um truque de modelagem de agente suavizador). Convergência teórica: nenhuma. Na prática: bom para tarefas fracamente acopladas, ruim para tarefas fortemente acopladas.

2. Treinamento centralizado, execução descentralizada (CTDE). Paradigma moderno mais comum. Cada agente possui sua própria política π_i condicionada à observação local o_i — execução descentralizada padrão no momento da implantação. Durante o treinamento, um crítico centralizado Q(s, a_1, …, a_n) é condicionado ao estado global completo e à ação conjunta. Exemplos:

• MADDPG (Lowe et al. 2017): DDPG com um crítico centralizado por agente.
• COMA (Foerster et al. 2017): baseline contrafactual — pergunta "qual teria sido minha recompensa se eu tivesse tomado a ação a' em vez da escolhida?" — isolando a minha contribuição.
• MAPPO / IPPO com crítico compartilhado (Yu et al. 2022): PPO com uma função de valor centralizada. Dominante em 2026 para MARL cooperativo.
• QMIX (Rashid et al. 2018): decomposição de valor — Q_tot(s, a) = f(Q_1(s, a_1), …, Q_n(s, a_n)) com mistura monotônica.

3. Self-play. Duas cópias do mesmo agente jogam entre si. A política do oponente es a minha política a partir de um snapshot do passado. AlphaGo / AlphaZero / MuZero. OpenAI Five. Funciona melhor para jogos de soma zero; o sinal de treinamento é simétrico.

4. League play. Uma extensão do self-play para ambientes de soma geral / adversários: mantém uma população de políticas passadas e atuais, amostra um oponente da liga e treina contra ele. Adiciona exploradores (especializados em vencer o melhor atual) e exploradores principais (especializados em vencer os exploradores). AlphaStar (StarCraft II). Necessário quando o jogo admite ciclos de estratégia de tipo "pedra-papel-tesoura".

Comunicação. Permite que os agentes enviem mensagens aprendidas m_i uns aos outros. Funciona em cenários cooperativos. Foerster et al. (2016) demonstraram que a comunicação interagente diferenciável pode ser treinada de ponta a ponta. Os sistemas multiagentes baseados em LLM de hoje (Phase 16) comunicam-se essencialmente em linguagem natural.

Construa

Este tutorial usa um GridWorld 6×6 com dois agentes cooperativos. Eles começam em cantos opostos e devem alcançar um objetivo comum. Recompensa compartilhada: -1 por passo enquanto qualquer agente ainda estiver se movendo, +10 quando ambos chegarem. Veja code/main.py.

Passo 1: o ambiente multiagente

class CoopGridWorld:
    def __init__(self):
        self.size = 6
        self.goal = (5, 5)

    def reset(self):
        return ((0, 0), (5, 0))  # two agents

    def step(self, state, actions):
        a1, a2 = state
        new1 = move(a1, actions[0])
        new2 = move(a2, actions[1])
        done = (new1 == self.goal) and (new2 == self.goal)
        reward = 10.0 if done else -1.0
        return (new1, new2), reward, done

O espaço de ação conjunta é |A|² = 16. O estado global é composto por duas posições.

Passo 2: Q-learning independente

Cada agente executa sua própria tabela Q com chave no estado conjunto. Em cada passo: ambos escolhem ações ε-greedy, coletam a transição conjunta e cada um atualiza seu próprio Q com a recompensa compartilhada.

def independent_q(env, episodes, alpha, gamma, epsilon):
    Q1, Q2 = defaultdict(default_q), defaultdict(default_q)
    for _ in range(episodes):
        s = env.reset()
        while not done:
            a1 = epsilon_greedy(Q1, s, epsilon)
            a2 = epsilon_greedy(Q2, s, epsilon)
            s_next, r, done = env.step(s, (a1, a2))
            target1 = r + gamma * max(Q1[s_next].values())
            target2 = r + gamma * max(Q2[s_next].values())
            Q1[s][a1] += alpha * (target1 - Q1[s][a1])
            Q2[s][a2] += alpha * (target2 - Q2[s][a2])
            s = s_next

Funciona nesta tarefa porque as recompensas são densas e alinhadas. Falha em tarefas fortemente acopladas (por exemplo, onde um agente precisa esperar pelo outro).

Passo 3: Q centralizado com atualização de valor decomposto

Use um Q sobre as ações conjuntas Q(s, a_1, a_2). Atualize a partir da recompensa compartilhada. Descentralize na execução marginalizando: π_i(s) = argmax_{a_i} max_{a_{-i}} Q(s, a_1, a_2). Troca o espaço de ação conjunta exponencial por uma visão global correta.

Passo 4: self-play simples (2 agentes adversários)

Mesmo agente, dois papéis. Treine o agente A contra o agente B; após K episódios, copie os pesos de A para B. Treinamento simétrico, progresso consistente. A receita do AlphaZero em miniatura.

Armadilhas

• Replay não estacionário. O experience replay com agentes independentes é pior do que com um único agente porque as transições antigas foram geradas por oponentes agora obsoletos. Solução: rotular novamente ou ponderar pela recência.
• Ambiguidade na atribuição de crédito. Recompensa compartilhada após um episódio longo; não há uma maneira clara de dizer qual agente contribuiu. Solução: baselines contrafatuais (COMA) ou modelagem de recompensa por agente.
• Desvio de política / perseguição. A melhor resposta de cada agente muda com a atualização de cada um. Solução: crítico centralizado, taxas de aprendizado baixas ou congelar um de cada vez.
• Hacking de recompensa por meio de coordenação. Os agentes encontram explorações coordenadas que o designer não previu. Agentes de leilão convergem para dar lances zero. Solução: design cuidadoso de recompensas, restrições comportamentais.
• Redundância de exploração. Ambos os agentes exploram os mesmos pares de estado-ação. Solução: bônus de entropia por agente ou condicionamento de papéis.
• Ciclos de liga. O self-play puro pode ficar preso em um ciclo de dominância. Solução: league play com oponentes diversos.
• Explosão de amostragem. n agentes × espaço de estados × ações conjuntas. Aproxime com aproximação de funções; espaços de ação fatorados (uma cabeça de saída de política por agente).

Use

O mapa de aplicação de MARL em 2026:

Em 2026, a maior área de crescimento do MARL é baseada em LLMs: enxames de agentes de modelos de linguagem negociando, debatendo e construindo software. O RL aparece como otimização de preferência em saídas no nível de trajetória, não no nível de token (Phase 16 · 03).

Envie

Salve como outputs/skill-marl-architect.md:

---
name: marl-architect
description: Pick the right multi-agent RL regime (IPPO, CTDE, self-play, league) for a given task.
version: 1.0.0
phase: 9
lesson: 10
tags: [rl, multi-agent, marl, self-play]
---

Given a task with `n` agents, output:

1. Regime classification. Cooperative / adversarial / general-sum. Justify.
2. Algorithm. IPPO / MAPPO / QMIX / self-play / league. Reason tied to coupling tightness and reward structure.
3. Information access. Centralized training (what global info goes to the critic)? Decentralized execution?
4. Credit assignment. Counterfactual baseline, value decomposition, or reward shaping.
5. Exploration plan. Per-agent entropy, population-based training, or league.

Refuse independent Q-learning on tightly-coupled cooperative tasks. Refuse to recommend self-play for general-sum with cycle risks. Flag any MARL pipeline without a fixed-opponent eval (cherry-picked self-play numbers are common).

Exercícios

1. Fácil. Treine o Q-learning independente no GridWorld cooperativo de 2 agentes. Quantos episódios são necessários até que o retorno médio seja > 0? Plote a curva de aprendizado conjunta.
2. Médio. Adicione uma tarefa de "coordenação": o objetivo só é alcançado quando ambos os agentes pisam nele na mesma rodada. O Q-learning independente ainda converge? O que quebra?
3. Difícil. Implemente um crítico centralizado para o treinamento estilo MAPPO e compare a velocidade de convergência com o PPO independente na tarefa de coordenação.

Termos-Chave

Leitura Adicional

• Lowe et al. (2017). Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments (MADDPG) — CTDE com um crítico centralizado.
• Foerster et al. (2017). Counterfactual Multi-Agent Policy Gradients (COMA) — baselines contrafatuais para atribuição de crédito.
• Rashid et al. (2018). QMIX: Monotonic Value Function Factorisation — decomposição de valor com monotonicidade.
• Yu et al. (2022). The Surprising Effectiveness of PPO in Cooperative Multi-Agent Games (MAPPO) — o PPO é surpreendentemente forte para MARL.
• Vinyals et al. (2019). Grandmaster level in StarCraft II using multi-agent reinforcement learning (AlphaStar) — league play em escala.
• Silver et al. (2017). Mastering the game of Go without human knowledge (AlphaGo Zero) — self-play puro em jogos de soma zero.
• Sutton & Barto (2018). Ch. 15 — Neuroscience & Ch. 17 — Frontiers — inclui o breve tratamento do livro didático sobre cenários multiagentes e o problema de não estacionariedade que o CTDE foi projetado para resolver.
• Zhang, Yang & Başar (2021). Multi-Agent Reinforcement Learning: A Selective Overview — visão geral abrangente cobrindo MARL cooperativo, competitivo e misto com resultados de convergência.