PEFT documentation

Полностью шардированная параллельная обработка данных

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Полностью шардированная параллельная обработка данных

Fully sharded data parallel (FSDP) разработан для распределённого обучения крупных предобученных моделей объёмом до 1T параметров. FSDP достигает этого, разбивая параметры модели, градиенты и состояния оптимизатора между процессами, работающими в режиме параллелизма данных, а также позволяет выгружать разбитые параметры модели в оперативную память CPU. Эффективность использования памяти, обеспечиваемая FSDP, позволяет масштабировать обучение до более крупных размеров батчей или моделей.

PEFT поддерживает FSDP1 и PyTorch FSDP2. Вы можете настроить FSDP через Trainer в Transformers или использовать его непосредственно в цикле обучения PyTorch.

FSDP2 с Transformers

Используйте PyTorch 2.6 или новее, а также актуальные версии Transformers, Accelerate, TRL и PEFT. В примере SFT используется SFTTrainer. Ниже приведена типичная конфигурация FSDP2:

{
  "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 использует определения слоёв трансформера модели. reshard_after_forward освобождает собранные параметры после каждого прямого прохода. FSDP2 разделяет отдельные параметры, поэтому не использует настройку use_orig_params из FSDP1. Дополнительные параметры конфигурации описаны в руководстве по FSDP для Transformers.

Отредактируйте модель, набор данных и параметры обучения в файле fsdp2_config.json примера. Запустите по одному процессу на каждый GPU из каталога examples/sft:

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

На GPU без поддержки BF16 установите "bf16": false и "fp16": true в JSON-файле.

В версиях PEFT, более ранних, чем v0.22, держите activation_checkpointing установленным в false, чтобы избежать экспорта пустых адаптеров. В PEFT v0.22 включено исправление экспорта адаптеров.

Сохранение и возобновление

Чтобы возобновить обучение, сохраните ту же конфигурацию FSDP и установите "resume_from_checkpoint": "path/to/checkpoint-N" в JSON-файле. Контрольные точки обучения содержат разбитые на части состояния модели и оптимизатора.

В конце обучения пример собирает полный словарь состояния перед экспортом адаптера:

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

Все ранги должны участвовать в сборе; только основной процесс записывает файлы адаптеров. Сбор полного словаря состояний временно увеличивает потребление памяти.

Для инференса загрузите экспортированный адаптер:

import torch

from peft import AutoPeftModelForCausalLM

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

Если при запуске SFT были добавлены токены, увеличившие эмбеддинги базовой модели, приведите размер эмбеддингов к значению, использовавшемуся во время обучения, перед загрузкой адаптера. В примере SFT увеличенные эмбеддинги дополняются до кратного 8:

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)

FSDP1 с Accelerate

В этом разделе используется скрипт обучения SFT для дообучения Llama-70B с помощью LoRA и FSDP1 на 8xH100 80GB на одном компьютере. Масштабирование на несколько машин возможно путём изменения конфигурации Accelerate.

Конфигурация

Начните с выполнения следующей команды, чтобы создать файл конфигурации FSDP с помощью 🤗 Accelerate. Флаг --config_file позволяет сохранить файл конфигурации в указанное место, в противном случае он сохраняется как файл default_config.yaml в кэше 🤗 Accelerate.

Файл конфигурации используется для установки параметров по умолчанию при запуске скрипта обучения.

accelerate config --config_file fsdp_config.yaml

Вас попросят ответить на несколько вопросов о вашей конфигурации и настроить следующие аргументы. В этом примере ответы на вопросы приведены на изображении ниже.

Creating Accelerate's config to use FSDP

После выполнения этих шагов соответствующий конфигурационный файл должен выглядеть следующим образом. Его можно найти в папке config по пути fsdp_config.yaml:

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

Команда запуска

