xllm
Single GPU DeepSpeed, download model without loading to RAM
Schneidende und Easy LLM -Finetuning unter Verwendung der fortschrittlichsten Methoden (Qlora, Deepspeed, GPTQ, Flash Achtung 2, FSDP usw.)
Entwicklung von Boris Zubarev | Cv | LinkedIn | [email protected]
Verwenden Sie großes Sprachmodelle (LLMs) für Ihre Arbeit und möchten sie effizienter mit fortschrittlichen Methoden schulen? Möchten Sie sich eher auf die Daten und Verbesserungen als auf sich wiederholende und zeitaufwändige Codierung für das LLM-Training konzentrieren?
X - flim ist Ihre Lösung. Es handelt sich um eine benutzerfreundliche Bibliothek, die die Trainingsoptimierung optimiert, sodass Sie sich auf die Verbesserung Ihrer Modelle und Daten konzentrieren können. X ausgestattet mit hochmodernen Trainingstechniken und von Ingenieuren, die Ihre Bedürfnisse verstehen, wird für Effizienz ausgestattet.
X - flim ist ideal, ob Sie sich auf die Produktion vorbereiten oder ein schnelles Prototyping -Tool benötigen.
W&BYi-34B , Mistal AI , Llama 2 , Zephyr , OpenChat , Falcon , Phi , Qwen , MPT und viele mehr X—LLM wird auf Python 3.8+, Pytorch 2.0.1+ und CUDA 11.8 getestet.
pip install xllm Version mit deepspeed , flash-attn und auto-gptq :
pip install " xllm[train] " Standard xllm -Version, die für die lokale Entwicklung empfohlen wird, wird xllm[train] für das Training empfohlen.
CUDA-Version: 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 die Konfiguration xllmMehr über Konfiguration
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".
) Um das QLoRA -Modell zu trainieren, müssen wir das Backbone -Modell mithilfe bitsandbytes Library und der INT4 (oder Int8) -Wichte laden.
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" ,
) Vorher müssen Sie sich bei Huggingface Hub anmelden oder den Umgebungsvariablen ein API Token hinzufügen.
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_steps in Huggingface -Hub gespeichertLoRA trainieren, werden nur LoRA -Gewichte gespeichert Vorher müssen Sie sich bei W&B anmelden oder den Umgebungsvariablen ein API Token hinzufügen.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
report_to_wandb = True ,
logging_steps = 5 ,
wandb_project = "xllm-demo" ,
) Dies wird dazu beitragen, während des Trainings less GPU memory zu verwenden, dh Sie können mehr als diese Technik lernen. Die Nachteile dieser Technik verlangsamen den Vorwärtsschritt, dh und slowing down training .
Sie trainieren größere Modelle (zum Beispiel 7b in Colab), jedoch auf Kosten der Trainingsgeschwindigkeit.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
use_gradient_checkpointing = True ,
) Dies beschleunigt das Training und den GPU -Speicherverbrauch, funktioniert jedoch nicht mit allen Modellen und GPUs. Dafür müssen Sie auch flash-attn installieren. Dies kann mit:
pip install "xllm[train]"
config = Config (
model_name_or_path = "meta-llama/Llama-2-7b-hf" ,
use_flash_attention_2 = True ,
)apply_lora ). Es ermöglicht eine enorme Reduzierung der Trainingskosten und hilft außerdem, das katastrophale Vergessen effektiv zu bekämpfen.load_in_4bit und prepare_model_for_kbit_training zusammen. Dies reduziert auch den Speicherverbrauch erheblich.use_gradient_checkpointing anzuwenden. Diese Methode reduziert auch den Speicherverbrauch stark, aber auf Kosten der Verlangsamung des Trainings.push_to_hub und hub_private_repo zu aktivieren und auch den Modellnamen in hub_model_id und save_steps anzugeben. Beispiel: "Bobazooba/Supadupallama-7b-lora". Während des Trainings wird jeder Kontrollpunkt Ihres Modells in der Hubface -Hub gespeichert. Wenn Sie apply_lora angegeben haben, werden nur die Lora -Gewichte gespeichert, die Sie später leicht mit dem Hauptmodell verschmelzen können, beispielsweise mit xllm .use_flash_attention_2 hinzuzufügenreport_to_wandb zu verwenden, wobei auch wandb_project (der Projektname in W & B) und wandb_entity (Benutzer- oder Organisationsname in W & B) angegeben wird.push_to_hub im Voraus im Huggingface -Hub anmelden oder das Token ( HUGGING_FACE_HUB_TOKEN ) in der .Env -Datei angeben müssen. In ähnlicher Weise müssen Sie sich bei der Verwendung report_to_wandb bei W & B anmelden. Sie können entweder das Token ( WANDB_API_KEY ) in der .Env -Datei angeben oder Sie werden aufgefordert, das Token in der Befehlszeile einzugeben. Qlora
Gradientenprüfung
Flash Achtung 2
Stabilisierungstraining
Schieben Sie Checkpoints auf das Hubface -Hub
W & B -Bericht
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" ,
)Dieser Vorgang gilt nur für Modelle mit einem Lora -Adapter.
Sie können explizit angeben, um das Modell nach dem Training zu verschmelzen.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
apply_lora = True ,
fuse_after_training = True ,
)Auch wenn Sie Qlora verwenden
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 ,
)Oder Sie können das Modell nach dem Training selbst verschmelzen.
experiment . fuse_lora () DeepSpeed ist für Trainingsmodelle für multiple GPUs erforderlich. DeepSpeed können Sie efficiently manage the resources of several GPUs during training . Beispielsweise können Sie distribute the gradients and the state of the optimizer to several GPUs , anstatt einen vollständigen Satz von Gradienten und den Zustand des Optimierers auf jeder GPU zu speichern. Das Training mit DeepSpeed kann nur aus der command line erfolgen.
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 ) Führen Sie den Zug aus (Geben Sie im Parameter num_gpus so viele GPUs an wie Sie)
deepspeed --num_gpus=8 train.py --deepspeed_stage 2Sie können auch andere Parameter übergeben
deepspeed --num_gpus=8 train.py
--deepspeed_stage 2
--apply_lora True
--stabilize True
--use_gradient_checkpointing True| Name | Kommentar | Link |
|---|---|---|
| X - Llm Prototyping | In diesem Notebook lernen Sie die Grundlagen der Bibliothek kennen | |
| Lama2 & Mistral AI Effiziente Feinabstimmung | 7B Modelltraining in Colab mit Qlora, BNB INT4, Gradientenprüfungen und X - Llm |
X—LLM ermöglicht nicht nur Prototypmodelle, sondern erleichtert auch die Entwicklung produktionsbereiteter Lösungen durch integrierte Funktionen und Anpassungen.
Die Verwendung von X—LLM zum Training eines Modells ist einfach und umfasst die wenigen Schritte:
Prepare - Erstellen Sie die Daten und das Modell bereit, indem Sie sie herunterladen und vorbereiten. Speichern Sie Daten lokal in config.train_local_path_to_data und config.eval_local_path_to_data , wenn Sie den Eval -Datensatz verwendenTrain - Verwenden Sie die im vorherigen Schritt erstellten Daten, um das Modell zu trainierenFuse - Wenn Sie Lora während des Trainings verwendet haben, verschmelzen Sie LoraQuantize - Optimieren Sie die Speicherverwendung Ihres Modells, indem Sie es quantisieren Denken Sie daran, dass diese Aufgaben in X—LLM in der Befehlszeile beginnen. Wenn Sie also auf das Gehen eingestellt sind, sieht es ungefähr so aus:
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 Im Moment können Sie mit der X—LLM -Bibliothek nur den Soda -Datensatz verwenden. Wir haben es für Demo -Zwecke so eingerichtet, aber wir planen, bald weitere Datensätze hinzuzufügen. Sie müssen herausfinden, wie Sie Ihren Datensatz herunterladen und umgehen können. Einfach ausgedrückt, Sie kümmern sich um Ihre Daten und X—LLM den Rest. Wir haben es absichtlich so gemacht, um Ihnen viel Platz zu bieten, um kreativ zu werden und den Inhalt Ihres Herzens anzupassen.
Sie können Ihren Datensatz ausführlich anpassen und zusätzliche Felder hinzufügen. All dies ermöglicht es Ihnen, praktisch jede Aufgabe in den Bereichen des Supervised Learning und Offline Reinforcement Learning zu implementieren.
Gleichzeitig haben Sie immer eine einfache Möglichkeit, Daten für die Sprachmodellierung einzureichen.
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 ) Um Ihr eigenes Projekt mit X—LLM einzurichten, müssen Sie zwei Dinge tun:
X—LLM Befehlszeilen-Tools hinzuSobald dies erledigt ist, kann Ihr Projekt gut gehen und Sie können die benötigten Schritte ausführen (wie vorbereiten, trainieren usw.).
Um Ihr Projekt mit X—LLM zu erstellen, lesen Sie die folgenden Materialien.
X—LLM ein Schritt-für-Schritt Die X—LLM -Bibliothek verwendet ein einzelnes Konfigurations -Setup für alle Schritte wie Vorbereitung, Training und die anderen Schritte. Es ist so gestaltet, dass Sie die verfügbaren Funktionen und die Anpassung leicht verstehen können. Config hat die Kontrolle fast über jeden einzelnen Teil jedes Schritts. Dank der Konfiguration können Sie Ihren Datensatz auswählen, Ihren Collator festlegen, die Art der Quantisierung während des Trainings verwalten, entscheiden, ob Sie LORA verwenden möchten, wenn Sie einen Checkpoint zum HuggingFace Hub und viel mehr übertragen müssen.
Konfigurationsweg: src.xllm.core.config.Config
Oder
from xllm import Config Sie haben die Flexibilität, viele Aspekte des Trainings Ihres Modells zu optimieren: Daten, wie Daten verarbeitet werden, Trainer, Konfiguration, wie das Modell geladen wird, was vor und nach dem Training passiert, und vieles mehr.
Für jeden Teil der xllm Pipeline haben wir einsatzbereit. Sie können einige Komponenten wie Datensatz, Collator, Trainer und Experiment vollständig ausschalten. Für einige Komponenten wie Experiment und Konfiguration haben Sie die Möglichkeit, einfach auf dem aufzubauen, was bereits vorhanden ist.
Etwas Cooles mit x - fluM bauen? Bitte wenden Sie sich an mich unter [email protected]. Ich würde gerne von dir hören.
Schreiben Sie uns, damit wir Ihr Projekt hinzufügen können.
Erwägen Sie, Ihrer Modellkarte ein Abzeichen hinzuzufügen.
Für GitHub -Projekt:
[ < 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)Zum Umarmen der Gesichts -Hub -Modellkarte:
[ < 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)Es wird so aussehen:
Im Moment haben wir keine kontinuierlichen Integrationstests, die eine GPU verwenden. Wir könnten jedoch in Zukunft solche Tests entwickeln. Es ist jedoch wichtig zu beachten, dass dies eine Zeit in ihre Entwicklung investieren und die Finanzierung der Maschinenwartung investieren würde.
Experiment Sie Rückrufe hinzufügen
