Accelerate documentation

DeepSpeed

Accelerate

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.15.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

DeepSpeed

DeepSpeed mengimplementasikan semua yang dijelaskan dalam ZeRO paper. Beberapa optimasi yang menonjol adalah:

Partisi status optimizer (ZeRO tahap 1)
Partisi gradien (ZeRO tahap 2)
Partisi parameter (ZeRO tahap 3)
Penanganan pelatihan presisi campuran kustom
Berbagai optimizer berbasis ekstensi CUDA yang cepat
ZeRO-Offload ke CPU dan Disk/NVMe
Partisi hierarkis dari parameter model (ZeRO++)

ZeRO-Offload memiliki makalah khusus: ZeRO-Offload: Democratizing Billion-Scale Model Training. Dan dukungan NVMe dijelaskan dalam makalah ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep Learning.

DeepSpeed ZeRO-2 terutama hanya digunakan untuk pelatihan, karena fiturnya tidak berguna untuk inferensi.

DeepSpeed ZeRO-3 juga dapat digunakan untuk inferensi karena memungkinkan model berukuran besar dimuat di beberapa GPU, yang tidak mungkin dilakukan pada satu GPU saja.

Accelerate mengintegrasikan DeepSpeed melalui 2 opsi:

Integrasi fitur DeepSpeed melalui spesifikasi deepspeed config file di accelerate config . Anda cukup menyediakan file config kustom Anda atau gunakan template kami. Sebagian besar dokumen ini berfokus pada fitur ini. Ini mendukung semua fitur inti DeepSpeed dan memberikan pengguna banyak fleksibilitas. Pengguna mungkin perlu mengubah beberapa baris kode tergantung pada config.
Integrasi melalui deepspeed_plugin. Ini mendukung subset fitur DeepSpeed dan menggunakan opsi default untuk sisa konfigurasi. Pengguna tidak perlu mengubah kode apa pun dan ini cocok bagi mereka yang merasa nyaman dengan sebagian besar pengaturan default DeepSpeed.

Apa yang terintegrasi?

Pelatihan:

Accelerate mengintegrasikan semua fitur DeepSpeed ZeRO. Ini mencakup semua tahap ZeRO 1, 2, dan 3, serta ZeRO-Offload, ZeRO-Infinity (yang dapat melakukan offload ke disk/NVMe), dan ZeRO++. Berikut adalah deskripsi singkat tentang Data Parallelism menggunakan ZeRO - Zero Redundancy Optimizer beserta diagram dari artikel blog ini

(Sumber: link)

a. Tahap 1 : Membagi (sharding) status optimizer di antara pekerja/GPU paralel data

b. Tahap 2 : Memecah status optimizer + gradien di antara worker/GPU paralel data

c. Tahap 3: Memecah status optimizer + gradien + parameter model di antara worker/GPU paralel data

d. Optimizer Offload: Memindahkan gradien + status optimizer ke CPU/Disk, dibangun di atas ZERO Stage 2

e. Param Offload: Memindahkan parameter model ke CPU/Disk di atas ZERO Stage 3

f. Partisi Hierarkis: Memungkinkan pelatihan multi-node yang efisien dengan pelatihan paralel data antar node dan sharding ZeRO-3 di dalam node, dibangun di atas ZeRO Stage 3.

Note: With respect to Disk Offload, the disk should be an NVME for decent speed but it technically works on any Disk

Inferensi:

DeepSpeed ZeRO Inference mendukung ZeRO stage 3 dengan ZeRO-Infinity. Ini menggunakan protokol ZeRO yang sama seperti saat pelatihan, tetapi tidak menggunakan optimizer dan lr scheduler, dan hanya stage 3 yang relevan. Untuk detail lebih lanjut, lihat: ZeRO Inference.

Bagaimana cara kerjanya?

Prasyarat: Instal DeepSpeed versi >=0.6.5. Silakan lihat Detail Instalasi DeepSpeed untuk informasi lebih lanjut.

Pertama, kita akan melihat integrasi yang mudah digunakan melalui accelerate config. Diikuti oleh integrasi deepspeed config file yang lebih fleksibel dan kaya fitur.

