AI-computestack voor training en inferentie | Dweve Core

Kies de doelgroep die bij je vraag past

De pagina bevat drie selecteerbare lezingen van hetzelfde onderwerp.

AI-codeagent en ondersteuning voor operators. Demostatistieken zijn illustratief.

Terminal, zoeken, linting, tests, Git en meer.

Gespecialiseerde agents werken samen over verschillende aandachtspunten.

Elke stap wordt met een tijdstempel vastgelegd.

Beleid, controles en tests worden altijd uitgevoerd.

Bekijk diffs, vraag wijzigingen aan en geef definitief akkoord.

Speel elke sessie bit voor bit opnieuw af als review nodig is.

Autonome agents die code schrijven en bewijs bijhouden

om netwerk timeouts, 5xx-responses en idempotent-safe condities af te handelen. Pure helper, volledig unit-getest.

Draait op gewone computers, waar ondersteund

Jouw spullen kunnen thuisblijven, in Europa.

Opslagformaat is niet het accumulatortype

Dweve Core is een complete AI-computestack voor training en inferentie. De meeste AI-platforms dekken slechts een deel en laten de rest aan andere leveranciers over. Core houdt modelontwerp, training, inferentie, kernels, dispatch en deployment in één samenhangend systeem. Op ondersteunde binaire workloads verbruikt Core 96% minder energie dan een GPU-stack.

25 geregistreerde numerieke formaatfamilies

Gedeeltelijke systemen creëren permanente afhankelijkheid

De definitie en de uitvoering raken langzaam uit elkaar.

Compressie zit in de tool van iemand anders.

Nieuwe hardware, nieuw serveersysteem, nieuw gedrag.

De roadmap van de leverancier wordt jouw roadmap.

Geen enkel systeem kan het resultaat verklaren.

Afhankelijkheid blijft bestaan omdat de rekenruimte eronder maar deels wordt gedekt.

De implementatie is het strategische bezit

Core houdt veranderingen in getalbreedte, verpakking, hardware en implementatie binnen één systeem. Een algoritme wordt geen ander product wanneer het verhuist van een x86-server naar ARM, een GPU, een browser of een gespecialiseerd doel. De bewerking blijft tijdens die verhuizing benoemd, inzichtelijk en in handen van dezelfde machine, en elk pad is geregistreerd in plaats van afgeleid uit een formaatlabel.

Het implementatieregister omvat meer dan 2.900 bewerkingen, 76 bewerkingscategorieën en 25 geregistreerde numerieke formaatfamilies. Elk pad wordt bepaald langs negen dimensies: algoritme, datatype, breedte, verpakking, accumulator, backend, instructieset, dispatchbeleid en determinismemodus. Het representatiecontract houdt die numerieke en fysieke keuzes aan de bewerking verbonden. De visual hieronder zet de meeste dimensies vast, zodat een kleine representatieve doorsnede leesbaar blijft. De telling beschrijft een register van concrete cellen en contracten, geen bewering dat alleen een formaatlabel of brede capabilityvlag een uitvoeringspad verklaart.

Hoe het wordt opgeslagen, hoe het wordt opgeteld.

Welk pad wordt gekozen, onder welk contract.

Het voorbeeld is klein omdat het implementatieregister dat niet is.

Er komt een nieuwe breedte, verpakking, host of contract.

De machine kiest het pad voor de nieuwe cel.

Welke code draaide, op welke machine, expliciet vermeld.

Zelfde bezit, zelfde eigenaar, nieuwe voorwaarde.

De eerste geërfde aanname die Core wegneemt, is dat één datatype alles zou moeten domineren.

De processor moet net zo vervangbaar zijn als het datatype.

Core behandelt niet één acceleratorecosysteem als de definitie van AI en al het andere als een mindere poort. De operaties hebben scalaire referentie-implementaties en doelspecifieke paden voor de ondersteunde CPU-, GPU-, FPGA-, browser- en implementatiebackends. De runtime kiest een implementatie op basis van de beschikbare machine en het beleid dat aan het werk gekoppeld is.

Een moderne x86-processor kan zijn vectorinstructies gebruiken. ARM en Apple silicon kunnen hun eigen paden gebruiken. GPU's van NVIDIA, AMD en Apple kunnen hun eigen backends gebruiken. Browseruitvoering kan waar passend WebAssembly of WebGPU gebruiken. Implementatieprogramma's kunnen gespecialiseerde hardware als doel nemen. De processor is een bestemming voor de operatie. Hij is niet de eigenaar van het model.

x86-vectoren, eigen paden voor ARM en Apple silicon.

GPU's van NVIDIA, AMD en Apple op hun eigen backends.

Gespecialiseerde hardware voor implementatieprogramma's.

Brede doellabels zijn goedkoop. Het echte pad in eigen beheer hebben is moeilijker.

Het datatype werd niet ondersteund, de doelhardware veranderde, en de quantiser had een andere runtime nodig.

De serveerstack kon het resultaat niet reproduceren. Inkoop opende opnieuw een leveranciersonderzoek.

De quantiser had een andere runtime nodig

Het resultaat kon niet worden gereproduceerd

