PEFT documentation

DeepSpeed

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

DeepSpeed

DeepSpeed — это библиотека, созданная для скорости и масштабируемости распределённого обучения больших моделей с миллиардами параметров. В её основе лежит Zero Redundancy Optimizer (ZeRO), который распределяет состояния оптимизатора (ZeRO-1), градиенты (ZeRO-2) и параметры (ZeRO-3) между процессами, работающими в режиме параллелизма данных. Это значительно снижает потребление памяти, позволяя масштабировать обучение до моделей с миллиардами параметров. Для достижения ещё большей эффективности использования памяти ZeRO-Offload снижает вычислительную нагрузку и потребление памяти на GPU, задействуя ресурсы CPU на этапе оптимизации.

Обе эти функции поддерживаются в 🤗 Accelerate, и вы можете использовать их вместе с 🤗 PEFT.

Совместимость с квантованием bitsandbytes + LoRA

Ниже приведена таблица, обобщающая совместимость LoRA из PEFT, библиотеки bitsandbytes и этапов DeepSpeed Zero в контексте дообучения. Этапы DeepSpeed Zero-1 и 2 не оказывают влияния на этапе инференса, так как этап 1 разделяет состояния оптимизатора, а этап 2 — состояния оптимизатора и градиенты:

Этап DeepSpeedСовместим ли?
Zero-1🟢
Zero-2🟢
Zero-3🟢

Для DeepSpeed Stage 3 + QLoRA обратитесь к разделу Использование PEFT QLoRA и DeepSpeed с ZeRO3 для дообучения больших моделей на нескольких GPU ниже.

Для подтверждения этих наблюдений мы прогнали официальные примеры скриптов SFT (Supervised Fine-tuning) из библиотеки Transformers Reinforcement Learning (TRL) с использованием QLoRA + PEFT и конфигураций accelerate, доступных здесь. Эти эксперименты были проведены на 2x NVIDIA T4 GPU.

Используйте PEFT и DeepSpeed с ZeRO3 для дообучения больших моделей на нескольких устройствах и нескольких узлах

Этот раздел руководства поможет вам освоить использование нашего скрипта обучения DeepSpeed для выполнения SFT. Вы настроите скрипт для SFT (супервизированной дообучения) модели Llama-70B с использованием LoRA и ZeRO-3 на 8 GPU H100 80GB на одном компьютере. Вы можете настроить масштабирование на несколько машин, изменив конфигурацию accelerate.

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

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

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

accelerate config --config_file deepspeed_config.yaml

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

`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`.

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

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: false

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

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

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 False

Обратите внимание, что мы используем LoRA с rank=8, alpha=16 и настраиваем все линейные слои. Мы передаём конфигурационный файл deepspeed и дообучаем модель Llama 70B на подмножестве набора данных ultrachat.

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

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

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

# 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()

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

В приведённом выше примере объём памяти, потребляемой на каждый GPU, составляет 64 ГБ (80%), как показано на скриншоте ниже:

GPU memory usage for the training run

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

You can also refer this blog post Falcon 180B Finetuning using 🤗 PEFT and DeepSpeed on how to finetune 180B Falcon model on 16 A100 GPUs on 2 machines.

Используйте PEFT QLoRA и DeepSpeed с ZeRO3 для дообучения больших моделей на нескольких GPU

В этом разделе мы рассмотрим, как использовать QLoRA и DeepSpeed Stage-3 для дообучения модели llama 70B на 2X40GB GPU. Для этого нам сначала нужны bitsandbytes>=0.43.3, accelerate>=1.0.1, transformers>4.44.2, trl>0.11.4 и peft>0.13.0. При использовании конфигурации Accelerate необходимо установить zero3_init_flag в true. Ниже приведена конфигурация, которую можно найти в deepspeed_config_z3_qlora.yaml:

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: false

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

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"

Обратите внимание на новый аргумент bnb_4bit_quant_storage_dtype, который определяет тип данных для упаковки 4-битных параметров. Например, при установке значения bfloat16 32/4 = 8 4-битных параметров упаковываются вместе после квантования.

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

...

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, составляет 36.6 GB. Таким образом, то, что ранее требовало 8X80GB GPU с DeepSpeed Stage 3+LoRA и несколько GPU с 80GB с DDP+QLoRA, теперь выполняется на 2X40GB GPU. Это делает дообучение больших моделей более доступным.

