🤖 AI

NeuronFabric: A Software Reference Architecture for On-Chip Transformer Training with Local Adam

Este artigo apresenta o NeuronFabric, uma arquitetura de referência de software e um protótipo em C# para treinamento de transformer em chip com atualizações Adam locais, o qual valida a correção numérica e demonstra que uma configuração BF16W (pesos em BF16 com momentos do otimizador em FP32) reduz os requisitos de memória para caber dentro da capacidade de BRAM de um dispositivo Xilinx ZCU102 para futuras implementações em FPGA e ASIC.

Autores originais: Evgeny Ukladchikov

Publicado 2026-06-16

📖 6 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Evgeny Ukladchikov

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

A Grande Ideia: Uma Máquina de Aprendizado Autossuficiente

Imagine que você está tentando ensinar um robô a escrever Shakespeare. Atualmente, a maioria do treinamento de IA funciona como um estudante com um professor muito lento.

O estudante (o chip) lê uma frase e tenta adivinhar a próxima palavra.
O estudante comete um erro e calcula como ele errou.
O estudante tem que correr até o escritório do professor (o computador hospedeiro) para buscar o gabarito.
O professor atualiza as notas do estudante, e o estudante corre de volta para tentar novamente.

Esse "ir e voltar" é lento e desperdiça muita energia.

O NeuronFabric propõe uma ideia diferente: Um estudante que guarda o gabarito no próprio bolso.
Neste sistema, o chip não apenas adivinha; ele calcula seus próprios erros, consulta suas próprias notas e atualiza sua própria memória instantaneamente, tudo sem nunca sair da sala. O artigo prova que essa matemática de "autoatualização" funciona corretamente em software, preparando o terreno para um futuro chip que possa fazer isso fisicamente.

Conceitos-Chave Explicados

1. O "Adam Local" (O Mecanismo de Autocorreção)

No padrão da IA, o "otimizador" (a parte que corrige os erros) geralmente vive em um computador separado. O NeuronFabric coloca o otimizador dentro de cada neurônio individual.

Analogia: Imagine uma sala de aula onde cada aluno tem seu próprio quadro branco particular. Quando erram uma questão, eles não esperam o professor vir até eles. Eles imediatamente apagam o erro, escrevem a correção e seguem em frente.
A Alegação do Artigo: Os autores construíram uma versão de software disso em C# (uma linguagem de programação). Eles provaram que, quando cada neurônio se atualiza localmente, a matemática ainda funciona, e o robô aprende a escrever textos coerentes.

2. O Truque "BF16W" (A Estratégia da Mochila)

Para caber este sistema de autoatualização em um chip pequeno (como um FPGA), a memória é o maior problema.

O Problema: Normalmente, para aprender, um robô precisa carregar três mochilas pesadas para cada pedaço de conhecimento:
1. O próprio conhecimento (Pesos/Weights).
2. Um registro de quão rápido ele aprendeu (Momento/Momentum).
3. Um registro de quanto ele variou (Variância/Variance).
- Se as mochilas forem muito pesadas, o robô não consegue carregar tudo em seu pequeno quarto (SRAM).
A Solução (BF16W): Os autores perceberam que poderiam encolher a mochila do "Conhecimento". Em vez de carregar uma mochila pesada e de alta precisão (32 bits), eles carregam uma leve e um pouco menos precisa (16 bits).
O Resultado: Eles mantiveram os registros de aprendizado pesados e precisos, mas tornaram a mochila do "conhecimento" metade do tamanho.
- Analogia: É como arrumar as malas para uma viagem. Você mantém suas joias caras e frágeis (as estatísticas de aprendizado) em uma caixa pesada e segura. Mas você troca seu casaco de inverno pesado (os pesos) por uma jaqueta fina e leve. Você economiza espaço suficiente na mala para caber seu saco de dormir (os buffers de ativação) para não ter que dormir no chão.
A Alegação do Artigo: Este truque economizou espaço suficiente para encaixar todo o sistema de aprendizado em um chip de médio porte (ZCU102) sem precisar se conectar à memória externa.

3. O "Orçamento de Vocabulário" (Espaço para o Pensamento)

Os autores descobriram uma armadilha oculta ao construir modelos de IA pequenos.

A Armadilha: Se você tem um orçamento de memória muito pequeno e tenta ensinar ao robô um dicionário enorme (vocabulário), o dicionário ocupa quase todo o espaço. Não sobra espaço para o robô realmente pensar ou aprender gramática.
Analogia: Imagine que você tem um caderno pequeno. Se você gastar 90% das páginas apenas escrevendo o alfabeto e um dicionário, restará apenas algumas páginas para escrever uma história. A história será um absurdo.
A Correção: Os autores usaram uma abordagem de "nível de byte" (tratando cada caractere como um único token) e um vocabulário pequeno (256 caracteres). Isso significou que o "dicionário" ocupou apenas um pequeno canto do caderno, deixando muito espaço para o robô aprender a escrever frases de Shakespeare.
A Alegação do Artigo: Eles mostraram que, se você não gerenciar esse "imposto do vocabulário", os modelos pequenos falham em fazer sentido, não importa quão boa seja a matemática.

