Stivă de calcul AI pentru antrenare și inferență | Dweve Core

Choose the audience that matches your question

The page contains three selectable readings of the same subject.

Agent de codare și asistență pentru operatori. Metricile demonstrative sunt ilustrative.

Terminal, căutare, lint, test, git și altele.

Își amintește contextul bazei de cod și al echipei.

Agenți specializați colaborează pe diferite domenii.

Fiecare pas este înregistrat cu marcaje temporale.

Politicile, verificările și testele rulează întotdeauna.

Revizuiește diffs, solicită modificări, aprobă final.

Redă orice sesiune bit cu bit când ceva necesită revizuire.

Citește retry.ts, a depistat bug-ul de timeout

Agenți autonomi care scriu cod și păstrează dovezi

pentru a gestiona timeout-uri de rețea, răspunsuri 5xx și condiții sigure pentru idempotență. Helper pur, complet testat unitar.

Capabilitate și determinism declarate pe celulă

Operare directă pe infrastructura controlată de client

Un singur model, mai multe căi deținute de furnizori

compresia trăiește într-un alt instrument

definiția și execuția nu mai coincid treptat

Rulează pe computere obișnuite, acolo unde este suportat

Poate funcționa offline, acolo unde este suportat.

Lucrurile tale pot rămâne acasă, în Europa.

Nu trebuie să cumperi un computer special.

celulă de execuție și contract de reluare înregistrate

dimensionat corect pentru fiecare sarcină

Formatul de stocare nu este de tip acumulator

Dweve Core este un stack complet de calcul AI pentru antrenare și inferență. Majoritatea platformelor AI acoperă doar o parte și lasă restul altor furnizori. Core păstrează crearea modelelor, antrenarea, inferența, kernel-urile, dispatch-ul și implementarea într-un singur sistem coerent. Pentru sarcini binare suportate, Core folosește cu 96% mai puțină energie decât un stack GPU.

25 de familii de formate numerice înregistrate

Sistemele parțiale creează dependență permanentă

Definiția și execuția nu mai coincid treptat.

Hardware nou, sistem de servire nou, comportament nou.

Foaia de parcurs a furnizorului devine foaia ta de parcurs.

Niciun sistem nu poate explica rezultatul.

Dependența persistă pentru că spațiul computațional de dedesubt este doar parțial acoperit.

Core menține schimbările de lățime numerică, împachetare, hardware și implementare într-un singur sistem de implementare. Un algoritm nu devine un produs diferit pentru că se mută de pe un server x86 pe ARM, pe un GPU, pe un browser sau pe o țintă specializată. Operația rămâne denumită, inspectabilă și deținută pe tot parcursul mutării, iar fiecare cale este înregistrată, nu dedusă dintr-o etichetă de format.

Registrul de implementări acoperă peste 2.900 de operații, 76 de categorii de operații și 25 de familii de formate numerice înregistrate. Fiecare cale este determinată pe nouă dimensiuni: algoritm, tip de date, lățime, împachetare, acumulator, backend, set de instrucțiuni, politică de dispatch și mod de determinism. Contractul de reprezentare menține aceste alegeri numerice și fizice atașate operației. Vizualul de mai jos fixează majoritatea acestor dimensiuni, astfel încât o felie mică reprezentativă să rămână lizibilă. Numărul descrie un registru de celule și contracte concrete, nu o afirmație că o etichetă de format sau o insignă largă de capabilitate explică singură o cale de execuție.

Eșantionul este mic pentru că registrul de implementări nu este.

Un algoritm supraviețuiește oricărei constrângeri

Sosește o lățime, o împachetare, un gazdă sau un contract nou.

Același activ, același deținător, condiție nouă.

Prima presupunere moștenită pe care Core o elimină este că un singur tip de date ar trebui să domine totul.

nicio treaptă nu este o funcție de cercetare

Procesorul ar trebui să fie la fel de înlocuibil ca și tipul de date.

Core nu tratează un ecosistem de acceleratoare ca definiție a AI și tot restul ca pe un port de rang inferior. Operațiile sale au implementări scalare de referință și căi specifice țintelor pe backend-urile acceptate pentru CPU, GPU, FPGA, browser și implementare. Runtime-ul selectează o implementare în funcție de mașina disponibilă și de politica atașată lucrării.

Un procesor x86 modern își poate folosi instrucțiunile vectoriale. ARM și siliciul Apple își pot folosi căile native. GPU-urile NVIDIA, AMD și Apple își pot folosi backend-urile respective. Execuția în browser poate folosi WebAssembly sau WebGPU acolo unde este cazul. Programele de implementare pot viza hardware specializat. Procesorul este o destinație pentru operație. Nu este proprietarul modelului.

Vectori x86, căi native ARM și siliciu Apple.

GPU-uri NVIDIA, AMD și Apple pe backend-urile lor.

