Meu Modelo de 102k parâmetros derrotando grande LLMs( Llama 3 70B, Kimi k2 (~1T), Gemini) em Damas

Recentemente, decidi implementar o algoritmo do AlphaZero do zero (from scratch) em PyTorch para jogar Damas (Checkers). O objetivo não era apenas recriar o paper da DeepMind, mas colocar essa implementação enxuta para brigar contra os LLMs do momento (Llama 3 70b e Kimi k2) e algoritmos clássicos (Minimax).

O resultado foi um estudo de caso interessante sobre a eficiência de redes neurais especializadas versus modelos de linguagem generalistas. Vou detalhar abaixo a arquitetura, o pipeline de treinamento e os benchmarks.

1. A Arquitetura (Policy-Value Network)

Diferente de engines clássicas (como Stockfish antigo) que usam funções de avaliação manuais (ex: peça = 3 pontos, dama = 5 pontos), o AlphaZero usa uma única Rede Neural para guiar a busca.

Implementei uma arquitetura CNN (Convolutional Neural Network) compacta para rodar em hardware acessível (Colab T4/P100):

• Input: Tensor (5, 8, 8). São 4 canais binários representando as peças do jogador atual e do oponente (normais e damas) + 1 canal indicando a vez de jogar.
• Body: 3 blocos convolucionais com 64 filtros cada, BatchNormalization e ativação ReLU. Isso extrai as características espaciais do tabuleiro.
• Two Heads (Duas Cabeças de Saída):
  1. Policy Head (Ator): Retorna um vetor de probabilidades para todos os movimentos possíveis. Ela aprende o que jogar.
  2. Value Head (Crítico): Retorna um escalar [-1, 1] indicando a chance de vitória daquele estado atual. Ela aprende quem está ganhando.

# Snippet da arquitetura (simplificado)
class PolicyValueNetwork(nn.Module):
    def __init__(self):
        super().__init__()
        self.body = nn.Sequential(
            nn.Conv2d(5, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(),
            # ... mais camadas conv ...
        )
        self.policy_head = nn.Conv2d(64, 4, 1) # Mapeia para probabilidades de movimento
        self.value_head = nn.Linear(64, 1)     # Mapeia para avaliação de vitória (tanh)

2. O Cérebro: MCTS (Monte Carlo Tree Search)

A rede neural sozinha não é suficiente. Ela fornece a "intuição", mas precisamos de "raciocínio". Para isso, acoplei a rede a um algoritmo MCTS.

A cada vez que a IA precisa jogar, ela roda 80 simulações (MCTS Sims). Em vez de rodar até o fim do jogo (o que seria lento), o MCTS usa a Value Head da rede neural para estimar o valor dos nós folha.

A fórmula de seleção de nós (PUCT) equilibra:

1. Exploitation: O valor Q (quão bom é esse movimento segundo a rede).
2. Exploration: A probabilidade a priori P (o que a rede sugere) ajustada pela contagem de visitas N (tentar movimentos pouco explorados).

3. Treinamento: Tabula Rasa e Self-Play

O modelo não recebeu nenhum dataset de jogos humanos. Ele aprendeu jogando contra si mesmo.

• Ciclo de Self-Play: A rede joga 25 partidas contra uma cópia dela mesma.
• Geração de Dados: Cada estado do tabuleiro, a probabilidade do MCTS (policy) e o resultado final do jogo (z) são salvos em um Replay Buffer (tamanho 75.000).
• Otimização: A cada ciclo, amostramos um batch do buffer e treinamos a rede para minimizar o erro entre:
  1. A predição da rede vs o resultado real do jogo (MSE Loss).
  2. O vetor de policy da rede vs a distribuição de visitas do MCTS (Cross-Entropy Loss).

Foram 500 épocas de treinamento para atingir a estabilidade.

4. O Benchmark: Davi vs Golias

Para validar a força da engine (AlphaCheckers-Zero), coloquei-a para jogar contra três oponentes distintos:

vs Minimax (Depth 8)

• Resultado: Empate Sólido (Draw).
• Análise: O Minimax com poda Alpha-Beta em profundidade 8 é um adversário formidável e taticamente perfeito em curto prazo. O fato da rede neural ter aprendido a empatar consistentemente demonstra que ela convergiu para uma estratégia ótima defensiva sem nunca ter sido programada com regras de damas a posteriori.

vs Llama 3.3 70b & Kimi k2 (LLMs)

Aqui a coisa ficou interessante. Usei Prompt Engineering para passar o estado do tabuleiro em notação algébrica/ASCII para os LLMs.

• Resultado: Vitória clara do AlphaCheckers.
• Análise: LLMs são modelos probabilísticos de tokens, não engines de lógica.
  1. Planejamento vs Reação: O Llama 3 entendeu as regras do jogo perfeitamente e fez jogadas válidas, mas ficou sempre na defensiva, reagindo aos movimentos do AlphaZero sem conseguir traçar uma estratégia ofensiva de longo prazo. Enquanto o AlphaZero simula centenas de sequências futuras com MCTS (planejamento de 10-20 movimentos à frente), o LLM opera basicamente "turno a turno", escolhendo a jogada que parece melhor no momento, sem visão estratégica profunda.
  2. Arquitetura vs Propósito: LLMs são treinados para predizer o próximo token mais provável, não para buscar em árvore de decisões. O Llama 3 (70B params) roda em clusters pesados e consome muito mais recursos, mas toda essa capacidade está distribuída em conhecimento linguístico geral. O AlphaCheckers (100k params) concentra toda sua "inteligência" em uma única tarefa: vencer em Damas.
  3. Ineficiência: O Llama 3 (70B params) exige GPUs de data center para rodar. O AlphaCheckers roda liso em CPU. O meu modelo tem apenas 102.355 parâmetros. Isso é cerca de 680.000 vezes menor que o Llama 3 70b e 9.769.918 vezes menor que o Kimi k2, provando matematicamente que a especialização supera o tamanho bruto em certas tarefas.

Conclusão e Repositório

Este projeto reforça a tese de que, para domínios fechados e determinísticos, arquiteturas especializadas (RL/AlphaZero) são ordens de grandeza mais eficientes e precisas que General Purpose LLMs.

O código completo, incluindo o loop de treinamento, a implementação do MCTS e os scripts de avaliação, está disponível no meu GitHub. Tentei deixar o código legível para quem quiser estudar RL na prática.

🔗 GitHub: MadrasLe/AlphaCheckers-Zero

Feedback são bem-vindos!

---