PEFT documentation
DeepSpeed
DeepSpeed
DeepSpeed, milyarlarca parametreye sahip büyük modellerin dağıtık eğitiminde hız ve ölçek için tasarlanmış bir kütüphanedir. Çekirdeğinde, optimizör durumlarını (ZeRO-1), gradyanları (ZeRO-2) ve parametreleri (ZeRO-3) veri paralel süreçler arasında parçalayan Zero Redundancy Optimizer (ZeRO) bulunur. Bu, bellek kullanımını önemli ölçüde azaltarak eğitiminizi milyar parametreli modellere ölçeklemenizi sağlar. Bellek verimliliğini daha da artırmak için ZeRO-Offload, optimizasyon sırasında CPU kaynaklarından yararlanarak GPU hesaplama ve bellek kullanımını azaltır.
Her iki özellik de 🤗 Accelerate tarafından desteklenmektedir ve 🤗 PEFT ile birlikte kullanabilirsiniz.
bitsandbytes nicelleştirme + LoRA ile uyumluluk
Aşağıdaki tablo, ince ayar (fine-tuning) açısından PEFT’nin LoRA’sı, bitsandbytes kütüphanesi ve DeepSpeed Zero aşamaları arasındaki uyumluluğu özetlemektedir. DeepSpeed Zero-1 ve 2, çıkarım (inference) sırasında hiçbir etki yaratmaz; çünkü 1. aşama optimizör durumlarını, 2. aşama ise optimizör durumlarını ve gradyanları parçalar (shard):
| DeepSpeed aşaması | Uyumluluk var mı? |
|---|---|
| Zero-1 | 🟢 |
| Zero-2 | 🟢 |
| Zero-3 | 🟢 |
DeepSpeed Stage 3 + QLoRA için lütfen aşağıdaki PEFT QLoRA ve ZeRO3 ile DeepSpeed'i büyük modelleri birden fazla GPU üzerinde ince ayar yapmak için kullanma bölümüne bakın.
Bu gözlemleri doğrulamak için, Transformers Reinforcement Learning (TRL) kütüphanesinin resmî örnek betiklerini QLoRA + PEFT ile ve burada bulunan accelerate yapılandırmalarını kullanarak çalıştırdık. Bu deneyleri 2x NVIDIA T4 GPU üzerinde çalıştırdık.
Büyük modelleri birden fazla cihazda ve birden fazla düğümde ince ayar yapmak için PEFT ve DeepSpeed'i ZeRO3 ile kullanın
Bu kılavuz bölümü, SFT (denetimli ince ayar) işlemi için eğitim betiğimizi nasıl kullanacağınızı öğrenmenize yardımcı olacaktır. Betiği, tek bir makinede 8xH100 80GB GPU'larda LoRA ve ZeRO-3 kullanarak Llama-70B modelinin SFT'sini yapmak üzere yapılandıracaksınız. accelerate yapılandırmasını değiştirerek birden fazla makineye ölçeklenmesini yapılandırabilirsiniz.
Yapılandırma
🤗 Accelerate ile bir DeepSpeed yapılandırma dosyası oluşturmak için aşağıdaki komutu çalıştırarak başlayın. --config_file bayrağı, yapılandırma dosyasını belirli bir konuma kaydetmenizi sağlar; aksi takdirde dosya, 🤗 Accelerate önbelleğinde default_config.yaml adıyla kaydedilir.
Yapılandırma dosyası, eğitim betiğini başlattığınızda varsayılan seçenekleri ayarlamak için kullanılır.
accelerate config --config_file deepspeed_config.yaml
Kurulumunuzla ilgili birkaç soru sorulacak ve aşağıdaki argümanları yapılandıracaksınız. Bu örnekte ZeRO-3 kullanacağınız için bu seçenekleri seçtiğinizden emin olun.
`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them. Pass the same value as you would pass via cmd argument else you will encounter mismatch error.
`gradient_clipping`: Enable gradient clipping with value. Don't set this as you will be passing it via cmd arguments.
`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2. Set this as `none` as don't want to enable offloading.
`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3. Set this as `none` as don't want to enable offloading.
`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3. Set this to `True`.
`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3. Set this to `True`.
`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training. Set this to `True`.Bu işlem tamamlandıktan sonra, ilgili yapılandırma aşağıdaki gibi görünmeli ve deepspeed_config.yaml dosyası config klasöründe bulunabilir:
compute_environment: LOCAL_MACHINE
debug: false
deepspeed_config:
deepspeed_multinode_launcher: standard
gradient_accumulation_steps: 4
offload_optimizer_device: none
offload_param_device: none
zero3_init_flag: true
zero3_save_16bit_model: true
zero_stage: 3
distributed_type: DEEPSPEED
downcast_bf16: 'no'
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 8
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: falseBaşlatma komutu
Başlatma komutu run_peft_deepspeed.sh adresinde mevcuttur ve aşağıda da gösterilmektedir:
accelerate launch --config_file "configs/deepspeed_config.yaml" train.py \
--seed 100 \
--model_name_or_path "meta-llama/Llama-2-70b-hf" \
--dataset_name "smangrul/ultrachat-10k-chatml" \
--chat_template_format "chatml" \
--add_special_tokens False \
--append_concat_token False \
--splits "train,test" \
--max_seq_len 2048 \
--num_train_epochs 1 \
--logging_steps 5 \
--log_level "info" \
--logging_strategy "steps" \
--eval_strategy "epoch" \
--save_strategy "epoch" \
--push_to_hub \
--hub_private_repo True \
--hub_strategy "every_save" \
--bf16 True \
--packing True \
--learning_rate 1e-4 \
--lr_scheduler_type "cosine" \
--weight_decay 1e-4 \
--warmup_steps 0 \
--max_grad_norm 1.0 \
--output_dir "llama-sft-lora-deepspeed" \
--per_device_train_batch_size 8 \
--per_device_eval_batch_size 8 \
--gradient_accumulation_steps 4 \
--gradient_checkpointing True \
--use_reentrant False \
--dataset_text_field "content" \
--use_flash_attn True \
--use_peft_lora True \
--lora_r 8 \
--lora_alpha 16 \
--lora_dropout 0.1 \
--lora_target_modules "all-linear" \
--use_4bit_quantization FalseLoRA'nın rank=8, alpha=16 parametreleriyle ve tüm lineer katmanları hedef alacak şekilde kullanıldığını fark edin. deepspeed yapılandırma dosyasını geçiriyor ve 70B Llama modelini ultrachat veri setinin bir alt kümesi üzerinde ince ayarlıyoruz.
Önemli kısımlar
Betik biraz daha derinlemesine inceleyelim, böylece neler olduğunu görebilir ve nasıl çalıştığını anlayabilirsiniz.
Bilmeniz gereken ilk şey, DeepSpeed yapılandırmasının geçirilmiş olması nedeniyle script'in dağıtık eğitim için DeepSpeed'i kullanmasıdır. SFTTrainer sınıfı, geçirilen peft yapılandırmasını kullanarak PEFT modelinin oluşturulmasındaki tüm ağır işleri üstlenir. Ardından trainer.train() çağrıldığında, SFTTrainer içsel olarak 🤗 Accelerate'i kullanarak DeepSpeed yapılandırmasını alır ve model, optimizör ve trainer'ı hazırlar; bu sayede oluşturulan DeepSpeed motoru eğitilir. Ana kod parçası aşağıdadır:
# trainer
trainer = SFTTrainer(
model=model,
processing_class=tokenizer,
args=training_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
peft_config=peft_config,
)
trainer.accelerator.print(f"{trainer.model}")
# train
checkpoint = None
if training_args.resume_from_checkpoint is not None:
checkpoint = training_args.resume_from_checkpoint
trainer.train(resume_from_checkpoint=checkpoint)
# saving final model
trainer.save_model()Bellek kullanımı
Yukarıdaki örnekte, aşağıdaki ekran görüntüsünde de görüldüğü üzere GPU başına tüketilen bellek 64 GB (%80)'dır:

Daha fazla kaynak
180B Falcon modelinin 2 makinedeki 16 A100 GPU üzerinde nasıl ince ayarlanacağına dair bu blog yazısına da göz atabilirsiniz: Falcon 180B Finetuning using 🤗 PEFT and DeepSpeed.
Büyük modelleri birden fazla GPU üzerinde ince ayar yapmak için PEFT QLoRA ve ZeRO3 ile DeepSpeed kullanın
Bu bölümde, 70B Llama modelini 2X40GB GPU'larda ince ayar yapmak için QLoRA ve DeepSpeed Stage-3'ün nasıl kullanılacağına bakacağız.
Bunun için öncelikle bitsandbytes>=0.43.3, accelerate>=1.0.1, transformers>4.44.2, trl>0.11.4 ve peft>0.13.0 gereklidir. Accelerate yapılandırması kullanılırken zero3_init_flag değerinin true olarak ayarlanması gerekir. Aşağıda, deepspeed_config_z3_qlora.yaml adresinde bulunabilen yapılandırma yer almaktadır:
compute_environment: LOCAL_MACHINE
debug: false
deepspeed_config:
deepspeed_multinode_launcher: standard
offload_optimizer_device: none
offload_param_device: none
zero3_init_flag: true
zero3_save_16bit_model: true
zero_stage: 3
distributed_type: DEEPSPEED
downcast_bf16: 'no'
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: falseAşağıda, run_peft_qlora_deepspeed_stage3.sh adresinde bulunan başlatma komutu verilmiştir:
accelerate launch --config_file "configs/deepspeed_config_z3_qlora.yaml" train.py \
--seed 100 \
--model_name_or_path "meta-llama/Llama-2-70b-hf" \
--dataset_name "smangrul/ultrachat-10k-chatml" \
--chat_template_format "chatml" \
--add_special_tokens False \
--append_concat_token False \
--splits "train,test" \
--max_seq_len 2048 \
--num_train_epochs 1 \
--logging_steps 5 \
--log_level "info" \
--logging_strategy "steps" \
--eval_strategy "epoch" \
--save_strategy "epoch" \
--push_to_hub \
--hub_private_repo True \
--hub_strategy "every_save" \
--bf16 True \
--packing True \
--learning_rate 1e-4 \
--lr_scheduler_type "cosine" \
--weight_decay 1e-4 \
--warmup_steps 0 \
--max_grad_norm 1.0 \
--output_dir "llama-sft-qlora-dsz3" \
--per_device_train_batch_size 2 \
--per_device_eval_batch_size 2 \
--gradient_accumulation_steps 2 \
--gradient_checkpointing True \
--use_reentrant True \
--dataset_text_field "content" \
--use_flash_attn True \
--use_peft_lora True \
--lora_r 8 \
--lora_alpha 16 \
--lora_dropout 0.1 \
--lora_target_modules "all-linear" \
--use_4bit_quantization True \
--use_nested_quant True \
--bnb_4bit_compute_dtype "bfloat16" \
--bnb_4bit_quant_storage_dtype "bfloat16"4-bit parametrelerin paketlenmesi için veri türünü belirten, bnb_4bit_quant_storage_dtype olarak geçen yeni argümana dikkat edin. Örneğin, bu değer bfloat16 olarak ayarlandığında, kuantizasyon sonrası 32/4 = 8 adet 4-bit parametre birlikte paketlenir.
Eğitim kodu açısından önemli kod değişiklikleri şunlardır:
...
bnb_config = BitsAndBytesConfig(
load_in_4bit=args.use_4bit_quantization,
bnb_4bit_quant_type=args.bnb_4bit_quant_type,
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=args.use_nested_quant,
+ bnb_4bit_quant_storage=quant_storage_dtype,
)
...
model = AutoModelForCausalLM.from_pretrained(
args.model_name_or_path,
quantization_config=bnb_config,
trust_remote_code=True,
attn_implementation="flash_attention_2" if args.use_flash_attn else "eager",
+ dtype=quant_storage_dtype or torch.float32,
)AutoModelForCausalLM için dtype'nin, bnb_4bit_quant_storage veri tipiyle aynı olduğunu fark edin. Bu kadar. Geri kalan her şey Trainer ve TRL tarafından ele alınır.
Bellek kullanımı
Yukarıdaki örnekte, GPU başına tüketilen bellek 36.6 GB'dir. Dolayısıyla, DeepSpeed Stage 3+LoRA ile 8X80GB GPU ve DDP+QLoRA ile birkaç 80GB GPU gerektiren işlem, artık 2X40GB GPU ile yapılabilir. Bu, büyük modellerin ince ayarını daha erişilebilir hale getirir.
Tek bir GPU üzerinde büyük modelleri ince ayar yapmak için PEFT ve DeepSpeed'i ZeRO3 ve CPU Offloading ile kullanın
Bu kılavuz bölümü, DeepSpeed eğitim betiğini nasıl kullanacağınızı öğrenmenize yardımcı olacaktır. Betiği, ZeRO-3 ve CPU Offload ile koşullu üretim için büyük bir modeli eğitecek şekilde yapılandıracaksınız.
💡 Başlamanıza yardımcı olmak için neden dil modellemesi ve koşullu üretim için örnek eğitim betiklerimize göz atın. Göreviniz betiklerdekiyle benzerse bu betikleri kendi uygulamalarınız için uyarlayabilir veya olduğu gibi kullanabilirsiniz.
Yapılandırma
🤗 Accelerate ile bir DeepSpeed yapılandırma dosyası oluşturmak için aşağıdaki komutu çalıştırarak başlayın. --config_file bayrağı, yapılandırma dosyasını belirli bir konuma kaydetmenizi sağlar; aksi takdirde dosya, 🤗 Accelerate önbelleğinde default_config.yaml adıyla kaydedilir.
Yapılandırma dosyası, eğitim betiğini başlattığınızda varsayılan seçenekleri ayarlamak için kullanılır.
accelerate config --config_file ds_zero3_cpu.yaml
Kurulumunuzla ilgili birkaç soru sorulacak ve aşağıdaki argümanları yapılandıracaksınız. Bu örnekte ZeRO-3'ü CPU-Offload ile birlikte kullanacağınız için bu seçenekleri seçtiğinizden emin olun.
`zero_stage`: [0] Disabled, [1] optimizer state partitioning, [2] optimizer+gradient state partitioning and [3] optimizer+gradient+parameter partitioning
`gradient_accumulation_steps`: Number of training steps to accumulate gradients before averaging and applying them.
`gradient_clipping`: Enable gradient clipping with value.
`offload_optimizer_device`: [none] Disable optimizer offloading, [cpu] offload optimizer to CPU, [nvme] offload optimizer to NVMe SSD. Only applicable with ZeRO >= Stage-2.
`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3.
`zero3_init_flag`: Decides whether to enable `deepspeed.zero.Init` for constructing massive models. Only applicable with ZeRO Stage-3.
`zero3_save_16bit_model`: Decides whether to save 16-bit model weights when using ZeRO Stage-3.
`mixed_precision`: `no` for FP32 training, `fp16` for FP16 mixed-precision training and `bf16` for BF16 mixed-precision training. Örnek bir config dosyası aşağıdaki gibi görünebilir. Dikkat edilmesi gereken en önemli nokta, zero_stage'in 3 olarak ayarlanması ve offload_optimizer_device ile offload_param_device'ün cpu olarak ayarlanmasıdır.
compute_environment: LOCAL_MACHINE
deepspeed_config:
gradient_accumulation_steps: 1
gradient_clipping: 1.0
offload_optimizer_device: cpu
offload_param_device: cpu
zero3_init_flag: true
zero3_save_16bit_model: true
zero_stage: 3
distributed_type: DEEPSPEED
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
machine_rank: 0
main_training_function: main
megatron_lm_config: {}
mixed_precision: 'no'
num_machines: 1
num_processes: 1
rdzv_backend: static
same_network: true
use_cpu: falseÖnemli kısımlar
Betik biraz daha derinlemesine inceleyelim, böylece neler olduğunu görebilir ve nasıl çalıştığını anlayabilirsiniz.
main işlevi içinde betik, dağıtık eğitim için gerekli tüm gereksinimleri başlatmak üzere bir Accelerator sınıfı oluşturur.
💡
mainfonksiyonunun içinde modeli ve veri setini değiştirmekte serbestsiniz. Veri setinizin formatı betiğinkinden farklıysa, kendi ön işleme fonksiyonunuzu da yazmanız gerekebilir.
Betik, bu durumda LoRA olan, kullandığınız 🤗 PEFT yöntemi için bir yapılandırma da oluşturur. LoraConfig, görev türünü ve düşük rütbeli matrislerin boyutu, matris ölçekleme faktörü ve LoRA katmanlarının dropout olasılığı gibi önemli parametreleri belirtir. Farklı bir 🤗 PEFT yöntemi kullanmak istiyorsanız, LoraConfig yerine uygun sınıfını kullanmayı unutmayın.
def main():
+ accelerator = Accelerator()
model_name_or_path = "facebook/bart-large"
dataset_name = "twitter_complaints"
+ peft_config = LoraConfig(
task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
)Betik boyunca, süreçlerin ne zaman yürütüleceğini kontrol etmeye ve senkronize etmeye yardımcı olan main_process_first ve wait_for_everyone fonksiyonlarını göreceksiniz.
get_peft_model() fonksiyonu, bir temel model ve daha önce hazırladığınız peft_config parametresini alarak bir PeftModel oluşturur:
model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+ model = get_peft_model(model, peft_config)Tüm ilgili eğitim nesnelerini, her şeyin eğitim için hazır olduğundan emin olmak üzere 🤗 Accelerate'in prepare fonksiyonuna iletin:
model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler = accelerator.prepare(
model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler
)Bir sonraki kod parçası, Accelerator'da DeepSpeed eklentisinin kullanılıp kullanılmadığını kontrol eder ve eklenti mevcutsa ZeRO-3 kullanıp kullanmadığımızı kontrol eder. Bu koşullu bayrak, model parametreleri bölünmüş olduğunda GPU'ları senkronize etmek için çıkarım sırasında generate fonksiyon çağrısı yapılırken kullanılır:
is_ds_zero_3 = False
if getattr(accelerator.state, "deepspeed_plugin", None):
is_ds_zero_3 = accelerator.state.deepspeed_plugin.zero_stage == 3Eğitim döngüsünün içinde, standart loss.backward() yerine yapılandırmanıza göre doğru backward() metodunu kullanan 🤗 Accelerate'in backward fonksiyonu kullanılır:
for epoch in range(num_epochs):
with TorchTracemalloc() as tracemalloc:
model.train()
total_loss = 0
for step, batch in enumerate(tqdm(train_dataloader)):
outputs = model(**batch)
loss = outputs.loss
total_loss += loss.detach().float()
+ accelerator.backward(loss)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad()Hepsi bu! Betiğin geri kalanı eğitim döngüsünü, değerlendirmeyi ve hatta onu Hub'a göndermeyi sizin için halleder.
Eğit
Eğitim betiğini başlatmak için aşağıdaki komutu çalıştırın. Daha önce yapılandırma dosyasını ds_zero3_cpu.yaml olarak kaydettiğiniz için, başlatıcıya --config_file argümanı ile yolu şu şekilde iletmeniz gerekir:
accelerate launch --config_file ds_zero3_cpu.yaml examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py
Eğitim sırasında bellek kullanımını izleyen bazı çıktı günlüklerini göreceksiniz ve işlem tamamlandığında betik, doğruluğu döndürür ve tahminleri etiketlerle karşılaştırır:
GPU Memory before entering the train : 1916
GPU Memory consumed at the end of the train (end-begin): 66
GPU Peak Memory consumed during the train (max-begin): 7488
GPU Total Peak Memory consumed during the train (max): 9404
CPU Memory before entering the train : 19411
CPU Memory consumed at the end of the train (end-begin): 0
CPU Peak Memory consumed during the train (max-begin): 0
CPU Total Peak Memory consumed during the train (max): 19411
epoch=4: train_ppl=tensor(1.0705, device='cuda:0') train_epoch_loss=tensor(0.0681, device='cuda:0')
100%|████████████████████████████████████████████████████████████████████████████████████████████| 7/7 [00:27<00:00, 3.92s/it]
GPU Memory before entering the eval : 1982
GPU Memory consumed at the end of the eval (end-begin): -66
GPU Peak Memory consumed during the eval (max-begin): 672
GPU Total Peak Memory consumed during the eval (max): 2654
CPU Memory before entering the eval : 19411
CPU Memory consumed at the end of the eval (end-begin): 0
CPU Peak Memory consumed during the eval (max-begin): 0
CPU Total Peak Memory consumed during the eval (max): 19411
accuracy=100.0
eval_preds[:10]=['no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint', 'no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint']
dataset['train'][label_column][:10]=['no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint', 'no complaint', 'no complaint', 'complaint', 'complaint', 'no complaint']Dikkat Edilmesi Gerekenler
- PEFT ve DeepSpeed kullanırken birleştirme (merging) şu anda desteklenmemektedir ve hata oluşturacaktır.
- CPU offloading kullanıldığında, PEFT ile optimizator durumlarını ve gradyanları adaptör ağırlıklarına küçültmenin getirdiği önemli kazanımlar CPU RAM üzerinde gerçekleşir ve GPU belleği açısından bir tasarruf olmaz.
- CPU offloading ile birlikte kullanıldığında, DeepSpeed Stage 3 ve qlora, CPU offloading'in devre dışı bırakılmasına kıyasla daha fazla GPU bellek kullanımıyla sonuçlanır.
Update on GitHub💡 Ağırlıkların birleştirilmesini (ve ayrıştırılmasını) gerektiren kodunuz varsa, önceden DeepSpeed Zero-3 ile parametreleri manuel olarak toplamayı deneyin:
import deepspeed is_ds_zero_3 = ... # check if Zero-3 with deepspeed.zero.GatheredParameters(list(model.parameters()), enabled= is_ds_zero_3): model.merge_adapter() # do whatever is needed, then unmerge in the same context if unmerging is required ... model.unmerge_adapter()