Accelerate documentation

Quantification de modèle

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.16.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Quantification de modèle

Intégration de bitsandbytes

Accelerate apporte la quantisation bitsandbytes à votre modèle. Vous pouvez désormais charger n'importe quel modèle pytorch en 8 bits ou 4 bits avec quelques lignes de code.

Si vous souhaitez utiliser des modèles Transformers avec bitsandbytes, vous devez suivre cette documentation.

Pour en savoir plus sur le fonctionnement de la quantification bitsandbytes, consultez les articles de blog sur la quantification 8 bits et la quantification 4 bits.

Prérequis

Vous devrez installer les prérequis suivants :

  • Installer la bibliothèque bitsandbytes
pip install bitsandbytes

Pour les appareils non-cuda, vous pouvez consulter le guide d’installation de bitsandbytes ici.

  • Installer la dernière version de accelerate depuis le code source
pip install git+https://github.com/huggingface/accelerate.git
  • Installez minGPT et huggingface_hub pour exécuter les exemples
git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
pip install huggingface_hub

Fonctionnement

Tout d'abord, nous devons initialiser notre modèle. Pour économiser de la mémoire, nous pouvons initialiser un modèle vide à l'aide du gestionnaire de contexte init_empty_weights().

Prenons le modèle GPT2 de la bibliothèque minGPT.

from accelerate import init_empty_weights
from mingpt.model import GPT

model_config = GPT.get_default_config()
model_config.model_type = 'gpt2-xl'
model_config.vocab_size = 50257
model_config.block_size = 1024

with init_empty_weights():
    empty_model = GPT(model_config)

Ensuite, nous devons obtenir le chemin d'accès aux poids de votre modèle. Le chemin peut être le fichier state_dict (par exemple « pytorch_model.bin ») ou un dossier contenant les points de contrôle fractionnés.

from huggingface_hub import snapshot_download
weights_location = snapshot_download(repo_id="marcsun13/gpt2-xl-linear-sharded")

Enfin, vous devez définir votre configuration de quantification avec BnbQuantizationConfig.

Voici un exemple de quantification 8 bits :

from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_8bit=True, llm_int8_threshold = 6)

Voici un exemple de quantification 4 bits :

from accelerate.utils import BnbQuantizationConfig
bnb_quantization_config = BnbQuantizationConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4")

Pour quantifier votre modèle vide avec la configuration sélectionnée, vous devez utiliser load_and_quantize_model().

from accelerate.utils import load_and_quantize_model
quantized_model = load_and_quantize_model(empty_model, weights_location=weights_location, bnb_quantization_config=bnb_quantization_config)

Enregistrer et charger un modèle 8 bits

Vous pouvez enregistrer votre modèle 8 bits avec accelerate à l'aide de save_model().

from accelerate import Accelerator
accelerate = Accelerator()
new_weights_location = "path/to/save_directory"
accelerate.save_model(quantized_model, new_weights_location)

quantized_model_from_saved = load_and_quantize_model(empty_model, weights_location=new_weights_location, bnb_quantization_config=bnb_quantization_config, device_map = "auto")

Notez que la sérialisation de modèles en 4 bits n'est actuellement pas prise en charge.

Décharger les modules sur le CPU et le disque

Vous pouvez décharger certains modules sur le CPU/le disque si vous ne disposez pas d’assez de place sur le GPU pour stocker l’intégralité du modèle sur vos GPU. Cela utilise l’inférence de grands modèles en arrière-plan. Consultez cette documentation pour plus de détails.

Pour la quantification 8 bits, les modules sélectionnés seront convertis en précision 8 bits.

Pour la quantification en 4 bits, les modules sélectionnés seront conservés dans le torch_dtype transmis par l'utilisateur dans BnbQuantizationConfig. Nous ajouterons le support de la conversion de ces modules déchargés en 4 bits lorsque la sérialisation en 4 bits sera possible.

Il suffit de passer un device_map personnalisé pour décharger les modules sur le cpu/disk. Les modules déchargés seront envoyés sur le GPU au besoin. Voici un exemple :

device_map = {
    "transformer.wte": 0,
    "transformer.wpe": 0,
    "transformer.drop": 0,
    "transformer.h": "cpu",
    "transformer.ln_f": "disk",
    "lm_head": "disk",
}

Ajuster finement un modèle quantifié

Il n'est pas possible d'effectuer un entraînement pur en 8 bits ou 4 bits sur ces modèles. Cependant, vous pouvez entraîner ces modèles en utilisant des méthodes d'ajustement fin efficace des paramètres (PEFT) et entraîner par exemple des adaptateurs au-dessus d'eux. Veuillez consulter la bibliothèque peft pour plus de détails.

Actuellement, vous ne pouvez pas ajouter d’adapters sur un modèle quantifié quelconque. Toutefois, grâce au support officiel des adapters avec les modèles Transformers, vous pouvez effectuer un fine-tuning de modèles quantisés. Si vous souhaitez effectuer un fine-tuning d’un modèle Transformers, suivez plutôt cette documentation. Consultez cette démo sur la façon d’effectuer un fine-tuning d’un modèle Transformers en 4 bits.

Notez qu’il n’est pas nécessaire de passer device_map lors du chargement du modèle pour l’entraînement. Il chargera automatiquement votre modèle sur votre GPU. Veuillez noter que device_map=auto doit être utilisé uniquement pour l’inférence.

Démo d’exemple - exécution de GPT2 1.5b sur Google Colab

Consultez la démo Google Colab pour exécuter des modèles quantifiés sur un modèle GPT2. Le point de contrôle du modèle GPT2-1.5B est en FP32 et utilise 6 Go de mémoire. Après quantification, il utilise 1,6 Go avec des modules 8 bits et 1,2 Go avec des modules 4 bits.

Update on GitHub