Команда запуска доступна в run_peft_fsdp.sh и также приведена ниже:

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 с rank=8, alpha=16 и нацеливаем его на все линейные слои. Мы передаём конфигурационный файл FSDP и дообучаем модель Llama 70B на подмножестве набора данных ultrachat.

Ключевые части

Давайте немного углубимся в скрипт, чтобы вы могли увидеть, что происходит, и понять, как он работает.

Первое, что нужно знать: скрипт использует FSDP для распределённого обучения, так как была передана конфигурация FSDP. Класс SFTTrainer выполняет всю основную работу по созданию PEFT-модели с использованием переданной конфигурации peft. После этого, когда вы вызываете trainer.train(), Trainer внутренне использует 🤗 Accelerate, чтобы подготовить модель, оптимизатор и тренаер с помощью конфигурации FSDP, создавая модель, обёрнутую в FSDP, которая затем обучается. Основной фрагмент кода приведён ниже:

# 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 параметр use_orig_params=False снижает потребление памяти за счёт отдельного обёртывания обучаемых и замороженных параметров. Текущий Trainer из Transformers автоматически устанавливает fsdp_auto_wrap_policy PEFT для этого случая, поэтому в примере не нужно задавать его вручную. В пользовательском цикле обучения FSDP1 на Accelerate эту политику необходимо задать до подготовки модели. Требование обёртывания плоских параметров не распространяется на FSDP2.

Использование памяти

В приведённом выше примере объём памяти, потребляемой на каждый GPU, составляет 72–80 ГБ (90–98%), как показано на скриншоте ниже. Незначительное увеличение объёма памяти GPU в конце происходит при сохранении модели с использованием типа state dict FULL_STATE_DICT вместо SHARDED_STATE_DICT, чтобы у модели были веса адаптеров, которые можно было бы загрузить обычным способом с помощью метода from_pretrained во время инференса:

GPU memory usage for the training run

FSDP1 с QLoRA

В этом разделе мы рассмотрим, как использовать QLoRA и FSDP для дообучения модели llama 70B на 2X24GB GPU. Answer.AI совместно с bitsandbytes и Hugging Face 🤗 открыли исходный код, позволяющий использовать FSDP+QLoRA, и подробно описали весь процесс в своей информативной статье You can now train a 70b language model at home. Теперь это интегрировано в экосистему Hugging Face.

Используйте текущие версии PEFT, Transformers, TRL и Accelerate с bitsandbytes>=0.43.3. Для этой конфигурации FSDP1 установите fsdp_cpu_ram_efficient_loading=true, fsdp_use_orig_params=false и fsdp_offload_params=true (оффлоад на CPU). Конфигурация доступна по адресу fsdp_config_qlora.yaml:

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

Команда запуска приведена ниже и доступна в файле run_peft_qlora_fsdp.sh:

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"

Обратите внимание на новый передаваемый аргумент bnb_4bit_quant_storage_dtype, который определяет тип данных для упаковки 4-битных параметров. Например, при установке значения bfloat16 после квантования вместе упаковываются 16/4 = 4 4-битных параметра. При использовании обучения с смешанной точностью на bfloat16 значение bnb_4bit_quant_storage_dtype может быть установлено в bfloat16 для чистого дообучения в bfloat16 или в float32 для автоматической смешанной точности (это потребляет больше памяти GPU). При использовании обучения с смешанной точностью на float16 значение bnb_4bit_quant_storage_dtype следует установить в float32 для стабильного обучения с автоматической смешанной точностью.

Что касается кода обучения, важные изменения в коде:

...

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,
)

Обратите внимание, что dtype для AutoModelForCausalLM совпадает с типом данных bnb_4bit_quant_storage. Всё. Остальное обрабатывается Trainer и TRL.

Использование памяти