Используйте PEFT и DeepSpeed с ZeRO3 и CPU Offloading для дообучения больших моделей на одном GPU

Этот раздел руководства поможет вам научиться использовать наш скрипт обучения DeepSpeed. Вы настроите скрипт для обучения большой модели условной генерации с использованием ZeRO-3 и CPU Offload.

💡 Чтобы помочь вам начать работу, ознакомьтесь с нашими примерами скриптов обучения для каузального языкового моделирования и условной генерации. Вы можете адаптировать эти скрипты под собственные задачи или использовать их без изменений, если ваша задача похожа на ту, что реализована в скриптах.

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

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

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

accelerate config --config_file ds_zero3_cpu.yaml

Вас попросят ответить на несколько вопросов о вашей конфигурации и настроить следующие аргументы. В этом примере вы будете использовать ZeRO-3 вместе с CPU-Offload, поэтому убедитесь, что выбрали именно эти параметры.

`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. 

Пример файла конфигурации может выглядеть следующим образом. Главное, на что стоит обратить внимание, — это то, что zero_stage установлен в значение 3, а offload_optimizer_device и offload_param_device установлены в cpu.

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

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

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

В функции main скрипт создаёт класс Accelerator для инициализации всех необходимых условий для распределённого обучения.

💡 Вы можете изменить модель и набор данных внутри функции main. Если формат вашего набора данных отличается от того, что используется в скрипте, возможно, вам также потребуется написать собственную функцию предобработки.

Скрипт также создаёт конфигурацию для используемого вами метода 🤗 PEFT, в данном случае — LoRA. LoraConfig задаёт тип задачи и важные параметры, такие как размерность матриц низкого ранга, коэффициент масштабирования матриц и вероятность dropout для слоёв LoRA. Если вы хотите использовать другой метод 🤗 PEFT, убедитесь, что вы заменили LoraConfig на соответствующий класс.

 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
     )

Throughout the script, you’ll see the main_process_first and wait_for_everyone functions which help control and synchronize when processes are executed.

Функция get_peft_model() принимает базовую модель и подготовленный ранее peft_config для создания PeftModel:

  model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
+ model = get_peft_model(model, peft_config)

Передайте все необходимые объекты для обучения в prepare из 🤗 Accelerate, который обеспечивает готовность всех компонентов к обучению:

model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler = accelerator.prepare(
    model, train_dataloader, eval_dataloader, test_dataloader, optimizer, lr_scheduler
)

Следующий фрагмент кода проверяет, используется ли плагин DeepSpeed в Accelerator, и, если плагин существует, проверяет, используется ли ZeRO-3. Этот условный флаг применяется при вызове функции generate во время инференса для синхронизации GPU, когда параметры модели разбиты на части:

is_ds_zero_3 = False
if getattr(accelerator.state, "deepspeed_plugin", None):
    is_ds_zero_3 = accelerator.state.deepspeed_plugin.zero_stage == 3

Внутри цикла обучения обычный вызов loss.backward() заменяется на backward из 🤗 Accelerate, который использует правильный метод backward() в зависимости от вашей конфигурации:

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

Всё! Остальная часть скрипта обрабатывает цикл обучения, оценку и даже публикует модель на Hub за вас.

Обучение

Выполните следующую команду, чтобы запустить скрипт обучения. Ранее вы сохранили файл конфигурации в ds_zero3_cpu.yaml, поэтому вам нужно передать путь к загрузчику с аргументом --config_file следующим образом:

accelerate launch --config_file ds_zero3_cpu.yaml examples/conditional_generation/peft_lora_seq2seq_accelerate_ds_zero3_offload.py

Вы увидите логи вывода, отслеживающие использование памяти во время обучения, а по завершении скрипт вернёт точность и сравнит предсказания с метками:

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']

Ограничения

  1. Слияние при использовании PEFT и DeepSpeed в настоящее время не поддерживается и приводит к ошибке.
  2. При использовании CPU offloading основная выгода от применения PEFT для сокращения состояний оптимизатора и градиентов до размера весов адаптера будет реализована в оперативной памяти CPU, и экономия видеопамяти GPU не произойдёт.
  3. Использование DeepSpeed Stage 3 и qlora с выгрузкой на CPU приводит к большему потреблению памяти GPU по сравнению с отключением выгрузки на CPU.

💡 Если ваш код требует слияния (и обратного слияния) весов, заранее вручную соберите параметры с помощью DeepSpeed Zero-3:

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()
Update on GitHub