Safetensors, CKPT, ONNX, GGUF : les principaux formats de modèles d’IA en 2025

L'essor de l'intelligence artificielle et de l'apprentissage automatique a engendré un besoin critique de méthodes de stockage et de distribution des modèles qui soient efficaces, sécurisées et compatibles avec différents systèmes. À mesure que les modèles gagnent en complexité et sont utilisés dans des contextes de plus en plus variés, le choix du format de sérialisation devient une décision cruciale. Ce choix influe sur les performances, l'utilisation des ressources et la sécurité des systèmes d'IA.

Ce rapport examine les principaux formats de sérialisation de modèles, notamment Safetensors, CKPT, ONNX et GGUF. Il met en lumière leurs caractéristiques uniques, leurs usages courants et leurs différences.

1. Introduction à la sérialisation de modèles en IA/ML

La sérialisation de modèles est le processus qui consiste à sauvegarder un modèle d'apprentissage automatique entraîné dans un fichier. Ce fichier peut ensuite être stocké, partagé ou rechargé pour une utilisation ultérieure, comme pour effectuer des prédictions, poursuivre l'entraînement ou réaliser des analyses. Cette capacité est essentielle à l'ensemble du cycle de vie de l'IA et du ML, de la recherche et développement au déploiement à grande échelle.

Le rôle essentiel des formats de modèles dans le cycle de vie de l'IA/ML

La sauvegarde des modèles dans un format standard est cruciale pour plusieurs raisons :

• Reproductibilité : Elle permet de répliquer et de valider avec précision les expériences de recherche.
• Collaboration : Les formats standards facilitent le partage de modèles entre les équipes, leur permettant de travailler ensemble et d'intégrer des modèles dans des systèmes plus vastes.
• Déploiement : La sérialisation transforme un modèle entraîné en un fichier portable qui peut être chargé et exécuté dans divers environnements, des serveurs cloud aux appareils en périphérie de réseau (edge).
• Apprentissage par transfert : Elle permet d'utiliser des modèles pré-entraînés comme base pour de nouvelles tâches, ce qui permet d'économiser un temps d'entraînement et des données considérables.

Aperçu des défis relevés par les formats modernes

Avec les progrès de l'apprentissage automatique, les formats de sérialisation modernes ont évolué pour relever plusieurs défis majeurs :

• Sécurité : L'une des préoccupations majeures est le risque de sécurité inhérent aux méthodes traditionnelles, en particulier celles utilisant le module pickle de Python. Ces méthodes peuvent autoriser l'exécution de code malveillant lors du chargement d'un modèle, ce qui constitue une grave menace pour la sécurité si le modèle provient d'une source non fiable.
• Performance : Les modèles actuels, vastes et complexes, exigent un chargement très rapide et une gestion efficace de la mémoire. C'est particulièrement important pour les appareils aux ressources limitées, comme les téléphones mobiles, et pour les applications qui nécessitent des réponses immédiates.
• Portabilité et interopérabilité : Le monde de l'apprentissage automatique utilise de nombreux frameworks (comme PyTorch, TensorFlow et JAX). Il faut des formats qui permettent aux modèles de passer facilement d'un framework à l'autre et de s'exécuter sur différents matériels (GPU, TPU) sans remaniement majeur.

Ces dernières années, la communauté de l'IA s'est tournée vers des formats plus efficaces et plus sûrs comme GGUF et Safetensors, ce qui témoigne d'un effort collectif pour résoudre ces problèmes.

Les premières méthodes de sauvegarde des modèles de ML, comme l'utilisation par PyTorch du module pickle de Python pour ses fichiers .pt et .pth, ont été choisies pour leur facilité d'utilisation. Elles permettaient de sauvegarder facilement des objets Python complexes, y compris la conception du modèle et son état d'entraînement (comme l'optimiseur). Bien que pratique pour la recherche dans un environnement Python, cette méthode a créé une faille de sécurité majeure. Le module pickle est conçu de manière à pouvoir exécuter n'importe quel code intégré dans un fichier pendant le processus de chargement. Cela signifie que le chargement d'un modèle d'apparence inoffensive provenant d'une source non fiable pourrait compromettre un système entier.