Plugin DeepSpeed Accelerate

Pada mesin Anda, cukup jalankan:

accelerate config

dan menjawab pertanyaan yang diajukan. Anda akan ditanya apakah ingin menggunakan file konfigurasi untuk DeepSpeed, dan Anda harus menjawab tidak. Kemudian, jawab pertanyaan-pertanyaan berikut untuk menghasilkan konfigurasi dasar DeepSpeed. Hal ini akan menghasilkan file konfigurasi yang akan digunakan secara otomatis untuk mengatur opsi default dengan benar saat melakukan

accelerate launch my_script.py --args_to_my_script

Sebagai contoh, berikut adalah cara menjalankan contoh NLP examples/nlp_example.py (dari root repo) dengan DeepSpeed Plugin:

Contoh Plugin DeepSpeed ZeRO Stage-2

compute_environment: LOCAL_MACHINE
deepspeed_config:
 gradient_accumulation_steps: 1
 gradient_clipping: 1.0
 offload_optimizer_device: none
 offload_param_device: none
 zero3_init_flag: true
 zero_stage: 2
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false

accelerate launch examples/nlp_example.py --mixed_precision fp16

Contoh Plugin DeepSpeed ZeRO Stage-3 dengan CPU Offload

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
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false

accelerate launch examples/nlp_example.py --mixed_precision fp16

Saat ini, Accelerate mendukung konfigurasi berikut melalui CLI:

`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_optimizer_nvme_path`: Decides Nvme Path to offload optimizer states. If unspecified, will default to 'none'.
`offload_param_device`: [none] Disable parameter offloading, [cpu] offload parameters to CPU, [nvme] offload parameters to NVMe SSD. Only applicable with ZeRO Stage-3.
`offload_param_nvme_path`: Decides Nvme Path to offload parameters. If unspecified, will default to 'none'.
`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.
`deepspeed_moe_layer_cls_names`: Comma-separated list of transformer Mixture-of-Experts (MoE) layer class names (case-sensitive) to wrap ,e.g, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention,JetMoEBlock` ...
`deepspeed_hostfile`: DeepSpeed hostfile for configuring multi-node compute resources.
`deepspeed_exclusion_filter`: DeepSpeed exclusion filter string when using mutli-node setup.
`deepspeed_inclusion_filter`: DeepSpeed inclusion filter string when using mutli-node setup.
`deepspeed_multinode_launcher`: DeepSpeed multi-node launcher to use, e.g. `pdsh`, `standard`, `openmpi`, `mvapich`, `mpich`, `slurm`, `nossh` (requires DeepSpeed >= 0.14.5). If unspecified, will default to `pdsh`.
`deepspeed_config_file`: path to the DeepSpeed config file in `json` format. See the next section for more details on this.

Untuk dapat menyesuaikan lebih banyak opsi, Anda perlu menggunakan file konfigurasi DeepSpeed.

File Konfigurasi DeepSpeed

Pada mesin Anda, cukup jalankan:

accelerate config

dan menjawab pertanyaan yang diajukan. Anda akan ditanya apakah ingin menggunakan file konfigurasi untuk deepspeed, jawab ya dan berikan path ke file konfigurasi deepspeed. Ini akan menghasilkan file konfigurasi yang akan digunakan secara otomatis untuk mengatur opsi default dengan benar saat melakukan

accelerate launch my_script.py --args_to_my_script

Sebagai contoh, berikut adalah cara menjalankan contoh NLP examples/by_feature/deepspeed_with_config_support.py (dari root repo) dengan DeepSpeed Config File:

Contoh File Konfigurasi DeepSpeed ZeRO Stage-2

compute_environment: LOCAL_MACHINE
deepspeed_config:
 deepspeed_config_file: /home/ubuntu/accelerate/examples/deepspeed_config_templates/zero_stage2_config.json
 zero3_init_flag: true
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false

dengan isi dari zero_stage2_config.json adalah:

{
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto",
            "torch_adam": true,
            "adam_w_mode": true
        }
    },
    "scheduler": {
        "type": "WarmupDecayLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto",
            "total_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 2,
        "allgather_partitions": true,
        "allgather_bucket_size": 2e8,
        "overlap_comm": true,
        "reduce_scatter": true,
        "reduce_bucket_size": "auto",
        "contiguous_gradients": true
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "steps_per_print": 2000,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}

accelerate launch examples/by_feature/deepspeed_with_config_support.py \
--config_name "gpt2-large" \
--tokenizer_name "gpt2-large" \
--dataset_name "wikitext" \
--dataset_config_name "wikitext-2-raw-v1" \
--block_size 128 \
--output_dir "./clm/clm_deepspeed_stage2_accelerate" \
--learning_rate 5e-4 \
--per_device_train_batch_size 24 \
--per_device_eval_batch_size 24 \
--num_train_epochs 3 \
--with_tracking \
--report_to "wandb"\

Contoh File Konfigurasi DeepSpeed untuk ZeRO Stage-3 dengan offload CPU

compute_environment: LOCAL_MACHINE
deepspeed_config:
 deepspeed_config_file: /home/ubuntu/accelerate/examples/deepspeed_config_templates/zero_stage3_offload_config.json
 zero3_init_flag: true
distributed_type: DEEPSPEED
fsdp_config: {}
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
mixed_precision: fp16
num_machines: 1
num_processes: 2
use_cpu: false

dengan isi dari zero_stage3_offload_config.json adalah:

{
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "weight_decay": "auto"
        }
    },
    "scheduler": {
        "type": "WarmupDecayLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto",
            "total_num_steps": "auto"
        }
    },
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        },
        "overlap_comm": true,
        "contiguous_gradients": true,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "sub_group_size": 1e9,
        "stage3_max_live_parameters": 1e9,
        "stage3_max_reuse_distance": 1e9,
        "stage3_gather_16bit_weights_on_model_save": "auto"
    },
    "gradient_accumulation_steps": 1,
    "gradient_clipping": "auto",
    "steps_per_print": 2000,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}

accelerate launch examples/by_feature/deepspeed_with_config_support.py \
--config_name "gpt2-large" \
--tokenizer_name "gpt2-large" \
--dataset_name "wikitext" \
--dataset_config_name "wikitext-2-raw-v1" \
--block_size 128 \
--output_dir "./clm/clm_deepspeed_stage3_offload_accelerate" \
--learning_rate 5e-4 \
--per_device_train_batch_size 32 \
--per_device_eval_batch_size 32 \
--num_train_epochs 3 \
--with_tracking \
--report_to "wandb"\

Contoh Konfigurasi ZeRO++ Anda dapat menggunakan fitur-fitur ZeRO++ dengan menggunakan parameter konfigurasi yang sesuai. Perhatikan bahwa ZeRO++ adalah ekstensi untuk ZeRO Stage 3. Berikut adalah cara file konfigurasi dapat dimodifikasi, dari tutorial ZeRO++ DeepSpeed:

{
    "zero_optimization": {
        "stage": 3,
        "reduce_bucket_size": "auto",

        "zero_quantized_weights": true,
        "zero_hpz_partition_size": 8,
        "zero_quantized_gradients": true,

        "contiguous_gradients": true,
        "overlap_comm": true
    }
}

Untuk partisi hierarkis, ukuran partisi zero_hpz_partition_size sebaiknya diatur ke jumlah GPU per node. (Sebagai contoh, file konfigurasi di atas mengasumsikan 8 GPU per node)

Perubahan kode penting saat menggunakan File Konfigurasi DeepSpeed

DeepSpeed Optimizers dan Schedulers. Untuk informasi lebih lanjut tentang hal-hal ini, lihat dokumentasi DeepSpeed Optimizers dan DeepSpeed Schedulers. Kami akan melihat perubahan yang diperlukan dalam kode saat menggunakan ini.