Je voegde geen functie toe. Je legde een nieuw gat in de machine bloot.

Handmatig afgesteld betekent dat iemand het resultaat in eigen beheer heeft

Een brede API is makkelijk te adverteren. Brede eigendom op machineniveau is veel moeilijker. Core telt een operatie niet als gedekt enkel omdat een generieke implementatie compileert voor een ander doel. De ondersteunde paden zijn geïmplementeerd en afgesteld op hun daadwerkelijke combinatie van operatie, representatie, packing, backend en instructieset.

Binaire matrixvermenigvuldiging op AVX-512 wordt niet behandeld als drijvendekommavermenigvuldiging met kleinere waarden. Packed-bit-operaties gebruiken de bitinstructies die de machine biedt. Integer- en fixed-point-operaties gebruiken de juiste accumulator en het juiste overflowgedrag. GPU-paden gebruiken de uitvoeringsstructuur van het doel. Scalaire implementaties blijven aanwezig als referentie en universele basis. Dat levert een verantwoord antwoord op een eenvoudige vraag: welke code voerde deze operatie op deze machine daadwerkelijk uit? Core kan het pad noemen.

Wat een gedekte cel in eigen beheer heeft

Geschreven voor wat daadwerkelijk berekend wordt.

Bitinstructies voor bits, geen geschaalde floats.

NEON-kernels voor ARM's eigen vectorarchitectuur.

Die verantwoordelijkheid moet doorlopen voorbij de kernel en over de hele levenscyclus van het model.

Eén machine van definitie tot inferentie

Het model wordt ontworpen in Core-termen.

Getraind voor de representatie die het gaat gebruiken.

Uitgevoerd door het systeem dat het trainde.

Gerouteerd naar het afgestelde pad voor de host.

Gebenchmarkt en gereproduceerd in dezelfde machine.

Zodra de levenscyclus coherent is, kan variatie een contract worden in plaats van een toeval.

Core vermeldt het contract van het pad dat daadwerkelijk draaide. Binaire, ternaire, signed en unsigned integer-, fixed-point-, adaptieve en exacte Core Native-paden zijn, waar gedekt, zuiver deterministisch zonder seed. Floating-, bfloat-, block-scaled en microscaled Core Native-paden gebruiken replay met een seed. Optionele Core op Kera maakt ondersteunde paden in die floatingfamilies eveneens zuiver deterministisch.

Een gereguleerde low-bit-, Q-format- of adaptieve workflow kan bit-identieke Core Native-replay eisen. Een workflow met floatingfamilies kan onder Core Native een vastgelegde seed en volledig record gebruiken. Creatieve sampling blijft een afzonderlijke generatiekeuze. Een deployment die zuiver deterministische bfloat-, block-scaled, microscaled of conventionele floating-pointuitvoering vereist, kan Core op Kera gebruiken en de seed weglaten. Dit zijn verschillende vastgelegde contracten voor de gekozen cel, geen uitwisselbare marketingnamen voor elk herhaald antwoord.

het geselecteerde pad vermeldt welk contract geldt

Binaire, integer-, Q-, adaptieve en exacte paden. Geen seed.

Replay van floating-, bfloat-, block-scaled en microscaled paden.

Ondersteunde floatingfamiliepaden, zonder seed vereist.

Als gedrag verandert, moet één systeem de verklaring in eigen beheer houden.

Wanneer een productieresultaat verandert in een gefragmenteerde stack, is de verantwoordelijkheid verspreid. Het framework geeft de exporter de schuld. De exporter geeft de runtime de schuld. De runtime geeft de kernel de schuld. De kernel geeft de driver de schuld. De driver geeft de hardware de schuld. Core brengt die verantwoordelijkheden samen in één systeem.

De modeldefinitie, numerieke keuzes, gekozen backend, dispatchpad, determinismemodus en het resulterende uitvoeringsrecord kunnen samen bekeken worden. Dat betekent niet dat elke externe afhankelijkheid verdwijnt. Databronnen, applicaties, besturingssystemen en hardware blijven bestaan. Het betekent dat de AI-machine zelf één verantwoorde grens heeft. Een beoordeling kan vragen welke implementatie draaide, op welk ondersteund doel en onder welk replaycontract, zonder het antwoord uit de interne systemen van verschillende leveranciers te moeten samenvoegen.

samen bekeken, niet verspreid over leveranciers

De definitie en de numerieke keuzes ervan.

Representatie, breedte, accumulator, modus.

Het gekozen pad en de machine waarop het draaide.

De registratie waarmee de run opnieuw kan worden bekeken.

Core is één AI-machine, maar heeft twee uitvoeringsvormen.

Elke vorm moet de implementatie kunnen laten bewegen zonder het AI-systeem te vervangen.

De hardware kan veranderen zonder het AI-systeem te vervangen

Infrastructuurbeslissingen mogen geen herschrijving van het model afdwingen. Core houdt het model, het operatoroppervlak, het numerieke ontwerp en het uitvoeringscontract binnen hetzelfde systeem, terwijl de implementatievorm verandert. De gekozen backend kan verschillen. De organisatie hoeft de AI-stack er niet omheen te herbouwen.