La création de formats comme Safetensors, ainsi que l'utilisation croissante d'ONNX et de GGUF, est une réponse directe à ce risque de sécurité, ainsi qu'au besoin de meilleures performances et d'une plus grande portabilité. Safetensors, par exemple, a été conçu spécifiquement pour empêcher l'exécution de code malveillant. Cela montre qu'à mesure que le domaine de l'apprentissage automatique mûrit et que l'IA passe de la recherche aux applications du monde réel, la sécurité et l'efficacité ne sont plus des considérations secondaires, mais des principes fondamentaux dans la conception de nouveaux formats. Ce changement représente une évolution nécessaire, passant de la flexibilité axée sur la recherche à la sécurité et à la robustesse de niveau production, corrigeant ainsi la « dette technique » des anciennes méthodes plus permissives.

Les formats natifs aux frameworks, tels que .pt/.pth pour PyTorch et .ckpt/.h5 pour TensorFlow/Keras, sont étroitement intégrés à leurs environnements respectifs. Si cela les rend efficaces au sein d'un seul écosystème, cela cause d'importants problèmes d'interopérabilité. Un modèle entraîné dans un framework ne peut pas être facilement utilisé dans un autre sans conversions complexes ou sans maintenir des systèmes distincts pour chaque framework. Cela conduit à des flux de développement et de déploiement déconnectés.

Le format ONNX (Open Neural Network Exchange) a été créé pour faire tomber ces barrières. Il fournit une norme « multiplateforme » et « indépendante des fournisseurs » pour les modèles. Pour ce faire, il définit la structure du modèle (son graphe de calcul) de manière abstraite, indépendamment de tout framework. De même, GGUF, bien qu'initialement conçu pour le projet llama.cpp, se concentre également sur l'amélioration de la compatibilité des grands modèles de langage (LLM) sur différentes plateformes.

La variété des formats actuels reflète une tension fondamentale dans l'industrie du ML : le désir de fonctionnalités spécifiques au framework pendant le développement (par exemple, le graphe dynamique de PyTorch pour la flexibilité de la recherche) contre le besoin d'un déploiement universel, efficace et sécurisé. Cette tension signifie que de multiples formats continueront d'exister, rendant les outils de conversion et les pipelines MLOps avancés de plus en plus essentiels pour relier le développement des modèles à leur déploiement. Différents formats continueront d'être utilisés pour des étapes spécifiques du cycle de vie du ML en fonction de leurs atouts uniques.

2. Comprendre Safetensors

Safetensors représente une avancée majeure dans la sérialisation de modèles, conçue spécifiquement pour résoudre les problèmes de sécurité et d'efficacité des méthodes traditionnelles de stockage de modèles.

Définition et principes de conception fondamentaux

Safetensors est un format de sérialisation moderne, sécurisé et rapide pour les modèles d'apprentissage profond, créé par Hugging Face. Son objectif principal est de fournir un moyen sûr de stocker et de partager des tenseurs — les tableaux multidimensionnels qui sont les briques de données fondamentales de l'apprentissage automatique. Le format est conçu pour être plus sûr et plus rapide que les anciens formats comme pickle.

Un principe fondamental de Safetensors est sa séparation stricte entre les poids du modèle (tenseurs) et tout code exécutable. Cette conception répond directement aux failles de sécurité des anciennes méthodes de sérialisation.

Fonctionnalités clés

• « Zéro copie » et chargement paresseux : L'une des clés des performances de Safetensors est sa capacité de « zéro copie » (zero-copy). Elle permet de mapper les données du modèle directement du disque vers la mémoire sans créer de copies supplémentaires, ce qui économise de la mémoire et accélère le chargement. Il prend également en charge le « chargement paresseux » (lazy loading), ce qui signifie que seules les parties nécessaires d'un grand modèle sont chargées en RAM au besoin. C'est très utile pour les modèles extrêmement volumineux ou les systèmes à mémoire limitée.
• Gestion structurée des métadonnées : Chaque fichier Safetensors inclut une section de métadonnées distincte au format JSON. Cette section liste tous les tenseurs du modèle avec des détails tels que leur forme, leur type de données et leur nom. Les métadonnées indiquent où les données réelles des tenseurs sont stockées séparément dans le fichier, ce qui améliore à la fois la lisibilité et la sécurité.
• Stockage de données contenant uniquement des tenseurs : La caractéristique de sécurité la plus importante de Safetensors est qu'il est conçu pour ne contenir « que des données de tenseurs brutes et les métadonnées associées ». Par son architecture, il « ne permet pas la sérialisation de code Python arbitraire ». Ce choix de conception fondamental élimine le risque d'exécution de code malveillant lors du chargement d'un modèle.
• Prise en charge de la quantification : Safetensors peut gérer les tenseurs quantifiés, ce qui contribue à réduire la taille des modèles et leur consommation de mémoire. Cependant, sa prise en charge de la quantification n'est « pas aussi flexible que celle de GGUF » car elle dépend des fonctionnalités fournies par le framework PyTorch.

