Uma plataforma, 1.930 algoritmos, todos os backends: como construímos a stack completa para IA discreta

Uma plataforma, 1.930 algoritmos, todos os backends: como construímos a stack completa para IA discreta

O problema da fragmentação

O seu ambiente de desenvolvimento de IA está fragmentado.

Faz protótipos em PyTorch porque os investigadores preferem-no. Implementa com TensorFlow porque as equipas de produção querem as ferramentas da Google. Escreve kernels CUDA para GPUs NVIDIA. Faz portes para ROCm para hardware AMD. Reescreve tudo para dispositivos móveis com TensorFlow Lite ou Core ML. Usa ONNX para converter entre frameworks, esperando que nada avarie. Mantém bases de código separadas para cloud, edge e browser.

Dez ferramentas diferentes. Milhares de dependências. Pesadelos de compatibilidade de versões. Alterações disruptivas em cada ciclo de lançamento.

Atualizar o PyTorch? Espera que a tua versão de CUDA corresponda. Queres implementar em AMD? Reescreve os teus kernels. Precisas de inferência no browser? Começa do zero com WebAssembly. Mudar de GPUs NVIDIA para AMD? Boa sorte a portar essa base de código. Implementar em FPGAs? Aprende um toolchain completamente diferente.

Esta fragmentação não é um acidente. É o resultado natural de cada framework otimizar para o seu caso de uso específico enquanto ignora a interoperabilidade. O PyTorch é excelente para investigação, mas trata a implementação como uma reflexão tardia. O TensorFlow tem como alvo a produção, mas a experiência de investigação é dolorosa. O CUDA prende-te ao hardware NVIDIA. Cada ferramenta resolve um problema enquanto cria mais três.

Há uma forma melhor.

Dweve Core: A plataforma completa para IA discreta

O Dweve Core é uma plataforma unificada para construir redes neuronais discretas de precisão binária a 8 bits. Não é outro framework. É uma substituição completa para a tua stack fragmentada.

Uma instalação. Uma API. Uma base de código. Implementação automática em CPU, GPU, FPGA, WebAssembly, onde quer que precises de executar.

Eis o que significa completo:

1.930 algoritmos que cobrem todas as operações de que precisas:

• 415 primitivas: Operações atómicas como XNOR, popcount, manipulação de bits, quantização, conversão entre formatos
• 500 kernels: Operações compostas otimizadas para padrões comuns
• 191 camadas: Blocos de construção completos de redes neuronais (convolução, densa, normalização, ativação, atenção)
• 674 algoritmos: Métodos de alto nível incluindo transformações, procedimentos de treino, pesquisa evolucionária, destilação de conhecimento
• 30 utilitários de interop: Pontes de ponto flutuante opcionais para abordagens híbridas
• 120 arquiteturas de modelos: Modelos de rede pré-otimizados de ResNets a Transformers

Isto não é um subconjunto. É completude matemática. Analisámos todas as principais arquiteturas de redes neuronais e construímos todas as operações de que necessitam, otimizadas para computação discreta a partir de primeiros princípios.

6 backends com compilação automática:

• SIMD CPU: Kernels otimizados à mão para x86 e ARM com deteção automática de ISA (SSE2, AVX2, AVX-512, NEON, SVE/SVE2)
• CUDA: Otimização para GPUs NVIDIA com primitivas de nível warp e utilização de Tensor Core
• Rust-HDL: Síntese direta de FPGA e ASIC a partir de descrições de algoritmos
• WebAssembly: Inferência no browser com suporte SIMD128 para processamento no dispositivo em conformidade com o RGPD
• ROCm: Otimização para GPUs AMD com operações de nível wavefront
• Metal: Otimização para Apple Silicon usando arquitetura de memória unificada

6 larguras de bits com precisão adaptativa:

• Binário (1 bit): Eficiência máxima com compressão de 16× em relação a FP16
• Ternário: {-1, 0, +1} com esparsidade explícita
• 2 bits: Quatro níveis para compressão equilibrada
• 3 bits: Oito níveis para camadas sensíveis à qualidade
• 4 bits: Dezasseis níveis aproximando-se da qualidade FP16
• 8 bits: Precisão quase total para operações críticas

A plataforma aprende a largura de bits ideal por camada durante o treino através de seleção baseada em gradientes. Não heurísticas. Não suposições. Otimização real baseada em como a precisão melhora com precisão adicional.

Escreva uma vez, implemente em qualquer lugar

A plataforma usa uma API Rust declarativa. Você descreve o que quer, e o compilador descobre como executá-la de forma otimizada no seu hardware de destino.

Exemplo de definição de rede:

let model = NetworkBuilder::new()
    .input(BinaryTensor::new([1024, 784]))
    .dense(784, 512, activation=BinaryActivation::Sign)
    .dense(512, 256, activation=BinaryActivation::Sign)
    .output(256, 10)
    .build();

É isso. Escreva isto uma vez, e o compilador gera automaticamente implementações otimizadas para cada backend.

O pipeline de compilação funciona através de quatro níveis:

Nível 1: IR de Rede Neural - A sua descrição de rede de alto nível é analisada num grafo computacional com operações, fluxo de dados e hiperparâmetros.

Nível 2: Otimização de Grafo - Passagens padrão do compilador eliminam código morto, dobram constantes, deduplicam expressões e fundem operações sequenciais. Uma camada densa seguida de normalização de lote e ativação torna-se um único kernel fundido que carrega a entrada uma vez e produz a saída final.

Nível 3: Dialeto BitOps - O grafo desce para operações ao nível do bit explicitamente tipadas com precisão. Esta representação intermédia é independente de hardware, mas próxima das operações reais da máquina. Construído sobre a infraestrutura MLIR (Multi-Level Intermediate Representation) para otimização de nível industrial.

Nível 4: Redução de Hardware - A geração final de código produz implementações específicas da plataforma. Para AVX-512, as operações de bit tornam-se instruções VPXORQ e VPOPCNTQ. Para CUDA, tornam-se intrínsecos ao nível do warp com acesso coalescido à memória. Para FPGA, tornam-se portas XNOR e árvores de somadores sintetizadas em Verilog.

O mesmo código-fonte corre no CPU do seu portátil durante o desenvolvimento, é implementado em GPUs na nuvem em produção e compila para FPGAs para inferência determinística em tempo real. Sem tradução. Sem portabilidade. Sem código específico da plataforma.

Construído para os clientes criarem

O Dweve Core alimenta o Dweve Loom, o nosso sistema de raciocínio baseado em restrições. Mas não é só para nós. É uma plataforma completa para qualquer pessoa que construa redes neurais discretas.

Pode construir:

• Arquiteturas personalizadas usando os 191 tipos de camadas e 674 algoritmos
• Modelos específicos de domínio otimizados para os seus requisitos exatos
• Abordagens híbridas que combinam computação discreta e contínua através dos 30 utilitários de interoperabilidade
• Métodos de treino inovadores usando pesquisa evolutiva, destilação de conhecimento ou estimadores de gradiente personalizados

A plataforma fornece:

Infraestrutura de treino completa: Seis variantes de estimador de passagem direta para fluxo de gradiente binário/ternário. Otimizadores conscientes de binarização que mantêm pesos de precisão total internamente enquanto binarizam para passagens diretas. Seleção automática de largura de bits através de otimização baseada em gradiente. Destilação progressiva em múltiplas etapas de FP32 até INT8, INT4, ternário e binário.

Otimização automática de hardware: Deteção em tempo de execução das capacidades da CPU (CPUID em x86, registos do sistema em ARM) e despacho automático para a implementação SIMD mais rápida disponível. Variantes de kernel de GPU selecionadas com base no tamanho do warp, memória partilhada e contagem de registos. Síntese FPGA com inserção automática de registos de pipeline com base em restrições de temporização.

Quantização flexível: Quantização simétrica e assimétrica com escalas por tensor, por canal ou por grupo. Quantização dinâmica com deteção de intervalo em tempo de execução ou quantização estática com escalas pré-calculadas a partir de dados de calibração. Cálculo de escalas otimizado por MSE e baseado em divergência KL para perda mínima de precisão.

Porque é que a computação discreta é importante

As redes neuronais tradicionais calculam tudo em vírgula flutuante de 16 ou 32 bits e depois tomam decisões discretas no final. Nós operamos diretamente no espaço discreto, de binário a 8 bits, eliminando a computação contínua intermédia.

Isto não é simples quantização de modelos existentes. A estrutura foi arquitetada desde os primeiros princípios em torno de operações discretas:

Realidade do hardware: Os processadores modernos consistem em milhares de milhões de transístores em dois estados. Uma porta XNOR requer 6 transístores. Um multiplicador de vírgula flutuante de 32 bits requer milhares e consome ordens de grandeza mais energia. As operações discretas alinham-se com os fundamentos do hardware.

Eficiência de memória: Os pesos binários empacotam 64 valores por palavra de 64 bits. Um ResNet-50 com 25,6 milhões de parâmetros ocupa 3,1MB em binário versus 50MB em FP16. O modelo inteiro cabe na cache L3 da CPU (típico: 36-64MB). Fica limitado pela computação em vez de pela memória.

Flexibilidade de implementação: Modelos pequenos permitem inferência no dispositivo. Sem dependência da nuvem. Sem latência de rede. Sem preocupações com privacidade de dados. Processe informação sensível inteiramente nos dispositivos dos utilizadores, sem nunca transmitir para servidores.