a. DS Optim + DS Scheduler: Kasus ketika kedua kunci optimizer dan scheduler hadir dalam file konfigurasi DeepSpeed. Dalam situasi ini, keduanya akan digunakan dan pengguna harus menggunakan accelerate.utils.DummyOptim dan accelerate.utils.DummyScheduler untuk menggantikan optimizer dan scheduler PyTorch/Custom di kode mereka. Berikut adalah potongan kode dari examples/by_feature/deepspeed_with_config_support.py yang menunjukkan hal ini:
```
 # Creates Dummy Optimizer if `optimizer` was specified in the config file else creates Adam Optimizer
 optimizer_cls = (
     torch.optim.AdamW
     if accelerator.state.deepspeed_plugin is None
     or "optimizer" not in accelerator.state.deepspeed_plugin.deepspeed_config
     else DummyOptim
 )
 optimizer = optimizer_cls(optimizer_grouped_parameters, lr=args.learning_rate)

 # Creates Dummy Scheduler if `scheduler` was specified in the config file else creates `args.lr_scheduler_type` Scheduler
 if (
     accelerator.state.deepspeed_plugin is None
     or "scheduler" not in accelerator.state.deepspeed_plugin.deepspeed_config
 ):
     lr_scheduler = get_scheduler(
         name=args.lr_scheduler_type,
         optimizer=optimizer,
         num_warmup_steps=args.num_warmup_steps,
         num_training_steps=args.max_train_steps,
     )
 else:
     lr_scheduler = DummyScheduler(
         optimizer, total_num_steps=args.max_train_steps, warmup_num_steps=args.num_warmup_steps
     )
```
b. Optim Custom + Scheduler Custom: Kasus ketika kedua kunci optimizer dan scheduler tidak ada di file konfigurasi DeepSpeed. Dalam situasi ini, tidak diperlukan perubahan kode dari pengguna, dan ini adalah kasus ketika menggunakan integrasi melalui DeepSpeed Plugin. Pada contoh di atas, kita dapat melihat bahwa kode tetap tidak berubah jika kunci optimizer dan scheduler tidak ada di file konfigurasi DeepSpeed.

c. Optim + DS Scheduler Kustom: Kasus ketika hanya kunci scheduler yang ada di file konfigurasi DeepSpeed. Dalam situasi ini, pengguna harus menggunakan accelerate.utils.DummyScheduler untuk menggantikan scheduler PyTorch/Kustom di kode mereka.

d. DS Optim + Custom Scheduler: Kasus ketika hanya kunci optimizer yang ada di file konfigurasi DeepSpeed. Hal ini akan menyebabkan error karena Anda hanya dapat menggunakan DS Scheduler saat menggunakan DS Optim.
Perhatikan nilai auto pada file konfigurasi DeepSpeed di atas. Nilai-nilai ini ditangani secara otomatis oleh metode prepare berdasarkan model, dataloaders, optimizer dummy, dan scheduler dummy yang diberikan ke metode prepare. Hanya bidang auto yang ditentukan dalam contoh di atas yang ditangani oleh metode prepare, sedangkan sisanya harus ditentukan secara eksplisit oleh pengguna.

Nilai auto dihitung sebagai:

reduce_bucket_size: hidden_size * hidden_size
stage3_prefetch_bucket_size: int(0.9 * hidden_size * hidden_size)
stage3_param_persistence_threshold: 10 * hidden_size

Agar fitur auto dapat berfungsi untuk 3 entri konfigurasi ini - Accelerate akan menggunakan model.config.hidden_size atau max(model.config.hidden_sizes) sebagai hidden_size. Jika keduanya tidak tersedia, peluncuran akan gagal dan Anda harus mengatur 3 entri konfigurasi ini secara manual. Ingatlah bahwa 2 entri konfigurasi pertama adalah buffer komunikasi - semakin besar ukurannya, semakin efisien komunikasi akan berjalan, namun semakin besar pula konsumsi memori GPU-nya, sehingga ini merupakan trade-off performa yang dapat disesuaikan.

Hal-hal yang perlu diperhatikan saat menggunakan File Konfigurasi DeepSpeed

Berikut adalah contoh skrip yang menggunakan deepspeed_config_file dalam berbagai skenario.

Kode test.py:

from accelerate import Accelerator
from accelerate.state import AcceleratorState


def main():
    accelerator = Accelerator()
    accelerator.print(f"{AcceleratorState()}")


