Accelerate documentation
Quantification de modèle
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
acceleratedepuis le code source
pip install git+https://github.com/huggingface/accelerate.git
- Installez
minGPTethuggingface_hubpour exécuter les exemples
git clone https://github.com/karpathy/minGPT.git
pip install minGPT/
pip install huggingface_hubFonctionnement
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