🤖 machine learning

Kilobyte Models: Neural Networks as a Seed and a Quantized Latent

Dit artikel introduceert "Kilobyte Models", een compressietechniek die neurale netwerken opslaat als een compact gekwantiseerde latente vector en een reproduceerbare integer seed in plaats van volledige gewichten, wat extreme opslagefficiëntie mogelijk maakt terwijl de nauwkeurigheid vergelijkbaar blijft met agressieve gewichtsquantisatie.

Oorspronkelijke auteurs: Sahil Rajesh Dhayalkar

Gepubliceerd 2026-08-04

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Sahil Rajesh Dhayalkar

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een enorme, ingewikkelde blauwdruk van een robot probeert te versturen naar een vriend aan de andere kant van de wereld. De blauwdruk is zo groot dat het dagen zou duren om hem per post te versturen, en de brievenbus van je vriend is piepklein. In de wereld van kunstmatige intelligentie worden deze "blauwdrukken" neurale netwerken genoemd, en zij zijn de hersenen achter alles, van fotofilters tot zelfrijdende auto's. Meestal moet je, om een brein te versturen, elk afzonderlijk getal versturen dat het laat werken — miljoenen of zelfs miljarden van die getallen. Dit is een enorm probleem voor apparaten zoals smartwatches of telefoons die een beperkte opslagruimte of trage internetverbindingen hebben.

Een lange tijd probeerden wetenschappers dit op te lossen door de getallen zelf te verkleinen (minder nauwkeurig te maken) of de getallen weg te laten die minder belangrijk leken. Maar er is een andere manier om ernaar te kijken: in plaats van de hele blauwdruk te sturen, wat als je alleen een klein "recept" of een geheime code stuurt? Als je vriend over een standaard set gereedschappen (een willekeurige generator) beschikt en het recept heeft, kan hij in zijn eigen keuken exact dezelfde robot weer opbouwen. Dit idee berust op het feit dat deze AI-hersenen eigenlijk niet miljarden unieke getallen nodig hebben om te functioneren; ze verschuilen zich vaak in een veel kleinere, eenvoudigere ruimte. De grote vraag is: kunnen we een gigantisch AI-brein verkleinen tot de omvang van een paar tekstberichten zonder de intelligentie te verliezen?

Dit artikel introduceert een slimme nieuwe methode genaamd "Kilobyte Models" die precies dat probeert te doen. In plaats van de werkelijke gewichten (de getallen die de AI laten denken) op te slaan, stelt de auteur voor om slechts twee kleine dingen op te slaan: een willekeurige "seed" (zoals een startgetal voor een spel) en een zeer korte, gecomprimeerde "latente" vector (een klein lijstje met instructies). Wanneer de AI moet draaien, gebruikt het apparaat de seed om de enorme, willekeurige "steiger" te regenereren die het nodig heeft, en gebruikt het vervolgens de kleine lijst met instructies om die steiger aan te passen tot het uiteindelijke brein.

De onderzoekers ontdekten dat deze aanpak verrassend goed werkt. In hun experimenten slaagden ze erin om een neuraal netwerk terug te brengen tot slechts enkele kilobytes — ongeveer de omvang van een kort tekstbericht — terwijl het bijna even slim bleef als het origineel. Zo comprimeerden ze een model dat handgeschreven cijfers herkent (MNIST) tot slechts 2 KB, en het gaf nog steeds 98,6% van de antwoorden correct. Nog indrukwekkender is dat ze lieten zien dat deze methode veel beter omgaat met extreme compressie dan traditionele methoden. Terwijl een standaard AI-model misschien crasht en onbruikbaar wordt als je het probeert te verkleinen naar 4 bits (een zeer kleine hoeveelheid data), bleef hun "Kilobyte Model" sterk en accuraat.

Het artikel verkende ook het gebruik hiervan als een "delta" of een kleine update voor een gigantisch, vooraf getraind AI-model. Stel je voor dat je een superintelligente AI hebt die alles weet over dieren, en je wilt dat deze specifiek leert over katten. In plaats van het hele nieuwe brein te sturen, stuur je alleen een 4 KB "patch" (de seed en de kleine latente vector) die het gigantische brein vertelt hoe het zijn focus moet verschuiven. Deze patch was duizenden malen kleiner dan het volledige model, maar stelde de AI er toch in om de nieuwe taak effectief te leren.

De auteur merkt echter voorzichtig op dat dit geen toverstaf is voor alles. De methode werkt het best wanneer het "recept" (de latente vector) groot genoeg is om de noodzakelijke instructies te bevatten; als de taak te moeilijk is of het recept te klein, raakt de AI een beetje in de war. Ook al is het bestand dat je stuurt heel klein, de computer moet het volledige brein nog steeds in zijn geheugen opbouwen om het te laten draaien, dus het maakt het computerwerk niet sneller, alleen makkelijker te dragen. Tot slot werkt deze truc momenteel voor standaard AI-netwerken, maar is het nog niet getest op de enorme "Large Language Models" die chatbots aansturen.

