# Hızlı Tur

Eğitim ortamınıza ([torchrun](https://pytorch.org/docs/stable/elastic/run.html), [DeepSpeed](https://www.deepspeed.ai/) vb.) ve kullanılabilir donanıma bağlı olarak kodunuzu başlatıp çalıştırmanın birçok yolu vardır. Accelerate, farklı dağıtık kurulumlarda başlatma ve eğitim için birleşik bir arayüz sunarak, kodunuzu bu farklı kurulumlara uyarlamaya ilişkin inceliklerle uğraşmak yerine PyTorch eğitim kodunuza odaklanmanızı sağlar. Bu sayede, GPU ve TPU gibi donanımlarla dağıtık kurulumlarda eğitim ve çıkarım için PyTorch kodunuzu kolayca ölçeklendirebilirsiniz. Accelerate, genellikle belleğe sığmayan gerçekten büyük modelleri yükleyip çıkarım yapmayı daha erişilebilir kılan Big Model Inference özelliğini de sunar.

Bu hızlı tur, Accelerate'in üç ana özelliğini tanıtır:

* dağıtık eğitim betikleri için birleşik bir komut satırı başlatma arayüzü
* Farklı dağıtık kurulumlarda çalışacak şekilde PyTorch eğitim kodunu uyarlamak için bir eğitim kütüphanesi
* Büyük Model Çıkarımı

## Birleşik başlatma arayüzü

Accelerate, [`accelerate config`](package_reference/cli#accelerate-config) komutundan üretilen birleşik bir yapılandırma dosyası aracılığıyla, herhangi bir dağıtık eğitim çerçevesi (DeepSpeed, FSDP vb.) için uygun yapılandırma değerlerini otomatik olarak seçer. SLURM kullanıyorsanız gibi belirli durumlarda faydalı olabileceğinden, yapılandırma değerlerini komut satırına açıkça iletebilirsiniz.

Ancak çoğu durumda, Accelerate'in eğitim kurulumunuz hakkında bilgi edinmesine yardımcı olmak için her zaman önce [`accelerate config`](package_reference/cli#accelerate-config) komutunu çalıştırmalısınız.

```bash
accelerate config
```

[`accelerate config`](package_reference/cli#accelerate-config) komutu, Accelerate önbellek klasöründe varsayılan bir default_config.yaml dosyası oluşturur ve kaydeder. Bu dosya, eğitim ortamınızın yapılandırmasını saklar ve Accelerate'in eğitim betiğinizi makinenize göre doğru şekilde başlatmasına yardımcı olur.

Ortamınızı yapılandırdıktan sonra, dağıtık ortamı test etmek için kısa bir betik başlatan [`accelerate test`](package_reference/cli#accelerate-test) komutuyla kurulumunuzu test edebilirsiniz.

```bash
accelerate test
```

> [!TIP]
> Yapılandırma dosyası, önbellek gibi varsayılan olmayan bir konumda kaydedildiyse, konumunu belirtmek için `--config_file` bayrağını `accelerate test` veya `accelerate launch` komutuna ekleyin.

Ortamınız hazır olduğunda, eğitim betiğinizi [`accelerate launch`](package_reference/cli#accelerate-launch) ile başlatın!

```bash
accelerate launch path_to_script.py --args_for_the_script
```

Daha fazla bilgi edinmek için, betiklerinizi başlatma hakkında daha fazla bilgi için [Dağıtık kodu başlatma](basic_tutorials/launch) eğitimine göz atın.

Ayrıca, çalıştırabileceğiniz çeşitli kurulumlar için bir dizi hazır **minimal** örnek yapılandırma sunan bir [yapılandırma zürafası](https://github.com/huggingface/accelerate/blob/main/examples/config_yaml_templates) da bulunmaktadır.

## Eğitim kodunu uyarla

Accelerate'in bir sonraki ana özelliği, PyTorch kodunuzu farklı dağıtık kurulumlarda çalışacak şekilde uyarlayan [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) sınıfıdır.

Çoklu GPU veya TPU üzerinde çalışabilmesini sağlamak için eğitim scriptinize yalnızca birkaç satır kod eklemeniz yeterlidir.

```diff
+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ device = accelerator.device
+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for batch in training_dataloader:
      optimizer.zero_grad()
      inputs, targets = batch
-     inputs = inputs.to(device)
-     targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
+     accelerator.backward(loss)
      optimizer.step()
      scheduler.step()
```

1. Eğitim betiğinizin başında [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) sınıfını içe aktarın ve örnekleyin. [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) sınıfı, dağıtık eğitim için gerekli her şeyi başlatır ve kodun nasıl başlatıldığına dayanarak eğitim ortamınızı (GPU'lu tek bir makine, birden fazla GPU'lu bir makine, birden fazla GPU'lu birden fazla makine veya bir TPU vb.) otomatik olarak algılar.

```python
from accelerate import Accelerator

accelerator = Accelerator()
```

2. Model ve giriş verileriniz üzerindeki `.cuda()` gibi çağrıları kaldırın. [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) sınıfı bu nesneleri sizin için uygun cihaza otomatik olarak yerleştirir.

> [!WARNING]
> Bu adım *isteğe bağlıdır* ancak Accelerate'in cihaz yerleşimini yönetmesine izin vermek en iyi uygulama olarak kabul edilir. [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator)'u başlatırken `device_placement=False` parametresini geçirerek otomatik cihaz yerleşimini devre dışı bırakabilirsiniz. Nesneleri `.to(device)` ile belirli bir cihaza yerleştirmek istiyorsanız, bunun yerine `accelerator.device` kullanmanızdan emin olun. Örneğin, bir modeli `accelerator.device` üzerine yerleştirmeden önce bir optimizör oluşturursanız, eğitim bir TPU üzerinde başarısız olur.

> [!WARNING]
> Accelerate, otomatik cihaz yerleşimi için varsayılan olarak engellenmeyen aktarımları kullanmaz; bu durum, istenmeyen CUDA senkronizasyonlarına yol açabilir. [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator)'u başlatırken `dataloader_config` olarak `non_blocking=True` ayarlı bir [DataLoaderConfiguration](/docs/accelerate/main/tr/package_reference/utilities#accelerate.DataLoaderConfiguration) geçirerek engellenmeyen aktarımları etkinleştirebilirsiniz. Her zamanki gibi, engellenmeyen aktarımlar yalnızca dataloader'da da `pin_memory=True` ayarlıysa çalışır. GPU'dan CPU'ya engellenmeyen aktarımların kullanılmasının, CPU işlemlerinin hazır olmayan tensörler üzerinde yapılmasına neden olması durumunda hatalı sonuçlara yol açabileceğine dikkat edin.

```py
device = accelerator.device
```

3. Eğitim için tüm ilgili PyTorch nesnelerini (optimizer, model, dataloader(lar), learning rate scheduler) oluşturuldukları anda [prepare()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.prepare) metoduna iletin. Bu yöntem, modeli dağıtık kurulumunuz için optimize edilmiş bir kapsayıcıya sarar, optimizer ve scheduler'ın Accelerate sürümünü kullanır ve GPU'lar veya TPU'lar arasında dağıtım için dataloader'ınızın shard edilmiş bir sürümünü oluşturur.

```python
model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
    model, optimizer, train_dataloader, lr_scheduler
)
```

4. Eğitim kurulumunuz için doğru `backward()` yöntemini kullanmak üzere `loss.backward()` ifadesini [backward()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.backward) ile değiştirin.

```py
accelerator.backward(loss)
```

Accelerate'in kodunuzu nasıl uyarladığına dair daha fazla ayrıntı öğrenmek için [Accelerate'in iç mekanizmaları](concept_guides/internal_mechanism) rehberini okuyun.

### Dağıtık değerlendirme

Dağıtık değerlendirme yapmak için doğrulama veri yükleyicinizi [prepare()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.prepare) yöntemine iletin:

```python
validation_dataloader = accelerator.prepare(validation_dataloader)
```

Dağıtık kurulumunuzdaki her cihaz yalnızca değerlendirme verisinin bir kısmını alır; bu nedenle tahminlerinizi [gather_for_metrics()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.gather_for_metrics) yöntemiyle bir arada gruplamalısınız. Bu yöntem, tüm tensörlerin her işlemde aynı boyutta olmasını gerektirir. Tensörleriniz her işlemde farklı boyutlarda ise (örneğin bir partide dinamik olarak maksimum uzunluğa dolgu yapıldığında), tensörünüzü [pad_across_processes()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.pad_across_processes) yöntemiyle işlemler arası en büyük boyuta doldurmalısınız. Tensörlerin 1B olması gerektiğini ve tensörlerin birinci boyut boyunca birleştirildiğini unutmayın.

```python
for inputs, targets in validation_dataloader:
    predictions = model(inputs)
    # Gather all predictions and targets
    all_predictions, all_targets = accelerator.gather_for_metrics((predictions, targets))
    # Example of use with a *Datasets.Metric*
    metric.add_batch(all_predictions, all_targets)
```

Daha karmaşık durumlar için (ör. 2D tensörler, tensörleri birleştirmek istememe, 3D tensörlerden oluşan sözlükler) `gather_for_metrics` içinde `use_gather_object=True` parametresini geçebilirsiniz. Bu, toplanan nesnelerin listesini döndürür. GPU tensörleriyle kullanımının iyi desteklenmediğini ve verimsiz olduğunu unutmayın.

> [!TIP]
> Bir veri setinin sonundaki veriler, bir partinin tüm işçiler arasında eşit olarak bölünebilmesi için yinelenmiş olabilir. [gather_for_metrics()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.gather_for_metrics) yöntemi, daha doğru bir metrik hesaplamak için yinelenen verileri otomatik olarak kaldırır.

## Büyük Model Çıkarımı

Accelerate'in Big Model Inference özelliği, genellikle belleğe sığmayan büyük modelleri çıkarım için yüklemek üzere iki ana işlev sunar: [init_empty_weights()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.init_empty_weights) ve [load_checkpoint_and_dispatch()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

> [!TIP]
> Big Model Inference'in kaputunun altında nasıl çalıştığını daha iyi anlamak için [Büyük modeller için çıkarım işleme](concept_guides/big_model_inference) kılavuzuna göz atın.

### Boş ağırlık başlatma

[init_empty_weights()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.init_empty_weights) bağlam yöneticisi, bir *model iskeleti* oluşturarak ve parametreler oluşturuldukça PyTorch'un [**meta**](https://pytorch.org/docs/main/meta.html) cihazına taşıyıp yerleştirerek herhangi bir boyuttaki modelleri başlatır. Bu sayede tüm ağırlıklar anında yüklenmez ve bir anda belleğe yalnızca modelin küçük bir kısmı yüklenir.

Örneğin, boş bir [Mixtral-8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1) modelini yüklemek, modelleri ve ağırlıkları CPU üzerinde tamamen yüklemekten çok daha az bellek gerektirir.

```py
from accelerate import init_empty_weights
from transformers import AutoConfig, AutoModelForCausalLM

config = AutoConfig.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
with init_empty_weights():
    model = AutoModelForCausalLM.from_config(config)
```

### Ağırlıkları yükle ve dağıt

[load_checkpoint_and_dispatch()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch) işlevi, tam veya parçalı denetim noktalarını boş modele yükler ve ağırlıkları tüm kullanılabilir cihazlar arasında otomatik olarak dağıtır.

`device_map` parametresi, her model katmanının nereye yerleştirileceğini belirler ve `"auto"` belirtildiğinde katmanlar önce GPU'ya, ardından CPU'ya ve hâlâ yeterli bellek yoksa bellek eşlemeli tensörler olarak sabit diske yerleştirilir. Cihazlar arasında bölünmemesi gereken modülleri belirtmek için `no_split_module_classes` parametresini kullanın (genellikle bunlar, artımsal bağlantıya sahip olanlardır).

```py
from accelerate import load_checkpoint_and_dispatch

model_checkpoint = "your-local-model-folder"
model = load_checkpoint_and_dispatch(
    model, checkpoint=model_checkpoint, device_map="auto", no_split_module_classes=['Block']
)
```

## Sonraki adımlar

Artık Accelerate'in ana özellikleriyle tanıştırıldığınıza göre, sonraki adımlarınız şunları içerebilir:

* Accelerate'in adım adım anlatımını içeren [öğreticilere](basic_tutorials/overview) göz atın. Dağıtık eğitim ve kütüphaneye yeni başladıysanız bu özellikle faydalı olacaktır.
* Belirli kullanım senaryolarında Accelerate'ı nasıl kullanacağınızı görmek için [kılavuzlara](usage_guides/explore) göz atın.
* [Kavram kılavuzlarını](concept_guides/internal_mechanism) okuyarak Accelerate'in iç işleyişine dair kavramsal anlayışınızı derinleştirin.
* Hangi parametrelerin ve seçeneklerin mevcut olduğunu görmek için sınıfları ve komutları [API referansında](package_reference/accelerator) arayın.

