O platformă, 1.930 de algoritmi, orice backend: cum am construit stiva completă pentru AI discret
Problema fragmentării
Mediul tău de dezvoltare AI este fragmentat.
Faci prototipuri în PyTorch pentru că cercetătorii îl preferă. Implementezi cu TensorFlow pentru că echipele de producție vor instrumentele Google. Scrii kernel-uri CUDA pentru GPU-urile NVIDIA. Porți pe ROCm pentru hardware-ul AMD. Rescrii totul pentru mobil folosind TensorFlow Lite sau Core ML. Folosești ONNX pentru a converti între framework-uri, sperând că nimic nu se strică. Menții baze de cod separate pentru cloud, edge și browser.
Zece instrumente diferite. Mii de dependențe. Coșmaruri cu compatibilitatea versiunilor. Modificări care sparg codul la fiecare ciclu de lansare.
Actualizezi PyTorch? Speri ca versiunea ta de CUDA să se potrivească. Vrei să implementezi pe AMD? Rescrii kernel-urile. Ai nevoie de inferență în browser? O iei de la zero cu WebAssembly. Treci de la GPU-uri NVIDIA la AMD? Mult succes cu portarea acelei baze de cod. Implementezi pe FPGA? Înveți un toolchain complet diferit.
Această fragmentare nu este un accident. Este rezultatul natural al faptului că fiecare framework este optimizat pentru cazul său specific de utilizare, ignorând interoperabilitatea. PyTorch excelează la cercetare, dar tratează implementarea ca pe o idee ulterioară. TensorFlow vizează producția, dar experiența de cercetare este dureroasă. CUDA te blochează pe hardware-ul NVIDIA. Fiecare instrument rezolvă o problemă, creând în același timp încă trei.
Există o cale mai bună.
Dweve Core: Platforma completă pentru AI discret
Dweve Core este o platformă unificată pentru construirea rețelelor neuronale discrete, de la precizie binară la 8 biți. Nu este un alt framework. Este un înlocuitor complet pentru stiva ta fragmentată.
O singură instalare. O singură API. O singură bază de cod. Implementare automată pe CPU, GPU, FPGA, WebAssembly, oriunde ai nevoie să rulezi.
Iată ce înseamnă „complet”:
1.930 de algoritmi care acoperă fiecare operație de care ai nevoie:
- 415 primitive: Operații atomice precum XNOR, popcount, manipularea biților, cuantizare, conversie între formate
- 500 de kernel-uri: Operații compozite optimizate pentru modele comune
- 191 de straturi: Blocuri complete pentru construirea rețelelor neuronale (convoluție, dens, normalizare, activare, atenție)
- 674 de algoritmi: Metode de nivel înalt, inclusiv transformări, proceduri de antrenare, căutare evolutivă, distilare a cunoștințelor
- 30 de utilitare de interoperabilitate: Poduri opționale cu virgulă mobilă pentru abordări hibride
- 120 de arhitecturi de modele: Șabloane de rețea pre-optimizate, de la ResNet la Transformers
Aceasta nu este o submulțime. Este completitudine matematică. Am analizat fiecare arhitectură majoră de rețea neuronală și am construit fiecare operație de care au nevoie, optimizată pentru calcul discret din primele principii.
6 backend-uri cu compilare automată:
- SIMD CPU: Kernel-uri optimizate manual pentru x86 și ARM, cu detectare automată a ISA (SSE2, AVX2, AVX-512, NEON, SVE/SVE2)
- CUDA: Optimizare pentru GPU-urile NVIDIA, cu primitive la nivel de warp și utilizarea Tensor Core
- Rust-HDL: Sinteză directă FPGA și ASIC din descrieri de algoritmi
- WebAssembly: Inferență în browser, cu suport SIMD128 pentru procesare on-device conformă cu GDPR
- ROCm: Optimizare pentru GPU-urile AMD, cu operații la nivel de wavefront
- Metal: Optimizare pentru Apple Silicon, folosind arhitectura de memorie unificată
6 lățimi de biți cu precizie adaptivă:
- Binar (1 bit): eficiență maximă, cu o compresie de 16× față de FP16
- Ternar: {-1, 0, +1} cu spațiere explicită
- 2 biți: patru niveluri pentru o compresie echilibrată
- 3 biți: opt niveluri pentru straturi sensibile la calitate
- 4 biți: șaisprezece niveluri care se apropie de calitatea FP16
- 8 biți: precizie aproape completă pentru operații critice
Platforma învață lățimea optimă de biți pentru fiecare strat în timpul antrenării, prin selecție bazată pe gradient. Nu euristici. Nu presupuneri. Optimizare reală, bazată pe modul în care acuratețea se îmbunătățește odată cu precizia adăugată.
Scrie o dată, implementează oriunde
Platforma folosește o API Rust declarativă. Descrii ce vrei, iar compilatorul își dă seama cum să o ruleze optim pe hardware-ul țintă.
Exemplu de definiție a rețelei:
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();Atât. Scrii asta o dată, iar compilatorul generează automat implementări optimizate pentru fiecare backend.
Pipeline-ul de compilare funcționează pe patru niveluri:
Nivelul 1: IR pentru rețele neuronale - Descrierea rețelei de nivel înalt este parsată într-un graf computațional cu operații, flux de date și hiperparametri.
Nivelul 2: Optimizarea grafului - Pașii standard de compilare elimină codul mort, pliază constantele, deduplică expresiile și fuzionează operațiile secvențiale. Un strat dens urmat de normalizare pe lot și activare devine un singur nucleu fuzionat care încarcă datele o singură dată și produce rezultatul final.
Nivelul 3: Dialectul BitOps - Graful este redus la operații la nivel de bit, tipate explicit cu precizie. Această reprezentare intermediară este independentă de hardware, dar apropiată de operațiile reale ale mașinii. Construit pe infrastructura MLIR (Multi-Level Intermediate Representation) pentru o optimizare de nivel industrial.
Nivelul 4: Reducerea la hardware - Generarea finală de cod produce implementări specifice platformei. Pentru AVX-512, operațiile pe biți devin instrucțiuni VPXORQ și VPOPCNTQ. Pentru CUDA, devin intrinseci la nivel de warp cu acces la memorie coalescent. Pentru FPGA, devin porți XNOR și arbori de sumatori sintetizați în Verilog.
Același cod sursă rulează pe procesorul laptopului tău în timpul dezvoltării, este implementat pe GPU-uri cloud în producție și se compilează pe FPGA pentru inferență deterministă în timp real. Fără traduceri. Fără portări. Fără cod specific platformei.
Construit pentru ca clienții să construiască
Dweve Core alimentează Dweve Loom, sistemul nostru de raționament bazat pe constrângeri. Dar nu este doar pentru noi. Este o platformă completă pentru oricine construiește rețele neuronale discrete.
Poți construi:
- Arhitecturi personalizate folosind cele 191 de tipuri de straturi și 674 de algoritmi
- Modele specifice domeniului optimizate pentru cerințele tale exacte
- Abordări hibride care combină calculul discret și cel continuu prin cele 30 de utilitare de interoperabilitate
- Metode noi de antrenare folosind căutare evolutivă, distilare de cunoștințe sau estimatori personalizați de gradient
Platforma oferă:
Infrastructură completă de antrenare: Șase variante de estimatori cu trecere directă pentru fluxul de gradient binar/ternar. Optimizatori conștienți de binarizare care mențin intern ponderi cu precizie completă, binarizând doar pentru trecerile înainte. Selectare automată a lățimii de biți prin optimizare pe bază de gradient. Distilare progresivă în mai multe etape, de la FP32 la INT8, INT4, ternar și binar.
Optimizare automată a hardware-ului: Detectare la rulare a capabilităților CPU (CPUID pe x86, registre de sistem pe ARM) și direcționare automată către cea mai rapidă implementare SIMD disponibilă. Variante de kernel GPU selectate pe baza dimensiunii warp-ului, memoriei partajate și numărului de registre. Sinteză FPGA cu inserare automată a registrelor de conductă pe baza constrângerilor de sincronizare.
Cuantizare flexibilă: Cuantizare simetrică și asimetrică cu scale per-tensor, per-canal sau per-grup. Cuantizare dinamică cu detectarea intervalului la rulare sau cuantizare statică cu scale precalculate din date de calibrare. Calcul al scalelor optim MSE și pe bază de divergență KL pentru o pierdere minimă de acuratețe.
De ce contează calculul discret
Rețelele neuronale tradiționale calculează totul în virgulă mobilă pe 16 sau 32 de biți, apoi iau decizii discrete la final. Noi operăm direct în spațiul discret, de la binar la 8 biți, eliminând calculul continuu intermediar.
Nu este vorba despre simpla cuantizare a modelelor existente. Cadrul este arhitecturat de la zero în jurul operațiilor discrete:
Realitatea hardware-ului: Procesoarele moderne constau din miliarde de tranzistori în două stări. O poartă XNOR necesită 6 tranzistori. Un multiplicator în virgulă mobilă pe 32 de biți necesită mii și consumă cu ordine de mărime mai multă energie. Operațiile discrete se aliniază cu fundamentele hardware-ului.
Eficiența memoriei: Ponderile binare împachetează 64 de valori într-un cuvânt de 64 de biți. Un ResNet-50 cu 25,6 milioane de parametri ocupă 3,1MB în format binar, față de 50MB în FP16. Întregul model încape în cache-ul L3 al CPU (de obicei: 36-64MB). Devii limitat de calcul, nu de memorie.
Flexibilitatea implementării: Modelele mici permit inferența pe dispozitiv. Fără dependență de cloud. Fără latență de rețea. Fără probleme de confidențialitate a datelor. Procesează informații sensibile integral pe dispozitivele utilizatorilor, fără a le transmite vreodată către servere.
Matricea completă de algoritmi
Platforma oferă acoperire cuprinzătoare pe trei dimensiuni: algoritmi, backend-uri și lățimi de biți.
Operații fundamentale (415 primitive):
- 46 operații pe biți: porți logice, manipulare, deplasări, numărare, căutare
- 16 operații pe câmpuri: extragere, depunere, împachetare, împrăștiere, adunare, creare de măști
- 25 reduceri: AND/OR/XOR logic, sumă/produs aritmetic, vot și consens
- 17 metrici de distanță: Hamming, Jaccard, Dice, Tanimoto, cosinus, Manhattan, Euclidian
- 12 operații de intercalare: intercalare pe 2 până la 4 căi, curbe de umplere a spațiului Morton și Hilbert
- 44 operații aritmetice: adunare, scădere, înmulțire, împărțire, operații în virgulă fixă
- 39 transformări: Walsh-Hadamard, FFT, DCT, NTT, wavelet (Haar, Daubechies, CDF97)
- 11 funcții hash: SHA-256, Blake3, xxHash, MinHash, SimHash, hashing sensibil la localitate
- 22 generatoare de numere aleatoare: LFSR, Mersenne Twister, ChaCha20, secvențe Sobol
- 15 cuantizări: simetrică, asimetrică, pe tensor, pe canal, calculul scalei
- 30 operații binare: XNOR-popcount, codare ternară, actualizări de ponderi, operații pe gradienți
- 48 conversii de format: conversii FP32/FP16/FP8/INT8/INT4/INT2 în toate direcțiile
- 42 operații în virgulă fixă: aritmetică, funcții transcendentale, saturare la toate lățimile de biți
Operații compozite (500 de nuclee):
Nuclee optimizate care combină primitive pentru modele comune. Variante de multiplicare a matricelor (standard, transpusă, în blocuri). Tipuri de convoluție (2D, 3D, depthwise, grupată, dilatată). Normalizare (pe lot, pe strat, pe grup, pe instanță). Funcții de activare (semn, tanh dur, liniară pe porțiuni). Mecanisme de atenție (auto-atenție, atenție încrucișată, multi-cap). Pooling (max, medie, stocastic).
Straturi de rețea (191 de straturi):
Blocuri complete pentru construirea rețelelor. Straturi dense cu ponderi binare, ternare și pe mai mulți biți. Straturi convoluționale cu toate variantele comune. Straturi recurente (LSTM, GRU cu porți binare). Straturi de atenție (produs scalar scalat, multi-cap, poziție relativă). Straturi de normalizare cu statistici pe lot și parametri învățați. Conexiuni reziduale cu potrivirea dimensiunilor.
Algoritmi de nivel înalt (674 de algoritmi):
Metode complete pentru antrenare, inferență și optimizare. Distilarea cunoștințelor cu rafinare progresivă în mai multe etape. Descoperirea evoluționistă a constrângerilor cu programare genetică. Căutarea arhitecturii neuronale pentru rețele discrete. Estimatori de gradient (direct, tăiat, adaptiv, cu impuls, hiperrețea). Optimizatori (BinaryAdam, TernaryAdam, cuantizare adaptivă). Antrenare distribuită cu agregare robustă Byzantine.
Profunzimea implementării backend
Fiecare algoritm există în mai multe variante optimizate per backend. Nu implementări generice. Cod specific hardware-ului care exploatează fiecare caracteristică arhitecturală.
CPU SIMD: SSE2 oferă compatibilitate universală x86-64 (fiecare procesor din 2001 încoace). AVX2 oferă o accelerare de 4-8× pe Haswell și mai noi (2013+). AVX-512 atinge 10-16× cu registre de mască pentru predicare și VPTERNLOG pentru orice funcție Booleană cu 3 intrări. NEON aduce o accelerare de 3-4× tuturor procesoarelor ARMv8, inclusiv mobile și Apple Silicon. SVE/SVE2 oferă cod agnostic de lungimea vectorului care utilizează automat vectori mai largi pe hardware mai nou.
CUDA: Primitivelor la nivel de warp organizează 32 de fire de execuție care rulează în sincron. Fiecare fir procesează 32 de valori binare împachetate în uint32. Un warp complet procesează 1.024 de valori binare în paralel. Intrinsecii hardware includ __popc pentru numărarea populației, __ballot_sync pentru votul la nivel de warp, __shfl_sync pentru comunicare rapidă fără memorie partajată. Accesul coalescent la memorie asigură utilizarea eficientă a lățimii de bandă. Utilizarea Tensor Core pentru operații cu matrice chiar și cu date binare.
Rust-HDL: Sinteză hardware directă din cod Rust adnotat. Cadrul generează automat Verilog/VHDL. Operațiile binare XNOR-popcount se mapează pe porți XNOR (logică combinatorie, zero întârziere de propagare) plus arbori de adunare. Registrele de pipeline sunt inserate automat pe baza constrângerilor de temporizare. Sinteza se face atât pentru FPGA (Xilinx, Intel), cât și pentru ASIC.
WebAssembly: SIMD128 oferă operații vectoriale pe 128 de biți în toate browserele moderne (Chrome 91+, Firefox 89+, Safari 16.4+). Operațiile includ v128.and/or/xor pentru logică pe biți și i8x16.popcnt pentru numărarea populației. Combinat cu Web Workers pentru multi-threading și SharedArrayBuffer pentru memorie partajată, atinge 60-80% din performanța CPU nativ. Inferența în browser pe dispozitiv permite procesare conformă cu GDPR, fără încărcări pe server.
ROCm: Optimizare la nivel de wavefront pentru arhitecturi AMD, cu 64 de fire per wavefront (dublu față de cei 32 ai NVIDIA). Fiecare fir procesează 32 de valori binare, rezultând 2.048 de valori per wavefront. Intrinseci similari cu CUDA, incluzând __builtin_popcount, __ballot și ds_swizzle. Modelul de programare este suficient de apropiat încât dezvoltatorii CUDA pot scrie cod ROCm imediat.
Metal: Optimizare pentru Apple Silicon folosind arhitectura de memorie unificată, în care CPU și GPU partajează RAM fizic cu coerență de cache. Elimină overhead-ul de copiere a datelor. Operațiile binare valorifică motoarele matriceale personalizate Apple. Neural Engine-ul M3 Max livrează 50-80 TOPS la inferență binară folosind acceleratoare dedicate integrate în SoC.
Ce nu facem (și de ce focusul contează)
Important de clarificat: nu facem totul. Focusul permite excelența.
Fără inferență în virgulă mobilă: Doar calcul discret, de la binar la 8 biți. Dacă aveți nevoie de FP32/FP16/BFloat16 pentru implementare, folosiți PyTorch sau JAX. Optimizăm exclusiv pentru operații discrete, permițând specializări imposibile cu virgulă mobilă în precizie mixtă. Nu poți fi excelent la toate. Am ales AI discret și am optimizat fără milă.
Fără grafuri dinamice de inferență: Modelele sunt compilate în grafuri statice pentru implementare. Antrenarea suportă calcul dinamic (necesar pentru flexibilitatea cercetării), dar inferența de producție este statică. Aceasta permite optimizare în avans: fuziunea kernel-urilor pe întreaga rețea, optimizarea layout-ului memoriei cu forme cunoscute ale tensorilor, inserarea instrucțiunilor de prefetch cu modele de acces previzibile.
Preprocesare focalizată a datelor: Oferim 8 algoritmi specializați pentru pregătirea intrărilor rețelelor neuronale (normalizare, scalare adaptivă, cuantizare învățată, augmentare binară), nu ETL de uz general. Pentru pipeline-uri de inginerie a caracteristicilor și încărcare de date, folosiți instrumentele existente (Pandas, Polars, DuckDB). Suntem excelenți la inferența discretă a rețelelor neuronale, de la binar la 8 biți. Nu înlocuim întregul vostru stack de date.
Acestea nu sunt limitări. Sunt focus. Prin constrângerea domeniului la rețele neuronale discrete cu grafuri statice de inferență, atingem o profunzime de optimizare pe care cadrele comprehensive nu o pot egala.
Construirea pe Dweve Core
Platforma este gata de utilizare. Puteți începe să construiți rețele neuronale discrete chiar astăzi.
Toolchain complet:
- API declarativă: DSL Rust cu NetworkBuilder pentru definirea modelului
- Infrastructură de compilare: pipeline de optimizare bazat pe MLIR, cu patru niveluri de IR
- Cadru de instruire: șase variante STE, optimizatoare conștiente de binaritate, selecție automată a lățimii de biți
- Generatoare de cod backend: C cu intrinsics pentru CPU, nuclee CUDA/HIP pentru GPU, Verilog pentru FPGA
- Instrumente de implementare: export în ONNX, Core ML, TensorFlow Lite sau binare autonome
Exemplu de flux de lucru:
1. Definiți rețeaua folosind NetworkBuilder
2. Instruiți cu optimizatoare conștiente de binaritate și selecție adaptivă a lățimii de biți
3. Compilați pentru hardware-ul țintă cu selecție automată a backend-ului
4. Implementați ca binar optimizat sau exportați în format standard
5. Rulați oriunde: servere cloud, dispozitive edge, browsere, FPGA
O platformă. Un singur codebase. Orice backend. AI discret complet.
Nu mai jonglați cu zece cadre. Nu mai rescrieți codul pentru fiecare țintă de implementare. Nu mai luptați cu compatibilitatea versiunilor. Construiți o dată pe Dweve Core și implementați oriunde.
Dweve Core alimentează Dweve Loom, sistemul nostru de raționament bazat pe constrângeri, care va fi lansat în 2026. Cadrul implementează stiva completă de 1.930 de algoritmi pe 6 backend-uri, cu cuantizare multi-bit adaptivă, de la binar la 8 biți. Construit de o echipă de ingineri olandezi pe parcursul a trei ani de dezvoltare.