xllm
Single GPU DeepSpeed, download model without loading to RAM
FINETUNING DE CURTE EAST LLM LLM usando os métodos mais avançados (Qlora, DeepSpeed, GPTQ, Flash Atenção 2, FSDP, etc)
Desenvolvido por Boris Zubarev | Cv | LinkedIn | [email protected]
Você está usando modelos de idiomas grandes (LLMs) para o seu trabalho e deseja treiná -los com mais eficiência com métodos avançados? Deseja se concentrar nos dados e melhorias, em vez de codificação repetitiva e demorada para o treinamento de LLM?
X - Llm é a sua solução. É uma biblioteca fácil de usar que simplifica a otimização de treinamento, para que você possa se concentrar em aprimorar seus modelos e dados . Equipado com técnicas de treinamento de ponta , o X-LLM é projetado para eficiência por engenheiros que entendem suas necessidades.
X - Llm é ideal, se você está se preparando para a produção ou precisa de uma ferramenta de prototipagem rápida .
W&BYi-34B , Mistal AI , Llama 2 , Zephyr , OpenChat , Falcon , Phi , Qwen , MPT e muito mais X—LLM é testado no Python 3.8+, Pytorch 2.0.1+ e CUDA 11.8.
pip install xllm Versão que inclui deepspeed , flash-attn e auto-gptq :
pip install " xllm[train] " Versão xllm padrão recomendada para o desenvolvimento local, xllm[train] recomendado para treinamento.
Versão 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 controla xllmMais sobre a configuração
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 treinar o modelo QLoRA , precisamos carregar o modelo de backbone usando a biblioteca bitsandbytes e os pesos 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" ,
) Antes disso, você deve fazer login no Huggingface Hub ou adicionar um API Token às variáveis do ambiente.
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 , apenas os pesos LoRA serão salvos Antes disso, você deve fazer login para W&B ou adicionar um API Token às variáveis do ambiente.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
report_to_wandb = True ,
logging_steps = 5 ,
wandb_project = "xllm-demo" ,
) Isso ajudará a usar less GPU memory durante o treinamento, ou seja, você poderá aprender mais do que sem essa técnica. As desvantagens dessa técnica estão desacelerando a etapa para a frente, ou seja, slowing down training .
Você estará treinando modelos maiores (por exemplo, 7b no COLAB), mas à custa da velocidade de treinamento.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
use_gradient_checkpointing = True ,
) Isso acelera o treinamento e o consumo de memória da GPU, mas não funciona com todos os modelos e GPUs. Você também precisa instalar flash-attn para isso. Isso pode ser feito 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 uma tremenda redução nos custos de treinamento e, além disso, ajuda a combater efetivamente o esquecimento catastrófico.load_in_4bit e prepare_model_for_kbit_training juntos. Isso também reduz significativamente o consumo de memória.use_gradient_checkpointing . Esse método também reduz bastante o consumo de memória, mas às custas de desacelerar o treinamento.push_to_hub e hub_private_repo , especificando também o nome do modelo em hub_model_id e save_steps . Exemplo: "Bobazooba/supadupallama-7b-lora". Durante o treinamento, todo ponto de verificação do seu modelo será salvo no hub do Huggingface. Se você especificou apply_lora , apenas os pesos da Lora serão salvos, que você poderá se fundir mais facilmente com o modelo principal, por exemplo, usando xllm .use_flash_attention_2report_to_wandb , especificando também wandb_project (o nome do projeto na W&B) e wandb_entity (nome do usuário ou organização na W&B).push_to_hub , você precisa fazer login no hub do huggingface com antecedência ou especificar o token ( HUGGING_FACE_HUB_TOKEN ) no arquivo .env. Da mesma forma, ao usar report_to_wandb , você precisará fazer login no W&B. Você pode especificar o token ( WANDB_API_KEY ) no arquivo .env ou será solicitado a inserir o token na linha de comando. Qlora
Ponto de verificação de gradiente
Flash Atenção 2
Estabilizar o treinamento
Poster pontos de verificação para o hub de huggingface
Relatório da 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 operação é apenas para modelos com um adaptador LORA.
Você pode especificar explicitamente para fundir o modelo após o treinamento.
config = Config (
model_name_or_path = "HuggingFaceH4/zephyr-7b-beta" ,
apply_lora = True ,
fuse_after_training = True ,
)Mesmo quando você está 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 ,
)Ou você pode fundir o modelo após o treinamento.
experiment . fuse_lora () DeepSpeed é necessária para treinar modelos em multiple GPUs . DeepSpeed permite efficiently manage the resources of several GPUs during training . Por exemplo, você pode distribute the gradients and the state of the optimizer to several GPUs , em vez de armazenar um conjunto completo de gradientes e o estado do otimizador em cada GPU. Iniciar o treinamento usando DeepSpeed só pode acontecer na 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 ) Execute o trem (no parâmetro num_gpus , especifique tantas GPUs quanto você)
deepspeed --num_gpus=8 train.py --deepspeed_stage 2Você também pode passar outros parâmetros
deepspeed --num_gpus=8 train.py
--deepspeed_stage 2
--apply_lora True
--stabilize True
--use_gradient_checkpointing True| Nome | Comentário | Link |
|---|---|---|
| X - prototipagem de llm | Neste caderno, você aprenderá o básico da biblioteca | |
| Llama2 e ajuste fino com eficiência de Ai | 7b Modelo Treinamento em Colab usando Qlora, BNB Int4, CheckPonsing de gradiente e X - Llm |
X—LLM permite não apenas protótipos de modelos, mas também facilita o desenvolvimento de soluções prontas para produção por meio de recursos e personalização internos.
Usar X—LLM para treinar um modelo é fácil e envolve essas poucas etapas:
Prepare - prepare os dados e o modelo baixando e preparando -os. Economiza dados localmente para config.train_local_path_to_data e config.eval_local_path_to_data se você estiver usando o conjunto de dados de avaliaçãoTrain - Use os dados preparados na etapa anterior para treinar o modeloFuse - Se você usou Lora durante o treinamento, Fuse LoraQuantize - otimize o uso de memória do seu modelo, quantizando -o Lembre -se, essas tarefas em X—LLM começam na linha de comando. Então, quando você está pronto para ir, lançar seu projeto completo será algo assim:
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 No momento, a biblioteca X—LLM permite usar apenas o conjunto de dados de refrigerante. Nós configuramos dessa maneira para fins de demonstração, mas planejamos adicionar mais conjuntos de dados em breve. Você precisará descobrir como baixar e lidar com seu conjunto de dados. Simplificando, você cuida de seus dados e X—LLM lida com o resto. Fizemos dessa maneira de propósito, para oferecer muito espaço para ser criativo e personalizar o conteúdo do seu coração.
Você pode personalizar seu conjunto de dados em detalhes, adicionando campos adicionais. Tudo isso permitirá que você implemente praticamente qualquer tarefa nas áreas de Supervised Learning e Offline Reinforcement Learning .
Ao mesmo tempo, você sempre tem uma maneira fácil de enviar dados para modelagem 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 seu próprio projeto usando X—LLM , você precisa fazer duas coisas:
X—LLM em seu projetoUma vez feito isso, seu projeto estará pronto e você poderá começar a executar as etapas necessárias (como preparar, treinar e assim por diante).
Para controlar o seu projeto com X—LLM , confira os materiais abaixo.
X—LLM e encaixá-lo em seu próprio projeto A biblioteca X—LLM usa uma única configuração de configuração para todas as etapas, como preparação, treinamento e outras etapas. Ele foi projetado de uma maneira que permite entender facilmente os recursos disponíveis e o que você pode ajustar. Config tem controle quase em cada parte de cada etapa. Graças à configuração, você pode escolher seu conjunto de dados, definir seu coletor, gerenciar o tipo de quantização durante o treinamento, decidir se deseja usar o LORA, se precisar empurrar um ponto de verificação para o HuggingFace Hub e muito mais.
Caminho de configuração: src.xllm.core.config.Config
Ou
from xllm import Config Você tem a flexibilidade de ajustar muitos aspectos do treinamento do seu modelo: dados, como os dados são processados, treinador, configuração, como o modelo é carregado, o que acontece antes e depois do treinamento e muito mais.
Temos componentes prontos para uso para todas as partes do pipeline xllm . Você pode alternar completamente alguns componentes, como conjunto de dados, colisor, treinador e experimento. Para alguns componentes como experimento e configuração, você tem a opção de apenas desenvolver o que já está lá.
Construindo algo legal com X - Llm? Por favor, entre em contato comigo em [email protected]. Eu adoraria ouvir de você.
Escreva para nós para que possamos adicionar seu projeto.
Considere adicionar um crachá ao seu cartão de modelo.
Para o projeto 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 abraçar o cartão de modelo do Face Hub:
[ < 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)Será assim:
No momento, não temos testes contínuos de integração que utilizam uma GPU. No entanto, podemos desenvolver esses tipos de testes no futuro. É importante observar, no entanto, que isso exigiria o investimento em seu desenvolvimento, bem como financiamento para a manutenção da máquina.
Experiment
