# Tamamen Parçalı Veri Paralelliği

Daha büyük modelleri daha yüksek batch boyutlarıyla eğitmeyi hızlandırmak için, tamamen parçalı veri paralel (fully sharded data parallel) bir model kullanabiliriz. Bu tür veri paralel paradigmi, optimizör durumlarını, gradyanları ve parametreleri parçalayarak daha fazla veri ve daha büyük modellerin sığdırılmasını sağlar. Konu hakkında ve avantajları hakkında daha fazla bilgi için [Fully Sharded Data Parallel blog](https://pytorch.org/blog/introducing-pytorch-fully-sharded-data-parallel-api/)'una göz atın. PyTorch'un en güncel Fully Sharded Data Parallel (FSDP) eğitim özelliğini entegre ettik. Yapmanız gereken tek şey, bunu config üzerinden etkinleştirmektir.

## Varsayılan olarak nasıl çalışır

Makinenizde (makinenizlerde) şunu çalıştırmanız yeterlidir:

```bash
accelerate config
```

ve sorulan soruları yanıtlayın. Bu işlem, … sırasında varsayılan seçeneklerin doğru şekilde ayarlanabilmesi için otomatik olarak kullanılacak bir yapılandırma dosyası oluşturur.

```bash
accelerate launch my_script.py --args_to_my_script
```

Örneğin, FSDP etkinleştirilmiş şekilde `examples/nlp_example.py` dosyasını (deponun kökünden) nasıl çalıştıracağınız aşağıda gösterilmektedir:

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

```bash
accelerate launch examples/nlp_example.py
```

Şu anda `Accelerate`, CLI üzerinden aşağıdaki yapılandırmayı destekler:

`fsdp_sharding_strategy`: [1] FULL_SHARD (optimizer durumlarını, gradyanları ve parametreleri parçalar), [2] SHARD_GRAD_OP (optimizer durumlarını ve gradyanları parçalar), [3] NO_SHARD (DDP), [4] HYBRID_SHARD (her düğümde tam bir kopya bulunurken optimizer durumlarını, gradyanları ve parametreleri her düğüm içinde parçalar), [5] HYBRID_SHARD_ZERO2 (her düğümde tam bir kopya bulunurken optimizer durumlarını ve gradyanları her düğüm içinde parçalar). Daha fazla bilgi için lütfen resmi [PyTorch dokümanlarına](https://pytorch.org/docs/stable/fsdp.html#torch.distributed.fsdp.ShardingStrategy) başvurun.

`fsdp_offload_params` : Parametrelerin ve gradyanların CPU'ya aktarılmasına karar verir

`fsdp_auto_wrap_policy`: [1] TRANSFORMER_BASED_WRAP, [2] SIZE_BASED_WRAP, [3] NO_WRAP

`fsdp_transformer_layer_cls_to_wrap`: Yalnızca Transformers için geçerlidir. `fsdp_auto_wrap_policy=TRANSFORMER_BASED_WRAP` kullanıldığında, kullanıcı, sarılacak transformer katman sınıf adalarının virgülle ayrılmış bir dizesini (büyük/küçük harfe duyarlı) sağlayabilir; örneğin `BertLayer`, `GPTJBlock`, `T5Block`, `BertLayer,BertEmbeddings,BertSelfOutput`. Bu önemlidir çünkü ağırlıkları paylaşan alt modüllerin (ör. gömme katmanları) farklı FSDP sarmalı birimlerinde kalmaması gerekir. Bu politika kullanıldığında, sarma işlemi, Multi-Head Attention'ı ardından birkaç MLP katmanı içeren her blok için gerçekleşir. Paylaşılan gömme katmanları dahil olmak üzere kalan katmanlar, uygun şekilde en dıştaki FSDP biriminde sarılır. Bu nedenle, transformer tabanlı modeller için bunu kullanın. Transformer modelleri için `model._no_split_modules` kullanabilirsiniz; bunun için `Do you want to use the model's `_no_split_modules` to wrap. It will try to use `model._no_split_modules` when possible. sorusuna `yes` yanıtını vermeniz yeterlidir.

`fsdp_min_num_params`: `fsdp_auto_wrap_policy=SIZE_BASED_WRAP` kullanıldığında minimum parametre sayısı.

`fsdp_backward_prefetch_policy`: [1] BACKWARD_PRE, [2] BACKWARD_POST, [3] NO_PREFETCH

`fsdp_forward_prefetch`: True ise, FSDP ileri geçiş sırasında çalışırken bir sonraki all-gather işlemini açıkça önceden getirir. Önceden getirme, ilk yinelemenin çalışma sırasını takip ettiği için bu özellik yalnızca statik grafik modellerde kullanılmalıdır. Yani, alt modüllerin sırası modelin çalışması sırasında dinamik olarak değişiyorsa bu özelliği etkinleştirmeyin.

`fsdp_state_dict_type`: [1] FULL_STATE_DICT, [2] LOCAL_STATE_DICT, [3] SHARDED_STATE_DICT

`fsdp_use_orig_params`: True ise, init sırasında düzensiz `requires_grad` değerlerine izin verir; bu da dondurulmuş ve eğitilebilir parametrelerin iç içe geçmesine olanak tanır. Bu ayar, [bu gönderide](https://dev-discuss.pytorch.org/t/rethinking-pytorch-fully-sharded-data-parallel-fsdp-from-first-principles/1019) tartışıldığı gibi parametre-verimli ince ayar gibi durumlarda faydalıdır. Bu seçenek ayrıca birden çok optimizör parametre grubuna sahip olmayı da sağlar. Modeli FSDP ile hazırlamadan/sarmalamadan önce optimizör oluşturulurken bu değer `True` olmalıdır.

`fsdp_cpu_ram_efficient_loading`: Yalnızca Transformers modelleri için geçerlidir. True ise, önceden eğitilmiş model kontrol noktasını yalnızca ilk süreç yüklerken diğer tüm süreçlerin ağırlıkları boş kalır. `from_pretrained` yöntemiyle önceden eğitilmiş Transformers modelini yüklerken hata alıyorsanız bu ayarı False olarak ayarlamalısınız. Bu ayar True olduğunda `fsdp_sync_module_states` de True olmak zorundadır, aksi takdirde ana süreç dışındaki tüm süreçlerde rastgele ağırlıklar oluşur ve eğitim sırasında beklenmeyen davranışlara yol açar. Bunun çalışması için, Transformers `from_pretrained` yöntemini çağırmadan önce dağıtık süreç grubunun başlatıldığından emin olun. Trainer API kullanıldığında, dağıtık süreç grubu `TrainingArguments` sınıfının bir örneğini oluşturduğunuzda başlatılır.

`fsdp_sync_module_states`: True ise, her bir ayrı sarmalanmış FSDP birimi, modül parametrelerini rank 0'dan yayınlayacaktır.

Ek ve daha ince ayarlı kontrol için, diğer FSDP parametrelerini `FullyShardedDataParallelPlugin` üzerinden belirleyebilirsiniz. `FullyShardedDataParallelPlugin` nesnesini oluştururken, accelerate yapılandırmasının bir parçası olmayan parametreleri veya bunları geçersiz kılmak istediğiniz parametreleri iletin. FSDP parametreleri, accelerate yapılandırma dosyasına veya başlatma komutu argümanlarına göre seçilir; `FullyShardedDataParallelPlugin` nesnesi üzerinden doğrudan ilettiğiniz diğer parametreler ise bunları ayarlar/geçersiz kılar.

Aşağıda bir örnek bulunmaktadır:

```py
from accelerate import FullyShardedDataParallelPlugin
from torch.distributed.fsdp.fully_sharded_data_parallel import FullOptimStateDictConfig, FullStateDictConfig

fsdp_plugin = FullyShardedDataParallelPlugin(
    state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),
    optim_state_dict_config=FullOptimStateDictConfig(offload_to_cpu=False, rank0_only=False),
)

accelerator = Accelerator(fsdp_plugin=fsdp_plugin)
```

## Kaydetme ve yükleme

FSDP modelleri kullanırken checkpoint alma için yeni önerilen yöntem, accelerate yapılandırmasını ayarlarken `StateDictType` olarak `SHARDED_STATE_DICT` kullanmaktır. Aşağıda, accelerate'in `save_state` yardımcısını kullanarak kaydetmek için kod parçası yer almaktadır.

```py
accelerator.save_state("ckpt")
```

Kontrol noktası klasörünü inceleyerek model ve optimizörün işlem başına parçalar halinde olduğunu görün:
```
ls ckpt
# optimizer_0  pytorch_model_0  random_states_0.pkl  random_states_1.pkl  scheduler.bin

cd ckpt

ls optimizer_0
# __0_0.distcp  __1_0.distcp

ls pytorch_model_0
# __0_0.distcp  __1_0.distcp
```

Eğitimi kaldığı yerden devam ettirmek için bunları geri yüklemek için accelerate'in `load_state` yardımcısını kullanın

```py
accelerator.load_state("ckpt")
```

transformers `save_pretrained` kullanırken, model durum sözlüğünü (state dict) kaydetmek için `state_dict=accelerator.get_state_dict(model)` parametresini iletin. Aşağıda bir örnek bulunmaktadır:

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

### State Dict

`accelerator.get_state_dict`, durum sözlüğünü yalnızca rank 0 için almak ve onu CPU'ya taşımak için `FullStateDictConfig(offload_to_cpu=True, rank0_only=True)` bağlam yöneticisini kullanarak alttaki `model.state_dict` uygulamasını çağırır.

Ardından `state` değerini `save_pretrained` yöntemine iletebilirsiniz. `state_dict` davranışını kontrol etmek için kullanabileceğiniz `StateDictType` ve `FullStateDictConfig` için çeşitli modlar mevcuttur. Daha fazla bilgi için [PyTorch belgelerini](https://pytorch.org/docs/stable/fsdp.html) inceleyin.

`StateDictType.SHARDED_STATE_DICT` seçeneğini kullanırsanız, `Accelerator.save_state` sırasında modelin ağırlıkları, modeldeki her alt bölme için `n` dosyaya ayrılır. Eğitimden sonra modelin içine geri yüklemek için bunları tek bir sözlükte birleştirmek isterseniz `merge_weights` yardımcı işlevini kullanabilirsiniz:

```py
from accelerate.utils import merge_fsdp_weights

# Our weights are saved usually in a `pytorch_model_fsdp_{model_number}` folder
merge_fsdp_weights("pytorch_model_fsdp_0", "output_path", safe_serialization=True)
```
Son çıktı, `safe_serialization=False` parametresi geçirilirse `pytorch_model.bin` dosyasına, aksi takdirde `model.safetensors` dosyasına kaydedilir.

Bu, CLI kullanılarak da çağrılabilir:
```bash
accelerate merge-weights pytorch_model_fsdp_0/ output_path
```

## FSDP bölme stratejileri ile DeepSpeed ZeRO Aşamaları arasındaki eşleme
* `FULL_SHARD`, DeepSpeed `ZeRO Stage-3`'e eşlenir. Optimizer durumlarını, gradyanları ve parametreleri parçalar.
* `SHARD_GRAD_OP`, DeepSpeed `ZeRO Stage-2`'ye eşlenir. Optimizer durumlarını ve gradyanları parçalar.
* `NO_SHARD`, `ZeRO Stage-0`'a eşlenir. Modelin, optimizör durumlarının ve gradyanların her GPU'da tam bir kopyasının bulunduğu, parçalamasız bir yapıdır.
* `HYBRID_SHARD`, `zero_hpz_partition_size=<num_gpus_per_node>` olacak şekilde `ZeRO++ Stage-3`'e eşlenir. Burada, optimizör durumları, gradyanlar ve parametreler her düğümün içinde bölünürken her düğümün tam bir kopyaya sahip olması sağlanır.

## Dikkat edilmesi gereken birkaç uyarı

- Birden fazla model söz konusu olduğunda, optimizörleri `accelerator.save_state()` ve `accelerator.load_state()` çağrılarının yanlış/beklenmedik davranışlara yol açmaması için, ilgili modellerle aynı sırada prepare çağrısına iletin.
- Bu özellik, `Transformers` kütüphanesindeki `run_translation.py` betiğindeki `--predict_with_generate` ile uyumlu değildir.

Daha fazla kontrol için kullanıcılar `FullyShardedDataParallelPlugin`'den yararlanabilir. Bu sınıfın bir örneğini oluşturduktan sonra, kullanıcılar bunu Accelerator sınıfının örneklenmesine iletebilir. Bu seçenekler hakkında daha fazla bilgi için lütfen PyTorch [FullyShardedDataParallel](https://github.com/pytorch/pytorch/blob/0df2e863fbd5993a7b9e652910792bd21a516ff3/torch/distributed/fsdp/fully_sharded_data_parallel.py#L236) koduna başvurun.

    FSDP ve DeepSpeed arasındaki benzerlikler ve farklılıklarla ilgilenenler için lütfen [buradaki kavram kılavuzuna](../concept_guides/fsdp_and_deepspeed) göz atın!
    