A matriz completa de algoritmos

A plataforma fornece cobertura abrangente em três dimensões: algoritmos, backends e larguras de bits.

Operações fundamentais (415 primitivas):

• 46 operações de bits: portas lógicas, manipulação, deslocamentos, contagem, localização
• 16 operações de campos: extrair, depositar, empacotar, dispersar, reunir, criação de máscaras
• 25 reduções: AND/OR/XOR lógicos, soma/produto aritméticos, votação e consenso
• 17 métricas de distância: Hamming, Jaccard, Dice, Tanimoto, cosseno, Manhattan, Euclidiana
• 12 operações de intercalação: intercalação de 2 a 4 vias, curvas de preenchimento de espaço de Morton e Hilbert
• 44 aritméticas: adição, subtração, multiplicação, divisão, operações de ponto fixo
• 39 transformadas: Walsh-Hadamard, FFT, DCT, NTT, wavelets (Haar, Daubechies, CDF97)
• 11 hashing: SHA-256, Blake3, xxHash, MinHash, SimHash, hashing sensível à localidade
• 22 geração de números aleatórios: LFSR, Mersenne Twister, ChaCha20, sequências de Sobol
• 15 quantizações: simétrica, assimétrica, por tensor, por canal, cálculo de escala
• 30 matemática binária: XNOR-popcount, codificação ternária, atualizações de pesos, operações de gradiente
• 48 conversões de formato: conversões FP32/FP16/FP8/INT8/INT4/INT2 em todas as direções
• 42 operações de ponto fixo: aritmética, transcendentais, saturação em todas as larguras de bits

Operações compostas (500 kernels):

Kernels otimizados que combinam primitivas para padrões comuns. Variantes de multiplicação de matrizes (padrão, transposta, em blocos). Tipos de convolução (2D, 3D, por profundidade, agrupada, dilatada). Normalização (em lote, por camada, por grupo, por instância). Funções de ativação (sinal, tanh rígida, linear por partes). Mecanismos de atenção (autoatenção, atenção cruzada, multi-cabeça). Pooling (máximo, médio, estocástico).

Camadas de rede (191 camadas):

Blocos de construção completos para construir redes. Camadas densas com pesos binários, ternários e de múltiplos bits. Camadas convolucionais com todas as variantes comuns. Camadas recorrentes (LSTM, GRU com portas binárias). Camadas de atenção (produto escalar escalado, multi-cabeça, posição relativa). Camadas de normalização com estatísticas de lote e parâmetros aprendidos. Conexões residuais com correspondência de dimensões.

Algoritmos de alto nível (674 algoritmos):

Métodos completos para treino, inferência e otimização. Destilação de conhecimento com refinamento progressivo em múltiplas etapas. Descoberta evolutiva de restrições com programação genética. Pesquisa de arquitetura neural para redes discretas. Estimadores de gradiente (direto, recortado, adaptativo, momentum, hiperrede). Otimizadores (BinaryAdam, TernaryAdam, quantização adaptativa). Treino distribuído com agregação robusta a bizantinos.

Profundidade da implementação do backend

Cada algoritmo existe em múltiplas variantes otimizadas por backend. Não são implementações genéricas. Código específico de hardware que explora todas as características arquiteturais.

CPU SIMD: SSE2 fornece compatibilidade universal x86-64 (todos os processadores desde 2001). AVX2 oferece aceleração de 4-8× em Haswell e mais recentes (2013+). AVX-512 atinge 10-16× com registos de máscara para predicação e VPTERNLOG para qualquer função booleana de 3 entradas. NEON traz aceleração de 3-4× a todos os processadores ARMv8, incluindo dispositivos móveis e Apple Silicon. SVE/SVE2 fornece código independente do comprimento do vetor que utiliza automaticamente vetores mais largos em hardware mais recente.

CUDA: Primitivas ao nível do warp organizam 32 threads a executar em sincronia. Cada thread processa 32 valores binários empacotados em uint32. Um warp completo processa 1.024 valores binários em paralelo. As instruções intrínsecas de hardware incluem __popc para contagem de população, __ballot_sync para votação no warp e __shfl_sync para comunicação rápida sem memória partilhada. O acesso coalescido à memória garante a utilização da largura de banda. Utilização dos Tensor Cores para operações matriciais mesmo com dados binários.

Rust-HDL: Síntese direta de hardware a partir de código Rust anotado. O framework gera Verilog/VHDL automaticamente. As operações binárias XNOR-popcount mapeiam para portas XNOR (lógica combinatória, atraso de propagação zero) mais árvores de somadores. Registos de pipeline inseridos automaticamente com base em restrições de temporização. Sintetiza para FPGAs (Xilinx, Intel) e ASICs.

