Safetensors, CKPT, ONNX, GGUF en andere belangrijke AI-modelformaten [2025]

De groei van kunstmatige intelligentie en machine learning heeft geleid tot een cruciale behoefte aan methoden om modellen op te slaan en te distribueren die efficiënt, veilig en compatibel zijn met verschillende systemen. Naarmate modellen complexer worden en in steeds meer diverse omgevingen worden ingezet, is de keuze van het serialisatieformaat een belangrijke beslissing. Deze keuze beïnvloedt de prestaties, het resourcegebruik en de veiligheid van AI-systemen.

Dit rapport onderzoekt de toonaangevende formaten voor modelserialisatie, waaronder Safetensors, CKPT, ONNX en GGUF. Het belicht hun unieke kenmerken, veelvoorkomende toepassingen en hoe ze zich tot elkaar verhouden.

1. Inleiding tot modelserialisatie in AI/ML

Modelserialisatie is het proces waarbij een getraind machinelearningmodel wordt opgeslagen in een bestand. Dit bestand kan vervolgens worden bewaard, gedeeld of opnieuw geladen voor later gebruik, zoals voor het doen van voorspellingen, het voortzetten van training of het uitvoeren van analyses. Deze mogelijkheid is essentieel voor de gehele levenscyclus van AI/ML, van onderzoek en ontwikkeling tot grootschalige implementatie.

De cruciale rol van modelformaten in de AI/ML-levenscyclus

Het opslaan van modellen in een standaardformaat is om verschillende redenen cruciaal:

• Reproduceerbaarheid: Het stelt onderzoekers in staat om experimenten nauwkeurig te repliceren en te valideren.
• Samenwerking: Standaardformaten maken het voor teams eenvoudig om modellen te delen, waardoor ze beter kunnen samenwerken en modellen in grotere systemen kunnen integreren.
• Implementatie: Serialisatie zet een getraind model om in een draagbaar bestand dat in verschillende omgevingen kan worden geladen en uitgevoerd, van cloudservers tot edge-apparaten.
• Transfer learning: Het maakt het gebruik van vooraf getrainde modellen als basis voor nieuwe taken mogelijk, wat aanzienlijke trainingstijd en data bespaart.

Overzicht van uitdagingen die door moderne formaten worden aangepakt

Naarmate machine learning is geëvolueerd, hebben moderne serialisatieformaten zich ontwikkeld om verschillende belangrijke uitdagingen op te lossen:

• Veiligheid: Een groot punt van zorg is het veiligheidsrisico bij traditionele methoden, met name die welke de pickle-module van Python gebruiken. Deze methoden kunnen kwaadaardige code uitvoeren wanneer een model wordt geladen, wat een ernstige veiligheidsdreiging vormt als het model afkomstig is van een onbetrouwbare bron.
• Prestaties: De grote en complexe modellen van vandaag vereisen zeer snelle laadtijden en efficiënt geheugenbeheer. Dit is vooral belangrijk voor apparaten met beperkte middelen, zoals mobiele telefoons, en voor toepassingen die onmiddellijke reacties vereisen.
• Portabiliteit en interoperabiliteit: De wereld van machine learning gebruikt veel verschillende frameworks (zoals PyTorch, TensorFlow en JAX). Er zijn formaten nodig die modellen gemakkelijk tussen deze frameworks kunnen verplaatsen en op verschillende hardware (GPU's, TPU's) kunnen draaien zonder ingrijpende aanpassingen.

In de afgelopen jaren is de AI-gemeenschap overgestapt op efficiëntere en veiligere formaten zoals GGUF en Safetensors, wat een gezamenlijke inspanning weerspiegelt om deze problemen aan te pakken.

Vroege methoden voor het opslaan van ML-modellen, zoals het gebruik van de pickle-module van Python door PyTorch voor zijn .pt- en .pth-bestanden, werden gekozen vanwege hun gebruiksgemak. Ze konden complexe Python-objecten gemakkelijk opslaan, inclusief zowel het ontwerp van het model als de trainingstoestand (zoals de optimizer). Hoewel dit handig was voor onderzoek in een Python-omgeving, creëerde het een groot veiligheidslek. De pickle-module is zo ontworpen dat het elke code kan uitvoeren die in een bestand is ingebed tijdens het laadproces. Dit betekent dat het laden van een ogenschijnlijk onschuldig model van een onbetrouwbare bron een heel systeem in gevaar kan brengen.