Principaux avantages

• Sécurité renforcée (atténuation de l'exécution de code arbitraire) : C'est le plus grand avantage de Safetensors. De par sa conception, il empêche totalement la sauvegarde de code Python dans le fichier. Cela élimine le risque de sécurité le plus grave des formats basés sur pickle : l'exécution de code malveillant lors du chargement d'un modèle. Cela fait de Safetensors le meilleur choix pour partager et utiliser des modèles provenant de sources publiques ou non fiables. Le format inclut également d'autres fonctions de sécurité comme des « techniques de chiffrement avancées » et des contrôles d'accès pour empêcher la falsification des données.
• Optimisation des performances : L'utilisation du « zéro copie » et du chargement paresseux se traduit par des « temps de chargement plus rapides et une consommation de mémoire plus faible ». Des tests de performance montrent qu'il est beaucoup « plus rapide » que pickle et peut être « 76,6 fois plus rapide sur CPU et 2 fois plus rapide sur GPU par rapport à la méthode de sauvegarde traditionnelle de PyTorch ».
• Portabilité : Le format est conçu pour être portable, ce qui signifie qu'il fonctionne avec différents langages de programmation. Il est ainsi plus facile de partager et d'utiliser des modèles dans divers systèmes logiciels.
• Intégration transparente : Safetensors s'intègre « de manière transparente avec les frameworks et bibliothèques d'apprentissage automatique existants ». Cela permet aux développeurs d'adopter facilement ce format plus sûr, sans apporter de modifications majeures à leurs flux de travail actuels.

Comparaison avec la sérialisation traditionnelle (par ex., Pickle)

Le module pickle de Python, utilisé pour les fichiers .pt et .pth de PyTorch, est intrinsèquement dangereux. Il permet de cacher n'importe quel code à l'intérieur d'un fichier sérialisé et de l'exécuter automatiquement lors du chargement du fichier. Il s'agit d'une vulnérabilité bien connue et grave, surtout lors de l'utilisation de modèles téléchargés depuis des sites publics. Bien que des outils comme picklescan puissent détecter certains schémas malveillants, ils ne sont pas infaillibles et ne peuvent garantir la sécurité.

Safetensors a été créé spécifiquement pour résoudre ce problème de sécurité. En n'autorisant que des données de tenseurs brutes et des métadonnées structurées dans le fichier, il élimine la possibilité d'exécuter du code malveillant. Au-delà de la sécurité, Safetensors offre également de bien meilleures performances. Sa conception pour le mappage mémoire et le chargement paresseux permet un chargement nettement plus rapide et une utilisation plus efficace de la mémoire par rapport à pickle, qui charge généralement l'intégralité du modèle en mémoire en une seule fois.

La faille de sécurité du module pickle de Python signifie que télécharger un fichier .pt ou .pth d'une source non fiable ne revient pas seulement à télécharger des données ; c'est comme exécuter un programme potentiellement dangereux. Il est admis qu'il n'existe « aucune solution 100 % infaillible pour vérifier la sécurité d'un fichier pickle sans l'exécuter ». La charge de la vérification de la sécurité du fichier incombe donc à l'utilisateur, ce qui est difficile et peu fiable.

Safetensors change cette dynamique en repensant le format lui-même pour empêcher l'inclusion de code malveillant dès le départ. Il déplace la responsabilité de la sécurité du difficile processus de vérification de l'utilisateur vers la sécurité intégrée du format. Cela marque un changement majeur dans la communauté de l'IA open-source, passant d'une approche « vérifier, puis faire confiance » à un modèle de « confiance par conception ». Ce changement reconnaît qu'il est presque impossible de détecter toutes les menaces possibles dans des fichiers complexes. En bloquant le vecteur d'attaque (exécution de code arbitraire), Safetensors rend le partage de modèles à grande échelle plus sûr, encourageant la collaboration et facilitant l'utilisation de modèles pré-entraînés par un plus grand nombre de personnes. Ce principe de « confiance par conception » est essentiel à la croissance et à la sécurité de l'ensemble de l'écosystème de l'IA.

Bien que Safetensors ait été créé principalement pour des raisons de sécurité (pour corriger les vulnérabilités de pickle), il offre également des gains de performance majeurs, tels qu'un chargement plus rapide, une consommation de mémoire plus faible et des opérations sans copie. Ces gains de performance ne sont pas un simple effet secondaire ; ils sont le résultat direct de la conception optimisée de Safetensors, qui utilise le mappage mémoire et le chargement paresseux pour gérer efficacement les données. Cela le rend naturellement plus efficace pour les grands modèles.

Cette combinaison d'une sécurité renforcée et d'améliorations significatives des performances a été un moteur clé de son adoption généralisée. Si Safetensors n'avait offert qu'une meilleure sécurité, son adoption aurait pu être plus lente, en particulier parmi les utilisateurs non immédiatement soucieux de la sécurité. Cependant, les avantages clairs et mesurables en matière de performance fournissent une excellente raison pour tout le monde de changer, accélérant son intégration dans les principales plateformes comme Hugging Face. Cela montre que dans l'ingénierie de l'IA, une technologie doit souvent offrir à la fois des avantages en matière de sécurité et de performance pour être rapidement et largement acceptée par l'industrie.

3. Aperçu des principaux formats de modèles

Outre Safetensors, plusieurs autres formats sont importants dans le monde de l'apprentissage automatique, chacun ayant ses propres caractéristiques et cas d'usage.

3.1. CKPT (Points de contrôle)

Un point de contrôle (checkpoint) d'IA n'est pas un type de fichier unique, mais plutôt un instantané de l'état d'un modèle sauvegardé à un moment précis de l'entraînement. Les points de contrôle sont essentiels pour sauvegarder la progression lors de longs entraînements.

Caractéristiques et cas d'usage typiques

Un point de contrôle contient généralement les paramètres appris d'un modèle, comme ses poids et ses biais. Il peut également stocker d'autres informations importantes nécessaires pour reprendre l'entraînement, telles que l'état de l'optimiseur, le numéro de l'époque actuelle et le calendrier du taux d'apprentissage. Les extensions de fichier pour les points de contrôle varient selon le framework. Pour PyTorch, il s'agit généralement de .pt ou .pth, tandis que pour TensorFlow/Keras, ce sont .ckpt ou .h5.

Les principaux avantages des fichiers CKPT sont les suivants :

• Reproductibilité : Ils garantissent qu'un modèle se comporte de manière cohérente lorsqu'il est rechargé, ce qui est essentiel pour valider la recherche et maintenir des performances fiables.
• Collaboration : Ils sont faciles à partager, ce qui permet aux développeurs de reproduire des résultats ou de s'appuyer sur des travaux existants.
• Flexibilité : Les formats .pt/.pth de PyTorch sont particulièrement flexibles, ce qui simplifie la sauvegarde et le chargement de modèles à des fins de recherche.

Les cas d'usage courants des fichiers CKPT incluent :

• Reprise de l'entraînement : Poursuivre une session d'entraînement qui a été interrompue, ce qui permet d'économiser beaucoup de temps et de ressources de calcul.
• Affinage (fine-tuning) : Utiliser un modèle pré-entraîné comme point de départ pour l'entraînement sur un nouvel ensemble de données plus spécifique.
• Évaluation du modèle : Tester les performances d'un modèle à différents stades de l'entraînement sans avoir à le ré-entraîner.
• Inférence : Charger un modèle entièrement entraîné dans un système de production pour faire des prédictions.
• Recherche et expérimentation : Analyser l'évolution d'un modèle dans le temps et ajuster systématiquement ses paramètres.
• Apprentissage par transfert : Servir de point de départ puissant pour des tâches connexes, ce qui réduit le temps d'entraînement et les besoins en données.
• Reprise après sinistre : Servir de sauvegarde pour reprendre le travail après une défaillance lors d'un long processus d'entraînement.

Considérations de sécurité

Le plus grand risque de sécurité avec les fichiers CKPT, en particulier les formats .pt et .pth de PyTorch, provient de leur dépendance au module pickle de Python. Cela signifie que ces fichiers peuvent être conçus pour contenir et exécuter du code Python malveillant lors de leur chargement (si la fonction torch.load est utilisée sans le paramètre weights_only=True). Cette vulnérabilité (CWE-502 : Désérialisation de données non fiables) peut avoir de graves conséquences, telles que le vol de données, un comportement altéré du modèle, voire une prise de contrôle complète du système.

L'industrie a reconnu ce risque, et Safetensors est apparu comme une option plus sûre. Comme indiqué, « la plupart des points de contrôle de l'IA Stable Diffusion sont sauvegardés dans des formats comme .ckpt ou .safetensors... .safetensors est une alternative plus sûre, conçue pour empêcher l'exécution de code malveillant. » Cela montre une tendance claire vers des formats plus sécurisés pour le partage de modèles.

Les CKPT, en particulier au format .pt/.pth de PyTorch, sont réputés pour être « très flexibles ». Cette flexibilité leur permet de sauvegarder non seulement les poids du modèle, mais aussi l'état de l'optimiseur et même des classes Python personnalisées, ce qui est très utile pour reprendre l'entraînement avec précision.

Cependant, cette même flexibilité est ce qui crée la vulnérabilité de sécurité. Comme le format peut sauvegarder n'importe quel objet Python, un attaquant peut cacher du code malveillant à l'intérieur d'un fichier de modèle. Lorsque le fichier est chargé sans les précautions appropriées, ce code s'exécute. Cela illustre un compromis fondamental dans la conception des systèmes : plus de flexibilité conduit souvent à une plus grande surface d'attaque et à des risques de sécurité accrus.

La solution de l'industrie consiste à adopter des formats comme Safetensors pour la distribution de modèles, même si les formats .pt/.pth plus flexibles sont toujours utilisés pour l'entraînement dans des environnements contrôlés. Cela montre une prise de conscience croissante que les différentes étapes du cycle de vie du ML nécessitent des niveaux de sécurité différents. La puissance de la sauvegarde de l'état complet de l'entraînement est mieux conservée dans un environnement de développement de confiance, tandis que le partage et le déploiement nécessitent des formats avec des garanties de sécurité intégrées.

3.2. ONNX (Open Neural Network Exchange)

ONNX, qui signifie Open Neural Network Exchange, est un format standard ouvert pour les modèles d'apprentissage automatique. Il est conçu pour permettre aux modèles de fonctionner avec différents frameworks d'apprentissage profond.

Caractéristiques et principaux cas d'usage

Un fichier ONNX contient la structure complète d'un modèle, y compris sa séquence d'opérations (le graphe de calcul), ses poids appris et d'autres métadonnées. L'un des principaux atouts d'ONNX est qu'il agit comme un traducteur universel. Les modèles entraînés dans des frameworks comme PyTorch, TensorFlow ou scikit-learn peuvent être convertis au format ONNX, permettant une approche « entraîner une fois, déployer n'importe où ».

Contrairement aux formats qui ne stockent que les poids des modèles (comme Safetensors ou GGUF), ONNX inclut le graphe de calcul du modèle. Cette structure basée sur un graphe offre « plus de flexibilité lors de la conversion de modèles entre différents frameworks ». ONNX offre une excellente portabilité sur de nombreuses plateformes, appareils et accélérateurs matériels (CPU, GPU, puces d'IA). Les modèles sont stockés au format Protobuf, qui est un moyen efficace et neutre en termes de plateforme de sauvegarder des données structurées.

Les principaux cas d'usage d'ONNX incluent :

• Déploiement inter-frameworks : Exécuter un modèle dans un framework ou un environnement différent de celui dans lequel il a été entraîné.
• Inférence haute performance : ONNX Runtime est un moteur d'inférence qui optimise automatiquement les modèles pour un matériel spécifique, ce qui se traduit souvent par des performances plus rapides.
• Déploiement en périphérie (edge) et sur mobile : Sa faible empreinte et son exécution optimisée font d'ONNX un bon choix pour exécuter des modèles sur des appareils à ressources limitées.
• Systèmes de production : Sa robustesse et sa portabilité le rendent populaire pour le déploiement de modèles dans des environnements de production exigeants.

Considérations de sécurité

Un risque de sécurité subtil mais sérieux avec les modèles ONNX est la possibilité de portes dérobées architecturales. Un attaquant pourrait modifier le graphe de calcul d'un modèle pour y inclure un chemin caché qui n'est déclenché que par des entrées spécifiques. Une fois activée, cette porte dérobée pourrait amener le modèle à produire des sorties malveillantes ou inattendues, tout en se comportant normalement avec des entrées standards, ce qui la rend difficile à détecter. D'autres risques incluent les attaques par inversion de modèle (extraction de données d'entraînement sensibles) et les attaques adverses (utilisation d'entrées malveillantes pour tromper le modèle).

Pour réduire ces menaces, plusieurs pratiques sont recommandées :

• Signer numériquement les modèles ONNX pour s'assurer qu'ils n'ont pas été altérés.
• Déployer les modèles dans des environnements isolés, comme des conteneurs Docker, avec une sécurité réseau renforcée.
• Utiliser des outils de surveillance pour suivre le comportement du modèle et détecter les anomalies.
• Suivre les meilleures pratiques de sécurité générales, telles que l'assainissement des entrées et la mise à jour des logiciels.

ONNX est généralement plus sûr que les formats basés sur pickle car il n'exécute pas de code arbitraire lors du chargement. Cependant, si un modèle ONNX utilise des couches personnalisées implémentées en externe, ces couches pourraient potentiellement contenir du code Python malveillant si elles ne sont pas gérées avec soin.

Inconvénients

Bien qu'ONNX prenne en charge les modèles quantifiés, il « ne prend pas en charge nativement les tenseurs quantifiés » de manière aussi transparente que GGUF. Il les décompose en tenseurs d'entiers et de facteurs d'échelle distincts, ce qui « peut entraîner une perte de qualité ». La conversion de modèles avec des couches complexes ou personnalisées qui ne sont pas standard dans ONNX peut également être difficile et peut nécessiter un travail personnalisé susceptible de ralentir les performances.

Les formats traditionnels basés sur pickle de Python (comme les fichiers .pt) sauvegardent des objets Python, qui peuvent inclure du code exécutable. Cela traite le modèle comme un programme. En revanche, ONNX se concentre sur la sauvegarde du « graphe de calcul » du modèle, une représentation plus abstraite de ses opérations et de son flux de données, plutôt qu'une implémentation de code spécifique.

C'est cette approche centrée sur le graphe qui confère à ONNX son excellente portabilité inter-frameworks et lui permet d'être optimisé pour différents matériels. En définissant la logique du modèle à un niveau supérieur, il devient indépendant du framework dans lequel il a été entraîné. Il s'agit d'un changement conceptuel important, passant d'une implémentation spécifique à un framework à une représentation de calcul portable. Bien que cela améliore considérablement la flexibilité du déploiement, cela crée également de nouvelles préoccupations en matière de sécurité, comme les portes dérobées architecturales, qui nécessitent des stratégies de sécurité différentes de celles utilisées pour les formats basés sur pickle.

3.3. GGUF (GPT-Generated Unified Format)

GGUF (GPT-Generated Unified Format) est un format de fichier conçu spécifiquement pour stocker et exécuter efficacement les grands modèles de langage (LLM). C'est une version améliorée de son prédécesseur, GGML, et vise à rendre les LLM plus faciles à utiliser, en particulier sur les ordinateurs personnels.

Caractéristiques et principaux cas d'usage

GGUF est conçu pour rendre les LLM plus petits et beaucoup plus rapides à charger. C'est crucial pour exécuter des modèles localement, où l'espace de stockage et la RAM sont souvent limités. Le format utilise des « techniques de compression avancées » pour y parvenir. Il fournit également un moyen standard d'empaqueter les poids, l'architecture et les métadonnées d'un modèle, garantissant qu'il fonctionne de manière cohérente sur différents logiciels, en particulier avec les moteurs d'inférence basés sur llama.cpp.

Une caractéristique clé de GGUF est son excellent support de la quantification. La quantification réduit la précision numérique des poids d'un modèle (par exemple, de nombres de 16 bits à 4 bits), ce qui réduit considérablement la taille du fichier et les calculs nécessaires pour l'exécuter. Les modèles GGUF sont disponibles à différents niveaux de quantification (de Q2 à Q8), offrant une gamme de compromis entre la taille et la qualité.

• Les niveaux de quantification inférieurs (comme Q2 ou Q3) donnent des fichiers très petits qui peuvent fonctionner sur du matériel avec moins de RAM, mais peuvent présenter une légère baisse de la qualité du modèle.
• Les niveaux de quantification supérieurs (comme Q6 ou Q8) maintiennent une meilleure qualité mais nécessitent plus de stockage et de RAM.

Les principaux cas d'usage de GGUF incluent :

• Déploiement local de LLM : Des outils comme Ollama utilisent GGUF pour permettre aux utilisateurs d'exécuter facilement de puissants LLM sur leurs propres ordinateurs.
• Assistants IA hors ligne : De nombreuses applications utilisent des modèles GGUF pour fournir des alternatives locales et privées aux outils d'IA basés sur le cloud.
• Assistance au codage : Les EDI et les éditeurs de code commencent à utiliser des modèles GGUF pour la complétion de code intelligente.
• Chatbots locaux : Les modèles GGUF sont souvent utilisés pour des systèmes d'IA conversationnels privés et réactifs.
• Recherche en IA : Sa flexibilité et son support de la quantification le rendent populaire auprès des chercheurs pour expérimenter avec les LLM sur du matériel accessible.

Considérations de sécurité

Contrairement à la croyance populaire, la bibliothèque sous-jacente GGML (sur laquelle GGUF est basé) a connu des vulnérabilités documentées liées à une « validation insuffisante du fichier d'entrée ». Ces failles peuvent entraîner des « vulnérabilités de corruption de mémoire potentiellement exploitables lors de l'analyse ». Des problèmes de sécurité spécifiques ont été identifiés où une entrée utilisateur non contrôlée pourrait provoquer des dépassements de tas, permettant potentiellement à un attaquant d'exécuter du code malveillant.

Il existe une idée fausse courante selon laquelle un fichier GGUF « ne peut pas contenir de code » et est « uniquement un fichier de modèle ». Cependant, un rapport de sécurité de Databricks a montré que bien que le fichier GGUF lui-même ne contienne pas de code Python exécutable, un fichier spécialement conçu peut exploiter des failles dans l'analyseur (le logiciel qui lit le fichier) pour provoquer une corruption de la mémoire et parvenir à l'exécution de code.

Pour réduire ces risques, il est préférable de :

• Utiliser des modèles et des outils provenant de sources réputées et bien connues (comme Koboldcpp).
• Exécuter les LLM dans des environnements isolés (comme des conteneurs Docker).
• Pour les tâches très sensibles, envisager d'utiliser une machine dédiée sans accès à Internet.

Inconvénients

Un inconvénient majeur de GGUF est que la plupart des modèles sont d'abord développés dans d'autres frameworks (comme PyTorch) et doivent être convertis au format GGUF. Ce processus de conversion n'est pas toujours facile, et certains modèles peuvent ne pas être entièrement pris en charge par les outils compatibles GGUF. De plus, modifier ou affiner un modèle après qu'il est au format GGUF n'est généralement « pas simple ».

Bien que GGUF soit conçu pour un chargement rapide et une utilisation efficace de la VRAM, la vitesse d'inférence réelle (la vitesse à laquelle le modèle génère des réponses) peut parfois être plus lente que celle des modèles non quantifiés. Cela peut se produire avec des niveaux de quantification plus bas en raison du travail supplémentaire nécessaire pour déquantifier les poids pendant l'inférence. Le principal avantage de GGUF en matière de performance est qu'il permet à de grands modèles de fonctionner sur du matériel grand public en économisant de la VRAM, pas qu'il les rend nécessairement plus rapides.

La caractéristique déterminante de GGUF est son intégration profonde avec la quantification, qui permet à de puissants LLM de fonctionner sur du « matériel grand public » avec une VRAM limitée. Cela contribue à démocratiser l'accès à l'IA. Cependant, cette efficacité implique des compromis. Bien que la quantification réduise la taille des modèles, des niveaux inférieurs peuvent légèrement réduire la qualité du modèle. De plus, la vitesse d'inférence peut parfois être plus lente qu'avec des modèles non quantifiés, surtout si la version non quantifiée tient entièrement dans la VRAM.

L'avantage de « vitesse » de GGUF fait généralement référence à un chargement plus rapide et à la capacité à exécuter un modèle plus grand sur du matériel limité, plutôt qu'à des performances brutes. GGUF illustre parfaitement la tendance à la « démocratisation de l'IA » en rendant les modèles avancés accessibles à un plus grand nombre de personnes. Cela oblige les utilisateurs à trouver un équilibre entre la qualité du modèle et les limitations de leur matériel. La disponibilité de plusieurs niveaux de quantification permet aux utilisateurs d'adapter les modèles à leurs besoins spécifiques, ce qui est la clé de la popularité du format dans la communauté de l'IA locale.

4. Analyse comparative des formats

Le choix d'un format de sérialisation de modèle approprié est une décision stratégique qui dépend de l'équilibre de divers facteurs, notamment la sécurité, les performances, l'efficacité des ressources, l'interopérabilité et le contexte d'application spécifique. Le tableau ci-dessous fournit un aperçu comparatif de Safetensors, CKPT, ONNX et GGUF à travers ces dimensions critiques.

Caractéristique / Format	Safetensors	CKPT (.pt/.pth)	ONNX	GGUF
Objectif principal	Stockage sécurisé et rapide de tenseurs pour les modèles d'apprentissage profond	Points de contrôle d'entraînement, paramètres de modèle, préservation de l'état	Interopérabilité entre frameworks, déploiement sur divers matériels	Stockage efficace de LLM, inférence locale optimisée sur du matériel grand public
Profil de sécurité	Élevé (pas d'exécution de code arbitraire par conception)	Faible (exécution de code arbitraire via la désérialisation Pickle)	Modéré (pas d'exécution de code arbitraire, mais portes dérobées architecturales possibles)	Modéré (vulnérabilités de la bibliothèque sous-jacente, mais le fichier lui-même n'est pas du code Python exécutable)
Vitesse de chargement	Très rapide (zéro copie, chargement paresseux)	Variable (peut être plus lent que Safetensors en raison du chargement complet)	Rapide (exécution optimisée, optimisations de graphe)	Rapide (mmap, efficace pour les LLM)
Utilisation de la mémoire	Efficace (chargement paresseux, chargement partiel)	Peut être élevée (charge l'intégralité du graphe d'objets)	Efficace (optimisations d'exécution)	Très efficace (quantification, économie de VRAM)
Espace disque	Efficace (compression, tenseurs uniquement)	Variable (peut être volumineux, inclut l'état complet)	Efficace (format Protobuf)	Très efficace (quantification, compression avancée)
Support de la quantification	Oui, mais moins flexible que GGUF (dépendant de PyTorch)	Oui (dépendant du framework)	Support natif limité (décompose les tenseurs)	Robuste (plusieurs niveaux, Q2-Q8, variantes spécialisées)
Portabilité	Élevée (entre différents langages de programmation)	Faible (étroitement couplé à des frameworks spécifiques)	Très élevée (inter-framework, multiplateforme, divers matériels)	Élevée (en particulier pour l'écosystème llama.cpp)
Applications principales	Partage sécurisé de modèles, format par défaut de Hugging Face	Entraînement, affinage, recherche, sauvegarde de modèles	Déploiement en production, mobile/edge, interopérabilité	Inférence locale de LLM, matériel grand public, applications de chat
Avantage clé	Sécurité par conception, chargement rapide, faible empreinte mémoire	Préservation de l'état d'entraînement, reproductibilité détaillée	Déploiement universel, optimisation de l'exécution, indépendance du framework	Efficacité des LLM sur le matériel grand public, quantification flexible
Inconvénient clé	Analyseur JSON requis pour les métadonnées en C++	Risque d'exécution de code arbitraire, taille de fichier importante	Complexité pour les couches personnalisées, quantification native limitée	Conversion souvent requise, ralentissement potentiel de l'inférence avec des quantifications plus basses

5. Conclusion

Le monde des formats de modèles d'apprentissage automatique est en constante évolution, poussé par le besoin d'une meilleure sécurité, de meilleures performances et d'une meilleure interopérabilité. Les formats traditionnels, comme les fichiers CKPT basés sur pickle, étaient flexibles pour la recherche mais introduisaient de graves risques de sécurité en permettant l'exécution de code arbitraire. Cela a conduit au développement et à l'adoption de formats plus récents et plus sûrs.

Safetensors est un exemple phare de cette évolution. En séparant les données du code et en utilisant des techniques de chargement efficaces, il offre une alternative sécurisée et performante pour le partage de modèles d'apprentissage profond, en particulier dans l'écosystème Hugging Face. Ses doubles avantages en matière de sécurité et de vitesse en ont fait un choix populaire dans les flux de travail de l'IA moderne.

ONNX résout le problème majeur de l'incompatibilité entre les frameworks. En représentant les modèles sous forme de graphes de calcul abstraits, il leur permet d'être déployés sur différents matériels et logiciels. Bien qu'ONNX empêche l'exécution de code arbitraire observée avec pickle, il présente ses propres problèmes de sécurité, comme les portes dérobées architecturales, qui nécessitent des mesures de protection différentes.

GGUF est une solution spécialisée pour exécuter de grands modèles de langage sur du matériel grand public. Ses puissantes fonctionnalités de quantification réduisent considérablement la taille des modèles et l'utilisation de la mémoire, rendant les puissants LLM accessibles à un plus grand nombre de personnes. Cependant, cette efficacité peut parfois se traduire par des vitesses d'inférence plus lentes, et ses bibliothèques sous-jacentes ont montré des vulnérabilités qui obligent les utilisateurs à être prudents.

En fin de compte, le meilleur format dépend du contexte spécifique.

• Safetensors est le premier choix pour partager de manière sécurisée et efficace des modèles d'apprentissage profond.
• ONNX est idéal pour déployer des modèles sur différents frameworks et matériels.
• GGUF offre une efficacité inégalée pour exécuter de grands modèles de langage sur des appareils locaux aux ressources limitées.

Bien que les formats CKPT traditionnels soient encore utiles pour sauvegarder la progression de l'entraînement dans des environnements contrôlés, ils sont remplacés par des alternatives plus sûres pour la distribution publique. À mesure que le domaine de l'IA mûrit, le développement continu de ces formats spécialisés sera essentiel pour faire progresser la puissance et la portée de l'apprentissage automatique.