if __name__ == "__main__":
    main()

Skenario 1: File konfigurasi accelerate yang diubah secara manual memiliki deepspeed_config_file bersama dengan entri lainnya.

Isi konfigurasi accelerate:

command_file: null
commands: null
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
  deepspeed_config_file: 'ds_config.json'
distributed_type: DEEPSPEED
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
gpu_ids: null
machine_rank: 0
main_process_ip: null
main_process_port: null
main_training_function: main
megatron_lm_config: {}
num_machines: 1
num_processes: 2
rdzv_backend: static
same_network: true
tpu_name: null
tpu_zone: null
use_cpu: false

ds_config.json:

{
    "bf16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 3,
        "stage3_gather_16bit_weights_on_model_save": false,
        "offload_optimizer": {
            "device": "none"
        },
        "offload_param": {
            "device": "none"
        }
    },
    "gradient_clipping": 1.0,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "gradient_accumulation_steps": 10,
    "steps_per_print": 2000000
}

Output dari accelerate launch test.py:

ValueError: When using `deepspeed_config_file`, the following accelerate config variables will be ignored:
['gradient_accumulation_steps', 'gradient_clipping', 'zero_stage', 'offload_optimizer_device', 'offload_param_device',
'zero3_save_16bit_model', 'mixed_precision'].
Please specify them appropriately in the DeepSpeed config file.
If you are using an accelerate config file, remove other config variables mentioned in the above specified list.
The easiest method is to create a new config following the questionnaire via `accelerate config`.
It will only ask for the necessary config variables when using `deepspeed_config_file`.

Skenario 2: Gunakan solusi dari error tersebut untuk membuat konfigurasi accelerate baru dan periksa bahwa error ambiguitas tidak lagi muncul.

Jalankan accelerate config:

$ accelerate config
-------------------------------------------------------------------------------------------------------------------------------
In which compute environment are you running?
This machine
-------------------------------------------------------------------------------------------------------------------------------
Which type of machine are you using?
multi-GPU
How many different machines will you use (use more than 1 for multi-node training)? [1]:
Do you wish to optimize your script with torch dynamo?[yes/NO]:
Do you want to use DeepSpeed? [yes/NO]: yes
Do you want to specify a json file to a DeepSpeed config? [yes/NO]: yes
Please enter the path to the json DeepSpeed config file: ds_config.json
Do you want to enable `deepspeed.zero.Init` when using ZeRO Stage-3 for constructing massive models? [yes/NO]: yes
How many GPU(s) should be used for distributed training? [1]:4
accelerate configuration saved at ds_config_sample.yaml

Isi konfigurasi accelerate:

compute_environment: LOCAL_MACHINE
deepspeed_config:
  deepspeed_config_file: ds_config.json
  zero3_init_flag: true
distributed_type: DEEPSPEED
downcast_bf16: 'no'
dynamo_backend: 'NO'
fsdp_config: {}
machine_rank: 0
main_training_function: main
megatron_lm_config: {}
num_machines: 1
num_processes: 4
rdzv_backend: static
same_network: true
use_cpu: false

Output dari accelerate launch test.py:

Distributed environment: DEEPSPEED  Backend: nccl
Num processes: 4
Process index: 0
Local process index: 0
Device: cuda:0
Mixed precision type: bf16
ds_config: {'bf16': {'enabled': True}, 'zero_optimization': {'stage': 3, 'stage3_gather_16bit_weights_on_model_save': False, 'offload_optimizer': {'device': 'none'}, 'offload_param': {'device': 'none'}}, 'gradient_clipping': 1.0, 'train_batch_size': 'auto', 'train_micro_batch_size_per_gpu': 'auto', 'gradient_accumulation_steps': 10, 'steps_per_print': inf, 'fp16': {'enabled': False}}

Skenario 3: Mengatur argumen perintah accelerate launch yang terkait dengan DeepSpeed menjadi "auto" dalam file konfigurasi DeepSpeed dan periksa bahwa semuanya berjalan sesuai harapan.

ds_config.json baru dengan "auto" untuk argumen perintah accelerate launch DeepSpeed:

{
    "bf16": {
        "enabled": "auto"
    },
    "zero_optimization": {
        "stage": "auto",
        "stage3_gather_16bit_weights_on_model_save": "auto",
        "offload_optimizer": {
            "device": "auto"
        },
        "offload_param": {
            "device": "auto"
        }
    },
    "gradient_clipping": "auto",
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "gradient_accumulation_steps": "auto",
    "steps_per_print": 2000000
}

Output dari accelerate launch --mixed_precision="fp16" --zero_stage=3 --gradient_accumulation_steps=5 --gradient_clipping=1.0 --offload_param_device="cpu" --offload_optimizer_device="nvme" --zero3_save_16bit_model="true" test.py:

Distributed environment: DEEPSPEED  Backend: nccl
Num processes: 4
Process index: 0
Local process index: 0
Device: cuda:0
Mixed precision type: fp16
ds_config: {'bf16': {'enabled': False}, 'zero_optimization': {'stage': 3, 'stage3_gather_16bit_weights_on_model_save': True, 'offload_optimizer': {'device': 'nvme'}, 'offload_param': {'device': 'cpu'}}, 'gradient_clipping': 1.0, 'train_batch_size': 'auto', 'train_micro_batch_size_per_gpu': 'auto', 'gradient_accumulation_steps': 5, 'steps_per_print': inf, 'fp16': {'enabled': True, 'auto_cast': True}}

Catatan:

Nilai "auto" yang tersisa ditangani dalam panggilan accelerator.prepare() seperti dijelaskan pada poin 2 dari Important code changes when using DeepSpeed Config File.
Hanya ketika gradient_accumulation_steps adalah auto, nilai yang diberikan saat membuat objek Accelerator melalui Accelerator(gradient_accumulation_steps=k) yang akan digunakan. Saat menggunakan DeepSpeed Plugin, nilai dari plugin tersebut yang akan digunakan dan akan menimpa nilai yang diberikan saat membuat objek Accelerator.

Menyimpan dan memuat

Penyimpanan dan pemuatan model tidak berubah untuk ZeRO Stage-1 dan Stage-2.
di bawah ZeRO Stage-3, state_dict hanya berisi placeholder karena bobot model dipartisi di beberapa GPU. ZeRO Stage-3 memiliki 2 opsi:

a. Menyimpan seluruh bobot model 16bit untuk dimuat langsung kemudian menggunakan model.load_state_dict(torch.load(pytorch_model.bin)). Untuk ini, atur zero_optimization.stage3_gather_16bit_weights_on_model_save ke True di file konfigurasi DeepSpeed atau atur zero3_save_16bit_model ke True di Plugin DeepSpeed. Perhatikan bahwa opsi ini memerlukan konsolidasi bobot pada satu GPU, sehingga dapat lambat dan membutuhkan banyak memori; gunakan fitur ini hanya jika diperlukan. Berikut adalah potongan kode dari examples/by_feature/deepspeed_with_config_support.py yang menunjukkan hal ini:
```
unwrapped_model = accelerator.unwrap_model(model)

# New Code #
# Saves the whole/unpartitioned fp16 model when in ZeRO Stage-3 to the output directory if
# `stage3_gather_16bit_weights_on_model_save` is True in DeepSpeed Config file or
# `zero3_save_16bit_model` is True in DeepSpeed Plugin.
# For Zero Stages 1 and 2, models are saved as usual in the output directory.
# The model name saved is `pytorch_model.bin`
unwrapped_model.save_pretrained(
    args.output_dir,
    is_main_process=accelerator.is_main_process,
    save_function=accelerator.save,
    state_dict=accelerator.get_state_dict(model),
)
```
b. Untuk mendapatkan bobot 32bit, pertama simpan model menggunakan model.save_checkpoint(). Berikut adalah potongan kode dari examples/by_feature/deepspeed_with_config_support.py yang menunjukkan hal ini:
```
success = model.save_checkpoint(PATH, ckpt_id, checkpoint_state_dict)
status_msg = f"checkpointing: PATH={PATH}, ckpt_id={ckpt_id}"
if success:
    logging.info(f"Success {status_msg}")
else:
    logging.warning(f"Failure {status_msg}")
```
Hal ini akan membuat partisi model dan optimizer ZeRO bersama dengan skrip zero_to_fp32.py di direktori checkpoint. Anda dapat menggunakan skrip ini untuk melakukan konsolidasi offline. Skrip ini tidak memerlukan file konfigurasi atau GPU. Berikut adalah contoh penggunaannya:
```
$ cd /path/to/checkpoint_dir
$ ./zero_to_fp32.py . pytorch_model.bin
Processing zero checkpoint at global_step1
Detected checkpoint of type zero stage 3, world_size: 2
Saving fp32 state dict to pytorch_model.bin (total_numel=60506624)
```
Untuk mendapatkan model 32bit untuk penyimpanan/inferensi, Anda dapat melakukan:
```
from deepspeed.utils.zero_to_fp32 import load_state_dict_from_zero_checkpoint

unwrapped_model = accelerator.unwrap_model(model)
fp32_model = load_state_dict_from_zero_checkpoint(unwrapped_model, checkpoint_dir)
```
Jika Anda hanya tertarik pada state_dict, Anda dapat melakukan hal berikut:
```
from deepspeed.utils.zero_to_fp32 import get_fp32_state_dict_from_zero_checkpoint

state_dict = get_fp32_state_dict_from_zero_checkpoint(checkpoint_dir)
```
Perhatikan bahwa semua fungsi ini membutuhkan memori (RAM umum) sekitar 2x dari ukuran checkpoint akhir.

