PEFT documentation

Tamamen Parçalı Veri Paralelliği

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Tamamen Parçalı Veri Paralelliği

Fully sharded data parallel (FSDP), 1T parametreye kadar büyük ön eğitilmiş modellerin dağıtık eğitimi için geliştirilmiştir. FSDP, model parametrelerini, gradyanları ve optimizör durumlarını veri paralel süreçler arasında dilimleyerek (sharding) bunu başarır ve dilimlenmiş model parametrelerini bir CPU'ya aktarabilir (offload). FSDP'nin sağladığı bellek verimliliği, eğitimi daha büyük batch veya model boyutlarına ölçeklendirmenizi sağlar.

PEFT, FSDP1 ve PyTorch FSDP2 destekler. FSDP'yi Transformers Trainer üzerinden yapılandırabilir veya doğrudan bir PyTorch eğitim döngüsünde kullanabilirsiniz.

Transformers ile FSDP2

PyTorch 2.6 veya daha yeni bir sürüm ile Transformers, Accelerate, TRL ve PEFT'nin güncel sürümlerini kullanın. SFT örneği SFTTrainer kullanır. İşte tipik bir FSDP2 yapılandırması:

{
  "fsdp": true,
  "fsdp_config": {
    "version": 2,
    "reshard_after_forward": true,
    "auto_wrap_policy": "TRANSFORMER_BASED_WRAP",
    "cpu_ram_efficient_loading": true,
    "state_dict_type": "SHARDED_STATE_DICT",
    "activation_checkpointing": false
  }
}

TRANSFORMER_BASED_WRAP, modelin transformer katman tanımlarını kullanır. reshard_after_forward, her ileri geçişten sonra toplanan parametreleri serbest bırakır. FSDP2, bireysel parametreleri dilimlediği için FSDP1'in use_orig_params ayarını kullanmaz. Daha fazla yapılandırma seçeneği için Transformers FSDP kılavuzu'na bakın.

Örnekteki fsdp2_config.json dosyasında model, veri seti ve eğitim seçeneklerini düzenleyin. examples/sft dizininden, GPU başına bir süreç başlatın:

torchrun --standalone --nproc_per_node=2 train.py configs/fsdp2_config.json

BF16 desteği olmayan GPU'larda, JSON dosyasında "bf16": false ve "fp16": true değerlerini ayarlayın.

v0.22'den önceki PEFT sürümlerinde, boş adaptör dışa aktarmalarını önlemek için activation_checkpointing değerini false olarak bırakın. PEFT v0.22, adaptör dışa aktarma düzeltmesini içerir.

Kaydet ve devam et

Eğitimi yeniden başlatmak için aynı FSDP yapılandırmasını koruyun ve JSON dosyasında "resume_from_checkpoint": "path/to/checkpoint-N" ayarını yapın. Eğitim kontrol noktaları, dilimlenmiş model ve optimizör durumlarını içerir.

Eğitimin sonunda, örnek, adaptörü dışa aktarmadan önce tam bir durum sözlüğü toplar:

if trainer.is_fsdp_enabled:
    trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
trainer.save_model()

Tüm sıralar toplama işleminde yer almalıdır; yalnızca ana süreç adaptör dosyalarını yazar. Tam durum sözlüğünün toplanması, bellek kullanımını geçici olarak artırır.

Çıkarım için dışa aktarılan adaptörü yükleyin:

import torch

from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("qwen-sft-lora-fsdp2", dtype=torch.float32)

Eğitim sırasında eklenen token'lar temel modelin gömme boyutunu büyüttüyse, adaptörü yüklemeye geçmeden önce eğitim anındaki gömme boyutunu eşleştirin. SFT örneği, büyümüş gömme boyutlarını 8'in katına yastıklıyor:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

from peft import PeftConfig, PeftModel

