Una piattaforma, 1.930 algoritmi, ogni backend: come abbiamo costruito lo stack completo per l'AI discreta
Il problema della frammentazione
Il tuo ambiente di sviluppo AI è frammentato.
Prototipi in PyTorch perché i ricercatori lo preferiscono. Distribuisci con TensorFlow perché i team di produzione vogliono gli strumenti di Google. Scrivi kernel CUDA per GPU NVIDIA. Fai il porting su ROCm per hardware AMD. Riscrivi tutto per il mobile usando TensorFlow Lite o Core ML. Usi ONNX per convertire tra framework, sperando che nulla si rompa. Mantieni codebase separate per distribuzione su cloud, edge e browser.
Dieci strumenti diversi. Migliaia di dipendenze. Incubi di compatibilità delle versioni. Modifiche che rompono tutto a ogni ciclo di rilascio.
Aggiorni PyTorch? Spera che la tua versione CUDA corrisponda. Vuoi distribuire su AMD? Riscrivi i tuoi kernel. Ti serve inferenza nel browser? Ricomincia da zero con WebAssembly. Passi da GPU NVIDIA ad AMD? Buona fortuna con il porting di quella codebase. Distribuisci su FPGA? Impara un toolchain completamente diverso.
Questa frammentazione non è un caso. È il risultato naturale di ogni framework che ottimizza per il proprio caso d'uso specifico ignorando l'interoperabilità. PyTorch eccelle nella ricerca ma tratta la distribuzione come un ripensamento. TensorFlow punta alla produzione ma l'esperienza di ricerca è dolorosa. CUDA ti blocca sull'hardware NVIDIA. Ogni strumento risolve un problema creandone altri tre.
C'è un modo migliore.
Dweve Core: la piattaforma completa per l'AI discreta
Dweve Core è una piattaforma unificata per costruire reti neurali discrete dalla precisione binaria a 8 bit. Non è un altro framework. È un sostituto completo del tuo stack frammentato.
Una sola installazione. Una sola API. Una sola codebase. Distribuzione automatica su CPU, GPU, FPGA, WebAssembly, ovunque tu debba eseguire.
Ecco cosa significa completo:
1.930 algoritmi che coprono ogni operazione di cui hai bisogno:
- 415 primitive: operazioni atomiche come XNOR, popcount, manipolazione dei bit, quantizzazione, conversione tra formati
- 500 kernel: operazioni composite ottimizzate per pattern comuni
- 191 layer: blocchi completi per reti neurali (convoluzione, dense, normalizzazione, attivazione, attention)
- 674 algoritmi: metodi di alto livello tra cui trasformate, procedure di addestramento, ricerca evolutiva, distillazione della conoscenza
- 30 utility di interoperabilità: ponti opzionali in virgola mobile per approcci ibridi
- 120 architetture di modelli: template di rete pre-ottimizzati dalle ResNet ai Transformer
Non è un sottoinsieme. È completezza matematica. Abbiamo analizzato ogni grande architettura di rete neurale e costruito ogni operazione di cui richiedono, ottimizzata per il calcolo discreto a partire dai principi fondamentali.
6 backend con compilazione automatica:
- SIMD CPU: kernel ottimizzati a mano per x86 e ARM con rilevamento automatico delle ISA (SSE2, AVX2, AVX-512, NEON, SVE/SVE2)
- CUDA: ottimizzazione per GPU NVIDIA con primitive a livello di warp e utilizzo dei Tensor Core
- Rust-HDL: sintesi diretta FPGA e ASIC da descrizioni di algoritmi
- WebAssembly: inferenza nel browser con supporto SIMD128 per elaborazione on-device conforme al GDPR
- ROCm: ottimizzazione per GPU AMD con operazioni a livello di wavefront
- Metal: ottimizzazione per Apple Silicon con architettura di memoria unificata
6 larghezze di bit con precisione adattiva:
- Binario (1 bit): Massima efficienza con compressione 16× rispetto a FP16
- Ternary: {-1, 0, +1} con sparsità esplicita
- 2 bit: Quattro livelli per una compressione bilanciata
- 3 bit: Otto livelli per layer sensibili alla qualità
- 4 bit: Sedici livelli che si avvicinano alla qualità FP16
- 8 bit: Precisione quasi completa per operazioni critiche
La piattaforma apprende la larghezza di bit ottimale per ogni layer durante l'addestramento tramite selezione basata sul gradiente. Niente euristiche. Niente congetture. Ottimizzazione reale basata su come la precisione migliora con l'aumento della precisione.
Scrivi una volta, distribuisci ovunque
La piattaforma utilizza un'API Rust dichiarativa. Descrivi ciò che vuoi e il compilatore determina come eseguirlo in modo ottimale sull'hardware di destinazione.
Esempio di definizione di rete:
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();Ecco fatto. Scrivilo una volta e il compilatore genera automaticamente implementazioni ottimizzate per ogni backend.
La pipeline di compilazione funziona su quattro livelli:
Livello 1: IR della rete neurale - La descrizione della rete ad alto livello viene analizzata e trasformata in un grafo computazionale con operazioni, flusso di dati e iperparametri.
Livello 2: Ottimizzazione del grafo - I passaggi standard del compilatore eliminano il codice morto, piegano le costanti, deduplicano le espressioni e fondono le operazioni sequenziali. Un layer denso seguito da normalizzazione batch e attivazione diventa un singolo kernel fuso che carica l'input una sola volta e produce l'output finale.
Livello 3: Dialetto BitOps - Il grafo viene abbassato a operazioni a livello di bit esplicitamente tipizzate con precisione. Questa rappresentazione intermedia è indipendente dall'hardware ma vicina alle operazioni macchina reali. Costruita sull'infrastruttura MLIR (Multi-Level Intermediate Representation) per un'ottimizzazione di livello industriale.
Livello 4: Abbassamento hardware - La generazione finale del codice produce implementazioni specifiche per piattaforma. Per AVX-512, le operazioni bit diventano istruzioni VPXORQ e VPOPCNTQ. Per CUDA, diventano intrinsic a livello di warp con accesso alla memoria coalescente. Per FPGA, diventano porte XNOR e alberi di adder sintetizzati in Verilog.
Lo stesso codice sorgente gira sulla CPU del tuo laptop durante lo sviluppo, viene distribuito su GPU cloud in produzione e viene compilato per FPGA per l'inferenza in tempo reale deterministica. Nessuna traduzione. Nessun porting. Nessun codice specifico per piattaforma.
Progettato per consentire ai clienti di creare
Dweve Core alimenta Dweve Loom, il nostro sistema di ragionamento basato su vincoli. Ma non è solo per noi. È una piattaforma completa per chiunque crei reti neurali discrete.
Puoi creare:
- Architetture personalizzate usando i 191 tipi di layer e i 674 algoritmi
- Modelli specifici per dominio ottimizzati per i tuoi requisiti esatti
- Approcci ibridi che combinano calcolo discreto e continuo tramite le 30 utility di interoperabilità
- Metodi di addestramento innovativi usando ricerca evolutiva, distillazione della conoscenza o stimatori di gradiente personalizzati
La piattaforma offre:
Infrastruttura di addestramento completa: Sei varianti di stimatore straight-through per il flusso del gradiente binario/ternario. Ottimizzatori binari che mantengono internamente pesi a piena precisione mentre binarizzano per i passaggi in avanti. Selezione automatica della larghezza in bit tramite ottimizzazione basata sul gradiente. Distillazione progressiva a più stadi da FP32 fino a INT8, INT4, ternario e binario.
Ottimizzazione hardware automatica: Rilevamento a runtime delle capacità della CPU (CPUID su x86, registri di sistema su ARM) e dispatch automatico all'implementazione SIMD più veloce disponibile. Varianti di kernel GPU selezionate in base alla dimensione del warp, alla memoria condivisa e al numero di registri. Sintesi FPGA con inserimento automatico di registri di pipeline basato sui vincoli di temporizzazione.
Quantizzazione flessibile: Quantizzazione simmetrica e asimmetrica con scale per tensore, per canale o per gruppo. Quantizzazione dinamica con rilevamento dell'intervallo a runtime o quantizzazione statica con scale precalcolate dai dati di calibrazione. Calcolo delle scale ottimale MSE e basato sulla divergenza KL per una perdita di accuratezza minima.
Perché il calcolo discreto è importante
Le reti neurali tradizionali calcolano tutto in virgola mobile a 16 o 32 bit, poi prendono decisioni discrete alla fine. Noi operiamo direttamente nello spazio discreto dal binario a 8 bit, eliminando il calcolo continuo intermedio.
Non si tratta di una semplice quantizzazione dei modelli esistenti. Il framework è architettato da zero attorno alle operazioni discrete:
Realtà hardware: I processori moderni sono composti da miliardi di transistor in due stati. Una porta XNOR richiede 6 transistor. Un moltiplicatore a virgola mobile a 32 bit ne richiede migliaia e consuma ordini di grandezza più energia. Le operazioni discrete si allineano ai fondamenti hardware.
Efficienza della memoria: I pesi binari impacchettano 64 valori per parola a 64 bit. Una ResNet-50 con 25,6 milioni di parametri occupa 3,1 MB in binario contro 50 MB in FP16. L'intero modello entra nella cache L3 della CPU (tipica: 36-64 MB). Diventi vincolato dal calcolo invece che dalla memoria.
Flessibilità di distribuzione: I modelli piccoli consentono l'inferenza on-device. Nessuna dipendenza dal cloud. Nessuna latenza di rete. Nessun problema di privacy dei dati. Elabora informazioni sensibili interamente sui dispositivi degli utenti senza mai trasmetterle ai server.
La matrice completa degli algoritmi
La piattaforma offre una copertura completa su tre dimensioni: algoritmi, backend e larghezze in bit.
Operazioni fondamentali (415 primitive):
- 46 operazioni bit: porte logiche, manipolazione, scorrimento, conteggio, ricerca
- 16 operazioni su campi: estrazione, deposito, impacchettamento, dispersione, raccolta, creazione di maschere
- 25 riduzioni: AND/OR/XOR logici, somma/prodotto aritmetici, votazione e consenso
- 17 metriche di distanza: Hamming, Jaccard, Dice, Tanimoto, coseno, Manhattan, Euclidea
- 12 operazioni di interleaving: interleave da 2 a 4 vie, curve di riempimento dello spazio di Morton e Hilbert
- 44 operazioni aritmetiche: addizione, sottrazione, moltiplicazione, divisione, operazioni a virgola fissa
- 39 trasformate: Walsh-Hadamard, FFT, DCT, NTT, wavelet (Haar, Daubechies, CDF97)
- 11 funzioni di hash: SHA-256, Blake3, xxHash, MinHash, SimHash, hashing sensibile alla località
- 22 generazione di numeri casuali: LFSR, Mersenne Twister, ChaCha20, sequenze di Sobol
- 15 quantizzazioni: simmetrica, asimmetrica, per tensore, per canale, calcolo della scala
- 30 operazioni binarie: XNOR-popcount, codifica ternaria, aggiornamenti dei pesi, operazioni sui gradienti
- 48 conversioni di formato: conversioni FP32/FP16/FP8/INT8/INT4/INT2 in tutte le direzioni
- 42 operazioni a virgola fissa: aritmetica, funzioni trascendenti, saturazione su tutte le larghezze di bit
Operazioni composite (500 kernel):
Kernel ottimizzati che combinano primitive per pattern comuni. Varianti di moltiplicazione di matrici (standard, trasposta, a blocchi). Tipi di convoluzione (2D, 3D, depthwise, raggruppata, dilatata). Normalizzazione (batch, layer, group, instance). Funzioni di attivazione (segno, tanh rigida, lineare a tratti). Meccanismi di attenzione (self-attention, cross-attention, multi-head). Pooling (max, average, stochastic).
Layer di rete (191 layer):
Blocchi costitutivi completi per la costruzione di reti. Layer densi con pesi binari, ternari e multi-bit. Layer convoluzionali con tutte le varianti comuni. Layer ricorrenti (LSTM, GRU con gate binari). Layer di attenzione (dot-product scalato, multi-head, posizione relativa). Layer di normalizzazione con statistiche batch e parametri appresi. Connessioni residue con corrispondenza delle dimensioni.
Algoritmi di alto livello (674 algoritmi):
Metodi completi per addestramento, inferenza e ottimizzazione. Distillazione della conoscenza con raffinamento progressivo multi-stadio. Scoperta evolutiva di vincoli con programmazione genetica. Ricerca di architetture neurali per reti discrete. Stimatori del gradiente (straight-through, con taglio, adattivi, con momento, hypernetwork). Ottimizzatori (BinaryAdam, TernaryAdam, quantizzazione adattiva). Addestramento distribuito con aggregazione robusta a Bisanzio.
Profondità dell'implementazione del backend
Ogni algoritmo esiste in più varianti ottimizzate per backend. Non implementazioni generiche. Codice specifico per l'hardware che sfrutta ogni caratteristica architetturale.
CPU SIMD: SSE2 fornisce compatibilità universale x86-64 (ogni processore dal 2001). AVX2 offre un'accelerazione di 4-8× su Haswell e successivi (2013+). AVX-512 raggiunge 10-16× con registri maschera per la predicazione e VPTERNLOG per qualsiasi funzione booleana a 3 ingressi. NEON porta un'accelerazione di 3-4× a tutti i processori ARMv8 inclusi mobile e Apple Silicon. SVE/SVE2 fornisce codice agnostico rispetto alla lunghezza del vettore che utilizza automaticamente vettori più ampi su hardware più recente.
CUDA: Le primitive a livello di warp organizzano 32 thread che eseguono in lockstep. Ogni thread elabora 32 valori binari impacchettati in uint32. Un warp completo elabora 1.024 valori binari in parallelo. Gli intrinsic hardware includono __popc per il conteggio della popolazione, __ballot_sync per il voto del warp, __shfl_sync per la comunicazione rapida senza memoria condivisa. L'accesso coalescente alla memoria garantisce l'utilizzo della larghezza di banda. Utilizzo dei Tensor Core per le operazioni sulle matrici anche con dati binari.
Rust-HDL: Sintesi hardware diretta dal codice Rust annotato. Il framework genera automaticamente Verilog/VHDL. Le operazioni binarie XNOR-popcount si mappano su porte XNOR (logica combinatoria, ritardo di propagazione zero) più alberi di addizione. I registri di pipeline vengono inseriti automaticamente in base ai vincoli di temporizzazione. Sintetizza sia su FPGA (Xilinx, Intel) sia su ASIC.
WebAssembly: SIMD128 fornisce operazioni vettoriali a 128 bit in tutti i browser moderni (Chrome 91+, Firefox 89+, Safari 16.4+). Le operazioni includono v128.and/or/xor per la logica bitwise e i8x16.popcnt per il conteggio della popolazione. Combinato con Web Workers per il multi-threading e SharedArrayBuffer per la memoria condivisa, raggiunge il 60-80% delle prestazioni native della CPU. L'inferenza nel browser sul dispositivo consente un'elaborazione conforme al GDPR senza caricamenti sul server.
ROCm: Ottimizzazione a livello di wavefront per le architetture AMD con 64 thread per wavefront (il doppio dei 32 di NVIDIA). Ogni thread elabora 32 valori binari per 2.048 valori per wavefront. Intrinsic simili a CUDA con __builtin_popcount, __ballot e ds_swizzle. Il modello di programmazione è abbastanza simile che gli sviluppatori CUDA possono scrivere codice ROCm immediatamente.
Metal: Ottimizzazione per Apple Silicon tramite architettura di memoria unificata in cui CPU e GPU condividono la RAM fisica con coerenza della cache. Elimina il sovraccarico della copia dei dati. Le operazioni binarie sfruttano i motori matriciali personalizzati di Apple. Il Neural Engine M3 Max offre 50-80 TOPS sull'inferenza binaria utilizzando acceleratori dedicati integrati nel SoC.
Cosa non facciamo (e perché la concentrazione conta)
È importante chiarire: non facciamo tutto. La concentrazione consente l'eccellenza.
Nessuna inferenza a virgola mobile: Solo calcolo discreto da binario a 8 bit. Se hai bisogno di FP32/FP16/BFloat16 per la distribuzione, usa PyTorch o JAX. Ottimizziamo esclusivamente per operazioni discrete, consentendo specializzazioni impossibili con la virgola mobile a precisione mista. Non puoi essere eccellente in tutto. Abbiamo scelto l'IA discreta e ottimizzato senza compromessi.
Nessun grafo di inferenza dinamico: I modelli vengono compilati in grafi statici per la distribuzione. L'addestramento supporta il calcolo dinamico (necessario per la flessibilità della ricerca), ma l'inferenza in produzione è statica. Ciò consente l'ottimizzazione ahead-of-time: fusione dei kernel sull'intera rete, ottimizzazione del layout di memoria con forme tensoriali note, inserimento di istruzioni di prefetch con pattern di accesso prevedibili.
Preelaborazione dei dati mirata: Forniamo 8 algoritmi specializzati per la preparazione degli input delle reti neurali (normalizzazione, scaling adattivo, quantizzazione appresa, aumento binario), non ETL generico. Per le pipeline di feature engineering e il caricamento dei dati, usa gli strumenti esistenti (Pandas, Polars, DuckDB). Siamo eccellenti nell'inferenza discreta delle reti neurali da binario a 8 bit. Non stiamo sostituendo l'intero stack di dati.
Queste non sono limitazioni. Sono concentrazione. Limitando l'ambito alle reti neurali discrete con grafi di inferenza statici, raggiungiamo una profondità di ottimizzazione che i framework completi non possono eguagliare.
Costruire su Dweve Core
La piattaforma è pronta all'uso. Puoi iniziare a costruire reti neurali discrete oggi.
Toolchain completa:
- API dichiarativa: DSL Rust con NetworkBuilder per la definizione del modello
- Infrastruttura del compilatore: pipeline di ottimizzazione basata su MLIR con quattro livelli IR
- Framework di addestramento: sei varianti STE, ottimizzatori binari-aware, selezione automatica della larghezza dei bit
- Generatori di codice backend: C con intrinsics per CPU, kernel CUDA/HIP per GPU, Verilog per FPGA
- Strumenti di distribuzione: esportazione in ONNX, Core ML, TensorFlow Lite o binari standalone
Esempio di flusso di lavoro:
1. Definisci la tua rete con NetworkBuilder
2. Addestra con ottimizzatori binari-aware e selezione adattiva della larghezza dei bit
3. Compila per l'hardware di destinazione con selezione automatica del backend
4. Distribuisci come binario ottimizzato o esporta in formato standard
5. Esegui ovunque: server cloud, dispositivi edge, browser, FPGA
Una piattaforma. Un'unica base di codice. Ogni backend. IA discreta completa.
Basta gestire dieci framework. Basta riscrivere il codice per ogni destinazione di distribuzione. Basta combattere con la compatibilità delle versioni. Costruisci una volta su Dweve Core e distribuisci ovunque.
Dweve Core alimenta Dweve Loom, il nostro sistema di ragionamento basato su vincoli in arrivo nel 2026. Il framework implementa l'intero stack di 1.930 algoritmi su 6 backend con quantizzazione multi-bit adattiva da binario a 8 bit. Creato da un team di ingegneri olandesi in tre anni di sviluppo.