Hawkeye: Reproducing GPU-Level Non-Determinism

Resumo Técnico: HAWKEYE

1. O Problema: Não-Determinismo em ML e a Falta de Verificabilidade

O aprendizado de máquina (ML) moderno, especialmente em grandes modelos (LLMs), depende massivamente de hardware acelerado, como as Tensor Cores da NVIDIA, para realizar multiplicações matriciais de alto desempenho. No entanto, esses hardwares introduzem não-determinismo nos resultados computacionais devido a:

• Arredondamento e Precisão: Estratégias de arredondamento específicas e tratamento de números subnormais.
• Ordem de Acumulação: A aritmética de ponto flutuante não é associativa. A ordem em que os produtos parciais são somados afeta o resultado final devido aos erros de arredondamento intermediários.
• Implementação de Hardware: Diferentes arquiteturas (Ampere, Hopper, Lovelace) e formatos de precisão (FP16, BF16, FP8) processam as mesmas instruções de maneiras ligeiramente diferentes.

Impacto: Isso impede a Verificação de ML. Se um auditor tentar reexecutar um cálculo em uma CPU para verificar se um provedor de serviço (cloud) executou o treinamento ou inferência corretamente, os resultados raramente coincidirão bit a bit com a execução original na GPU, mesmo que ambos estejam corretos. As soluções atuais ou introduzem sobrecarga computacional excessiva, degradam a qualidade do modelo ou dependem de heurísticas sem garantias formais.

2. Metodologia: A Abordagem do Hawkeye

O Hawkeye é um sistema projetado para reproduzir com precisão absoluta (bit-exact) as operações de multiplicação matricial de Tensor Cores da NVIDIA em uma CPU, sem modificar os kernels originais da GPU. A metodologia baseia-se em uma sequência sistemática de testes direcionados para "engenharia reversa" do comportamento interno do hardware.

Etapas Principais da Metodologia:

1. Caracterização via CUDA/PTX: Os autores implementam kernels CUDA personalizados que invocam instruções de hardware (MMA) via assembly inline (PTX) para isolar o comportamento das Tensor Cores.
2. Testes Direcionados (Target Tests): O framework executa uma série de testes matemáticos cuidadosamente construídos para descobrir:
   • Ordem de Soma: Identifica a estrutura hierárquica de agrupamento dos produtos parciais (ex: como 16 produtos são somados).
   • Precisão Interna: Determina quantos bits de mantissa são usados internamente durante a acumulação (ex: 24 bits em Ampere vs. 25 bits em Hopper).
   • Modo de Arredondamento: Detecta se o hardware usa arredondamento para o par mais próximo, para zero, ou truncamento durante o alinhamento de expoentes e conversão final.
   • Normalização: Identifica se a normalização ocorre imediatamente após a multiplicação ou é adiada até a acumulação.
   • Comportamento de Subnormais: Analisa como números subnormais são tratados e se perdem precisão antes da soma.
3. Simulação: Os resultados desses testes são codificados em um simulador de software que replica exatamente a pipeline numérica descoberta.

3. Contribuições Chave

• Reprodução Bit-Absoluta: O Hawkeye consegue replicar os resultados das Tensor Cores da NVIDIA em uma CPU com 100% de precisão bit a bit, eliminando a ambiguidade entre "erro de execução" e "não-determinismo de hardware".
• Descoberta de Detalhes Ocultos: O trabalho revela detalhes de implementação que não são documentados publicamente, como:
  • Ampere (FP16): Usa uma acumulação em dois estágios (primeiro 8 produtos + acumulador, depois os outros 8) com precisão interna de 24 bits e arredondamento para zero.
  • Hopper (FP16): Usa uma acumulação unificada de todos os 16 produtos com precisão interna de 25 bits.
  • BF16: Permite que valores intermediários excedam temporariamente o intervalo representável de FP32 antes de serem convertidos, lidando com overflow via saturação para infinito apenas no resultado final.
• Independência de Arquitetura: O framework foi testado e validado em múltiplas arquiteturas (Ampere, Hopper, Lovelace) e formatos de dados (FP16, BF16, FP8).

4. Resultados Empíricos

• Precisão: Em testes com 100.000 multiplicações matriciais aleatórias de tamanho 16x16, o Hawkeye alcançou uma taxa de sucesso de 100% na replicação bit-exact entre a execução simulada na CPU e a execução real na GPU.
• Desempenho: Embora a execução na CPU seja mais lenta que na GPU, o artigo argumenta que, para auditoria, a velocidade não é o fator crítico, pois o auditor precisa apenas reexecutar o cálculo uma vez para verificar a integridade.
• Validação: O código fonte e os simuladores foram disponibilizados publicamente, permitindo que terceiros validem os resultados.

5. Significado e Impacto

O Hawkeye representa um avanço fundamental para a confiança e auditoria em ML:

• Auditoria de Terceiros: Permite que auditores verifiquem se um provedor de serviços de ML (como AWS, Azure, Google) está realmente executando o modelo solicitado, sem atalhos (ex: treinar menos épocas) ou backdoors, sem depender da reexecução na mesma GPU.
• Solução para Não-Determinismo: Oferece uma solução prática para o problema de não-determinismo sem sacrificar a precisão numérica ou exigir a desativação de recursos de hardware (o que causaria lentidão extrema).
• Base para Verificação Formal: Estabelece a base necessária para integrar a verificação de ML em sistemas de prova criptográfica e pipelines de treinamento distribuído, onde a reprodutibilidade é um requisito de segurança.

Em resumo, o Hawkeye transforma a "caixa preta" das operações de ponto flutuante em GPUs em um processo transparente e reproduzível, permitindo que a verificação de modelos de IA seja feita com rigor matemático e sem ambiguidades.