4. O Objetivo "Sem Hospedeiro" (O Chip Independente)

O objetivo final desta pesquisa é um chip que não precise de um computador (CPU) para dizer a ele como aprender.

Estado Atual: O artigo descreve um protótipo de software. Ele roda em um computador padrão para provar que a matemática está correta.
Estado Futuro: O objetivo é colocar essa exata mesma lógica de software em um chip físico (FPGA).
A Alegação: Se eles conseguirem fazer o chip físico realizar isso, ele será capaz de treinar a si mesmo com novos dados sem nunca enviar dados para um servidor ou esperar que um computador atualize seus pesos. Seria uma máquina de aprendizado verdadeiramente "no chip" (on-chip).

O Que Eles Realmente Alcançaram?

Construíram uma prova de conceito: Escreveram um programa em C# que treina um pequeno modelo de IA (334.000 parâmetros) inteiramente por conta própria.
Provaram que a matemática funciona: A IA aprendeu a gerar textos que parecem Shakespeare (ex: "HAMLET: Break him of him..."). Não estava perfeito, mas era coerente.
Provaram que a matemática da memória funciona: Calcularam exatamente quanto espaço é necessário e mostraram que, com o truque da "jaqueta leve" (BF16W), todo o sistema cabe em um chip específico (ZCU102) com espaço de sobra.
O que eles NÃO fizeram: Eles não construíram o chip físico ainda. Eles não mediram a velocidade ou o consumo de energia do chip. Eles apenas mediram o software rodando em um computador normal.

Resumo

Pense neste artigo como o projeto e a simulação do motor de um novo tipo de carro.
O autor diz: "Eu projetei um motor onde a injeção de combustível e as velas de ignição conversam diretamente entre si sem um computador central. Eu construí uma simulação de computador deste motor, e ele funciona perfeitamente. Também calculei que este motor é pequeno o suficiente para caber em um carro compacto. Agora, preciso construir o motor de metal real para provar que ele funciona."

O artigo é a prova de que o design é sólido; o chip físico é o próximo passo.

Resumo Técnico: NeuronFabric

Declaração do Problema

Os aceleradores neurais publicamente documentados atualmente separam, de forma geral, a fase de computação da atualização do estado do otimizador. Chips focados apenas em inferência (ex: Groq LPU, Apple ANE, IBM NorthPole) carecem de computação de gradiente em chip, enquanto aceleradores de treinamento (ex: Cerebras, Tenstorrent) tipicamente delegam as atualizações de pesos para uma CPU host ou GPU externa. Essa separação arquitetural cria gargalos significativos:

Tráfego de Pesos: A inferência exige o carregamento de todos os pesos de uma memória externa (HBM) para cada passagem de forward.
Latência de Treinamento: O chip que computa os gradientes não os aplica; as atualizações são orquestradas separadamente, muitas vezes exigindo movimentação de dados para fora do chip.
Limitações de Aprendizado Contínuo: Chips de inferência não podem atualizar pesos a partir de novos dados sem recarregar o modelo inteiro de um cluster externo, um processo que leva de minutos a horas.

O artigo propõe que um chip de silício onde cada neurônio detém seus próprios pesos e executa o otimizador Adam localmente poderia minimizar o tráfego fora do chip e permitir um treinamento verdadeiramente em chip. No entanto, antes de se comprometer com o silício, a validade matemática e a correção numérica de tal arquitetura de "Adam local" devem ser estabelecidas.

Metodologia

Os autores desenvolveram o NeuronFabric, uma arquitetura de referência de software completa implementada em C# sem frameworks externos de aprendizado de máquina. O sistema é projetado para que cada abstração de software mapeie diretamente para um bloco de hardware (ex: NeuronCore para BRAM, Forward() para cadeias DSP48).

Arquitetura Central:

Adam Local: Cada NeuronCore armazena seu próprio vetor de pesos $w$ e viés $b$ . Durante a passagem de backward, ele computa gradientes e atualiza os pesos in-place usando o algoritmo Adam. Não há um barramento de pesos entre os núcleos.
Configuração do Modelo: Um transformer autorregressivo de 334K parâmetros (Pre-LN) treinado no corpus de Shakespeare.
- Dimensões: Embedding $d=88$ , 4 cabeças, Feedforward $f=264$ , 4 camadas.
- Vocabulário: 256 (nível de byte).
- Técnicas: Atribuição de pesos (weight tying — a projeção de saída reutiliza a matriz de embedding) para economizar parâmetros.