adapter_path = "qwen-sft-lora-fsdp2"
config = PeftConfig.from_pretrained(adapter_path)
tokenizer = AutoTokenizer.from_pretrained(adapter_path)
base_model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, dtype=torch.float32)
# Match the SFT example: grow the embeddings if needed, but never shrink them.
if len(tokenizer) > base_model.get_input_embeddings().num_embeddings:
    base_model.resize_token_embeddings(len(tokenizer), pad_to_multiple_of=8)
model = PeftModel.from_pretrained(base_model, adapter_path)

Accelerate ile FSDP1

Bu bölüm, tek bir makinede 8xH100 80GB GPU'larda Llama-70B'yi LoRA ve FSDP1 ile ince ayar yapmak için SFT eğitim betiğini kullanır. Accelerate yapılandırmasını değiştirerek birden fazla makineye ölçeklendirebilirsiniz.

Yapılandırma

🤗 Accelerate ile FSDP 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 fsdp_config.yaml

Kurulumunuzla ilgili birkaç soru sorulacak ve aşağıdaki argümanları yapılandıracaksınız. Bu örnekte, aşağıdaki görüntüde gösterildiği gibi anketi yanıtlayacaksınız.

Creating Accelerate's config to use FSDP

Bu işlem tamamlandıktan sonra, ilgili yapılandırma aşağıdaki gibi görünmeli ve fsdp_config.yaml dosyası config klasöründe bulunabilir:

compute_environment: LOCAL_MACHINE
debug: false
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_version: 1
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch: BACKWARD_PRE
  fsdp_cpu_ram_efficient_loading: true
  fsdp_forward_prefetch: false
  fsdp_offload_params: false
  fsdp_sharding_strategy: FULL_SHARD
  fsdp_state_dict_type: SHARDED_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_use_orig_params: false
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: false

Başlatma komutu

Başlatma komutu run_peft_fsdp.sh adresinde mevcuttur ve aşağıda da gösterilmektedir:

accelerate launch --config_file "configs/fsdp_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_length 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-fsdp" \
--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 False

LoRA'nın rank=8, alpha=16 parametreleriyle ve tüm lineer katmanları hedef alacak şekilde kullanıldığını fark edin. FSDP 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, FSDP yapılandırmasının iletildiği için script'in dağıtık eğitimde FSDP kullandığıdır. SFTTrainer sınıfı, iletilen peft yapılandırmasını kullanarak PEFT modelini oluşturma işinin tamamını üstlenir. Ardından trainer.train() çağrıldığında, Trainer, FSDP yapılandırmasını kullanarak model, optimizer ve trainer'ı hazırlamak için içsel olarak 🤗 Accelerate'ı kullanır; bu sayede oluşturulan FSDP sarmalı model 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}")
if hasattr(trainer.model, "print_healthcheck"):
    trainer.model.print_healthcheck()

# 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
if trainer.is_fsdp_enabled:
    trainer.accelerator.state.fsdp_plugin.set_state_dict_type("FULL_STATE_DICT")
trainer.save_model()

FSDP1 ile use_orig_params=False, eğitilebilir ve dondurulmuş parametreleri ayrı ayrı sarmalayarak bellek kullanımını azaltır. Mevcut Transformers Trainer, bu durum için PEFT’nin fsdp_auto_wrap_policy politikasını kurar; örneğin bunu manuel olarak ayarlaması gerekmez. Özel bir Accelerate FSDP1 eğitim döngüsü, modeli hazırlamadan önce bu politikayı ayarlamalıdır. Bu düz parametre sarmalama gereksinimi FSDP2 için geçerli değildir.

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 72-80 GB (%90-98) civarındadır. Son kısımdaki hafif GPU bellek artışı, modelin çıkarım sırasında from_pretrained yöntemiyle normal şekilde yüklenebilecek adaptör ağırlıklarına sahip olması için SHARDED_STATE_DICT yerine FULL_STATE_DICT state dict türü kullanılarak kaydedilmesi sırasında gerçekleşir:

GPU memory usage for the training run

QLoRA ile FSDP1