В приведённом выше примере объём памяти, потребляемой на каждый GPU, составляет 19,6 ГБ, а использование оперативной памяти CPU составляет около 107 ГБ. При отключении выгрузки на CPU использование памяти GPU составляет 35,6 ГБ/ GPU. Таким образом, то, что для полной дообучения требовало 16 GPU по 80 ГБ, 8 GPU по 80 ГБ с FSDP+LoRA и пару GPU по 80 ГБ с DDP+QLoRA, теперь требует всего 2 GPU по 24 ГБ. Это делает дообучение больших моделей более доступным.

Дополнительные ресурсы

Вы также можете обратиться к репозиторию llama-recipes и руководству Getting started with Llama, чтобы узнать, как выполнять дообучение с использованием FSDP и PEFT.

Ограничения

  1. В FSDP1 (интеграция Accelerate с FSDP, использованная выше) слияние не поддерживается и вызывает ошибку. В FSDP2 (fully_shard) методы merge_adapter() и unmerge_adapter() получают доступ к разбитым параметрам: слияние обычного LoRA (включая safe_merge) для базовых слоёв Linear, Embedding и свёрточных работает, как и DoRA и (IA)^3 для Linear. Другие адаптеры или комбинации слоёв не покрываются этими методами и либо вызывают ошибку, либо могут молча не слиться, поэтому проверяйте результат перед тем, как полагаться на него. Один из известных примеров — слой DoRA, у которого base_layer обёрнут собственным модулем FSDP2, что приводит к ошибке.
  2. Передача параметра конфигурации modules_to_save в настоящее время не протестирована.
  3. Экономия памяти GPU при использовании CPU Offloading на данный момент не протестирована.
  4. При использовании FSDP+QLoRA paged_adamw_8bit в настоящее время приводит к ошибке при сохранении контрольной точки.
  5. Обучение с DoRA в сочетании с FSDP должно работать (хотя и с меньшей скоростью, чем LoRA). При использовании вместе с bitsandbytes (QDoRA) 4-битное квантование также должно работать, однако 8-битное квантование имеет известные проблемы и не рекомендуется.
  6. В FSDP2 set_adapter() и set_requires_grad() пересобирают модули FSDP2 внутри PeftModel, включая сам PeftModel, чтобы изменения requires_grad дошли до разбитых параметров.
  7. Выход из disable_adapter() выполняется только в том случае, если FSDP2 заменил зарегистрированные объекты параметров внутри него, как это происходит с шардированными параметрами при forward, или если повторное включение изменяет requires_grad по сравнению с его значением на входе.
  8. merge_adapter() и unmerge_adapter() также перераспределяют модули FSDP2, чтобы слияние и обратное слияние затрагивали разбитые параметры; без перераспределения слияние попадало бы в неразбитые параметры, оставшиеся зарегистрированными после forward, и следующее перераспределение их удалило бы. Само слияние выполняется на месте в разбитых параметрах.
  9. Модули FSDP2, разделяющие параметры объединённого слоя адаптера, не подвергаются повторному разделению при вызове set_adapter() и set_requires_grad(), поэтому необходимо выполнить разделение (unmerge) перед вызовом этих методов. При входе в контекст disable_adapter() в режиме FSDP2 объединённые слои автоматически разделяются, чтобы разделение затронуло разделённые параметры; в результате объединение не сохраняется после выхода из контекста.
  10. При reshard_after_forward=False или для корневого модуля со значением по умолчанию None следующий прямой проход снова выполняет all-gather.
  11. Модули FSDP2, оборачивающие PeftModel, не подвергаются ресхардированию; вызовите reshard() для них перед этими методами.
  12. Методы обучения промптов и адаптивные промпты пока не описаны.
  13. При использовании FSDP2/HSDP вызывайте get_peft_model_state_dict() или save_pretrained() на каждом участвующем ранге: сборка распределённых тензоров адаптеров является коллективной операцией. Для save_pretrained() передавайте is_main_process=True только на ранге, выполняющем запись. Собираются только выбранные элементы адаптера (включая явно запрошенные эмбеддинги или modules_to_save); веса базовой модели, не вошедшие в выборку, остаются разбитыми на части.
Update on GitHub