Hub

API docs

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

GGUF

Hugging Face Hub prend en charge tous les formats de fichiers, mais propose des fonctionnalités intégrées pour le format GGUF, un format binaire optimisé pour le chargement et l'enregistrement rapides des modèles, ce qui le rend très efficace pour l'inférence. GGUF est conçu pour être utilisé avec GGML et d'autres exécuteurs. GGUF a été développé par @ggerganov, qui est également le développeur de llama.cpp, un framework d'inférence LLM en C/C++ très populaire. Les modèles initialement développés dans des frameworks comme PyTorch peuvent être convertis au format GGUF pour être utilisés avec ces moteurs.

Comme nous pouvons le voir sur ce graphique, contrairement aux formats de fichiers ne contenant que des tenseurs comme safetensors – qui est également un format de modèle recommandé pour le Hub – GGUF encode à la fois les tenseurs et un ensemble standardisé de métadonnées.

Rechercher des fichiers GGUF

Vous pouvez parcourir tous les modèles avec des fichiers GGUF en filtrant par le tag GGUF : hf.co/models?library=gguf. De plus, vous pouvez utiliser l'outil ggml-org/gguf-my-repo pour convertir/quantiser les poids de votre modèle en poids GGUF.

Par exemple, vous pouvez consulter TheBloke/Mixtral-8x7B-Instruct-v0.1-GGUF pour voir les fichiers GGUF en action.

Visualiseur des métadonnées et des informations sur les tenseurs

Le Hub dispose d’un visualiseur pour les fichiers GGUF qui permet à un utilisateur de consulter les métadonnées et les informations sur les tenseurs (nom, forme, précision). Le visualiseur est disponible sur la page du modèle (exemple) et sur la page des fichiers (exemple).

Utilisation avec des outils open source

Analyse des métadonnées avec @huggingface/gguf

Nous avons également créé un parseur GGUF en javascript qui fonctionne sur des fichiers hébergés à distance (par exemple, Hugging Face Hub).

npm install @huggingface/gguf

import { gguf } from "@huggingface/gguf";
// remote GGUF file from https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF
const URL_LLAMA = "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/191239b/llama-2-7b-chat.Q2_K.gguf";
const { metadata, tensorInfos } = await gguf(URL_LLAMA);

Retrouvez plus d'informations ici.

Types de quantification

type	source	description
F64	Wikipedia	Nombre à virgule flottante de précision double au format IEEE 754 standard sur 64 bits.
I64	GH	Nombre entier à largeur fixe de 64 bits.
F32	Wikipedia	Nombre à virgule flottante de précision simple au format IEEE 754 standard sur 32 bits.
I32	GH	Nombre entier à largeur fixe de 32 bits.
F16	Wikipedia	Nombre flottant demi-précision standard IEEE 754 sur 16 bits.
BF16	Wikipedia	Version raccourcie 16 bits du nombre à virgule flottante de précision simple IEEE 754 sur 32 bits.
I16	GH	Nombre entier à largeur fixe de 16 bits.
Q8_K	GH	Quantification 8 bits (`q`). Chaque bloc contient 256 poids. Utilisé uniquement pour quantifier les résultats intermédiaires. Tous les produits scalaires de 2 à 6 bits sont implémentés pour ce type de quantification. Formule des poids : `w = q * block_scale`.
I8	GH	Nombre entier à largeur fixe de 8 bits.
Q6_K	GH	Quantification 6 bits (`q`). Super-blocs de 16 blocs, chaque bloc contenant 16 poids. Formule des poids : `w = q * block_scale(8-bit)`, ce qui donne 6,5625 bits par poids.
Q5_K	GH	Quantification 5 bits (`q`). Super-blocs de 8 blocs, chaque bloc contenant 32 poids. Formule des poids : `w = q * block_scale(6-bit) + block_min(6-bit)`, ce qui donne 5,5 bits par poids.
Q4_K	GH	Quantification 4 bits (`q`). Super-blocs de 8 blocs, chaque bloc contenant 32 poids. Formule des poids : `w = q * block_scale(6-bit) + block_min(6-bit)`, ce qui donne 4,5 bits par poids.
Q3_K	GH	Quantification 3 bits (`q`). Super-blocs de 16 blocs, chaque bloc contenant 16 poids. Formule des poids : `w = q * block_scale(6-bit)`, ce qui donne 3,4375 bits par poids.
Q2_K	GH	Quantification 2 bits (`q`). Super-blocs de 16 blocs, chaque bloc contenant 16 poids. Formule des poids : `w = q * block_scale(4-bit) + block_min(4-bit)`, ce qui donne 2,625 bits par poids.
IQ4_NL	GH	Quantification 4 bits (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`.
IQ4_XS	HF	Quantification 4 bits (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 4,25 bits par poids.
IQ3_S	HF	Quantification 3 bits (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 3,44 bits par poids.
IQ3_XXS	HF	Quantification 3 bits (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 3,06 bits par poids.
IQ2_XXS	HF	Quantification 2 bits (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 2,06 bits par poids.
IQ2_S	HF	Quantification 2 bits (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 2,5 bits par poids.
IQ2_XS	HF	Quantification 2 bits (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 2,31 bits par poids.
IQ1_S	HF	Quantification 1 bit (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 1,56 bits par poids.
IQ1_M	GH	Quantification 1 bit (`q`). Super-blocs de 256 poids. Le poids `w` est obtenu à l'aide de `super_block_scale` & `importance matrix`, ce qui donne 1,75 bits par poids.
TQ1_0	GH	Quantification ternaire.
TQ2_0	GH	Quantification ternaire.
MXFP4	GH	Microscaling Block Floating Point 4 bits.
Types hérités
Q8_0	GH	Quantification 8 bits par arrondi au plus proche (`q`). Chaque bloc contient 32 poids. Formule des poids : `w = q * block_scale`. Méthode de quantification obsolète (peu utilisée à ce jour).
Q8_1	GH	Quantification 8 bits par arrondi au plus proche (`q`). Chaque bloc contient 32 poids. Formule des poids : `w = q * block_scale + block_minimum`. Méthode de quantification obsolète (peu utilisée à ce jour).
Q5_0	GH	Quantification 5 bits par arrondi au plus proche (`q`). Chaque bloc contient 32 poids. Formule des poids : `w = q * block_scale`. Méthode de quantification obsolète (peu utilisée à ce jour).
Q5_1	GH	Quantification 5 bits par arrondi au plus proche (`q`). Chaque bloc contient 32 poids. Formule des poids : `w = q * block_scale + block_minimum`. Méthode de quantification obsolète (peu utilisée à ce jour).
Q4_0	GH	Quantification 4 bits par arrondi au plus proche (`q`). Chaque bloc contient 32 poids. Formule des poids : `w = q * block_scale`. Méthode de quantification obsolète (peu utilisée à ce jour).
Q4_1	GH	Quantification 4 bits par arrondi au plus proche (`q`). Chaque bloc contient 32 poids. Formule des poids : `w = q * block_scale + block_minimum`. Méthode de quantification obsolète (peu utilisée à ce jour).

si vous constatez une inexactitude dans le tableau ci-dessus, veuillez ouvrir une PR sur ce fichier.

Update on GitHub

←Tâches Utilisation de GGUF avec llama.cpp→