Esquema de Precisão BF16W:
Para lidar com as rigorosas restrições de SRAM em FPGAs de treinamento, os autores introduziram o BF16W (Brain Floating Point 16 Weights).

Armazenamento: Os pesos são armazenados como BF16 (2 bytes).
Computação: Os pesos são convertidos para FP32 para computação de forward/backward e atualizações de momentos do Adam.
Momentos: Os primeiros ( $m$ ) e segundos ( $v$ ) momentos do Adam permanecem em FP32 (4 bytes cada) para garantir a estabilidade.
Atualização: Após o passo do Adam, o peso FP32 atualizado é arredondado de volta para BF16 e gravado no armazenamento.

Restrição de Orçamento de Vocabulário:
O artigo identifica uma restrição crítica para modelos de poucos parâmetros: a tabela de embedding ( $|V| \times d$ ) consome uma parcela desproporcional do orçamento de parâmetros ("imposto do vocabulário"), deixando capacidade insuficiente para as camadas do transformer aprenderem padrões estruturais. Isso foi quantificado através de três domínios, mostrando que quando a capacidade de raciocínio restante ( $P_{reason}$ ) cai abaixo de ~20K, a geração de texto coerente falha.

Principais Contribuições

Implementação de Referência de Software: Uma implementação completa em C#, livre de frameworks, de um transformer com backpropagation total e atualizações de Adam local, executando treinamento, avaliação e checkpointing em um único binário.
Validação do BF16W: Demonstração de que armazenar pesos em BF16 enquanto mantém os momentos em FP32 reduz o uso de SRAM de 12 bytes/parâmetro para 10 bytes/parâmetro com uma penalidade de convergência negligível (+0.020 na perda de validação em Shakespeare).
Quantificação do Orçamento de Vocabulário: Evidência empírica mostrando que, para um hardware de orçamento fixo, a tabela de embedding domina o modelo, necessitando de vocabulários menores ou arquiteturas de múltiplos chips especializados (ex: chips de embedding separados).
Alvo de Viabilidade para FPGA: Uma configuração concreta (modelo 334K BF16W) que cabe inteiramente nos 4.0 MB de BRAM on-chip de uma FPGA Xilinx ZCU102, deixando 660 KB de margem para buffers de ativação, sem exigir acesso ao DDR durante o treinamento.

Resultados

O sistema foi validado em uma máquina Windows 11 (AMD Ryzen 9 9900X CPU, NVIDIA RTX 4090 GPU) usando o corpus de Shakespeare (80K amostras).

Corretude: Verificações numéricas de gradiente (diferenças finitas vs. gradientes analíticos) passaram para todos os componentes, confirmando a corretude matemática da implementação de Adam local.
Convergência:
- GPU FP32 (Oracle): Alcançou uma perda de validação de 1.5224.
- CPU BF16W: Alcançou uma perda de validação de 1.5426.
- O gap de +0.020 é atribuído à diferença de precisão entre o armazenamento de pesos em BF16 e a computação em FP32.
Qualidade Generativa: O modelo produziu texto coerente em nível de caractere com estruturas de diálogo e padrões de nomes de personagens reconhecíveis de Shakespeare, confirmando que o loop de treinamento converge para uma solução funcional.
Eficiência de SRAM:
- FP32 Adam (12 bytes/param): 4.00 MB total (preenche exatamente a BRAM da ZCU102, deixando zero espaço para ativações).
- BF16W Adam (10 bytes/param): 3.34 MB total (deixa 660 KB livres para ativações e estado de controle).

Significância e Alegações

O artigo declara explicitamente seu escopo modesto: NeuronFabric é um protótipo de pesquisa, não um acelerador de produção. Ele não contém medições de FPGA ou resultados de fechamento de tempo (timing closure).

A principal significância do artigo reside em:

Estabelecer o Estado da Arte (Prior Art): Serve como uma divulgação arquitetural pública e referência de software para estabelecer a arquitetura de "atualização de Adam local" como prior art para futuras implementações em FPGA/ASIC.
Prova de Conceito: Demonstra que a matemática funciona e que os números estão corretos para um transformer que treina inteiramente em chip com estado de otimizador local, sem uma CPU host no loop de atualização.
Definição do Caminho a Seguir: Estabelece o modelo 334K BF16W de Shakespeare como um alvo falsificável para futuras implementações em FPGA. Se a mesma curva de perda puder ser alcançada na FPGA sem intervenção do host, a viabilidade do treinamento de transformer em chip torna-se um fato mensurável em vez de uma projeção de software.

Os autores concluem que o próximo passo imediato é implementar este loop de treinamento específico na FPGA ZCU102 para verificar se os resultados de software se traduzem em hardware, validando assim o paradigma de treinamento "sem CPU host".