De creatie van formaten zoals Safetensors, samen met het groeiende gebruik van ONNX en GGUF, is een directe reactie op dit veiligheidsrisico en op de behoefte aan betere prestaties en portabiliteit. Safetensors werd bijvoorbeeld specifiek ontwikkeld om de uitvoering van kwaadaardige code te voorkomen. Dit toont aan dat naarmate het veld van machine learning volwassener wordt en AI zich verplaatst van onderzoek naar praktijktoepassingen, veiligheid en efficiëntie niet langer bijzaak zijn, maar kernprincipes bij het ontwerpen van nieuwe formaten. Deze verandering vertegenwoordigt een noodzakelijke verschuiving van op onderzoek gerichte flexibiliteit naar productieveilige robuustheid, waarmee de 'technische schuld' van oudere, meer permissieve methoden wordt aangepakt.

Framework-specifieke formaten, zoals .pt/.pth voor PyTorch en .ckpt/.h5 voor TensorFlow/Keras, zijn nauw geïntegreerd met hun specifieke frameworks. Hoewel dit ze efficiënt maakt binnen één ecosysteem, veroorzaakt het aanzienlijke problemen met interoperabiliteit. Een model dat in het ene framework is getraind, kan niet gemakkelijk in een ander worden gebruikt zonder complexe conversies of het onderhouden van afzonderlijke systemen voor elk framework. Dit leidt tot onsamenhangende ontwikkelings- en implementatieworkflows.