Kortom, het artikel suggereert dat door het opslaan van miljoenen getallen in te ruilen voor een kleine seed en een korte instructielijst, we krachtige AI-hersenen in ruimtes van slechts enkele kilobytes kunnen passen. Het is alsof je beseft dat je niet de hele bibliotheek naar een vriend hoeft te mailen; je hoeft alleen maar een specifiek boekennummer en een paar aantekeningen te mailen, en hij kan exact het boek dat hij nodig heeft printen met zijn eigen printer.

Technische Samenvatting: Kilobyte-modellen

Probleemstelling

De kosten voor opslag en transmissie van getrainde neurale netwerken schalen lineair met hun aantal parameters, wat een kritieke flessenhals vormt voor bandbreedtebeperkte implementaties zoals edge-apparaten, over-the-air updates en massaal geschaalde adapters. Hoewel standaard compressietechnieken (pruning, kwantisatie, low-rank factorisatie, distillatie) de beschrijving van gewichtstensors verminderen, vereisen ze nog steeds het opslaan van een aanzienlijk deel van de oorspronkelijke parameterset. De auteur identificeert een behoefte aan een extreem compressieparadigma waarbij het inzetbare artefact niet de gewichten zelf zijn, maar een compact "recept" voor het regenereren ervan.

Methodologie

Het paper introduceert Kilobyte-modellen, een framework dat een neuraal netwerk representeert als een deterministische integer seed en een korte, gekwantiseerde latente vector. Deze aanpak bouwt voort op Mapping Networks (Sen en Mukherjee 2026), die netwerkgewichten uitdrukken als een niet-lineaire functie van een compacte trainbare latente vector en een vaste willekeurige basis.

Kernmechanisme

Reparametrisatie: In plaats van gewichten $\theta$ direct te optimaliseren, optimaliseert het model een latente vector $z \in \mathbb{R}^d$ (waarbij $d \ll P$ , en $P$ het totale aantal parameters is). De gewichten worden gegenereerd via een vaste kaart $g(z)$ :
$g(z) = \sigma(W_0 z + \alpha \|z\|_2^2 \mathbf{1} + b_0)$
Hierbij is $W_0$ een vaste projectiematrix, $b_0$ een vaste initialisatiecentra, en $\sigma$ een niet-lineariteit (tanh).
Seed-gebaseerde Regeneratie: De vaste componenten ( $W_0$ en $b_0$ ) worden niet opgeslagen. In plaats daarvan worden ze deterministisch geregenereerd vanuit een integer seed $s$ met behulp van een reproduceerbare, blokgewijze willekeurige basis. Dit stelt de ontvanger in staat om de volledige projectiematrix te reconstrueren zonder deze op te slaan, mits zij de seed bezitten.
Samenstelling van het Artefact: Het inzetbare artefact $A$ $A$ bestaat uit:
- Seed ( $s$ ): Een 64-bits integer (8 bytes) die wordt gebruikt om de basis te regenereren.
- Gekwantiseerde Latente ( $Q_b(z^*)$ ): De getrainde latente vector gekwantiseerd naar $b$ bits.
- Normalisatieparameters ( $\theta_{norm}$ ): Een kleine set normalisatie affiene parameters (schaal/verschuiving) die letterlijk worden opgeslagen, aangezien deze buiten het bereik van de generatiemap liggen.
Schaalbare Basisgeneratie: Om netwerken te verwerken waarbij de projectiematrix het geheugen van het apparaat overschrijdt, hanteert de auteur een blokgewijze generatiestrategie. De matrix wordt rij-voor-rij geconstrueerd met behulp van een pseudo-willekeurige generator die wordt ge-seed door een combinatie van de master seed en de blokindex, waardoor volledige matrix-materialisatie wordt vermeden.
Fine-tuning als een Delta: Het framework breidt zich uit naar fine-tuning door de latente vector te behandelen als een gecomprimeerde adapter. De kaart genereert een verplaatsing van een bevroren pre-trained basis ( $\theta_{ft} = \theta_{pre} + W_0 z$ ), waarbij alleen de seed en de gekwantiseerde delta hoeven te worden verzonden.

Trainingsregimes

Single Latent Vector Training (SLVT): Een enkele latente vector genereert alle parameters.
Layer-Wise Training (LWT): Afzonderlijke latente vectoren worden aan elke laag toegewezen, wat fijnere controle en allocatie van het latente budget naar gelang de moeilijkheidsgraad van de laag mogelijk maakt.
Kwantisatiestrategieën: Het paper evalueert zowel Post-Training Quantization (PTQ) als Quantization-Aware Training (QAT), waarbij de latente vector wordt verfijnd met gesimuleerde afronding om te overleven bij agressieve reductie van de bitbreedte.

