xllm
Single GPU DeepSpeed, download model without loading to RAM
Cutting Edge & Easy LLM Finetuning en utilisant les méthodes les plus avancées (Qlora, Deeppeed, GPTQ, Flash Attention 2, FSDP, etc.)
Développé par Boris Zubarev | CV | LinkedIn | [email protected]
Utilisez-vous de grands modèles de langage (LLM) pour votre travail et souhaitez les former plus efficacement avec des méthodes avancées? Vous souhaitez se concentrer sur les données et les améliorations plutôt que sur le codage répétitif et long pour la formation LLM?
X - llm est votre solution. Il s'agit d'une bibliothèque conviviale qui rationalise l'optimisation de la formation, vous pouvez donc vous concentrer sur l'amélioration de vos modèles et données . Équipé de techniques de formation de pointe , X - LLM est conçu pour l'efficacité par les ingénieurs qui comprennent vos besoins.
X - llm est idéal, que vous vous prépariez pour la production ou que vous ayez besoin d'un outil de prototypage rapide .
W&BYi-34B , Mistal AI , Llama 2 , Zephyr , OpenChat , Falcon , Phi , Qwen , MPT et bien d'autres X—LLM est testé sur Python 3.8+, Pytorch 2.0.1+ et CUDA 11.8.
pip install xllm Version qui inclut deepspeed , flash-attn et auto-gptq :
pip install " xllm[train] " Version xllm par défaut recommandée pour le développement local, xllm[train] recommandé pour la formation.
Version CUDA: 11.8 Docker: huggingface/transformers-pytorch-gpu:latest
from xllm import Config
from xllm . datasets import GeneralDataset
from xllm . experiments import Experiment
# Init Config which controls the internal logic of xllm
# QLoRA example
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
apply_lora = True ,
load_in_4bit = True ,
)
# Prepare the data
train_data = [ "Hello!" ] * 100
train_dataset = GeneralDataset . from_list ( data = train_data )
# Build Experiment from Config: init tokenizer and model, apply LoRA and so on
experiment = Experiment ( config = config , train_dataset = train_dataset )
experiment . build ()
# Run Experiment (training)
experiment . run ()
# # [Optional] Fuse LoRA layers
# experiment.fuse_lora()
# [Optional] Or push LoRA weights to HuggingFace Hub
experiment . push_to_hub ( repo_id = "YOUR_NAME/MODEL_NAME" )Config les contrôles xllmEn savoir plus sur la configuration
config = Config (
model_name_or_path = "openchat/openchat_3.5" ,
apply_lora = True ,
) config = Config (
model_name_or_path = "openchat/openchat_3.5" ,
apply_lora = True ,
lora_rank = 8 ,
lora_alpha = 32 ,
lora_dropout = 0.05 ,
raw_lora_target_modules = "all" ,
# Names of modules to apply LoRA. A comma-separated string, for example: "k,q,v" or "all".
) Pour former le modèle QLoRA , nous devons charger le modèle de squelette en utilisant la bibliothèque bitsandbytes et les poids INT4 (ou INT8).
config = Config (
model_name_or_path = "01-ai/Yi-34B" ,
apply_lora = True ,
load_in_4bit = True ,
prepare_model_for_kbit_training = True ,
) config = Config (
model_name_or_path = "01-ai/Yi-34B" ,
apply_lora = True ,
load_in_4bit = True ,
prepare_model_for_kbit_training = True ,
llm_int8_threshold = 6.0 ,
llm_int8_has_fp16_weight = True ,
bnb_4bit_use_double_quant = True ,
bnb_4bit_quant_type = "nf4" ,
) Avant cela, vous devez vous connecter à Huggingface Hub ou ajouter un API Token aux variables d'environnement.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
push_to_hub = True ,
hub_private_repo = True ,
hub_model_id = "BobaZooba/AntModel-7B-XLLM-Demo-LoRA" ,
save_steps = 25 ,
)save_stepsLoRA , seuls les poids LoRA seront sauvés Avant cela, vous devez vous connecter à W&B ou ajouter un API Token aux variables d'environnement.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
report_to_wandb = True ,
logging_steps = 5 ,
wandb_project = "xllm-demo" ,
) Cela aidera à utiliser less GPU memory pendant la formation, c'est-à-dire que vous pourrez en savoir plus que sans cette technique. Les inconvénients de cette technique ralentissent l'étape avant, c'est-à-dire slowing down training .
Vous entraînerez des modèles plus grands (par exemple 7B dans Colab), mais au détriment de la vitesse d'entraînement.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
use_gradient_checkpointing = True ,
) Cela accélère l'entraînement et la consommation de mémoire GPU, mais il ne fonctionne pas avec tous les modèles et GPU. Vous devez également installer flash-attn pour cela. Cela peut être fait en utilisant:
pip install "xllm[train]"
config = Config (
model_name_or_path = "meta-llama/Llama-2-7b-hf" ,
use_flash_attention_2 = True ,
)apply_lora ). Il permet une énorme réduction des coûts de formation et, de plus, aide à lutter très efficacement que l'oubli catastrophique.load_in_4bit et prepare_model_for_kbit_training . Cela réduit également considérablement la consommation de mémoire.use_gradient_checkpointing . Cette méthode réduit également considérablement la consommation de mémoire, mais au détriment du ralentissement de la formation.push_to_hub et hub_private_repo , spécifiant également le nom du modèle dans hub_model_id et save_steps . Exemple: "Bobazooba / Supadupalma-7b-lora". Pendant la formation, chaque point de contrôle de votre modèle sera enregistré dans le hub Huggingface. Si vous avez spécifié apply_lora , seuls les poids LORA seront enregistrés, ce que vous pourrez plus facilement fusionner avec le modèle principal, par exemple, en utilisant xllm .use_flash_attention_2report_to_wandb , spécifiant également wandb_project (le nom du projet dans W&B) et wandb_entity (nom de l'utilisateur ou de l'organisation dans W&B).push_to_hub , vous devez vous connecter au centre Huggingface au préalable ou spécifier le jeton ( HUGGING_FACE_HUB_TOKEN ) dans le fichier .env. De même, lors de l'utilisation report_to_wandb , vous devrez vous connecter à W&B. Vous pouvez soit spécifier le jeton ( WANDB_API_KEY ) dans le fichier .env, soit vous serez invité à entrer le jeton sur la ligne de commande. Qlora
Poignage de contrôle du gradient
Attention au flash 2
Stabiliser la formation
Poussez les points de contrôle à HuggingFace Hub
Rapport W&B
config = Config (
model_name_or_path = "meta-llama/Llama-2-7b-hf" ,
tokenizer_padding_side = "right" , # good for llama2
warmup_steps = 1000 ,
max_steps = 10000 ,
logging_steps = 1 ,
save_steps = 1000 ,
per_device_train_batch_size = 2 ,
gradient_accumulation_steps = 2 ,
max_length = 2048 ,
stabilize = True ,
use_flash_attention_2 = True ,
apply_lora = True ,
load_in_4bit = True ,
prepare_model_for_kbit_training = True ,
use_gradient_checkpointing = True ,
push_to_hub = False ,
hub_private_repo = True ,
hub_model_id = "BobaZooba/SupaDupaLlama-7B-LoRA" ,
report_to_wandb = False ,
wandb_project = "xllm-demo" ,
wandb_entity = "bobazooba" ,
)Cette opération est uniquement pour des modèles avec un adaptateur LORA.
Vous pouvez explicitement spécifier pour fusionner le modèle après la formation.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
apply_lora = True ,
fuse_after_training = True ,
)Même lorsque vous utilisez Qlora
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
apply_lora = True ,
load_in_4bit = True ,
prepare_model_for_kbit_training = True ,
fuse_after_training = True ,
)Ou vous pouvez fusionner le modèle vous-même après l'entraînement.
experiment . fuse_lora () DeepSpeed est nécessaire pour la formation de modèles sur multiple GPUs . DeepSpeed vous permet de efficiently manage the resources of several GPUs during training . Par exemple, vous pouvez distribute the gradients and the state of the optimizer to several GPUs , plutôt que de stocker un ensemble complet de gradients et l'état de l'optimiseur sur chaque GPU. Le démarrage de la formation en utilisant DeepSpeed ne peut se produire qu'à partir de la command line .
train.py
from xllm import Config
from xllm . datasets import GeneralDataset
from xllm . cli import cli_run_train
if __name__ == '__main__' :
train_data = [ "Hello!" ] * 100
train_dataset = GeneralDataset . from_list ( data = train_data )
cli_run_train ( config_cls = Config , train_dataset = train_dataset ) Exécutez Train (dans le paramètre num_gpus , spécifiez autant de GPU que vous)
deepspeed --num_gpus=8 train.py --deepspeed_stage 2Vous pouvez également passer d'autres paramètres
deepspeed --num_gpus=8 train.py
--deepspeed_stage 2
--apply_lora True
--stabilize True
--use_gradient_checkpointing True| Nom | Commentaire | Lien |
|---|---|---|
| Prototypage x - llm | Dans ce cahier, vous apprendrez les bases de la bibliothèque | |
| LLAMA2 & MISTRAL AI AFFECT | Formation du modèle 7B à Colab à l'aide de Qlora, BNB INT4, Points de contrôle du gradient et X - LLM |
X—LLM permet non seulement de prototyper les modèles, mais facilite également le développement de solutions prêtes à la production grâce à des capacités et une personnalisation intégrées.
L'utilisation de X—LLM pour former un modèle est facile et implique ces quelques étapes:
Prepare - Préparez les données et le modèle en les téléchargeant et en les préparant. Enregistre les données localement sur config.train_local_path_to_data et config.eval_local_path_to_data si vous utilisez un ensemble de données EVALTrain - Utilisez les données préparées à l'étape précédente pour former le modèleFuse - Si vous avez utilisé Lora pendant la formation, Fuse LoraQuantize - Optimisez l'utilisation de la mémoire de votre modèle en la quantifiant N'oubliez pas que ces tâches dans X—LLM commencent à partir de la ligne de commande. Ainsi, lorsque vous êtes prêt à partir, le lancement de votre projet complet ressemblera à ceci:
python3 MY_PROJECT/cli/prepare.py
--dataset_key MY_DATASET
--model_name_or_path mistralai/Mistral-7B-v0.1
--path_to_env_file ./.envdeepspeed --num_gpus=8 MY_PROJECT/cli/train.py
--use_gradient_checkpointing True
--deepspeed_stage 2
--stabilize True
--model_name_or_path mistralai/Mistral-7B-v0.1
--use_flash_attention_2 False
--load_in_4bit True
--apply_lora True
--raw_lora_target_modules all
--per_device_train_batch_size 8
--warmup_steps 1000
--save_total_limit 0
--push_to_hub True
--hub_model_id MY_HF_HUB_NAME/LORA_MODEL_NAME
--hub_private_repo True
--report_to_wandb True
--path_to_env_file ./.envpython3 MY_PROJECT/cli/fuse.py
--model_name_or_path mistralai/Mistral-7B-v0.1
--lora_hub_model_id MY_HF_HUB_NAME/LORA_MODEL_NAME
--hub_model_id MY_HF_HUB_NAME/MODEL_NAME
--hub_private_repo True
--force_fp16 True
--fused_model_local_path ./fused_model/
--path_to_env_file ./.envpython3 MY_PROJECT/cli/quantize.py
--model_name_or_path ./fused_model/
--apply_lora False
--stabilize False
--quantization_max_samples 128
--quantized_model_path ./quantized_model/
--prepare_model_for_kbit_training False
--quantized_hub_model_id MY_HF_HUB_NAME/MODEL_NAME_GPTQ
--quantized_hub_private_repo True
--path_to_env_file ./.env À l'heure actuelle, la bibliothèque X—LLM vous permet d'utiliser uniquement l'ensemble de données Soda. Nous l'avons configuré de cette façon à des fins de démonstration, mais nous prévoyons d'ajouter plus de jeux de données. Vous devrez comprendre comment télécharger et gérer votre ensemble de données. Autrement dit, vous prenez soin de vos données, et X—LLM gère le reste. Nous l'avons fait de cette façon exprès, pour vous donner beaucoup de place pour faire preuve de créativité et personnaliser au contenu de votre cœur.
Vous pouvez personnaliser votre ensemble de données en détail, en ajoutant des champs supplémentaires. Tout cela vous permettra de mettre en œuvre pratiquement toutes les tâches dans les domaines de Supervised Learning et Offline Reinforcement Learning .
En même temps, vous avez toujours un moyen facile de soumettre des données pour la modélisation du langage.
from xllm import Config
from xllm . datasets import GeneralDataset
from xllm . cli import cli_run_train
if __name__ == '__main__' :
train_data = [ "Hello!" ] * 100
train_dataset = GeneralDataset . from_list ( data = train_data )
cli_run_train ( config_cls = Config , train_dataset = train_dataset ) Pour configurer votre propre projet en utilisant X—LLM , vous devez faire deux choses:
X—LLM dans votre projetUne fois cela fait, votre projet sera bon à partir, et vous pouvez commencer à exécuter les étapes dont vous avez besoin (comme préparer, s'entraîner, etc.).
Pour maîtriser la construction de votre projet avec X—LLM , consultez les matériaux ci-dessous.
X—LLM et de l'intégrer dans votre propre projet La bibliothèque X—LLM utilise une seule configuration de configuration pour toutes les étapes comme la préparation, la formation et les autres étapes. Il est conçu d'une manière qui vous permet de comprendre facilement les fonctionnalités disponibles et ce que vous pouvez ajuster. Config a un contrôle presque sur chaque partie de chaque étape. Grâce à la configuration, vous pouvez choisir votre ensemble de données, définir votre collator, gérer le type de quantification pendant la formation, décider si vous souhaitez utiliser LORA, si vous devez pousser un point de contrôle sur le HuggingFace Hub , et bien plus encore.
Chemin de configuration: src.xllm.core.config.Config
Ou
from xllm import Config Vous avez la flexibilité de modifier de nombreux aspects de la formation de votre modèle: données, comment les données sont traitées, formateur, config, comment le modèle est chargé, ce qui se passe avant et après la formation, et bien plus encore.
Nous avons des composants prêts à l'emploi pour chaque partie du pipeline xllm . Vous pouvez entièrement changer certains composants comme l'ensemble de données, le collator, le formateur et l'expérience. Pour certains composants comme Experiment and Config, vous avez la possibilité de simplement construire sur ce qui est déjà là.
Construire quelque chose de cool avec x - llm? Veuillez me contacter à [email protected]. J'adorerais avoir de vos nouvelles.
Écrivez-nous afin que nous puissions ajouter votre projet.
Envisagez d'ajouter un badge à votre carte de modèle.
Pour le projet GitHub:
[ < img src = " https://github.com/BobaZooba/xllm/blob/main/static/images/xllm-badge.png " alt = " Powered by X—LLM " width = " 175 " height = " 32 " / > ](https://github.com/BobaZooba/xllm)Pour étreindre la carte du modèle Hub Face:
[ < img src = " https://cdn-uploads.huggingface.co/production/uploads/6074d5f1134c000d1ae10d42/JudU3rrPP5i87CfwINANO.png " alt = " Powered by X—LLM " width = " 175 " height = " 32 " / > ](https://github.com/BobaZooba/xllm)Cela ressemblera à ceci:
Pour le moment, nous n'avons pas de tests d'intégration continue qui utilisent un GPU. Cependant, nous pourrions développer ce type de tests à l'avenir. Il est important de noter, cependant, que cela nécessiterait d'investir du temps dans leur développement, ainsi que le financement de la maintenance des machines.
Experiment