WebAssembly sau WebGPU acolo unde este cazul.

Hardware specializat pentru programele de implementare.

Etichetele largi de țintă sunt ieftine. Să deții calea reală este mai greu.

Tipul de date nu era acceptat, hardware-ul țintă s-a schimbat, iar cuantizatorul avea nevoie de alt runtime.

Stiva de servire nu putea reda rezultatul. Achizițiile au deschis o altă revizuire a furnizorului.

Cuantizatorul avea nevoie de alt runtime

Nu ai adăugat o singură funcție. Ai expus o altă gaură în mașină.

Reglat manual înseamnă că cineva deține rezultatul

O API largă este ușor de promovat. Deținerea largă la nivel de mașină este mult mai grea. Core nu consideră o operație acoperită doar pentru că o implementare generică compilează pe altă țintă. Căile acceptate sunt implementate și reglate pentru combinația lor reală de operație, reprezentare, împachetare, backend și set de instrucțiuni.

Înmulțirea binară de matrice pe AVX-512 nu este tratată ca înmulțire de matrice în virgulă mobilă cu valori mai mici. Operațiile cu biți împachetați folosesc instrucțiunile de biți disponibile pe mașină. Operațiile cu numere întregi și punct fix folosesc acumulatorul corect și comportamentul corect de overflow. Căile GPU folosesc structura de execuție a țintei. Implementările scalare rămân prezente ca referință și planșeu universal. Asta creează un răspuns responsabil la o întrebare simplă: ce cod a efectuat efectiv această operație pe această mașină? Core poate numi calea.

Scrisă pentru ceea ce se calculează efectiv.

Instrucțiuni de biți pentru biți, nu flotanți scalați.

Comportament corect de overflow, prin design.

Kernel-uri NEON scrise pentru arhitectura vectorială proprie a ARM.

Această deținere trebuie să continue dincolo de kernel și pe tot parcursul ciclului de viață al modelului.

O singură mașină de la definiție la inferență

Un singur ciclu de viață, un singur sistem

stațiile pe care modelul nu le părăsește niciodată

Antrenat pentru reprezentarea pe care o va folosi.

Odată ce ciclul de viață este coerent, variația poate deveni un contract, nu un accident.

Core declară contractul căii care a rulat efectiv. Căile Core Native binare, ternare, întregi cu semn și fără semn, în virgulă fixă, adaptive și exacte sunt pur deterministe acolo unde sunt acoperite, fără seed. Căile Core Native în virgulă flotantă, bfloat, cu scalare pe bloc și microscalate folosesc reluare cu seed. Core opțional pe Kera face căile acceptate din acele familii flotante pur deterministe și ele.

Un flux de lucru reglementat cu biți mici, format Q sau adaptiv poate cere reluare Core Native identică bit cu bit. Un flux de lucru cu familie flotantă poate folosi un seed fixat și o înregistrare completă sub Core Native. Eșantionarea creativă rămâne o alegere separată de generare. O implementare care cere execuție pur deterministă bfloat, cu scalare pe bloc, microscalată sau în virgulă flotantă convențională poate folosi Core pe Kera și poate elimina seed-ul. Acestea sunt contracte declarate diferite pentru celula selectată, nu nume de marketing interschimbabile pentru fiecare răspuns repetat.

Căi binare, întregi, Q, adaptive și exacte. Fără seed.

Reluare în virgulă flotantă, bfloat, cu scalare pe bloc și microscalată.

Căi acceptate din familii flotante, fără seed necesar.

nu este moștenită niciodată din întâmplare

Când comportamentul se schimbă, un singur sistem ar trebui să dețină în continuare explicația.

Când un rezultat de producție se schimbă într-un stack fragmentat, responsabilitatea este distribuită. Cadrul dă vina pe exportator. Exportatorul dă vina pe runtime. Runtime-ul dă vina pe kernel. Kernel-ul dă vina pe driver. Driver-ul dă vina pe hardware. Core aduce aceste responsabilități într-un singur sistem.

Definiția modelului, alegerile numerice, backend-ul selectat, calea de dispatch, modul de determinism și înregistrarea de execuție rezultată pot fi examinate împreună. Asta nu înseamnă că fiecare dependență externă dispare. Sursele de date, aplicațiile, sistemele de operare și hardware-ul există în continuare. Înseamnă că mașina AI în sine are o singură graniță responsabilă. O revizuire poate întreba ce implementare a rulat, pe ce țintă acceptată și sub ce contract de reluare, fără a asambla răspunsul din sistemele interne ale mai multor furnizori.

Calea selectată și mașina pe care a rulat.

Înregistrarea care permite ca rularea să fie examinată din nou.

Core păstrează o singură mașină AI, dar are două posturi de execuție.

Oricare postură ar trebui să permită implementarea fără a înlocui sistemul AI.

Hardware-ul se poate schimba fără a înlocui sistemul AI