Belangrijkste Bijdragen

Formalisering van het Kilobyte-model: De auteur definieert een inzetbaar artefact waarvan de grootte wordt bepaald door de latente dimensie $d$ en bitbreedte $b$ in plaats van het aantal parameters $P$ , en formaliseert de afruil tussen opslag en capaciteit.
Seeded Basis op Schaal: Introductie van een blokgewijze, reproduceerbare willekeurige basis die gewichtsregeneratie voor grote netwerken mogelijk maakt zonder dat de projectiematrix in het geheugen hoeft te verblijven.
Fine-tuning Adaptatie: Uitbreiding van de parametrisatie om kilobyte-grote adapters voor pre-trained modellen te creëren, wat een hyper-gecomprimeerd alternatief biedt voor standaard parameter-efficiënte fine-tuning methoden.
Empirische Validatie: Demonstratie dat Kilobyte-modellen de nauwkeurigheid van agressief gekwantiseerde netwerken kunnen evenaren terwijl ze slechts een fractie van de opslagruimte innemen.

Experimentele Resultaten

De auteur heeft de aanpak geëvalueerd op Convolutional Neural Networks (CNN's), LSTM's en Multi-Layer Perceptrons (MLP's) over diverse datasets (MNIST, FashionMNIST, Beijing Air Quality, HIGGS, Covertype, Oxford-IIIT Pets).

Extreme Compressie: Een 4-bit gemapt model bereikte 98,6% nauwkeurigheid op MNIST met slechts 2 KB opslag (een 26 $\times$ reductie ten opzichte van een gekwantiseerde baseline).
Regressietaken: Op een tijdreeks-regressietaken bereikte een 4-bit QAT-model een MSE van 0,00061 met slechts 140 bytes, ongeveer 370 $\times$ kleiner dan het full-precision model.
Fine-tuning Efficiëntie: Bij het fine-tunen van een ResNet-50 op de Oxford-IIIT Pets dataset bereikte een 4-bit QAT-adapter 88,4% nauwkeurigheid in slechts 4 KB. In contrast hiermee stortte een volledige ResNet-50 die naar 4-bit PTQ was gecomprimeerd, in tot een nauwkeurigheid van 2,9%.
Vergelijking met SOTA: De Kilobyte-adapter presteerde beter dan VeRA (een parameter-efficiënte methode) bij strikte kilobyte-budgetten (4 KB vs. 13,9 KB voor vergelijkbare nauwkeurigheid). Hoewel LoRA en VeRA een hogere nauwkeurigheid bereikten met grotere opslagbudgetten (tot 0,6 MB), behield het Kilobyte-model een superieure prestatie in het ultra-lage opslagregime.
Impact van Kwantisatie: Er werd vastgesteld dat Quantization-Aware Training (QAT) cruciaal is voor het behoud van nauwkeurigheid bij lage bitbreedtes (4-bit), terwijl Post-Training Quantization (PTQ) aanzienlijke prestatieverliezen leed.

Betekenis en Claims

Het paper claimt dat Kilobyte-modellen een krachtige strategie vormen voor bandbreedtebeperkte implementaties door de opslaggrootte van een model los te koppelen van het aantal parameters. Door de compressiebelasting volledig te verschuiven naar een compacte latente ruimte en gebruik te maken van reproduceerbare willekeurige bases, demonstreert de auteur dat modellen kunnen worden opgeslagen en verzonden in kilobytes terwijl een hoge nauwkeurigheid behouden blijft.

De auteur positioneert dit werk als een aanvulling op, in plaats van een vervanging voor, standaard compressietechnieken. Waar standaard methoden gewichtstensors verkleinen, vermijden Kilobyte-modellen het volledig representeren van de volledige parameterset tijdens de optimalisatie. Het framework is bijzonder significant voor scenario's waar de opslaggrootte de beperkende factor is (bijv. over-the-air updates voor edge-apparaten), waarbij een reductie van 5 tot 160 $\times$ in artefactgrootte wordt geboden ten opzichte van volledige fine-tuning of standaard parameter-efficiënte methoden, zij het met een lichte nauwkeurigheidsafruil op complexe datasets.

Erkende Beperkingen:

Inference Compute: De methode comprimeert niet de inferentie-latentie of het geheugengebruik, aangezien gewichten als dense floating-point waarden worden geregenereerd vóór de inferentie.
Capaciteitsbottleneck: De nauwkeurigheid wordt beperkt door de latente dimensie $d$ , wat leidt tot een lichte prestatiekloof ten opzichte van volledige netwerken op moeilijkere datasets.
Afhankelijkheid: Fine-tuning vereist dat het base pre-trained model aanwezig is op het implementatieapparaat.
Architectuur Scope: De huidige implementatie strekt zich niet uit tot Transformers of Large Language Models.