Alors que les modèles de langue importants (LLM) continuent de croître en échelle, il en va de même pour les moyens efficaces de stocker, de les déployer et d'exécuter sur des appareils à faible ressource. Bien que ces modèles offrent des capacités puissantes, leur taille et leurs demandes de mémoire peuvent faire du déploiement un défi, en particulier sur le matériel des consommateurs. C'est là que la quantification du modèle et les formats de stockage spécialisés comme GGUF (format générique GPT unifié) entrent en jeu.
Dans ce guide, nous nous plongerons dans le format GGUF, explorerons ses avantages et fournirons un tutoriel étape par étape sur la conversion des modèles en GGUF. En cours de route, nous allons aborder l'histoire de la quantification du modèle et comment GGUF a évolué pour soutenir les LLM modernes. À la fin, vous comprenez en profondeur pourquoi GGUF compte et comment commencer à l'utiliser pour vos propres modèles.
Cet article a été publié dans le cadre du Blogathon de la science des données.
Le voyage vers GGUF commence par comprendre l'évolution de la quantification du modèle. La quantification réduit la précision des paramètres du modèle, les compressant efficacement pour réduire la mémoire et les demandes de calcul. Voici un aperçu rapide:
Au début, les modèles d'apprentissage en profondeur ont été stockés dans les formats natifs de cadres comme TensorFlow et Pytorch. Les modèles TensorFlow ont utilisé des fichiers .pb, tandis que Pytorch a utilisé .pt ou .pth. Ces formats ont fonctionné pour des modèles plus petits mais ont présenté des limitations:
La montée en puissance de l'interopérabilité entre les cadres a conduit au développement de l'ONNX, qui a permis aux modèles de se déplacer entre les environnements. Cependant, bien que ONNX ait fourni des optimisations, il a toujours été principalement construit autour de poids de précision complète et a offert un support de quantification limité.
Au fur et à mesure que les modèles grandissaient, les chercheurs se sont tournés vers la quantification, qui compriment les poids des flotteurs 32 bits (FP32) à 16 bits (FP16) ou même plus bas, comme des entiers 8 bits (INT8). Cette approche réduit considérablement les exigences de mémoire, ce qui permet d'exécuter des modèles sur plus de types de matériel. Par exemple:
# Importer les bibliothèques nécessaires
Importer une torche
importer torch.nn comme nn
Importer Torch.quantisation comme quant
# Étape 1: Définissez un modèle de réseau neuronal simple à Pytorch
classe SimpleModel (nn.module):
def __init __ (soi):
Super (Simplemodel, self) .__ init __ ()
self.fc1 = nn.linear (10, 50) # première couche entièrement connectée
self.fc2 = nn.linear (50, 20) # Deuxième couche entièrement connectée
self.fc3 = nn.linear (20, 5) # couche de sortie
Def en avant (self, x):
x = torch.relu (self.fc1 (x)) # activation relu après la première couche
x = torch.relu (self.fc2 (x)) # activation relu après la deuxième couche
x = self.fc3 (x) # couche de sortie
retour x
# Étape 2: Initialisez le modèle et basculez en mode d'évaluation
modèle = SimpleModel ()
Model.Eval ()
# Enregistrer le modèle avant la quantification pour référence
torch.save (modèle, "simple_model.pth")
# Étape 3: Appliquer la quantification dynamique au modèle
# Ici, nous ne quantifions que les couches linéaires, en changeant leurs poids en int8
quantized_model = quant.quantize_dynamic (
modèle, {nn.linear}, dtype = torch.qint8
)
# Enregistrer le modèle quantifié
torch.save (Quantized_Model, "Quantized_simple_model.pth")
# Exemple utilisation du modèle quantifié avec des données factice
dummy_input = torch.randn (1, 10) # Exemple de tenseur d'entrée avec 10 fonctionnalités
Output = Quantized_Model (Dummy_Input)
Imprimer ("Sortie du modèle quantifié:", sortie)
Lorsque vous travaillez avec de grands modèles de langue, il est crucial de comprendre la différence de taille entre les versions originales et quantifiées. Cette comparaison met non seulement les avantages de la compression des modèles, mais informe également les stratégies de déploiement pour une utilisation efficace des ressources.
Importer un système d'exploitation
# Chemins vers les modèles enregistrés
original_model_path = "simple_model.pth"
quantized_model_path = "Quantized_simple_model.pth"
# Fonction pour obtenir la taille du fichier dans KB
def get_file_size (chemin):
size_bytes = os.path.getSize (chemin)
size_kb = size_bytes / 1024 # converti en kb
return size_kb
# Vérifiez les tailles des modèles originaux et quantifiés
original_size = get_file_size (original_model_path)
quantized_size = get_file_size (quantized_model_path)
print (f "Taille du modèle original: {original_size: .2f} kb")
print (f "Taille du modèle quantifié: {quantized_size: .2f} kb")
print (f "Réduction de taille: {((original_size - quantized_size) / original_size) * 100: .2f}%")
Cependant, même la précision 8 bits était insuffisante pour des modèles de langage extrêmement grands comme GPT-3 ou LLAMA, ce qui a stimulé le développement de nouveaux formats comme GGML et, finalement, GGUF.
GGUF, ou format générique GPT unifié, a été développé comme extension du GGML pour prendre en charge des modèles encore plus grands. Il s'agit d'un format de fichier pour le stockage de modèles pour l'inférence avec GGML et les exécuteurs basés sur GGML. GGUF est un format binaire conçu pour le chargement rapide et la sauvegarde des modèles, et pour faciliter la lecture. Les modèles sont traditionnellement développés à l'aide de Pytorch ou d'un autre cadre, puis convertis en GGUF pour une utilisation en GGML.
GGUF est un format de fichier successeur pour GGML, GGMF et GGJT, et est conçu pour être sans ambiguïté en contenant toutes les informations nécessaires pour charger un modèle. Il est également conçu pour être extensible, afin que de nouvelles informations puissent être ajoutées aux modèles sans casser la compatibilité. Il a été conçu avec trois buts en tête:
Le format GGUF brille pour les développeurs qui ont besoin de déployer de grands modèles lourds de ressources sur du matériel limité sans sacrifier les performances. Voici quelques avantages de base:
Le format GGUF utilise une convention de dénomination spécifique pour fournir des informations clés du modèle en un coup d'œil. Cette convention aide les utilisateurs à identifier les caractéristiques importantes du modèle telles que l'architecture, la taille des paramètres, le type de réglage fin, la version, le type de codage et les données de fragment - la gestion et le déploiement du modèle créant plus facilement.
La convention de dénomination GGUF suit cette structure:
Chaque composant du nom donne un aperçu du modèle:
Exemples de dénomination
Avant de plonger dans la conversion, assurez-vous d'avoir les conditions suivantes:
Les techniques de quantification jouent un rôle central dans l'optimisation des réseaux de neurones en réduisant leur taille et leurs exigences de calcul. En convertissant des poids et des activations de haute précision en représentations de bit inférieures, ces méthodes permettent un déploiement efficace de modèles sans compromettre de manière significative les performances.
Vous trouverez ci-dessous comment vous pouvez convertir votre modèle au format GGUF.
Dans ce cas, nous choisissons le modèle Flan-T5 de Google pour quantifier. Vous pouvez suivre la commande pour télécharger directement le modèle depuis HuggingFace
! Pip installer HuggingFace-Hub De HuggingFace_Hub Importer Snapshot_download Model_ # Remplacez par l'ID du modèle que vous souhaitez télécharger snapshot_download (repo_id = model_id, local_dir = "t5")
Nous utilisons llama.cpp pour quantifier le modèle au format GGUF
! git clone https://github.com/ggerganov/llama.cpp
Si dans Google Collaboratoire, suivez le code ci-dessous, sinon vous pouvez accéder au répertoire des exigences pour installer le "Exigences-Convert_HF_TO_GGUF.txt"
! pip install -r /content/llama.cpp/requiments/requiments-convert_hf_to_gguf.txt
Le niveau de quantification détermine le compromis entre la taille du modèle et la précision. La quantification inférieure (comme 4 bits) enregistre la mémoire mais peut réduire la précision. Par exemple, si vous ciblez un déploiement uniquement du processeur et que vous n'avez pas besoin de précision maximale, INT4 pourrait être un bon choix. Ici, nous choisissons «Q8_0».
Si dans Google Collab, exécutez le script ci-dessous, suivez le commentaire.
#! Python {Path to convert_hf_to_gguf.py} {chemin vers hf_model} --outfile {name_of_outputfile.gguf} --outType {Type de quantification}
! python /content/llama.cpp/convert_hf_to_gguf.py / contenu / t5 --outfile t5.gguf --outType Q8_0Lors du déploiement de modèles d'apprentissage automatique, il est crucial de comprendre la différence de taille entre les versions originales et quantifiées. Cette comparaison met en évidence la façon dont la quantification peut réduire considérablement la taille du modèle, conduisant à une efficacité améliorée et à des temps d'inférence plus rapides sans perte de précision substantielle.
# Vérifiez les tailles des modèles originaux et quantifiés
original_model_path = "/ content / t5 / modèle.safetensers"
quantized_model_path = "t5.gguf"
original_size = get_file_size (original_model_path)
quantized_size = get_file_size (quantized_model_path)
print (f "Taille du modèle original: {original_size: .2f} kb")
print (f "Taille du modèle quantifié: {quantized_size: .2f} kb")
print (f "Réduction de taille: {((original_size - quantized_size) / original_size) * 100: .2f}%")
Nous avons pu voir une réduction de taille de 73,39% stupéfiante en utilisant la technique de quantification GGUF.
Pour obtenir les meilleurs résultats, gardez à l'esprit ces conseils:
Alors que les modèles continuent de croître, des formats comme GGUF joueront un rôle de plus en plus critique dans la rendez-vous accessible à une IA à grande échelle. Nous pouvons bientôt voir des techniques de quantification plus avancées qui préservent encore plus de précision tout en réduisant davantage les exigences de la mémoire. Pour l'instant, GGUF reste à l'avant-garde, permettant un déploiement efficace de modèles de gros langues sur les processeurs et les appareils Edge.
Le format GGUF change de jeu pour le déploiement efficace de modèles de langue importants sur des appareils à ressources limitées. Des premiers efforts dans la quantification du modèle au développement de GGUF, le paysage du stockage du modèle d'IA a évolué pour rendre les modèles puissants accessibles à un public plus large. En suivant ce guide, vous pouvez désormais convertir des modèles au format GGUF, ce qui facilite les déployer pour les applications du monde réel.
La quantification continuera d'évoluer, mais la capacité de GGUF à soutenir des niveaux de précision variés et une gestion efficace des métadonnées garantit qu'elle restera pertinente. Essayez de convertir vos modèles en GGUF et explorez les avantages de première main!
A. GGUF (Generic GPT Unified Format) est un format de stockage de modèle avancé conçu pour stocker et exécuter efficacement les modèles de grande langue quantifiés. Contrairement à son prédécesseur, le GGML, qui a une évolutivité limitée pour les modèles dépassant 100 Go, GGUF prend en charge de vastes options de quantification 4 bits et 8 bits et offre une riche capacité de stockage de métadonnées, améliorant la gestion et le déploiement du modèle.
Q2. Comment la quantification affecte-t-elle les performances du modèle?A. La quantification réduit la précision des paramètres d'un modèle, diminuant considérablement sa taille et son utilisation de la mémoire. Bien que cela puisse entraîner une légère baisse de précision, les techniques de quantification bien conçues (comme celles de GGUF) peuvent maintenir des niveaux de performance acceptables, ce qui rend possible de déployer de grands modèles sur des appareils liés aux ressources.
Q3. Quelles sont les principales composantes de la convention de dénomination GGUF?A. La convention de dénomination GGUF se compose de plusieurs composants, notamment le nom de base (architecture du modèle), Sizelabel (classe de poids des paramètres), Finetune (objectif de réglage fin), version (numéro de version modèle), encodage (schéma de codage de poids), type (objectif de fichier) et Thard (pour les modèles divisés). Ensemble, ces composants fournissent des informations essentielles sur le modèle.
Q4. Comment puis-je valider les noms de fichiers GGUF?A. Vous pouvez valider les noms de fichiers GGUF en utilisant une expression régulière qui vérifie la présence d'au moins le nom de base, Sizelabel et la version dans le bon ordre. Cela garantit que le fichier adhère à la convention de dénomination et contient les informations nécessaires pour l'identification du modèle.
Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Base de données de restauration MySQL
Quels sont les frameworks Spring ?
Comment débloquer les restrictions d'autorisation Android
Langage C pour trouver le multiple le plus petit commun
Qu'est-ce que la rigidité de l'utilisateur
Quel est le code espace en HTML
utilisation de la commande head
Le but du niveau
Quelles sont les principales différences entre Linux et Windows
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
