Rede de Cabeça Dupla e Rede Residual
Uma das inovações arquitetônicas mais importantes do AlphaGo Zero é o uso de uma Rede de Cabeça Dupla (Dual-Head Network) para substituir o design de rede dupla do AlphaGo original. Esta mudança aparentemente simples trouxe melhorias significativas de desempenho e um processo de aprendizado mais elegante.
Este artigo analisará em profundidade os princípios de design desta arquitetura, as bases matemáticas e por que ela é tão eficaz.
Design da Rede de Cabeça Dupla
Arquitetura Geral
A rede neural do AlphaGo Zero pode ser dividida em três partes:
Vamos analisar cada parte uma a uma.
Backbone Compartilhado (Shared Backbone)
O backbone compartilhado é uma Rede Residual (ResNet) profunda, responsável por extrair características do estado do tabuleiro.
Detalhes da Arquitetura
| Componente | Especificação |
|---|---|
| Camada de entrada | Convolução 3×3, 256 canais |
| Blocos residuais | 40 (ou 20 na versão compacta) |
| Por bloco residual | 2 camadas de convolução 3×3, 256 canais |
| Função de ativação | ReLU |
| Normalização | Batch Normalization |
Representação Matemática
Seja a entrada x (dimensão 17 x 19 x 19), a saída do backbone compartilhado é:
f(x) = ResNet_40(Conv_3x3(x))
Onde f(x) (dimensão 256 x 19 x 19) é a representação de características de alta dimensão.
Policy Head (Cabeça de Política)
A Policy Head é responsável por prever a probabilidade de jogada em cada posição.
Detalhes da Arquitetura
Saída do backbone compartilhado (256 × 19 × 19)
↓
Convolução 1×1 (2 canais)
↓
Batch Normalization
↓
ReLU
↓
Achatamento (2 × 19 × 19 = 722)
↓
Camada totalmente conectada (362)
↓
Softmax
↓
Saída: 362 probabilidades (361 posições + Pass)
Representação Matemática
π = Softmax(FC(Flatten(ReLU(BN(Conv_1x1(f(x)))))))
A saída π é um vetor de 362 dimensões, com todos os elementos não negativos e soma igual a 1.
Value Head (Cabeça de Valor)
A Value Head é responsável por prever a taxa de vitória da posição atual.
Detalhes da Arquitetura
Saída do backbone compartilhado (256 × 19 × 19)
↓
Convolução 1×1 (1 canal)
↓
Batch Normalization
↓
ReLU
↓
Achatamento (1 × 19 × 19 = 361)
↓
Camada totalmente conectada (256)
↓
ReLU
↓
Camada totalmente conectada (1)
↓
Tanh
↓
Saída: Taxa de vitória [-1, 1]
Representação Matemática
v = Tanh(FC_1(ReLU(FC_2(Flatten(ReLU(BN(Conv_1x1(f(x)))))))))
A saída v está no intervalo [-1, 1]:
- v = 1: O lado atual com certeza ganha
- v = -1: O lado atual com certeza perde
- v = 0: Equilibrado
Por que Compartilhar o Backbone?
Compreensão Intuitiva
"Onde devo jogar a seguir" (Policy) e "Quem vai ganhar" (Value) — estas duas perguntas na verdade precisam entender os mesmos padrões de tabuleiro:
- Formas: Quais formas são boas, quais são ruins
- Influência: Qual lado é maior, onde ainda há espaço
- Vida e morte: Quais pedras já estão vivas, quais ainda estão em ko
- Combate: Onde há ataques e capturas, qual é o resultado local
Se usar duas redes independentes, estas características precisam ser aprendidas duas vezes. O backbone compartilhado permite que essas características de baixo nível sejam aprendidas apenas uma vez, e ambas as tarefas podem usá-las.
Perspectiva de Aprendizado Multi-tarefa
Do ponto de vista de aprendizado de máquina, isto é uma forma de Aprendizado Multi-tarefa (Multi-task Learning):
L = L_policy + L_value
Duas tarefas compartilhando representação de baixo nível traz várias vantagens:
1. Efeito de Regularização
Parâmetros compartilhados equivalem a regularização implícita. Se uma característica é útil apenas para Policy e não para Value (ou vice-versa), é mais difícil ser amplificada excessivamente.
O número efetivo de parâmetros é menor que a soma dos parâmetros de duas redes independentes.
2. Eficiência de Dados
Cada partida produz simultaneamente rótulos de Policy (probabilidades de busca MCTS) e rótulos de Value (resultado final). O backbone compartilhado permite que ambos os rótulos sejam usados para treinar características compartilhadas, aumentando a eficiência de utilização de dados.
3. Sinais de Gradiente Mais Ricos
Gradientes de ambas as tarefas fluem para o backbone compartilhado:
∂L/∂θ_shared = ∂L_policy/∂θ_shared + ∂L_value/∂θ_shared
Isto fornece sinais de supervisão mais ricos, tornando as características compartilhadas mais robustas.
Evidência Experimental
Experimentos de ablação da DeepMind mostram que a rede de cabeça dupla tem desempenho significativamente melhor que redes duplas separadas:
| Configuração | Classificação ELO | Diferença Relativa |
|---|---|---|
| Redes Policy + Value separadas | Linha de base | - |
| Rede de cabeça dupla (backbone compartilhado) | +300 ELO | ~65% de diferença de taxa de vitória |
Uma diferença de 300 ELO significa que a rede de cabeça dupla tem aproximadamente 65% de taxa de vitória contra redes separadas. Esta é uma melhoria significativa.
Princípios da Rede Residual
O Dilema das Redes Profundas
Antes da invenção da ResNet, redes neurais profundas enfrentavam um paradoxo:
Teoricamente, redes mais profundas deveriam ser pelo menos tão boas quanto redes mais rasas (no pior caso, as camadas extras podem aprender o mapeamento identidade). Mas na prática, redes mais profundas frequentemente tinham desempenho pior.
Este é o Problema de Degradação (Degradation Problem):
- O erro de treinamento aumenta com a profundidade (não é overfitting, é dificuldade de otimização)
- Gradientes desaparecem gradualmente durante a retropropagação (Vanishing Gradient)
- Parâmetros de camadas profundas quase não conseguem ser atualizados efetivamente
Design do Bloco Residual
Kaiming He e colaboradores propuseram uma solução elegante e simples em 2015: Conexão Residual (Skip Connection).
Representação Matemática
Rede tradicional: Aprender mapeamento alvo H(x)
y = H(x)
Rede residual: Aprender mapeamento residual F(x) = H(x) - x
y = F(x) + x
Por que a Conexão Residual Funciona?
1. Rodovia de Gradientes
Considere o gradiente na retropropagação:
∂L/∂x = ∂L/∂y × ∂y/∂x = ∂L/∂y × (1 + ∂F(x)/∂x)
A chave está no +1. Mesmo se ∂F(x)/∂x for muito pequeno ou zero, o gradiente ainda pode ser passado de volta diretamente através do +1.
É como construir uma "rodovia de gradientes", permitindo que gradientes fluam livremente da camada de saída de volta para a camada de entrada.
2. Mapeamento Identidade é Mais Fácil de Aprender
Se a solução ótima está próxima do mapeamento identidade (H(x) aproximadamente igual a x), então:
- Rede tradicional: Precisa aprender H(x) = x, pode ser difícil
- Rede residual: Só precisa aprender F(x) aproximadamente igual a 0, relativamente fácil
Inicializando pesos em zero ou próximo de zero, o bloco residual naturalmente tende ao mapeamento identidade.
3. Efeito de Ensemble
Uma ResNet profunda pode ser vista como um ensemble implícito de muitas redes rasas. Se há n blocos residuais, a informação pode fluir por 2^n caminhos diferentes.
Este efeito de ensemble aumenta a robustez do modelo.
O Avanço da ResNet no ImageNet
A ResNet alcançou resultados impressionantes na competição ImageNet de 2015:
| Profundidade | Taxa de erro Top-5 |
|---|---|
| VGG-19 (sem residual) | 7.3% |
| ResNet-34 | 5.7% |
| ResNet-152 | 4.5% |
| Nível humano | ~5.1% |
Uma ResNet de 152 camadas não só pode ser treinada, mas é muito melhor que a VGG de 19 camadas. Isto prova que a conexão residual realmente resolve o problema de treinamento de redes profundas.
ResNet de 40 Camadas do AlphaGo Zero
Por que Escolher 40 Camadas?
A DeepMind testou ResNets de diferentes profundidades:
| Número de Blocos Residuais | Total de Camadas | Classificação ELO |
|---|---|---|
| 5 | 11 | Linha de base |
| 10 | 21 | +200 |
| 20 | 41 | +400 |
| 40 | 81 | +500 |
Redes mais profundas são de fato mais fortes, mas o benefício marginal diminui. O AlphaGo Zero usa 20 ou 40 blocos residuais:
- AlphaGo Zero (versão do paper): 40 blocos residuais, 256 canais
- Versão compacta: 20 blocos residuais, 256 canais
A configuração de 40 camadas alcança um bom equilíbrio entre força de jogo e custo de treinamento.
Configuração Específica
A configuração da ResNet do AlphaGo Zero é a seguinte:
Entrada: 17 × 19 × 19
↓
Camada conv: 3×3, 256 canais, BN, ReLU
↓
Bloco residual ×40:
├─ Camada conv: 3×3, 256 canais, BN, ReLU
├─ Camada conv: 3×3, 256 canais, BN
└─ Skip connection + ReLU
↓
Policy Head / Value Head
Estimativa de Parâmetros
| Componente | Parâmetros (aprox.) |
|---|---|
| Convolução de entrada | 17 × 3 × 3 × 256 ≈ 39K |
| Por bloco residual | 2 × 256 × 3 × 3 × 256 ≈ 1.2M |
| 40 blocos residuais | 40 × 1.2M ≈ 47M |
| Policy Head | ~1M |
| Value Head | ~0.2M |
| Total | ~48M |
Aproximadamente 48 milhões de parâmetros, uma rede neural de tamanho médio pelos padrões modernos.
O Papel do Batch Normalization
Cada camada convolucional é seguida por Batch Normalization (BN), que é crucial para a estabilidade do treinamento:
1. Normalização de Ativações
BN normaliza as ativações de cada camada para média 0 e variância 1:
x_hat = (x - μ_B) / sqrt(σ_B² + ε)
y = γ × x_hat + β
Onde γ e β são parâmetros aprendíveis.
2. Mitigação do Internal Covariate Shift
Em redes profundas, a distribuição de entrada de cada camada muda à medida que os parâmetros das camadas anteriores são atualizados. BN mantém a distribuição de entrada de cada camada estável, acelerando a convergência do treinamento.
3. Efeito de Regularização
BN usa estatísticas do mini-batch durante o treinamento, introduzindo aleatoriedade, tendo um leve efeito de regularização.
Comparação com Outras Arquiteturas
vs. CNN do AlphaGo Original
| Característica | AlphaGo Original | AlphaGo Zero |
|---|---|---|
| Tipo de arquitetura | CNN padrão | ResNet |
| Profundidade | 13 camadas | 41-81 camadas |
| Conexão residual | Não | Sim |
| Número de redes | 2 (separadas) | 1 (compartilhada) |
| BN | Não | Sim |
vs. Rede Estilo VGG
VGG foi a arquitetura vice-campeã do ImageNet 2014, usando convoluções 3×3 empilhadas:
| Característica | VGG | ResNet |
|---|---|---|
| Profundidade máxima treinável | ~19 camadas | 152+ camadas |
| Fluxo de gradiente | Diminui por camada | Tem rodovia |
| Dificuldade de treinamento | Difícil em profundidade | Profundo é treinável |
vs. Inception / GoogLeNet
Inception usa convoluções multi-escala em paralelo:
| Característica | Inception | ResNet |
|---|---|---|
| Destaques | Características multi-escala | Empilhamento profundo |
| Complexidade | Maior | Simples |
| Aplicabilidade ao Go | Média | Excelente |
O design simples da ResNet é mais adequado para Go, uma tarefa que requer raciocínio profundo.
vs. Transformer
A arquitetura Transformer proposta em 2017 teve grande sucesso em NLP. Alguns tentaram aplicar Transformers ao Go:
| Característica | ResNet | Transformer |
|---|---|---|
| Viés indutivo | Localidade (convolução) | Atenção global |
| Codificação posicional | Implícita (convolução) | Explícita |
| Desempenho em Go | Excelente | Viável mas não supera ResNet |
| Eficiência computacional | Maior | Menor (O(n²)) |
Para problemas com estrutura espacial clara como Go, o viés indutivo de CNN/ResNet é mais apropriado.
Análise Aprofundada das Escolhas de Design
Por que usar convoluções 3×3?
O AlphaGo Zero usa convoluções 3×3 em toda parte, em vez de kernels maiores:
- Eficiência de parâmetros: Duas convoluções 3×3 têm campo receptivo igual a uma 5×5, mas menos parâmetros (18 vs 25)
- Rede mais profunda: Com a mesma quantidade de parâmetros, pode empilhar mais camadas
- Mais não-linearidade: ReLU entre cada camada aumenta a expressividade
Por que usar 256 canais?
256 canais é uma escolha empírica:
- Muito poucos (como 64): Expressividade insuficiente, não consegue capturar padrões complexos
- Muitos (como 512): Parâmetros dobram, custo de treinamento aumenta muito, mas melhoria de força é limitada
Experimentos posteriores do KataGo mostraram que o número de canais pode ser ajustado de acordo com os recursos de treinamento:
- Baixos recursos: 128 canais, 20 blocos
- Altos recursos: 256 canais, 40 blocos
- Recursos ainda maiores: 384 canais, 60 blocos
Por que Policy Head usa Softmax e Value Head usa Tanh?
Policy Head: Softmax
Jogar é um problema de classificação — escolher uma entre 361 posições (mais Pass). A saída Softmax satisfaz:
- Todas as probabilidades não negativas: π_i >= 0
- Soma das probabilidades igual a 1: Σπ_i = 1
Isto é consistente com a definição de distribuição de probabilidade.
Value Head: Tanh
A taxa de vitória é um problema de regressão — prever um valor contínuo. O intervalo de saída do Tanh é [-1, 1]:
- Limitado: Não produz valores extremos
- Simétrico: Vitória e derrota tratadas simetricamente
- Diferenciável: Conveniente para cálculo de gradiente
Usar Tanh em vez de saída ilimitada (como camada linear) pode prevenir instabilidade no treinamento.
Detalhes de Treinamento
Função de Perda
A perda total do AlphaGo Zero é a soma de três termos:
L = L_policy + L_value + L_reg
Policy Loss
Usa perda de entropia cruzada, fazendo a saída da rede se aproximar das probabilidades de busca MCTS:
L_policy = -Σ π_MCTS(a) × log(π_net(a))
Onde:
- π_MCTS(a) é a probabilidade de busca MCTS para a ação a
- π_net(a) é a probabilidade de saída da rede
Value Loss
Usa Erro Quadrático Médio (MSE), fazendo a saída da rede se aproximar do resultado real:
L_value = (v_net - z)²
Onde:
- v_net é a taxa de vitória prevista pela rede
- z é o resultado real da partida (+1 ou -1)
Regularization Loss
Usa regularização L2 para prevenir overfitting:
L_reg = c × ||θ||²
Onde c é o coeficiente de regularização e θ são os parâmetros da rede.
Configuração do Otimizador
| Parâmetro | Valor |
|---|---|
| Otimizador | SGD + Momentum |
| Momentum | 0.9 |
| Taxa de aprendizado inicial | 0.01 |
| Decaimento da taxa de aprendizado | Pela metade a cada X passos |
| Batch Size | 32 × 2048 = 64K (distribuído) |
| Coeficiente de regularização L2 | 1e-4 |
Data Augmentation
O tabuleiro de Go tem 8 simetrias (4 rotações × 2 reflexões). Durante o treinamento, cada posição pode produzir 8 amostras de treinamento equivalentes.
Isto aumenta os dados de treinamento efetivos em 8 vezes, sem necessidade de auto-jogo adicional.
Considerações de Implementação
Otimização de Memória
Treinar uma ResNet de 40 camadas requer muita memória:
- Forward pass: Precisa armazenar ativações de cada camada (para backpropagation)
- Backward pass: Precisa armazenar gradientes
Estratégias de otimização:
- Gradient Checkpointing: Armazenar apenas algumas ativações, recalcular quando necessário
- Treinamento de precisão mista: Usar FP16 para reduzir uso de memória
- Treinamento distribuído: Distribuir batch entre múltiplas GPUs/TPUs
Otimização de Inferência
Durante inferência, não são necessárias estatísticas de mini-batch do BN, pode usar médias móveis acumuladas durante o treinamento:
x_hat = (x - μ_moving) / sqrt(σ_moving² + ε)
Isto torna a inferência mais rápida e os resultados determinísticos.
Quantização e Compressão
O deployment pode comprimir ainda mais a rede:
- Quantização de pesos: FP32 → INT8, memória reduzida em 4×
- Poda: Remover conexões de pesos pequenos
- Destilação de conhecimento: Usar rede grande para treinar rede pequena
Correspondência de Animações
Conceitos centrais discutidos neste artigo e números de animação:
| Número | Conceito | Correspondência Física/Matemática |
|---|---|---|
| 🎬 E3 | Rede de cabeça dupla | Aprendizado multi-tarefa |
| 🎬 D12 | Conexão residual | Rodovia de gradientes |
| 🎬 D8 | Rede neural convolucional | Campo receptivo local |
| 🎬 D10 | Batch Normalization | Normalização de distribuição |
Leitura Adicional
- Artigo anterior: Visão Geral do AlphaGo Zero — Por que não precisa de registros de partidas humanas
- Próximo artigo: O Processo de Treinamento do Zero — Evolução detalhada dos Dias 0-3
- Aprofundamento técnico: CNN e Go Combinados — Por que CNN é adequada para tabuleiros
Referências
- Silver, D., et al. (2017). "Mastering the game of Go without human knowledge." Nature, 550, 354-359.
- He, K., et al. (2016). "Deep Residual Learning for Image Recognition." CVPR 2016.
- Ioffe, S., & Szegedy, C. (2015). "Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift." ICML 2015.
- Caruana, R. (1997). "Multitask Learning." Machine Learning, 28(1), 41-75.
- Veit, A., et al. (2016). "Residual Networks Behave Like Ensembles of Relatively Shallow Networks." NeurIPS 2016.