xllm
Single GPU DeepSpeed, download model without loading to RAM
Cutting Edge & Easy LLM Finetuning utilizando los métodos más avanzados (Qlora, Deepeed, GPTQ, Flash Atention 2, FSDP, etc.)
Desarrollado por Boris Zubarev | CV | LinkedIn | [email protected]
¿Está utilizando modelos de idiomas grandes (LLM) para su trabajo y desea capacitarlos de manera más eficiente con métodos avanzados? ¿Desea concentrarse en los datos y mejoras en lugar de la codificación repetitiva y que lleva mucho tiempo para la capacitación de LLM?
X - llm es tu solución. Es una biblioteca fácil de usar que optimiza la optimización de capacitación, por lo que puede concentrarse en mejorar sus modelos y datos . Equipado con técnicas de entrenamiento de vanguardia , X-LLM está diseñada para la eficiencia de los ingenieros que entienden sus necesidades.
X - LLM es ideal si te estás preparando para la producción o necesitas una herramienta de prototipos rápidos .
W&BYi-34B , Mistal AI , Llama 2 , Zephyr , OpenChat , Falcon , Phi , Qwen , MPT y muchos más X—LLM se prueba en Python 3.8+, Pytorch 2.0.1+ y CUDA 11.8.
pip install xllm Versión que incluye deepspeed , flash-attn y auto-gptq :
pip install " xllm[train] " Versión xllm predeterminada recomendada para el desarrollo local, xllm[train] recomendado para capacitación.
Versión 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 Controls xllmMás sobre la configuración
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".
) Para entrenar el modelo QLoRA , necesitamos cargar el modelo de la columna vertebral utilizando los pesos de la biblioteca bitsandbytes e int4 (o 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" ,
) Antes de eso, debe iniciar sesión en Huggingface Hub o agregar un API Token a las variables de entorno.
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 , solo se guardarán los pesos LoRA Antes de eso, debe iniciar sesión en W&B o agregar un API Token a las variables de entorno.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
report_to_wandb = True ,
logging_steps = 5 ,
wandb_project = "xllm-demo" ,
) Esto ayudará a usar less GPU memory durante la capacitación, es decir, podrá aprender más que sin esta técnica. Las desventajas de esta técnica están ralentizando el paso hacia adelante, es decir, slowing down training .
Entrenará modelos más grandes (por ejemplo 7b en Colab), pero a expensas de la velocidad de entrenamiento.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
use_gradient_checkpointing = True ,
) Esto acelera el entrenamiento y el consumo de memoria GPU, pero no funciona con todos los modelos y GPU. También debe instalar flash-attn para esto. Esto se puede hacer usando:
pip install "xllm[train]"
config = Config (
model_name_or_path = "meta-llama/Llama-2-7b-hf" ,
use_flash_attention_2 = True ,
)apply_lora ). Permite una reducción tremenda en los costos de capacitación y, además, ayuda a combatir de manera muy efectiva el olvido catastrófico.load_in_4bit y prepare_model_for_kbit_training juntos. Esto también reduce significativamente el consumo de memoria.use_gradient_checkpointing . Este método también reduce en gran medida el consumo de memoria, pero a expensas de desacelerar el entrenamiento.push_to_hub y hub_private_repo , también especificando el nombre del modelo en hub_model_id y save_steps . Ejemplo: "Bobazooba/Supadupallama-7B-Lora". Durante el entrenamiento, cada punto de control de su modelo se guardará en el Hub Huggingface. Si especificó apply_lora , solo se guardarán los pesos Lora, que luego puede fusionarse fácilmente con el modelo principal, por ejemplo, usando xllm .use_flash_attention_2report_to_wandb , también especificando wandb_project (el nombre del proyecto en W&B) y wandb_entity (nombre de usuario u organización en W&B).push_to_hub , debe iniciar sesión en el Hub Huggingface de antemano o especificar el token ( HUGGING_FACE_HUB_TOKEN ) en el archivo .env. Del mismo modo, al usar report_to_wandb , deberá iniciar sesión en W&B. Puede especificar el token ( WANDB_API_KEY ) en el archivo .env o se le pedirá que ingrese el token en la línea de comando. Qlora
Punta de control de gradiente
Atención flash 2
Estabilizar el entrenamiento
Presionar los puntos de control al Hub Huggingface
Informe 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" ,
)Esta operación es solo para modelos con un adaptador Lora.
Puede especificar explícitamente para fusionar el modelo después del entrenamiento.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
apply_lora = True ,
fuse_after_training = True ,
)Incluso cuando estás usando 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 ,
)O puede fusionar el modelo usted mismo después del entrenamiento.
experiment . fuse_lora () Se necesita DeepSpeed para modelos de entrenamiento en multiple GPUs . DeepSpeed le permite efficiently manage the resources of several GPUs during training . Por ejemplo, puede distribute the gradients and the state of the optimizer to several GPUs , en lugar de almacenar un conjunto completo de gradientes y el estado del optimizador en cada GPU. Comenzar el entrenamiento usando DeepSpeed solo puede ocurrir desde 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 ) Ejecutar el tren (en el parámetro num_gpus , especifique tantas GPU como lo haya hecho)
deepspeed --num_gpus=8 train.py --deepspeed_stage 2También puede pasar otros parámetros
deepspeed --num_gpus=8 train.py
--deepspeed_stage 2
--apply_lora True
--stabilize True
--use_gradient_checkpointing True| Nombre | Comentario | Enlace |
|---|---|---|
| Prototipos X - LLM | En este cuaderno aprenderá los conceptos básicos de la biblioteca. | |
| LLAMA2 y AI Mistral AI eficiente fino | Entrenamiento modelo 7b en Colab usando Qlora, BNB INT4, Punto de control de gradiente y X - LLM |
X—LLM permite no solo prototipos de modelos, sino que también facilita el desarrollo de soluciones listas para la producción a través de capacidades incorporadas y personalización.
Usar X—LLM para entrenar un modelo es fácil e implica estos pocos pasos:
Prepare : prepare los datos y el modelo descargándolos y preparándolos. Guarda datos localmente a config.train_local_path_to_data y config.eval_local_path_to_data Si está utilizando el conjunto de datos EVALTrain : use los datos preparados en el paso anterior para entrenar el modeloFuse : si usaste Lora durante el entrenamiento, Fuse LoraQuantize : optimice el uso de la memoria de su modelo cuantificando Recuerde, estas tareas en X—LLM comienzan desde la línea de comando. Entonces, cuando esté listo para ir, lanzar su proyecto completo se verá así:
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 En este momento, la biblioteca X—LLM le permite usar solo el conjunto de datos de refrescos. Lo hemos establecido de esta manera para fines de demostración, pero pronto estamos planeando agregar más conjuntos de datos. Deberá descubrir cómo descargar y manejar su conjunto de datos. En pocas palabras, se ocupa de sus datos, y X—LLM maneja el resto. Lo hemos hecho de esta manera a propósito, para darle mucho espacio para ser creativo y personalizar el contenido de su corazón.
Puede personalizar su conjunto de datos en detalle, agregando campos adicionales. Todo esto le permitirá implementar prácticamente cualquier tarea en las áreas de Supervised Learning y Offline Reinforcement Learning .
Al mismo tiempo, siempre tiene una manera fácil de enviar datos para el modelado de idiomas.
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 ) Para configurar su propio proyecto usando X—LLM , debe hacer dos cosas:
X—LLM en su proyectoUna vez hecho esto, su proyecto estará listo para comenzar, y puede comenzar a ejecutar los pasos que necesita (como preparar, entrenar, etc.).
Para controlar su proyecto con X—LLM , consulte los materiales a continuación.
X—LLM y ajustarlo en su propio proyecto La biblioteca X—LLM utiliza una configuración de una sola configuración para todos los pasos como preparación, entrenamiento y otros pasos. Está diseñado de una manera que le permite comprender fácilmente las características disponibles y lo que puede ajustar. Config tiene control casi cada parte de cada paso. Gracias a la configuración, puede elegir su conjunto de datos, configurar su colatador, administrar el tipo de cuantificación durante la capacitación, decidir si desea usar Lora, si necesita empujar un punto de control al HuggingFace Hub y mucho más.
Ruta de configuración: src.xllm.core.config.Config
O
from xllm import Config Tiene la flexibilidad de ajustar muchos aspectos de la capacitación de su modelo: datos, cómo se procesan los datos, el entrenador, la configuración, cómo se carga el modelo, lo que sucede antes y después del entrenamiento, y mucho más.
Tenemos componentes listos para usar para cada parte de la tubería xllm . Puede cambiar por completo algunos componentes como el conjunto de datos, el colatador, el entrenador y el experimento. Para algunos componentes como Experiment y Config, tiene la opción de construir lo que ya está allí.
Construyendo algo genial con x - llm? Por favor, comuníquese conmigo a [email protected]. Me encantaría saber de ti.
Escríbanos para que podamos agregar su proyecto.
Considere agregar una insignia a su tarjeta modelo.
Para el proyecto 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)Para abrazar la tarjeta modelo del centro de la cara:
[ < 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)Se verá así:
Por el momento, no tenemos pruebas de integración continua que utilizan una GPU. Sin embargo, podríamos desarrollar este tipo de pruebas en el futuro. Sin embargo, es importante tener en cuenta que esto requeriría tiempo de inversión en su desarrollo, así como fondos para el mantenimiento de la máquina.
Experiment