Bu bölümde, 70B llama modelini 2X24GB GPU'larda ince ayar yapmak için QLoRA ve FSDP'nin nasıl kullanılacağına bakacağız. Answer.AI, bitsandbytes ve Hugging Face 🤗 ile iş birliği içinde, FSDP+QLoRA kullanımını mümkün kılan kodu açık kaynak olarak yayımlamış ve tüm süreci içgörülü blog yazılarında You can now train a 70b language model at home açıkladı. Bu özellik artık Hugging Face ekosistemine entegre edildi.

Güncel PEFT, Transformers, TRL ve Accelerate sürümlerini bitsandbytes>=0.43.3 ile kullanın. Bu FSDP1 yapılandırması için fsdp_cpu_ram_efficient_loading=true, fsdp_use_orig_params=false ve fsdp_offload_params=true (CPU offloading) değerlerini ayarlayın. Yapılandırma fsdp_config_qlora.yaml adresinde mevcuttur:

compute_environment: LOCAL_MACHINE                                                                                                                                           
debug: false                                                                                                                                                                 
distributed_type: FSDP
downcast_bf16: 'no'
fsdp_config:
  fsdp_version: 1
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch: BACKWARD_PRE
  fsdp_cpu_ram_efficient_loading: true
  fsdp_forward_prefetch: false
  fsdp_offload_params: true
  fsdp_sharding_strategy: FULL_SHARD
  fsdp_state_dict_type: SHARDED_STATE_DICT
  fsdp_sync_module_states: true
  fsdp_use_orig_params: false
machine_rank: 0
main_training_function: main
mixed_precision: 'no'
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

Başlatma komutu, run_peft_qlora_fsdp.sh adresinde bulunan aşağıdaki gibidir:

accelerate launch --config_file "configs/fsdp_config_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_length 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-fsdp" \
--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"

Geçirilen yeni argümanı, 4 bit parametrelerin paketlenmesi için veri türünü belirten bnb_4bit_quant_storage_dtype argümanını fark edin. Örneğin, bfloat16 olarak ayarlandığında, 16/4 = 4 adet 4 bit parametre, kuantizasyon sonrası birlikte paketlenir. bfloat16 ile karma hassasiyetli eğitim kullanıldığında, bnb_4bit_quant_storage_dtype saf bfloat16 ince ayarı için bfloat16 veya otomatik karma hassasiyet için (bu daha fazla GPU belleği tüketir) float32 olabilir. float16 ile karma hassasiyetli eğitim kullanıldığında, bnb_4bit_quant_storage_dtype kararlı otomatik karma hassasiyetli eğitim için float32 olarak ayarlanmalıdır.

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 19.6 GB iken CPU RAM kullanımı yaklaşık 107 GB'dir. CPU offloading devre dışı bırakıldığında, GPU bellek kullanımı 35.6 GB/ GPU olur. Dolayısıyla, tam finetuning için 16X80GB GPU, FSDP+LoRA ile 8X80GB GPU ve DDP+QLoRA ile birkaç 80GB GPU gerektiren işlem, artık 2X24GB GPU ile yapılabilir. Bu, büyük modellerin finetuning'ini daha erişilebilir hale getirir.

Daha fazla kaynak

FSDP ve PEFT kullanarak ince ayar yapma konusunda llama-recipes deposuna ve Getting started with Llama kılavuzuna da başvurabilirsiniz.