ZeRO Inference

DeepSpeed ZeRO Inference mendukung ZeRO stage 3 dengan ZeRO-Infinity. Ini menggunakan protokol ZeRO yang sama seperti pelatihan, tetapi tidak menggunakan optimizer dan lr scheduler, dan hanya stage 3 yang relevan. Dengan integrasi accelerate, Anda hanya perlu menyiapkan model dan dataloader seperti yang ditunjukkan di bawah ini:

model, eval_dataloader = accelerator.prepare(model, eval_dataloader)

Beberapa hal yang perlu diperhatikan

Integrasi saat ini tidak mendukung Pipeline Parallelism dari DeepSpeed.
Integrasi saat ini tidak mendukung mpu, sehingga membatasi parallelism tensor yang didukung di Megatron-LM.
Integrasi saat ini tidak mendukung beberapa model.

Multi-node DeepSpeed

DeepSpeed mendukung inferensi dan pelatihan multi-node melalui berbagai launcher yang berbeda. Anda dapat menentukan launcher yang berbeda dengan mengatur konfigurasi deepspeed_multinode_launcher di CLI atau di file konfigurasi DeepSpeed.

Saat ini, accelerate mendukung pengaluran konfigurasi untuk launcher multi-node DeepSpeed berikut: pdsh (default), standard, openmpi, mvapich, mpich, slurm, nossh (memerlukan DeepSpeed >= 0.14.5).

Silakan baca dokumentasi DeepSpeed untuk informasi lebih lanjut tentang launcher yang berbeda. Secara default, DeepSpeed akan mencoba menggunakan SSH tanpa kata sandi dari node mesin utama ke node lain untuk menjalankan perintah launcher. Dalam konfigurasi ini, perintah accelerate launch hanya perlu dijalankan di node utama. Jika menggunakan launcher nossh, Anda perlu menjalankan perintah accelerate launch di setiap node menggunakan konfigurasi yang disalin.

Sumber Daya DeepSpeed

Dokumentasi untuk bagian internal yang terkait dengan deepspeed dapat ditemukan di sini.

Makalah:

Terakhir, harap diingat bahwa Accelerate hanya mengintegrasikan DeepSpeed, jadi jika Anda memiliki masalah atau pertanyaan terkait penggunaan DeepSpeed, silakan buat issue di DeepSpeed GitHub.

Bagi yang tertarik dengan kesamaan dan perbedaan antara FSDP dan DeepSpeed, silakan lihat panduan konsep di sini!

Update on GitHub

←Pelatihan presisi rendah (FP8) Menggunakan beberapa model dengan DeepSpeed→