Het ONNX-formaat (Open Neural Network Exchange) werd gecreëerd om deze barrières te doorbreken. Het biedt een 'cross-platform' en 'leverancier-neutrale' standaard voor modellen. Dit bereikt het door de structuur van het model (de computatiegraaf) op een abstracte manier te definiëren die onafhankelijk is van een specifiek framework. Ook GGUF, hoewel oorspronkelijk gemaakt voor het llama.cpp-project, richt zich op het verbeteren van de compatibiliteit voor grote taalmodellen (LLM's) op verschillende platforms.

De verscheidenheid aan formaten weerspiegelt vandaag de dag een kernspanning in de ML-industrie: de wens voor framework-specifieke functies tijdens de ontwikkeling (bv. de dynamische graaf van PyTorch voor onderzoeksflexibiliteit) versus de noodzaak van universele, efficiënte en veilige implementatie. Deze spanning betekent dat er meerdere formaten zullen blijven bestaan, waardoor conversietools en geavanceerde MLOps-pijplijnen steeds belangrijker worden om modelontwikkeling met implementatie te verbinden. Verschillende formaten zullen gebruikt blijven worden voor specifieke fasen van de ML-levenscyclus, op basis van hun unieke sterke punten.

2. Inzicht in Safetensors

Safetensors is een grote stap voorwaarts in modelserialisatie, specifiek ontworpen om de veiligheids- en efficiëntieproblemen van traditionele methoden voor modelopslag op te lossen.

Definitie en kernprincipes van het ontwerp

Safetensors is een modern, veilig en snel serialisatieformaat voor deeplearningmodellen, ontwikkeld door Hugging Face. Het hoofddoel is een veilige manier te bieden om tensoren – de multidimensionale arrays die de fundamentele databouwstenen van machine learning zijn – op te slaan en te delen. Het formaat is ontworpen om veiliger en sneller te zijn dan oudere formaten zoals pickle.

Een kernprincipe van Safetensors is de strikte scheiding van modelgewichten (tensoren) en uitvoerbare code. Dit ontwerp pakt de veiligheidslekken in oudere serialisatiemethoden direct aan.

Belangrijkste kenmerken

• Zero-copy en lazy loading: Een sleutel tot de prestaties van Safetensors is de 'zero-copy'-mogelijkheid. Hiermee kunnen modelgegevens direct van de schijf in het geheugen worden gemapt zonder extra kopieën te maken, wat geheugen bespaart en het laden versnelt. Het ondersteunt ook 'lazy loading', wat betekent dat alleen de noodzakelijke delen van een groot model in het RAM worden geladen wanneer dat nodig is. Dit is zeer nuttig voor extreem grote modellen of systemen met beperkt geheugen.
• Gestructureerde metadatabehandeling: Elk Safetensors-bestand bevat een afzonderlijke metadatsectie in JSON-formaat. Deze sectie somt alle tensoren in het model op met details zoals hun vorm, datatype en naam. De metadata verwijst naar waar de daadwerkelijke tensordata afzonderlijk in het bestand is opgeslagen, wat zowel de leesbaarheid als de veiligheid verbetert.
• Alleen-tensor dataopslag: Het belangrijkste veiligheidskenmerk van Safetensors is dat het ontworpen is om 'alleen ruwe tensordata en bijbehorende metadata' te bevatten. Door zijn architectuur 'staat het niet toe om willekeurige Python-code te serialiseren'. Deze fundamentele ontwerpkeuze elimineert het risico op het uitvoeren van kwaadaardige code bij het laden van een model.
• Ondersteuning voor kwantisatie: Safetensors kan gekwantiseerde tensoren verwerken, wat helpt om modellen kleiner te maken en minder geheugen te gebruiken. De ondersteuning voor kwantisatie is echter 'niet zo flexibel als GGUF', omdat deze afhankelijk is van de functies die het PyTorch-framework biedt.

Voornaamste voordelen

• Verbeterde veiligheid (beperking van willekeurige code-uitvoering): Dit is het grootste voordeel van Safetensors. Het ontwerp voorkomt volledig dat Python-code in het bestand wordt opgeslagen. Dit elimineert het ernstigste veiligheidsrisico dat in op pickle gebaseerde formaten wordt aangetroffen: het uitvoeren van kwaadaardige code wanneer een model wordt geladen. Dit maakt Safetensors de beste keuze voor het delen en gebruiken van modellen van openbare of onbetrouwbare bronnen. Het formaat bevat ook andere beveiligingsfuncties zoals 'geavanceerde versleutelingstechnieken' en toegangscontroles om geknoei met data te voorkomen.
• Prestatieoptimalisatie: Het gebruik van zero-copy en lazy loading resulteert in 'snellere laadtijden en lager geheugengebruik'. Benchmarks tonen aan dat het veel 'sneller' is dan pickle en '76,6x sneller op CPU en 2x sneller op GPU kan zijn in vergelijking met de traditionele PyTorch'-opslagmethode.
• Portabiliteit: Het formaat is ontworpen om draagbaar te zijn, wat betekent dat het werkt in verschillende programmeertalen. Dit maakt het gemakkelijker om modellen te delen en te gebruiken in diverse softwaresystemen.
• Naadloze integratie: Safetensors biedt 'naadloze integratie met bestaande machinelearningframeworks en -bibliotheken'. Dit stelt ontwikkelaars in staat om dit veiligere formaat gemakkelijk over te nemen, zonder grote wijzigingen in hun huidige workflows aan te brengen.

Vergelijking met traditionele serialisatie (bv. Pickle)

De pickle-module van Python, die wordt gebruikt voor de .pt- en .pth-bestanden van PyTorch, is inherent onveilig. Het staat toe dat willekeurige code in een geserialiseerd bestand wordt verborgen en automatisch wordt uitgevoerd wanneer het bestand wordt geladen. Dit is een bekende en ernstige kwetsbaarheid, vooral bij het gebruik van modellen die van openbare websites worden gedownload. Hoewel tools zoals picklescan sommige kwaadaardige patronen kunnen detecteren, zijn ze niet waterdicht en kunnen ze de veiligheid niet garanderen.

Safetensors werd specifiek ontwikkeld om dit veiligheidsprobleem op te lossen. Door alleen ruwe tensordata en gestructureerde metadata in het bestand toe te staan, wordt de mogelijkheid om kwaadaardige code uit te voeren geëlimineerd. Naast veiligheid biedt Safetensors ook veel betere prestaties. Het ontwerp voor memory mapping en lazy loading leidt tot aanzienlijk snellere laadtijden en efficiënter geheugengebruik in vergelijking met pickle, dat doorgaans het hele model in één keer in het geheugen laadt.

Het veiligheidslek in Python's pickle betekent dat het downloaden van een .pt- of .pth-bestand van een onbetrouwbare bron niet alleen het downloaden van data is; het is als het uitvoeren van een potentieel schadelijk programma. Het is bekend dat er 'geen 100% waterdichte oplossing is om de veiligheid van een pickle-bestand te verifiëren zonder het uit te voeren'. Dit legt de last van het controleren van de veiligheid van het bestand bij de gebruiker, wat moeilijk en onbetrouwbaar is.

Safetensors verandert deze dynamiek door het formaat zelf opnieuw te ontwerpen om te voorkomen dat schadelijke code wordt opgenomen. Het verschuift de veiligheidsverantwoordelijkheid van het moeilijke verificatieproces van de gebruiker naar de ingebouwde veiligheid van het formaat. Dit markeert een belangrijke verschuiving in de open-source AI-gemeenschap van een 'verifieer en vertrouw dan'-aanpak naar een 'vertrouw op basis van ontwerp'-model. Deze verandering erkent dat het bijna onmogelijk is om te scannen op elke mogelijke dreiging in complexe bestanden. Door de aanvalsvector (willekeurige code-uitvoering) te blokkeren, maakt Safetensors het veiliger om modellen op grote schaal te delen, wat samenwerking bevordert en het voor meer mensen gemakkelijker maakt om vooraf getrainde modellen te gebruiken. Dit 'vertrouw op basis van ontwerp'-principe is essentieel voor de groei en veiligheid van het gehele AI-ecosysteem.

Hoewel Safetensors voornamelijk om veiligheidsredenen werd gecreëerd (om de kwetsbaarheden van pickle op te lossen), biedt het ook aanzienlijke prestatieverbeteringen, zoals sneller laden, lager geheugengebruik en zero-copy-operaties. Deze prestatiewinsten zijn niet slechts een bijeffect; ze zijn een direct gevolg van het geoptimaliseerde ontwerp van Safetensors, dat memory mapping en lazy loading gebruikt om data efficiënt te verwerken. Dit maakt het van nature efficiënter voor grote modellen.

Deze combinatie van verbeterde veiligheid en aanzienlijke prestatieverbeteringen is een belangrijke drijfveer geweest voor de wijdverbreide adoptie ervan. Als Safetensors alleen betere beveiliging had geboden, was de adoptie mogelijk langzamer verlopen, vooral onder gebruikers die niet direct op beveiliging gericht zijn. De duidelijke en meetbare prestatievoordelen bieden echter een sterke reden voor iedereen om over te stappen, wat de integratie in grote platforms zoals Hugging Face versnelt. Dit toont aan dat in AI-engineering een technologie vaak zowel beveiligings- als prestatievoordelen moet bieden om snel en breed door de industrie te worden geaccepteerd.

3. Overzicht van belangrijke modelformaten

Naast Safetensors zijn er verschillende andere formaten belangrijk in de wereld van machine learning, elk met zijn eigen kenmerken en toepassingen.

3.1. CKPT (Checkpoints)

Een AI-checkpoint is geen enkel bestandstype, maar eerder een momentopname van de staat van een model, opgeslagen op een specifiek punt tijdens de training. Checkpoints zijn essentieel voor het opslaan van voortgang tijdens lange trainingssessies.

Kenmerken en typische toepassingen

Een checkpoint bevat doorgaans de geleerde parameters van een model, zoals de gewichten en biases. Het kan ook andere belangrijke informatie opslaan die nodig is om de training te hervatten, zoals de staat van de optimizer, het huidige epochnummer en het leertempo-schema. De bestandsextensies voor checkpoints variëren per framework. Voor PyTorch zijn dit meestal .pt of .pth, terwijl het voor TensorFlow/Keras .ckpt of .h5 is.

Belangrijke voordelen van CKPT-bestanden zijn:

• Reproduceerbaarheid: Ze zorgen ervoor dat een model zich consistent gedraagt wanneer het opnieuw wordt geladen, wat essentieel is voor het valideren van onderzoek en het behouden van betrouwbare prestaties.
• Samenwerking: Ze zijn gemakkelijk te delen, waardoor ontwikkelaars resultaten kunnen repliceren of voortbouwen op bestaand werk.
• Flexibiliteit: De .pt/.pth-formaten van PyTorch zijn bijzonder flexibel, wat het eenvoudig maakt om modellen op te slaan en te laden voor onderzoeksdoeleinden.

Veelvoorkomende toepassingen voor CKPT-bestanden zijn:

• Training hervatten: Een onderbroken trainingssessie voortzetten, wat aanzienlijke tijd en rekenkracht bespaart.
• Fine-tuning: Een vooraf getraind model als startpunt gebruiken voor training op een nieuwe, specifiekere dataset.
• Model-evaluatie: De prestaties van een model in verschillende trainingsfasen testen zonder het opnieuw te hoeven trainen.
• Inferentie: Een volledig getraind model in een productiesysteem laden om voorspellingen te doen.
• Onderzoek en experimentatie: Analyseren hoe een model in de loop van de tijd evolueert en de parameters systematisch afstemmen.
• Transfer learning: Dienen als een krachtig startpunt voor gerelateerde taken, wat de trainingstijd en de benodigde data vermindert.
• Noodherstel: Fungeren als back-up om het werk te hervatten na een storing tijdens een lang trainingsproces.

Veiligheidsoverwegingen

Het grootste veiligheidsrisico bij CKPT-bestanden, met name de .pt- en .pth-formaten van PyTorch, komt voort uit hun afhankelijkheid van de pickle-module van Python. Dit betekent dat deze bestanden zo kunnen worden ontworpen dat ze kwaadaardige Python-code bevatten en uitvoeren wanneer ze worden geladen (als de functie torch.load wordt gebruikt zonder de instelling weights_only=True). Deze kwetsbaarheid (CWE-502: Deserialisatie van onbetrouwbare data) kan ernstige gevolgen hebben, zoals datadiefstal, gewijzigd modelgedrag of zelfs een volledige overname van het systeem.

De industrie heeft dit risico erkend, en Safetensors is naar voren gekomen als een veiliger alternatief. Zoals opgemerkt, 'De meeste Stable Diffusion AI-checkpoints worden opgeslagen in formaten zoals .ckpt of .safetensors... .safetensors is een veiliger alternatief, ontworpen om de uitvoering van kwaadaardige code te voorkomen.' Dit toont een duidelijke trend naar veiligere formaten voor het delen van modellen.

CKPT's, met name in het .pt/.pth-formaat van PyTorch, staan bekend als 'zeer flexibel'. Deze flexibiliteit stelt hen in staat om niet alleen modelgewichten op te slaan, maar ook de staat van de optimizer en zelfs aangepaste Python-klassen, wat zeer nuttig is om de training nauwkeurig te hervatten.

Echter, juist deze flexibiliteit creëert de veiligheidskwetsbaarheid. Omdat het formaat elk Python-object kan opslaan, kan een aanvaller kwaadaardige code in een modelbestand verbergen. Wanneer het bestand zonder de juiste voorzorgsmaatregelen wordt geladen, wordt die code uitgevoerd. Dit illustreert een fundamentele afweging in systeemontwerp: meer flexibiliteit leidt vaak tot een groter aanvalsoppervlak en grotere veiligheidsrisico's.

De oplossing van de industrie is om formaten zoals Safetensors te gebruiken voor het distribueren van modellen, zelfs als de flexibelere .pt/.pth-formaten nog steeds worden gebruikt voor training in gecontroleerde omgevingen. Dit toont een groeiend begrip dat verschillende fasen van de ML-levenscyclus verschillende beveiligingsniveaus vereisen. De kracht van het opslaan van de volledige trainingstoestand kan het beste binnen een vertrouwde ontwikkelomgeving worden gehouden, terwijl het delen en implementeren formaten vereisen met ingebouwde veiligheidsgaranties.

3.2. ONNX (Open Neural Network Exchange)

ONNX, wat staat voor Open Neural Network Exchange, is een open-standaardformaat voor machinelearningmodellen. Het is ontworpen om modellen te laten werken in verschillende deeplearningframeworks.

Kenmerken en voornaamste toepassingen

Een ONNX-bestand bevat de volledige structuur van een model, inclusief de reeks operaties (de computatiegraaf), de geleerde gewichten en andere metadata. Een grote kracht van ONNX is dat het fungeert als een universele vertaler. Modellen die zijn getraind in frameworks als PyTorch, TensorFlow of scikit-learn kunnen worden geconverteerd naar het ONNX-formaat, wat een 'train één keer, implementeer overal'-aanpak mogelijk maakt.

In tegenstelling tot formaten die alleen modelgewichten opslaan (zoals Safetensors of GGUF), bevat ONNX de computatiegraaf van het model. Deze op een graaf gebaseerde structuur biedt 'meer flexibiliteit bij het converteren van modellen tussen verschillende frameworks'. ONNX biedt uitstekende portabiliteit op vele platforms, apparaten en hardwareversnellers (CPU's, GPU's, AI-chips). De modellen worden opgeslagen in het Protobuf-formaat, wat een efficiënte, platformneutrale manier is om gestructureerde data op te slaan.

Voornaamste toepassingen van ONNX zijn:

• Cross-framework implementatie: Een model uitvoeren in een ander framework of een andere omgeving dan waarin het is getraind.
• Hoogwaardige inferentie: De ONNX Runtime is een inferentie-engine die modellen automatisch optimaliseert voor specifieke hardware, wat vaak leidt tot betere prestaties.
• Edge- en mobiele implementatie: De kleine voetafdruk en geoptimaliseerde runtime maken ONNX een goede keuze voor het uitvoeren van modellen op apparaten met beperkte middelen.
• Productiesystemen: De robuustheid en portabiliteit maken het populair voor het implementeren van modellen in veeleisende productieomgevingen.

Veiligheidsoverwegingen

Een subtiel maar ernstig veiligheidsrisico bij ONNX-modellen is het potentieel voor architecturale achterdeurtjes. Een aanvaller kan de computatiegraaf van een model wijzigen om een verborgen pad op te nemen dat alleen wordt geactiveerd door specifieke inputs. Wanneer geactiveerd, kan dit achterdeurtje ervoor zorgen dat het model kwaadaardige of onverwachte output produceert, terwijl het zich bij standaard inputs normaal gedraagt, wat detectie bemoeilijkt. Andere risico's zijn onder meer modelinversie-aanvallen (het extraheren van gevoelige trainingsdata) en vijandige aanvallen (het gebruik van kwaadaardige inputs om het model te misleiden).

Om deze dreigingen te verminderen, worden verschillende praktijken aanbevolen:

• Onderteken ONNX-modellen digitaal om te verzekeren dat er niet mee is geknoeid.
• Implementeer modellen in geïsoleerde omgevingen, zoals Docker-containers, met sterke netwerkbeveiliging.
• Gebruik monitoringtools om het modelgedrag te volgen en afwijkingen te detecteren.
• Volg algemene best practices voor beveiliging, zoals het saneren van inputs en het up-to-date houden van software.

ONNX is over het algemeen veiliger dan op pickle gebaseerde formaten omdat het geen willekeurige code uitvoert bij het laden. Als een ONNX-model echter gebruikmaakt van extern geïmplementeerde aangepaste lagen, kunnen die lagen potentieel kwaadaardige Python-code bevatten als ze niet zorgvuldig worden beheerd.

Nadelen

Hoewel ONNX gekwantiseerde modellen ondersteunt, 'ondersteunt het niet van nature gekwantiseerde tensoren' zo naadloos als GGUF dat doet. Het splitst ze op in afzonderlijke integer- en schaalfactortensoren, wat 'kan leiden tot verminderde kwaliteit'. Het converteren van modellen met complexe of aangepaste lagen die niet standaard zijn in ONNX kan ook moeilijk zijn en kan maatwerk vereisen dat de prestaties kan vertragen.

Traditionele formaten gebaseerd op Python's pickle (zoals .pt-bestanden) slaan Python-objecten op, die uitvoerbare code kunnen bevatten. Dit behandelt het model als een programma. ONNX richt zich daarentegen op het opslaan van de 'computatiegraaf' van het model – een meer abstracte weergave van de operaties en datastroom, in plaats van een specifieke code-implementatie.

Deze graaf-centrische aanpak geeft ONNX zijn uitstekende cross-framework portabiliteit en maakt het mogelijk om het te optimaliseren voor verschillende hardware. Door de logica van het model op een hoger niveau te definiëren, wordt het onafhankelijk van het framework waarin het is getraind. Dit is een belangrijke conceptuele verschuiving, van een framework-specifieke implementatie naar een draagbare computationele representatie. Hoewel dit de implementatieflexibiliteit aanzienlijk verbetert, creëert het ook nieuwe veiligheidsproblemen, zoals architecturale achterdeurtjes, die andere beveiligingsstrategieën vereisen dan die voor op pickle gebaseerde formaten.

3.3. GGUF (GPT-Generated Unified Format)

GGUF (GPT-Generated Unified Format) is een bestandsformaat dat speciaal is ontworpen voor het efficiënt opslaan en uitvoeren van grote taalmodellen (LLM's). Het is een verbeterde versie van zijn voorganger, GGML, en heeft als doel LLM's gemakkelijker in gebruik te maken, vooral op personal computers.

Kenmerken en voornaamste toepassingen

GGUF is ontworpen om LLM's kleiner en veel sneller te laden. Dit is cruciaal voor het lokaal uitvoeren van modellen, waar opslagruimte en RAM vaak beperkt zijn. Het formaat gebruikt 'geavanceerde compressietechnieken' om dit te bereiken. Het biedt ook een standaardmanier om de gewichten, architectuur en metadata van een model te verpakken, waardoor het consistent werkt in verschillende software, vooral met inferentie-engines gebaseerd op llama.cpp.

Een belangrijk kenmerk van GGUF is de uitstekende ondersteuning voor kwantisatie. Kwantisatie vermindert de numerieke precisie van de gewichten van een model (bijv. van 16-bits naar 4-bits getallen), wat de bestandsgrootte en de benodigde rekenkracht om het uit te voeren drastisch verlaagt. GGUF-modellen zijn beschikbaar in verschillende kwantisatieniveaus (van Q2 tot Q8), wat een reeks afwegingen biedt tussen grootte en kwaliteit.

• Lagere kwantisatieniveaus (zoals Q2 of Q3) resulteren in zeer kleine bestanden die kunnen draaien op hardware met minder RAM, maar mogelijk een lichte daling in modelkwaliteit hebben.
• Hogere kwantisatieniveaus (zoals Q6 of Q8) behouden een betere kwaliteit, maar vereisen meer opslag en RAM.

Voornaamste toepassingen van GGUF zijn:

• Lokale LLM-implementatie: Tools zoals Ollama gebruiken GGUF om het voor gebruikers gemakkelijk te maken om krachtige LLM's op hun eigen computers uit te voeren.
• Offline AI-assistenten: Veel toepassingen gebruiken GGUF-modellen om lokale, private alternatieven te bieden voor cloudgebaseerde AI-tools.
• Code-assistentie: IDE's en code-editors beginnen GGUF-modellen te gebruiken voor intelligente code-aanvulling.
• Lokale chatbots: GGUF-modellen worden vaak gebruikt voor private en responsieve conversationele AI-systemen.
• AI-onderzoek: De flexibiliteit en kwantisatie-ondersteuning maken het populair onder onderzoekers voor het experimenteren met LLM's op toegankelijke hardware.

Veiligheidsoverwegingen

In tegenstelling tot wat vaak wordt gedacht, heeft de onderliggende GGML-bibliotheek (waarop GGUF is gebaseerd) gedocumenteerde kwetsbaarheden gehad met betrekking tot 'onvoldoende validatie van het invoerbestand'. Deze fouten kunnen leiden tot 'potentieel misbruikbare geheugenbeschadigingskwetsbaarheden tijdens het parsen'. Specifieke beveiligingsproblemen zijn geïdentificeerd waarbij ongecontroleerde gebruikersinvoer heap-overflows kan veroorzaken, wat een aanvaller potentieel in staat stelt kwaadaardige code uit te voeren.

Er is een veelvoorkomende misvatting dat een GGUF-bestand 'geen code kan bevatten' en 'uitsluitend een modelbestand' is. Een beveiligingsrapport van Databricks toonde echter aan dat hoewel het GGUF-bestand zelf geen uitvoerbare Python-code bevat, een speciaal vervaardigd bestand fouten in de parser (de software die het bestand leest) kan misbruiken om geheugenbeschadiging te veroorzaken en code-uitvoering te bereiken.

Om deze risico's te verminderen, is het het beste om:

• Modellen en tools van bekende, gerenommeerde bronnen (zoals Koboldcpp) te gebruiken.
• LLM's in geïsoleerde omgevingen (zoals Docker-containers) uit te voeren.
• Voor zeer gevoelige taken een speciale machine zonder internettoegang te overwegen.

Nadelen

Een groot nadeel van GGUF is dat de meeste modellen eerst in andere frameworks (zoals PyTorch) worden ontwikkeld en naar het GGUF-formaat moeten worden geconverteerd. Dit conversieproces is niet altijd eenvoudig, en sommige modellen worden mogelijk niet volledig ondersteund door GGUF-compatibele tools. Bovendien is het wijzigen of fine-tunen van een model nadat het in het GGUF-formaat is, over het algemeen 'niet eenvoudig'.

Hoewel GGUF is ontworpen voor snel laden en efficiënt VRAM-gebruik, kan de daadwerkelijke inferentiesnelheid (hoe snel het model reacties genereert) soms langzamer zijn dan bij niet-gekwantiseerde modellen. Dit kan gebeuren bij lagere kwantisatieniveaus vanwege het extra werk dat nodig is om de gewichten tijdens de inferentie te dekwantiseren. Het belangrijkste prestatievoordeel van GGUF is dat het grote modellen in staat stelt om op consumentenhardware te draaien door VRAM te besparen, niet dat het ze noodzakelijkerwijs sneller maakt.

Het bepalende kenmerk van GGUF is de diepe integratie met kwantisatie, waardoor krachtige LLM's kunnen draaien op 'consumentenhardware' met beperkt VRAM. Dit helpt de toegang tot AI te democratiseren. Deze efficiëntie brengt echter afwegingen met zich mee. Hoewel kwantisatie modellen kleiner maakt, kunnen lagere niveaus de modelkwaliteit enigszins verminderen. Ook kan de inferentiesnelheid soms lager zijn dan bij niet-gekwantiseerde modellen, vooral als de niet-gekwantiseerde versie volledig in het VRAM past.

Het 'snelheidsvoordeel' van GGUF verwijst meestal naar sneller laden en de mogelijkheid om een groter model op beperkte hardware uit te voeren, in plaats van naar pure prestaties. GGUF vat de trend van 'democratisering van AI' perfect samen door geavanceerde modellen toegankelijk te maken voor meer mensen. Dit vereist dat gebruikers een balans vinden tussen modelkwaliteit en de beperkingen van hun hardware. De beschikbaarheid van meerdere kwantisatieniveaus stelt gebruikers in staat om modellen aan te passen aan hun specifieke behoeften, wat de sleutel is tot de populariteit van het formaat in de lokale AI-gemeenschap.

4. Vergelijkende analyse van formaten

De keuze van een geschikt modelserialisatieformaat is een strategische beslissing die afhangt van een balans tussen verschillende factoren, waaronder veiligheid, prestaties, resource-efficiëntie, interoperabiliteit en de specifieke toepassingscontext. De onderstaande tabel biedt een vergelijkend overzicht van Safetensors, CKPT, ONNX en GGUF op basis van deze kritieke dimensies.

Kenmerk / Formaat	Safetensors	CKPT (.pt/.pth)	ONNX	GGUF
Hoofddoel	Veilige, snelle tensoropslag voor deeplearningmodellen	Trainingscheckpoints, modelparameters, behoud van staat	Cross-framework interoperabiliteit, implementatie op diverse hardware	Efficiënte LLM-opslag, geoptimaliseerde lokale inferentie op consumentenhardware
Veiligheidsprofiel	Hoog (geen willekeurige code-uitvoering door ontwerp)	Laag (willekeurige code-uitvoering via Pickle-deserialisatie)	Gemiddeld (geen willekeurige code-uitvoering, maar architecturale achterdeurtjes mogelijk)	Gemiddeld (kwetsbaarheden in onderliggende bibliotheek, maar bestand zelf geen uitvoerbare Python-code)
Laadsnelheid	Zeer snel (zero-copy, lazy loading)	Varieert (kan langzamer zijn dan Safetensors door volledige lading)	Snel (geoptimaliseerde runtime, graafoptimalisaties)	Snel (mmap, efficiënt voor LLM's)
Geheugengebruik	Efficiënt (lazy loading, gedeeltelijk laden)	Kan hoog zijn (laadt volledige objectgraaf)	Efficiënt (runtime-optimalisaties)	Zeer efficiënt (kwantisatie, VRAM-besparing)
Schijfruimte	Efficiënt (compressie, alleen-tensor)	Varieert (kan groot zijn, bevat volledige staat)	Efficiënt (Protobuf-formaat)	Zeer efficiënt (kwantisatie, geavanceerde compressie)
Kwantisatie-ondersteuning	Ja, maar minder flexibel dan GGUF (PyTorch-afhankelijk)	Ja (framework-afhankelijk)	Beperkte native ondersteuning (decomprimeert tensoren)	Robuust (meerdere niveaus, Q2-Q8, gespecialiseerde varianten)
Portabiliteit	Hoog (tussen verschillende programmeertalen)	Laag (nauw verbonden met specifieke frameworks)	Zeer hoog (cross-framework, cross-platform, diverse hardware)	Hoog (vooral voor het llama.cpp-ecosysteem)
Voornaamste toepassingen	Veilig delen van modellen, standaard bij Hugging Face	Training, fine-tuning, onderzoek, modelopslag	Productie-implementatie, mobiel/edge, interoperabiliteit	Lokale LLM-inferentie, consumentenhardware, chattoepassingen
Belangrijkste voordeel	Veiligheid door ontwerp, snel laden, lage geheugenvoetafdruk	Behoud van trainingstoestand, gedetailleerde reproduceerbaarheid	Universele implementatie, runtime-optimalisatie, framework-agnostisch	Efficiëntie van LLM's op consumentenhardware, flexibele kwantisatie
Belangrijkste nadeel	JSON-parser vereist voor metadata in C++	Risico op willekeurige code-uitvoering, grote bestandsgroottes	Complexiteit bij aangepaste lagen, beperkte native kwantisatie	Conversie vaak vereist, potentieel tragere inferentie bij lagere kwantisaties

5. Conclusie

De wereld van machinelearningmodelformaten is voortdurend in ontwikkeling, gedreven door de behoefte aan betere veiligheid, prestaties en interoperabiliteit. Traditionele formaten, zoals op pickle gebaseerde CKPT-bestanden, waren flexibel voor onderzoek maar introduceerden ernstige veiligheidsrisico's door willekeurige code-uitvoering toe te staan. Dit heeft geleid tot de ontwikkeling en adoptie van nieuwere, veiligere formaten.

Safetensors is een toonaangevend voorbeeld van deze verschuiving. Door data van code te scheiden en efficiënte laadtechnieken te gebruiken, biedt het een veilig en performant alternatief voor het delen van deeplearningmodellen, vooral in het Hugging Face-ecosysteem. De dubbele voordelen van veiligheid en snelheid hebben het tot een populaire keuze gemaakt in moderne AI-workflows.

ONNX lost het grote probleem van framework-incompatibiliteit op. Door modellen te representeren als abstracte computatiegrafen, kunnen ze worden geïmplementeerd op verschillende hardware en software. Hoewel ONNX de willekeurige code-uitvoering van pickle voorkomt, heeft het zijn eigen veiligheidsproblemen, zoals architecturale achterdeurtjes, die andere beschermende maatregelen vereisen.

GGUF is een gespecialiseerde oplossing voor het uitvoeren van grote taalmodellen op consumentenhardware. De krachtige kwantisaiekenmerken verminderen de modelgrootte en het geheugengebruik drastisch, waardoor krachtige LLM's toegankelijk worden voor meer mensen. Deze efficiëntie kan echter soms resulteren in lagere inferentiesnelheden, en de onderliggende bibliotheken hebben kwetsbaarheden vertoond die vereisen dat gebruikers voorzichtig zijn.

Uiteindelijk hangt het beste formaat af van de specifieke context.

• Safetensors is de beste keuze voor het veilig en efficiënt delen van deeplearningmodellen.
• ONNX is ideaal voor het implementeren van modellen op verschillende frameworks en hardware.
• GGUF biedt ongeëvenaarde efficiëntie voor het uitvoeren van grote taalmodellen op lokale apparaten met beperkte middelen.

Hoewel traditionele CKPT-formaten nog steeds nuttig zijn voor het opslaan van trainingsvoortgang in gecontroleerde omgevingen, worden ze vervangen door veiligere alternatieven voor openbare distributie. Naarmate het AI-veld volwassener wordt, zal de voortdurende ontwikkeling van deze gespecialiseerde formaten essentieel zijn voor het bevorderen van de kracht en het bereik van machine learning.