Dikkat Edilmesi Gerekenler

  1. FSDP1 (yukarıda kullanılan Accelerate FSDP entegrasyonu) ile birleştirme desteklenmez ve bir hata oluşturur. FSDP2 (fully_shard) ile merge_adapter() ve unmerge_adapter() parçalı parametrelere ulaşır: Linear, Embedding ve konvolüsyonlu temel katmanlarda düz LoRA (dahil safe_merge) birleştirme çalışır, aynı şekilde Linear üzerinde DoRA ve (IA)^3 de çalışır. Diğer adaptörler veya katman kombinasyonları bu yöntemlerle kapsanmaz ve ya bir hata oluşturur ya da sessizce birleştirilemez; bu nedenle sonuca güvenmeden önce doğrulayın. Bilinen bir örnek, kendi FSDP2 modülü tarafından sarılmış bir base_layer'a sahip DoRA katmanıdır; bu durum bir hata oluşturur.
  2. modules_to_save yapılandırma parametresinin geçirilmesi şu anda test edilmemiştir.
  3. CPU Offloading kullanılırken GPU bellek tasarrufu şu anda test edilmemiştir.
  4. FSDP+QLoRA kullanıldığında, paged_adamw_8bit şu anda bir kontrol noktası (checkpoint) kaydedilirken hata vermektedir.
  5. FSDP ile DoRA eğitimi çalışmalıdır (LoRA'ya kıyasla daha düşük hızda). bitsandbytes ile birleştirildiğinde (QDoRA), 4-bit kuantizasyon da çalışmalıdır, ancak 8-bit kuantizasyonun bilinen sorunları vardır ve önerilmez.
  6. FSDP2 ile set_adapter() ve set_requires_grad(), requires_grad değişikliklerinin parçalara ayrılmış parametrelere ulaşabilmesi için PeftModel içindeki FSDP2 modüllerini, PeftModel dahil olmak üzere yeniden parçalar (reshard).
  7. disable_adapter()'dan çıkış, yalnızca FSDP2'nin içindeki kayıtlı parametre nesnelerini, shard'lı parametrelerle bir forward'in yaptığı gibi değiştirmesi veya yeniden etkinleştirmenin requires_grad değerini girişteki durumundan farklı bir hale getirmesi durumunda gerçekleşir.
  8. merge_adapter() ve unmerge_adapter() fonksiyonları, birleştirme ve birleştirme kaldırma işlemlerinin parçalanmış parametrelere ulaşabilmesi için FSDP2 modüllerini de yeniden parçalar (reshard); yeniden parçalamadan yapılan bir birleştirme, ileri yayılımın (forward) kaydettiği parçalanmamış parametrelere uygulanır ve sonraki yeniden parçalamada bu değişiklik silinir. Birleştirme işlemi, parçalanmış parametrelere doğrudan (in place) yazılır.
  9. FSDP2 modülleri, birleştirilmiş bir adaptör katmanının parametrelerini parçalara ayırdığında, bu parametreler set_adapter() ve set_requires_grad() tarafından yeniden parçalanmaz; bu nedenle bu yöntemleri çağırmadan önce birleştirmeyi geri alın. FSDP2 altında disable_adapter() bağlamına girildiğinde, birleştirilmiş katmanlar otomatik olarak birleştirme işlemi geri alınır, böylece bu işlem parçalara ayrılmış parametrelere ulaşır; dolayısıyla birleştirme işlemi bağlam boyunca korunmaz.
  10. reshard_after_forward=False kullanıldığında veya varsayılan None değerine sahip kök modül için, sonraki forward işlemi yeniden all-gather yapar.
  11. PeftModel'i saran FSDP2 modülleri yeniden bölünmez (reshard edilmez); bu yöntemleri çağırmadan önce bunlar üzerinde reshard() çağrısı yapın.
  12. Prompt öğrenme yöntemleri ve uyarlama promptu henüz kapsam dışıdır.
  13. FSDP2/HSDP ile get_peft_model_state_dict() veya save_pretrained() çağrısı, her katılımcı rank üzerinde yapılmalıdır: dağıtık adaptör tensörlerinin toplanması kolektif bir işlemdir. save_pretrained() için is_main_process=True parametresi yalnızca yazan rank üzerinde geçirilmelidir. Yalnızca seçilen adaptör girdileri (açıkça istenen gömme katmanları veya modules_to_save dahil) toplanır; seçilmeyen temel model ağırlıkları parçalı (sharded) olarak kalır.
Update on GitHub