WebAssembly: SIMD128 fornece operações vetoriais de 128 bits em todos os navegadores modernos (Chrome 91+, Firefox 89+, Safari 16.4+). As operações incluem v128.and/or/xor para lógica bit a bit e i8x16.popcnt para contagem de população. Combinado com Web Workers para multi-threading e SharedArrayBuffer para memória partilhada, atinge 60-80% do desempenho nativo da CPU. A inferência no navegador permite processamento em conformidade com o RGPD sem envios para servidores.

ROCm: Otimização ao nível do wavefront para arquiteturas AMD com 64 threads por wavefront (o dobro dos 32 da NVIDIA). Cada thread processa 32 valores binários, resultando em 2.048 valores por wavefront. Instruções intrínsecas semelhantes às do CUDA com __builtin_popcount, __ballot e ds_swizzle. O modelo de programação é suficientemente próximo para que programadores de CUDA escrevam código ROCm imediatamente.

Metal: Otimização para Apple Silicon utilizando arquitetura de memória unificada, onde a CPU e a GPU partilham RAM física com coerência de cache. Elimina a sobrecarga de cópia de dados. As operações binárias aproveitam os motores matriciais personalizados da Apple. O Neural Engine do M3 Max oferece 50-80 TOPS em inferência binária usando aceleradores dedicados integrados no SoC.

O que não fazemos (e porque é que o foco importa)

É importante esclarecer: não fazemos tudo. O foco permite a excelência.

Sem inferência em vírgula flutuante: Apenas computação discreta, de binário a 8 bits. Se precisar de FP32/FP16/BFloat16 para implementação, use PyTorch ou JAX. Otimizamos exclusivamente para operações discretas, permitindo especializações impossíveis com vírgula flutuante de precisão mista. Não se pode ser excelente em tudo. Escolhemos IA discreta e otimizamos sem piedade.

Sem grafos de inferência dinâmicos: Os modelos são compilados para grafos estáticos na implementação. O treino suporta computação dinâmica (necessária para a flexibilidade da investigação), mas a inferência em produção é estática. Isto permite otimização antecipada: fusão de kernels em toda a rede, otimização do layout de memória com formas de tensor conhecidas e inserção de instruções de pré-busca com padrões de acesso previsíveis.

Pré-processamento de dados focado: Fornecemos 8 algoritmos especializados para a preparação de entradas de redes neuronais (normalização, escalonamento adaptativo, quantização aprendida, aumento binário), não ETL de uso geral. Para pipelines de engenharia de características e carregamento de dados, utilize ferramentas existentes (Pandas, Polars, DuckDB). Somos excelentes em inferência discreta de redes neuronais, de binário a 8 bits. Não estamos a substituir toda a sua stack de dados.

Estas não são limitações. São foco. Ao restringir o âmbito a redes neuronais discretas com grafos de inferência estáticos, alcançamos uma profundidade de otimização que os frameworks abrangentes não conseguem igualar.

Construir sobre o Dweve Core

A plataforma está pronta a usar. Pode começar a construir redes neuronais discretas hoje.

Toolchain completo:

• API declarativa: DSL em Rust com NetworkBuilder para definição de modelos
• Infraestrutura de compilador: pipeline de otimização baseado em MLIR com quatro níveis de IR
• Estrutura de treino: seis variantes de STE, otimizadores com conhecimento binário, seleção automática de largura de bits
• Geradores de código de backend: C com intrínsecos para CPU, kernels CUDA/HIP para GPU, Verilog para FPGA
• Ferramentas de implementação: exportação para ONNX, Core ML, TensorFlow Lite ou binários autónomos

Exemplo de fluxo de trabalho:

1. Defina a sua rede com o NetworkBuilder
2. Treine com otimizadores com conhecimento binário e seleção adaptativa de largura de bits
3. Compile para o hardware de destino com seleção automática de backend
4. Implemente como binário otimizado ou exporte para um formato padrão
5. Execute em qualquer lugar: servidores na cloud, dispositivos de ponta, navegadores, FPGAs

Uma plataforma. Um código-base. Todos os backends. IA discreta completa.

Pare de gerir dez estruturas. Pare de reescrever código para cada destino de implementação. Pare de lutar contra a compatibilidade de versões. Crie uma vez com o Dweve Core e implemente em qualquer lugar.

O Dweve Core alimenta o Dweve Loom, o nosso sistema de raciocínio baseado em restrições que será lançado em 2026. A estrutura implementa a pilha completa de 1.930 algoritmos em 6 backends com quantização adaptativa de múltiplos bits, de binário a 8 bits. Criada por uma equipa de engenharia neerlandesa ao longo de três anos de desenvolvimento.