# Yardımcı işlevler ve sınıflar

Aşağıda, kullanım senaryilerine göre ayrılmış olarak 🤗 Accelerate'in sağladığı çeşitli yardımcı işlevler yer almaktadır.

## Sabitler

🤗 Accelerate genelinde referans olarak kullanılan sabitler

[Accelerator.save_state()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.save_state) kullanılırken kullanılan sabitler şunlardır:

`utils.MODEL_NAME`: `"pytorch_model"`
`utils.OPTIMIZER_NAME`: `"optimizer"`
`utils.RNG_STATE_NAME`: `"random_states"`
`utils.SCALER_NAME`: `"scaler.pt`
`utils.SCHEDULER_NAME`: `"scheduler`

[Accelerator.save_model()](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator.save_model) kullanılırken kullanılan sabitler şunlardır

`utils.WEIGHTS_NAME`: `"pytorch_model.bin"`
`utils.SAFE_WEIGHTS_NAME`: `"model.safetensors"`
`utils.WEIGHTS_INDEX_NAME`: `"pytorch_model.bin.index.json"`
`utils.SAFE_WEIGHTS_INDEX_NAME`: `"model.safetensors.index.json"`

## Veri Sınıfları

Bunlar, 🤗 Accelerate boyunca kullanılan temel dataclass'lerdir ve parametre olarak geçirilebilirler.

### Bağımsız[[accelerate.utils.ComputeEnvironment]]

Bunlar, kullanılan dağıtık sistemin türü gibi kontroller için kullanılan bağımsız dataclass'lardır

#### accelerate.utils.ComputeEnvironment[[accelerate.utils.ComputeEnvironment]]

```python
accelerate.utils.ComputeEnvironment(*values)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L597)

Hesaplama ortamının bir türünü temsil eder.

Değerler:

- **LOCAL_MACHINE** -- özel/özel küme donanımı.
- **AMAZON_SAGEMAKER** -- Hesaplama ortamı olarak Amazon SageMaker.

#### accelerate.DistributedType[[accelerate.DistributedType]]

```python
accelerate.DistributedType(*values)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L524)

Dağıtık ortam türünü temsil eder.

Değerler:

- **YOK** -- Dağıtık bir ortam değil, yalnızca tek bir süreç.
- **MULTI_CPU** -- Birden fazla CPU düğümünde dağıtılmış.
- **MULTI_GPU** -- Birden fazla GPU üzerinde dağıtılmış.
- **MULTI_MLU** -- Birden fazla MLU üzerinde dağıtılmış.
- **MULTI_SDAA** -- Birden fazla SDAA üzerinde dağıtılmış.
- **MULTI_MUSA** -- Birden fazla MUSA üzerinde dağıtılmış.
- **MULTI_SUPA** -- Birden fazla Biren SUPA cihazında dağıtılmış.
- **MULTI_NPU** -- Birden fazla NPU üzerinde dağıtılmış.
- **MULTI_XPU** -- Birden fazla XPU üzerinde dağıtılmış.
- **MULTI_HPU** -- Birden fazla HPU üzerinde dağıtık.
- **MULTI_NEURON** -- Birden fazla Neuron çekirdeğinde dağıtılmış.
- **DEEPSPEED** -- DeepSpeed kullanımı.
- **FSDP** -- Fully Sharded Data Parallelism (FSDP) kullanımı.
- **XLA** -- TorchXLA kullanımı.
- **MEGATRON_LM** -- Megatron-LM kullanımı.

#### accelerate.utils.DynamoBackend[[accelerate.utils.DynamoBackend]]

```python
accelerate.utils.DynamoBackend(*values)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L612)

Bir dynamo arka ucunu temsil eder (bkz. https://pytorch.org/docs/stable/torch.compiler.html).

Değerler:

- **HAYIR** -- torch dynamo kullanmayın.
- **EAGER** -- Çıkarılan GraphModule'ü çalıştırmak için PyTorch kullanır. Bu, TorchDynamo sorunlarını ayıklarken oldukça faydalıdır.
- **AOT_EAGER** -- Derleyici kullanmadan AotAutograd kullanır, yani AotAutograd'ın çıkarılan ileri ve geri grafikleri için yalnızca PyTorch eager kullanılır. Bu, hata ayıklama için faydalıdır ve hızlanma sağlaması olası değildir.
- **INDUCTOR** -- Kod üretimi yapılmış Triton çekirdeklerinden yararlanarak AotAutograd ve cudagraphs ile TorchInductor arka ucunu kullanır. [Daha fazla bilgi](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747)
- **AOT_TS_NVFUSER** -- AotAutograd/TorchScript ile nvFuser. [Daha fazla bilgi](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **NVPRIMS_NVFUSER** -- PrimTorch ile nvFuser. [Daha fazla bilgi](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **CUDAGRAPHS** -- AotAutograd ile cudagraphs. [Daha fazla bilgi](https://github.com/pytorch/torchdynamo/pull/757)
- **OFI** -- Torchscript optimize_for_inference kullanır. Yalnızca çıkarım. [Daha fazla bilgi](https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html)
- **FX2TRT** -- Çıkarım optimizasyonları için Nvidia TensorRT kullanır. Yalnızca çıkarım. [Daha fazla bilgi](https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst)
- **ONNXRT** -- CPU/GPU üzerinde çıkarım için ONNXRT kullanır. Sadece çıkarım. [Daha fazla bilgi](https://onnxruntime.ai/)
- **TENSORRT** -- TensorRT'nin çıkarım optimizasyonları için çalıştırılmasında ONNXRT kullanır. [Daha fazla bilgi](https://github.com/onnx/onnx-tensorrt)
- **AOT_TORCHXLA_TRACE_ONCE** -- Eğitim için TorchDynamo optimizasyonu ile Pytorch/XLA kullanır. [Daha fazla bilgi](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TORCHXLA_TRACE_ONCE** -- Çıkarım için TorchDynamo optimizasyonu ile Pytorch/XLA kullanır. [Daha fazla bilgi](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TVM** -- Çıkarım optimizasyonları için Apache TVM kullanır. [Daha fazla bilgi](https://tvm.apache.org/)
- **HPU_BACKEND** -- Çıkarım optimizasyonları için HPU arka ucunu kullanır.
- **NEURON** -- Trainium/Inferentia için AWS Neuron arka ucunu kullanır.

#### accelerate.utils.LoggerType[[accelerate.utils.LoggerType]]

```python
accelerate.utils.LoggerType(*values)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L667)

Desteklenen deney izleyici türlerinden birini temsil eder

Değerler:

- **HEPSİ** -- ortamda mevcut olan ve desteklenen tüm izleyiciler
- **TENSORBOARD** -- Deney izleyici olarak TensorBoard
- **WANDB** -- wandb, deney izleyici olarak
- **TRACKIO** -- deney izleyici olarak trackio
- **COMETML** -- comet_ml bir deney izleyici olarak
- **MLFLOW** -- mlflow bir deney izleyici olarak
- **CLEARML** -- clearml bir deney izleyici olarak
- **DVCLIVE** -- dvclive bir deney izleyici olarak
- **SWANLAB** -- deney izleyici olarak swanlab

#### accelerate.utils.PrecisionType[[accelerate.utils.PrecisionType]]

```python
accelerate.utils.PrecisionType(*values)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L695)

Yüzen nokta değerlerinde kullanılan bir hassasiyet türünü temsil eder

Değerler:

- **HAYIR** -- tam hassasiyet (FP32) kullanılarak
- **FP16** -- yarım hassasiyet kullanımı
- **BF16** -- beyin kayan nokta hassasiyeti kullanılarak

#### accelerate.utils.RNGType[[accelerate.utils.RNGType]]

```python
accelerate.utils.RNGType(*values)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L711)

#### accelerate.utils.SageMakerDistributedType[[accelerate.utils.SageMakerDistributedType]]

```python
accelerate.utils.SageMakerDistributedType(*values)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L565)

Dağıtık ortam türünü temsil eder.

Değerler:

- **YOK** -- Dağıtık bir ortam değil, yalnızca tek bir süreç.
- **DATA_PARALLEL** -- sagemaker dağıtık veri paralelliği kullanılarak.
- **MODEL_PARALLEL** -- sagemaker dağıtık model paralelliği kullanımı.

### Kwargs[[accelerate.AutocastKwargs]]

Bunlar, Accelerate'in arka planda yönettiği, PyTorch ekosistemi genelindeki belirli etkileşimler için yapılandırılabilir argümanlardır.

#### accelerate.AutocastKwargs[[accelerate.AutocastKwargs]]

```python
accelerate.AutocastKwargs(enabled: bool = True, cache_enabled: bool | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L104)

Bu nesneyi [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) içinde kullanarak `torch.autocast`'in nasıl davrandığını özelleştirebilirsiniz. Her bir argüman hakkında daha fazla bilgi için bu [bağlam yöneticisinin](https://pytorch.org/docs/stable/amp.html#torch.autocast) dokümantasyonuna bakın.

Örnek:

```python
from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

kwargs = AutocastKwargs(cache_enabled=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.DistributedDataParallelKwargs[[accelerate.DistributedDataParallelKwargs]]

```python
accelerate.DistributedDataParallelKwargs(dim: int = 0, broadcast_buffers: bool = True, bucket_cap_mb: int = 25, find_unused_parameters: bool = False, check_reduction: bool = False, gradient_as_bucket_view: bool = False, static_graph: bool = False, comm_hook: DDPCommunicationHookType = <DDPCommunicationHookType.NO: 'no'>, comm_wrapper: typing.Literal[<DDPCommunicationHookType.NO: 'no'>, <DDPCommunicationHookType.FP16: 'fp16'>, <DDPCommunicationHookType.BF16: 'bf16'>] = <DDPCommunicationHookType.NO: 'no'>, comm_state_option: dict = <factory>)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L146)

Bu nesneyi, modelinizin `torch.nn.parallel.DistributedDataParallel` ile nasıl sarılacağını özelleştirmek için [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) içinde kullanın. Her bir argüman hakkında daha fazla bilgi için bu [sarıcının](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) dokümantasyonuna bakın.

Örnek:

```python
from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.GradScalerKwargs[[accelerate.GradScalerKwargs]]

```python
accelerate.GradScalerKwargs(init_scale: float = 65536.0, growth_factor: float = 2.0, backoff_factor: float = 0.5, growth_interval: int = 2000, enabled: bool = True)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L224)

Bu nesneyi, karma hassasiyet davranışını, özellikle kullanılan `torch.amp.GradScaler` veya `torch.cuda.amp.GradScaler`'ın nasıl oluşturulacağını özelleştirmek için [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) içinde kullanın. Her argüman hakkında daha fazla bilgi için bu [ölçekleyicinin](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) belgelerine bakın.

Örnek:

```python
from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

kwargs = GradScalerKwargs(backoff_factor=0.25)
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.InitProcessGroupKwargs[[accelerate.InitProcessGroupKwargs]]

```python
accelerate.InitProcessGroupKwargs(backend: str | None = 'nccl', init_method: str | None = None, timeout: datetime.timedelta | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L249)

Dağıtık süreçlerin başlatılmasını özelleştirmek için bu nesneyi [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) içinde kullanın. Her bir argüman hakkında daha fazla bilgi için bu [yöntemin](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) belgelerine başvurun.

Not: `timeout` değeri `None` olarak ayarlanırsa, varsayılan değer `backend`'in nasıl ayarlandığına göre belirlenir.

```python
from datetime import timedelta
from accelerate import Accelerator
from accelerate.utils import InitProcessGroupKwargs

kwargs = InitProcessGroupKwargs(timeout=timedelta(seconds=800))
accelerator = Accelerator(kwargs_handlers=[kwargs])
```

#### accelerate.utils.KwargsHandler[[accelerate.utils.KwargsHandler]]

```python
accelerate.utils.KwargsHandler()
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L59)

Bir dataclass için `to_kwargs()` metodunu uygulayan dahili mixin.

#### to_kwargs[[accelerate.utils.KwargsHandler.to_kwargs]]

```python
to_kwargs()
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L67)

Bu sınıfın varsayılan değerlerinden farklı değerlere sahip öznitelikleri içeren bir sözlük döndürür.

## Eklentiler[[accelerate.DeepSpeedPlugin]]

Bunlar, [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator) nesnesine iletilebilecek eklentilerdir. Dokümantasyonun başka bölümlerinde tanımlanmış olsalar da, kolaylık olması açısından hepsi burada görüntülenebilir:

#### accelerate.DeepSpeedPlugin[[accelerate.DeepSpeedPlugin]]

```python
accelerate.DeepSpeedPlugin(hf_ds_config: Any = None, gradient_accumulation_steps: int = None, gradient_clipping: float = None, zero_stage: int = None, is_train_batch_min: bool = True, offload_optimizer_device: str = None, offload_param_device: str = None, offload_optimizer_nvme_path: str = None, offload_param_nvme_path: str = None, zero3_init_flag: bool = None, zero3_save_16bit_model: bool = None, transformer_moe_cls_names: str = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1044)

**Parametreler:**

hf_ds_config (`Any`, varsayılan `None`) : DeepSpeed yapılandırma dosyasına, sözlüğe veya `accelerate.utils.deepspeed.HfDeepSpeedConfig` sınıfının bir nesnesine yol.

gradient_accumulation_steps (`int`, varsayılan `None`) : Optimizer durumlarının güncellenmeden önce gradyanların biriktirileceği adım sayısı. Ayarlanmazsa, `Accelerator`'dan gelen değer doğrudan kullanılır.

gradient_clipping (`float`, varsayılan `None`) : Belirtilen değerle gradyan kırpma (gradient clipping) etkinleştirilir.

zero_stage (`int`, varsayılan `None`) : Olası seçenekler 0, 1, 2, 3'tür. Varsayılan değer ortam değişkeninden alınır.

is_train_batch_min (`bool`, varsayılan `True`) : Hem eğitim hem de değerlendirme veri yükleyicileri belirtilirse, bu parametre `train_batch_size` değerini belirler.

offload_optimizer_device (`str`, varsayılan `None`) : Olası seçenekler none|cpu|nvme. Yalnızca ZeRO Aşamaları 2 ve 3 ile geçerlidir.

offload_param_device (`str`, varsayılan `None`) : Olası seçenekler none|cpu|nvme. Yalnızca ZeRO Stage 3 ile geçerlidir.

offload_optimizer_nvme_path (`str`, varsayılan `None`) : Olası seçenekler /nvme|/local_nvme. Yalnızca ZeRO Stage 3 ile geçerlidir.

offload_param_nvme_path (`str`, varsayılan `None`) : Olası seçenekler /nvme|/local_nvme. Yalnızca ZeRO Stage 3 ile geçerlidir.

zero3_init_flag (`bool`, varsayılan `None`) : 16-bit modelin kaydedilip kaydedilmeyeceğini belirtmek için bayrak. Yalnızca ZeRO Stage-3 ile geçerlidir.

zero3_save_16bit_model (`bool`, varsayılan `None`) : 16-bit modelin kaydedilip kaydedilmeyeceğini belirtmek için bayrak. Yalnızca ZeRO Stage-3 ile geçerlidir.

transformer_moe_cls_names (`str`, varsayılan `None`) : Virgülle ayrılmış Transformers MoE katman sınıfı adları listesi (büyük/küçük harfe duyarlı). Örneğin, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention`, `JetMoEBlock` vb.

Bu eklenti, DeepSpeed'i entegre etmek için kullanılır.

#### deepspeed_config_process[[accelerate.DeepSpeedPlugin.deepspeed_config_process]]

```python
deepspeed_config_process(prefix = '', mismatches = None, config = None, must_match = True, **kwargs)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1280)

DeepSpeed yapılandırmasını, kwargs'daki değerlerle işleyin.

#### seç[[accelerate.DeepSpeedPlugin.select]]

```python
select(_from_accelerator_state: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1435)

HfDeepSpeedWeakref'in mevcut deepspeed eklenti yapılandırmasını kullanmasını ayarlar

#### accelerate.FullyShardedDataParallelPlugin[[accelerate.FullyShardedDataParallelPlugin]]

```python
accelerate.FullyShardedDataParallelPlugin(fsdp_version: int = None, sharding_strategy: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') = None, reshard_after_forward: str | ForwardRef('torch.distributed.fsdp.ShardingStrategy') | bool = None, backward_prefetch: str | ForwardRef('torch.distributed.fsdp.BackwardPrefetch') | None = None, mixed_precision_policy: dict | str | ForwardRef('torch.distributed.fsdp.MixedPrecision') | ForwardRef('torch.distributed.fsdp.MixedPrecisionPolicy') | None = None, auto_wrap_policy: typing.Callable | typing.Literal['transformer_based_wrap', 'size_based_wrap', 'no_wrap'] | None = None, cpu_offload: bool | ForwardRef('torch.distributed.fsdp.CPUOffload') | ForwardRef('torch.distributed.fsdp.CPUOffloadPolicy') = None, ignored_modules: collections.abc.Iterable[torch.nn.Module] | str | None = None, state_dict_type: str | ForwardRef('torch.distributed.fsdp.StateDictType') = None, state_dict_config: ForwardRef('torch.distributed.fsdp.FullStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedStateDictConfig') | None = None, optim_state_dict_config: ForwardRef('torch.distributed.fsdp.FullOptimStateDictConfig') | ForwardRef('torch.distributed.fsdp.ShardedOptimStateDictConfig') | None = None, limit_all_gathers: bool = True, use_orig_params: bool | None = None, param_init_fn: typing.Callable[[torch.nn.Module], NoneType] | None = None, sync_module_states: bool | None = None, forward_prefetch: bool = None, activation_checkpointing: bool = None, activation_checkpointing_offload: bool = None, cpu_ram_efficient_loading: bool = None, transformer_cls_names_to_wrap: list[str] | None = None, min_num_params: int | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1467)

**Parametreler:**

fsdp_version (`int`, varsayılan `1`) : Kullanılacak FSDP sürümü. Varsayılan olarak 1'dir. 2 olarak ayarlanırsa, başlatıcı yapılandırmanın FSDP2 biçimine dönüştürülmesini bekler.

sharding_strategy (`Union[str, torch.distributed.fsdp.ShardingStrategy]`, varsayılan `'FULL_SHARD'`) : Kullanılacak sharding stratejisi. `str` veya `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy` örneği olmalıdır. `reshard_after_forward` lehine kullanımdan kaldırılmıştır.

reshard_after_forward (`Union[str, torch.distributed.fsdp.ShardingStrategy, bool]`, `fsdp_version=1` için varsayılan `'FULL_SHARD'` ve `fsdp_version=2` için `True`) : Kullanılacak sharding stratejisi. `fsdp_version` 2 olarak ayarlandıysa bool olmalı, aksi halde `str` veya `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy` örneği olmalıdır.

backward_prefetch (`Union[str, torch.distributed.fsdp.BackwardPrefetch]`, varsayılan olarak `'NO_PREFETCH'`) : Kullanılacak geriye dönük ön yükleme (backward prefetch) stratejisi. Bir `str` veya `torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch` örneği olmalıdır.

mixed_precision_policy (`Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]`, varsayılan olarak `None`) : FullyShardedDataParallel ile karma hassasiyetli eğitimi etkinleştirmek için bir yapılandırma. Bir `dict` geçiriliyorsa, aşağıdaki anahtarlara sahip olmalıdır: `param_dtype`, `reduce_dtype` ve `buffer_dtype`; `fsdp_version` 2 olarak ayarlanırsa `torch.distributed.fsdp.MixedPrecisionPolicy` örneği de olabilir. Bir `str` geçiriliyorsa, aşağıdaki değerlerden biri olmalıdır: fp8, fp16, bf16, fp32 ve `param_dtype`, `reduce_dtype` ile `buffer_dtype` değerlerini ayarlamak için kullanılır.

auto_wrap_policy (`Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), defaults to `NO_WRAP`) : A callable or string specifying a policy to recursively wrap layers with FSDP. If a string, it must be one of `transformer_based_wrap`, `size_based_wrap`, or `no_wrap`. See `torch.distributed.fsdp.wrap.size_based_wrap_policy` for a direction on what it should look like.

cpu_offload (`Union[bool, torch.distributed.fsdp.CPUOffload, torch.distributed.fsdp.CPUOffloadPolicy]`, varsayılan `False`) : Parametrelerin CPU'ya aktarılıp aktarılmayacağı. `fsdp_version` 2 olarak ayarlandıysa, bir `bool` veya `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload` ya da `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy` örneği olmalıdır.

ignored_modules (`Optional[Union[Iterable[torch.nn.Module], str]]`, varsayılan `None`) : FSDP ile sarmalanırken yoksayılacak modüllerin listesi. Bir dize geçirildiğinde, modüller adlarına göre regex fullmatch kullanılarak eşleştirilir. `fsdp_version` 2 olarak ayarlanırsa, modüller parametrelere dönüştürülür ve kullanılır.

state_dict_type (`Union[str, torch.distributed.fsdp.StateDictType]`, varsayılan `'FULL_STATE_DICT'`) : Kullanılacak state dict türü. Bir dize ise, `full_state_dict`, `local_state_dict` veya `sharded_state_dict` değerlerinden biri olmalıdır.

state_dict_config (`Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]`, varsayılan olarak `None`) : Kullanılacak state dict yapılandırması. Geçirilmezse `state_dict_type` değerine göre belirlenir.

optim_state_dict_config (`Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]`, varsayılan olarak `None`) : Kullanılacak optim state dict yapılandırması. Geçirilmezse `state_dict_type` değerine göre belirlenir.

limit_all_gathers (`bool`, varsayılan `True`) : FSDP'nin, çok fazla havada all-gather işlemi oluşmasını önlemek için CPU iş parçacığını açıkça senkronize etmesini sağlar. Bu bool, yalnızca all-gather'ları zamanlayan parçalı stratejileri etkiler. Bunu etkinleştirmek, CUDA malloc yeniden deneme sayısını azaltmaya yardımcı olabilir.

use_orig_params (`bool`, varsayılan `False`) : Optimizör için orijinal parametrelerin kullanılıp kullanılmayacağı.

param_init_fn (`Optional[Callable[[torch.nn.Module], None]`, varsayılan `None`) : Şu anda meta cihazda olan modüllerin gerçek bir cihaza nasıl başlatılacağını belirten bir `Callable[torch.nn.Module] -> None`. Yalnızca `sync_module_states` `True` olduğunda geçerlidir. Varsayılan olarak, modül üzerinde `to_empty` çağıran bir `lambda`'dır.

sync_module_states (`bool`, varsayılan `False`) : Başlatma sonrasında tüm rank'lar arasında parametrelerin aynı olmasını sağlamak için her bir ayrı sarmalanmış FSDP biriminin modül parametrelerini rank 0'dan yayımlaması (broadcast) gerekir mi. `cpu_ram_efficient_loading` `True` değilse varsayılan `False`'dir; `cpu_ram_efficient_loading` `True` ise bu ayar zorunlu olarak etkinleştirilir.

forward_prefetch (`bool`, varsayılan `False`) : FSDP'nin ileri geçiş sırasında çalışırken bir sonraki all-gather işlemini açıkça önceden yüklemesini (prefetch) belirtir. Yalnızca Statik grafiklerle kullanın.

activation_checkpointing (`bool`, varsayılan `False`) : Belirli katmanların aktivasyonlarını temizleyip geriye doğru yayılım sırasında yeniden hesaplayarak bellek kullanımını azaltan bir teknik. Bu, fiilen ek hesaplama süresini azaltılmış bellek kullanımıyla takas eder.

cpu_ram_efficient_loading (`bool`, varsayılan `None`) : True ise, yalnızca ilk süreç önceden eğitilmiş model kontrol noktasını yüklerken diğer tüm süreçlerin ağırlıkları boş kalır. Yalnızca Transformers için geçerlidir. Bunu kullanırken `sync_module_states` `True` olmalıdır.

transformer_cls_names_to_wrap (`Optional[List[str]]`, varsayılan `None`) : Sarılacak transformer katman sınıf adlarının listesi. Yalnızca `auto_wrap_policy` `transformer_based_wrap` olduğunda geçerlidir.

min_num_params (`Optional[int]`, varsayılan `None`) : Bir modülün sarılabilmesi için sahip olması gereken en az parametre sayısı. Yalnızca `auto_wrap_policy` `size_based_wrap` olduğunda geçerlidir.

Bu eklenti, tamamen parçalı veri paralelliğini etkinleştirmek için kullanılır.

#### set_auto_wrap_policy[[accelerate.FullyShardedDataParallelPlugin.set_auto_wrap_policy]]

```python
set_auto_wrap_policy(model)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1943)

`model` verildiğinde, iletilen politika ve `transformer_cls_to_wrap` kullanılıp kullanılamayacağına dayanarak bir `auto_wrap_policy` oluşturur.

#### set_mixed_precision[[accelerate.FullyShardedDataParallelPlugin.set_mixed_precision]]

```python
set_mixed_precision(mixed_precision, buffer_autocast = False, override = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1983)

FSDP için karma hassasiyet politikasını ayarlar

#### set_state_dict_type[[accelerate.FullyShardedDataParallelPlugin.set_state_dict_type]]

```python
set_state_dict_type(state_dict_type = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L1898)

`StateDictType`'ye göre state dict yapılandırmasını ayarlayın.

#### validate_mixed_precision_policy[[accelerate.FullyShardedDataParallelPlugin.validate_mixed_precision_policy]]

```python
validate_mixed_precision_policy()
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2031)

Karışık hassasiyet politikasını doğrular; gerekmediyse import'ları getirmemek için soyutlanmıştır.

#### accelerate.utils.GradientAccumulationPlugin[[accelerate.utils.GradientAccumulationPlugin]]

```python
accelerate.utils.GradientAccumulationPlugin(num_steps: int = None, adjust_scheduler: bool = True, sync_with_dataloader: bool = True, sync_each_batch: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L903)

**Parametreler:**

num_steps (`int`) : Gradyanların biriktirileceği adım sayısı.

adjust_scheduler (`bool`, *isteğe bağlı*, varsayılan `True`) : Biriktilen adım sayısını dikkate alarak zamanlayıcı adımlarını ayarlayıp ayarlamayacağı. Kullanılan zamanlayıcı gradyan birikimi için ayarlanmadıysa `True` olmalıdır.

sync_with_dataloader (`bool`, *isteğe bağlı*, varsayılan `True`) : Dataloader'ın sonunda gradyan ayarlarını senkronize edip etmeyeceğini belirtir.

sync_each_batch (`bool`, *isteğe bağlı*) : Gradyanların her veri grubunda ayarlanmasının senkronize edilip edilmeyeceğini belirtir. Dağıtık eğitimde gradyan biriktirme kullanılırken `True` olarak ayarlamak, hızdan ödün verilerek bellek gereksinimlerini azaltabilir.

Gradyan birikimi davranışını yapılandırmak için bir eklenti. [Accelerator](/docs/accelerate/main/tr/package_reference/accelerator#accelerate.Accelerator)'a yalnızca `gradient_accumulation_plugin` veya `gradient_accumulation_steps`'ten birini iletebilirsiniz. İkisini birden iletmek bir hata oluşturur.

Örnek:

```python
from accelerate.utils import GradientAccumulationPlugin

gradient_accumulation_plugin = GradientAccumulationPlugin(num_steps=2)
accelerator = Accelerator(gradient_accumulation_plugin=gradient_accumulation_plugin)
```

#### accelerate.utils.MegatronLMPlugin[[accelerate.utils.MegatronLMPlugin]]

```python
accelerate.utils.MegatronLMPlugin(tp_degree: int = None, pp_degree: int = None, use_custom_fsdp: bool = None, overlap_cpu_optimizer_d2h_h2d: bool = None, no_load_optim: bool = None, eod_mask_loss: bool = None, no_save_optim: bool = None, optimizer_cpu_offload: bool = None, use_precision_aware_optimizer: bool = None, decoder_last_pipeline_num_layers: int = None, recompute_granularity: str = None, recompute_method: str = None, recompute_num_layers: int = None, attention_backend: bool = None, expert_model_parallel_size: int = None, context_parallel_size: int = None, attention_dropout: float = None, hidden_dropout: float = None, attention_softmax_in_fp32: bool = None, expert_tensor_parallel_size: int = None, calculate_per_token_loss: bool = None, use_rotary_position_embeddings: bool = None, num_micro_batches: int = None, gradient_clipping: float = None, sequence_parallelism: bool = None, recompute_activations: bool = None, use_distributed_optimizer: bool = None, pipeline_model_parallel_split_rank: int = None, num_layers_per_virtual_pipeline_stage: int = None, is_train_batch_min: str = True, train_iters: int = None, train_samples: int = None, weight_decay_incr_style: str = 'constant', start_weight_decay: float = None, end_weight_decay: float = None, lr_decay_style: str = 'linear', lr_decay_iters: int = None, lr_decay_samples: int = None, lr_warmup_iters: int = None, lr_warmup_samples: int = None, lr_warmup_fraction: float = None, min_lr: float = 0, consumed_samples: list[int] = None, no_wd_decay_cond: typing.Callable | None = None, scale_lr_cond: typing.Callable | None = None, lr_mult: float = 1.0, megatron_dataset_flag: bool = False, seq_length: int = None, encoder_seq_length: int = None, decoder_seq_length: int = None, tensorboard_dir: str = None, set_all_logging_options: bool = False, eval_iters: int = 100, eval_interval: int = 1000, return_logits: bool = False, custom_train_step_class: typing.Any | None = None, custom_train_step_kwargs: dict[str, typing.Any] | None = None, custom_model_provider_function: typing.Callable | None = None, custom_prepare_model_function: typing.Callable | None = None, custom_megatron_datasets_provider_function: typing.Callable | None = None, custom_get_batch_function: typing.Callable | None = None, custom_loss_function: typing.Callable | None = None, other_megatron_args: dict[str, typing.Any] | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2213)

**Parametreler:**

tp_degree (`int`, varsayılan `None`) : Tensor paralelliği derecesi.

pp_degree (`int`, varsayılan `None`) : Pipeline paralelliği derecesi.

num_micro_batches (`int`, varsayılan `None`) : Mikro toplu iş sayısı.

gradient_clipping (`float`, varsayılan `None`) : Küresel L2 Normuna dayalı gradyan kırpma değeri (devre dışı bırakmak için 0).

sequence_parallelism (`bool`, varsayılan `None`) : Sıralı paralelliği etkinleştirir.

recompute_activations (`bool`, varsayılan `None`) : Seçici aktivasyon yeniden hesaplama özelliğini etkinleştirir.

use_distributed_optimizer (`bool`, varsayılan `None`) : Dağıtık optimizasyonu etkinleştirir.

pipeline_model_parallel_split_rank (`int`, varsayılan `None`) : Kodlayıcının ve çözücünün ayrılacağı sıra.

num_layers_per_virtual_pipeline_stage (`int`, varsayılan `None`) : Sanal boru hattı aşaması başına katman sayısı.

is_train_batch_min (`str`, varsayılan `True`) : Hem tran hem de eval dataloader'ları belirtilirse, bu parametre `micro_batch_size` değerini belirler.

train_iters (`int`, varsayılan `None`) : Tüm eğitim çalışmaları boyunca eğitilecek toplam örnek sayısı. `MegatronLMDummyScheduler` kullanırken train-iters veya train-samples parametrelerinden birinin sağlanması gerektiğini unutmayın.

train_samples (`int`, varsayılan `None`) : Tüm eğitim çalışmaları boyunca eğitilecek toplam örnek sayısı. `MegatronLMDummyScheduler` kullanırken train-iters veya train-samples parametrelerinden birinin sağlanması gerektiğini unutmayın.

weight_decay_incr_style (`str`, varsayılan `'constant'`) : Ağırlık azaltma artışı fonksiyonu. seçenekler=["constant", "linear", "cosine"].

start_weight_decay (`float`, varsayılan `None`) : L2 düzenlemesi için başlangıç ağırlık çürümesi katsayısı.

end_weight_decay (`float`, varsayılan `None`) : L2 düzenlemesi için çalışmanın sonundaki ağırlık çürümesi katsayısı.

lr_decay_style (`str`, varsayılan `'linear'`) : Öğrenme oranı azaltma fonksiyonu. seçenekler=['constant', 'linear', 'cosine'].

lr_decay_iters (`int`, varsayılan `None`) : Öğrenme oranı azalması için yineleme sayısı. None ise varsayılan olarak `train_iters` kullanılır.

lr_decay_samples (`int`, varsayılan `None`) : Öğrenme oranı azalması için örnek sayısı. None ise varsayılan olarak `train_samples` kullanılır.

lr_warmup_iters (`int`, varsayılan `None`) : Öğrenme hızının doğrusal olarak ısınma (warmup) için kaç yineleme boyunca uygulanacağı.

lr_warmup_samples (`int`, varsayılan `None`) : Öğrenme hızının doğrusal olarak ısınma (warmup) için örnek sayısı.

lr_warmup_fraction (`float`, varsayılan `None`) : Öğrenme hızının doğrusal olarak ısınma için kullanıldığı lr-warmup-(iters/samples) oranı.

min_lr (`float`, varsayılan `0`) : Öğrenme hızı için minimum değer. Zamanlayıcı, bu eşiğin altındaki değerleri kırpma (clip) işlemine tabi tutar.

consumed_samples (`List`, varsayılan olarak `None`) : `accelerator.prepare` çağrısına giden dataloader'larla aynı sırada tüketilen örnek sayısı.

no_wd_decay_cond (`Optional`, varsayılan `None`) : Ağırlık çürümesini devre dışı bırakma koşulu.

scale_lr_cond (`Optional`, varsayılan `None`) : Öğrenme hızını ölçeklemek için koşul.

lr_mult (`float`, varsayılan `1.0`) : Öğrenme hızı çarpanı.

megatron_dataset_flag (`bool`, varsayılan `False`) : Veri setinin biçiminin Megatron-LM Indexed/Cached/MemoryMapped biçimini izleyip izlemediğini belirtir.

seq_length (`int`, varsayılan `None`) : İşlenecek maksimum dizi uzunluğu.

encoder_seq_length (`int`, varsayılan `None`) : Kodlayıcı için işlenecek maksimum dizi uzunluğu.

decoder_seq_length (`int`, varsayılan `None`) : Dekoder için işlenecek maksimum dizi uzunluğu.

tensorboard_dir (`str`, varsayılan `None`) : Tensorboard günlüklerinin kaydedileceği yol.

set_all_logging_options (`bool`, varsayılan `False`) : Tüm günlük kaydı seçeneklerinin ayarlanıp ayarlanmayacağı.

eval_iters (`int`, varsayılan `100`) : Doğrulama/test için değerlendirme amacıyla çalıştırılacak yineleme sayısı.

eval_interval (`int`, varsayılan `1000`) : Doğrulama kümesinde değerlendirme çalıştırma aralığı.

return_logits (`bool`, varsayılan `False`) : Modelden logitlerin döndürülüp döndürülmeyeceğini belirtir.

custom_train_step_class (`Optional`, varsayılan `None`) : Özel eğitim adımı sınıfı.

custom_train_step_kwargs (`Optional`, varsayılan `None`) : Özel eğitim adım kwargs'ları.

custom_model_provider_function (`Optional`, varsayılan `None`) : Özel model sağlayıcı işlevi.

custom_prepare_model_function (`Optional`, varsayılan `None`) : Özel model hazırlama işlevi.

custom_megatron_datasets_provider_function (`Optional`, varsayılan `None`) : Özel megatron train_valid_test veri seti sağlayıcı işlevi.

custom_get_batch_function (`Optional`, varsayılan `None`) : Özel get batch işlevi.

custom_loss_function (`Optional`, varsayılan `None`) : Özel kayıp fonksiyonu.

other_megatron_args (`Optional`, varsayılan `None`) : Diğer Megatron-LM argümanları. Lütfen Megatron-LM'e başvurun.

Tensor, pipeline, sequence ve data paralelliğini etkinleştirmek için Megatron-LM eklentisi. Ayrıca seçici aktivasyon yeniden hesaplama ve optimize edilmiş füzyonlu çekirdekleri etkinleştirmek için.

#### accelerate.utils.TorchDynamoPlugin[[accelerate.utils.TorchDynamoPlugin]]

```python
accelerate.utils.TorchDynamoPlugin(backend: DynamoBackend = None, mode: str = None, fullgraph: bool = None, dynamic: bool = None, options: Any = None, disable: bool = False, use_regional_compilation: bool = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L955)

**Parametreler:**

backend (`DynamoBackend`, varsayılan olarak `None`) : Geçerli bir Dynamo arka ucu. Daha fazla ayrıntı için https://pytorch.org/docs/stable/torch.compiler.html adresine bakın.

mode (`str`, varsayılan `None`) : Olası seçenekler 'default', 'reduce-overhead' veya 'max-autotune'.

fullgraph (`bool`, varsayılan `None`) : Modelin birkaç alt grafik olarak bölünmesinin kabul edilebilir olup olmadığı.

dynamic (`bool`, varsayılan `None`) : İzleme için dinamik şekil kullanılıp kullanılmayacağı.

options (`Any`, varsayılan `None`) : Arka uca iletilecek seçeneklerin sözlüğü.

disable (`bool`, varsayılan `False`) : Test için torch.compile() işlevini devre dışı bırakır

use_regional_compilation (`bool`, varsayılan `None`) : `GPT2LMHeadModel` örneğinde olduğu gibi, aynı sınıfın tekrarlanan bloklarını hedef alarak ve bunları sıralı derleyerek derleyicinin önbelleğine erişmek suretiyle torch.compile() için soğuk başlatma derleme süresini azaltmak için kullanın. Bu örnekte tekrarlanan blok/sınıf `GPT2Block`'tür ve `model.transformer.h[0]` olarak erişilebilir. Modelin geri kalanı (ör. model.lm_head) ayrı derlenir.

Bu eklenti, bir modeli PyTorch 2.0 ile derlemek için kullanılır

## Yapılandırmalar[[accelerate.utils.BnbQuantizationConfig]]

Bunlar, yapılandırılabilir ve ilgili entegrasyona aktarılabilecek sınıflardır

#### accelerate.utils.BnbQuantizationConfig[[accelerate.utils.BnbQuantizationConfig]]

```python
accelerate.utils.BnbQuantizationConfig(load_in_8bit: bool = False, llm_int8_threshold: float = 6.0, load_in_4bit: bool = False, bnb_4bit_quant_type: str = 'fp4', bnb_4bit_use_double_quant: bool = False, bnb_4bit_compute_dtype: str = 'fp16', torch_dtype: dtype = None, skip_modules: list[str] = None, keep_in_fp32_modules: list[str] = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L2952)

**Parametreler:**

load_in_8bit (`bool`, varsayılan `False`) : 8bit kuantizasyonu etkinleştirir.

llm_int8_threshold (`float`, varsayılan `6.0`) : Çizgi eşiği değeri. Yalnızca `load_in_8bit=True` olduğunda geçerlidir.

load_in_4bit (`bool`, varsayılan `False`) : 4bit kuantizasyonu etkinleştirir.

bnb_4bit_quant_type (`str`, varsayılan `fp4`) : `bnb.nn.Linear4Bit` katmanlarındaki kuantizasyon veri türünü ayarlar. Seçenekler {'fp4','np4'}.

bnb_4bit_use_double_quant (`bool`, varsayılan `False`) : İlk kuantizasyondan gelen kuantizasyon sabitlerinin yeniden kuantize edildiği iç içe kuantizasyonu etkinleştirir.

bnb_4bit_compute_dtype (`bool`, varsayılan `fp16`) : Bu, giriş zamanından farklı olabilecek hesaplama türünü ayarlar. Örneğin, girdiler fp32 olabilir, ancak hızlandırma için hesaplama bf16 olarak ayarlanabilir. Seçenekler {'fp32','fp16','bf16'}.

torch_dtype (`torch.dtype`, varsayılan olarak `None`) : Bu, kalan kuantize edilmemiş katmanların dtype değerini ayarlar. `bitsandbytes` kütüphanesi, 8 bitlik modeller için değerin `torch.float16` olarak ayarlanmasını ve 4 bitlik modeller için hesaplama dtype'ı ile aynı dtype'ın kullanılmasını önerir.

skip_modules (`List[str]`, varsayılan `None`) : Kuantize etmediğimiz modüllerin açık bir listesi. Bu modüllerin dtype'ı `torch_dtype` olacaktır.

keep_in_fp32_modules (`List`, varsayılan olarak `None`) : Kuantize etmediğimiz modüllerin açık bir listesi. Bunları `torch.float32` olarak tutuyoruz.

BitsAndBytes 4bit ve 8bit kuantizasyonunu etkinleştirmek için bir eklenti

#### accelerate.DataLoaderConfiguration[[accelerate.DataLoaderConfiguration]]

```python
accelerate.DataLoaderConfiguration(split_batches: bool = False, dispatch_batches: bool = None, even_batches: bool = True, use_seedable_sampler: bool = False, data_seed: int = None, non_blocking: bool = False, use_stateful_dataloader: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L745)

**Parametreler:**

split_batches (`bool`, varsayılan `False`) : Hızlandırıcının, veri yükleyicilerin (dataloaders) ürettiği partileri (batches) cihazlar arasında bölüp bölmeyeceğini belirtir. `True` ise, kullanılan dağıtık süreç türü ne olursa olsun, fiilen kullanılan parti boyutu aynı olacaktır; ancak bu değer, kullandığınız `num_processes` sayısının tam bir katı olmalıdır. `False` ise, fiilen kullanılan parti boyutu, betiğinizde ayarlanan değerin süreç sayısı ile çarpımı olacaktır.

dispatch_batches (`bool`, varsayılan `None`) : `True` olarak ayarlanırsa, Accelerator tarafından hazırlanan dataloader yalnızca ana süreçte (main process) üzerinden iterasyon yapılır ve ardından toplar (batches) bölünerek her sürece yayınlanır. Altta yatan veri seti bir `IterableDataset` olan `DataLoader` için varsayılan olarak `True`, diğer durumlarda `False` olur.

even_batches (`bool`, varsayılan `True`) : `True` olarak ayarlanırsa, tüm süreçler arasındaki toplam parti boyutu veri setini tam olarak bölmediğinde, partinin tüm işçiler arasında eşit şekilde bölünebilmesi için veri setinin başındaki örnekler kopyalanır.

use_seedable_sampler (`bool`, varsayılan `False`) : Tamamen tohumlanabilir rastgele bir örnekleyici (`data_loader.SeedableRandomSampler`) kullanılıp kullanılmayacağını belirtir. Farklı bir örneklemleme tekniği kullanarak eğitim sonuçlarının tamamen yeniden üretilebilir olmasını sağlar. Tohumdan tohuma sonuçlar farklılık gösterebilir, ancak birden fazla farklı tohumu karşılaştırmak için kullanıldığında ortalama farklar ihmal edilebilir düzeydedir. En iyi sonuçlar için [set_seed()](/docs/accelerate/main/tr/package_reference/utilities#accelerate.utils.set_seed) ile birlikte çalıştırılmalıdır.

data_seed (`int`, varsayılan `None`) : `use_seedable_sampler` kullanıldığında altta yatan üreteç için kullanılacak tohum. `None` ise, üreteç torch'taki mevcut varsayılan tohumu kullanır.

non_blocking (`bool`, varsayılan `False`) : `True` olarak ayarlanırsa, Accelerator tarafından hazırlanan dataloader, engelleyici olmayan hosttan cihaza aktarmaları kullanacak ve bu da dataloader iletişimi ile hesaplama arasında daha iyi bir örtüşme sağlayacaktır. Doğru çalışması için hazırlanan dataloader'da `pin_memory`'nin `True` olarak ayarlanması önerilir.

use_stateful_dataloader (`bool`, varsayılan `False`) : `True` olarak ayarlanırsa, Accelerator tarafından hazırlanan dataloader, [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader) tarafından desteklenir. Bunun için StatefulDataLoader'i destekleyen 0.8.0 veya daha yüksek bir `torchdata` sürümünün yüklü olması gerekir.

`accelerator.prepare` çağrılırken dataloader ile ilgili öğeler için yapılandırma.

#### accelerate.utils.ProjectConfiguration[[accelerate.utils.ProjectConfiguration]]

```python
accelerate.utils.ProjectConfiguration(project_dir: str = None, logging_dir: str = None, automatic_checkpoint_naming: bool = False, total_limit: int = None, iteration: int = 0, save_on_each_node: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L840)

**Parametreler:**

project_dir (`str`, varsayılan `None`) : Verileri depolamak için bir dizin yolu.

logging_dir (`str`, varsayılan `None`) : Yerel olarak uyumlu kayıt tutucuların günlüklerini depolamak için bir dizin yolu. None ise, varsayılan olarak `project_dir` kullanılır.

automatic_checkpoint_naming (`bool`, varsayılan `False`) : Kaydedilen durumların otomatik olarak yinelemeli olarak adlandırılıp adlandırılmayacağı.

total_limit (`int`, varsayılan `None`) : Tutulacak toplam kaydedilmiş durumların maksimum sayısı.

iteration (`int`, varsayılan `0`) : Güncel kaydetme yinelemesi.

save_on_each_node (`bool`, varsayılan `False`) : Çoklu düğümlü dağıtık eğitim sırasında modellerin ve kontrol noktalarının her düğümde mi yoksa yalnızca ana düğümde mi kaydedileceğini belirtir.

İç proje ihtiyaçlarına göre Accelerator nesnesi için yapılandırma.

#### set_directories[[accelerate.utils.ProjectConfiguration.set_directories]]

```python
set_directories(project_dir: str | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/dataclasses.py#L892)

`self.project_dir` ve `self.logging_dir` değerlerini uygun değerlere ayarlar.

## Ortam Değişkenleri

Farklı kullanım senaryoları için etkinleştirilebilen ortam değişkenleri şunlardır

* `ACCELERATE_DEBUG_MODE` (`str`): accelerate'ın hata ayıklama modunda çalıştırılıp çalıştırılmayacağını belirtir. Daha fazla bilgi [burada](../basic_tutorials/troubleshooting#hanging-code-and-timeout-errors) mevcuttur.

## Veri Manipülasyonu ve İşlemleri[[accelerate.utils.broadcast]]

Bunlar, dağıtık süreçlerde kullanılabilen ancak aynı `torch` işlemlerini taklit eden veri işlemlerini içerir.

#### accelerate.utils.broadcast[[accelerate.utils.broadcast]]

```python
accelerate.utils.broadcast(tensor, from_process: int = 0)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L583)

**Parametreler:**

tensor (`torch.Tensor` içeren iç içe geçmiş liste/tuple/sözlük) : Toplanacak veri.

from_process (`int`, *isteğe bağlı*, varsayılan 0) : Verinin gönderileceği süreç

**Dönüş:**

`tensor` ile aynı veri yapısı, tüm tensörler uygun cihaza yayınlanmış (broadcast) olarak.

Gömülü bir liste/tuple/dictionary içindeki tensörleri, tensörü tüm cihazlara özyinelemeli olarak yayınlayın.

#### accelerate.utils.broadcast_object_list[[accelerate.utils.broadcast_object_list]]

```python
accelerate.utils.broadcast_object_list(object_list, from_process: int = 0)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L658)

**Parametreler:**

object_list (list of picklable objects) : Yayınlanacak nesnelerin listesi. Bu liste yerinde (inplace) değiştirilecektir.

from_process (`int`, *isteğe bağlı*, varsayılan 0) : Verinin gönderileceği süreç.

**Dönüş:**

0 numaralı süreçten gelen nesneleri içeren aynı liste.

Bir süreçten diğer süreçlere picklenebilir nesneler listesini yayınlayın.

#### accelerate.utils.concatenate[[accelerate.utils.concatenate]]

```python
accelerate.utils.concatenate(data, dim = 0)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L702)

**Parametreler:**

data (tensör listelerinden oluşan iç içe geçmiş liste/tuple/sözlük `torch.Tensor`) : Birleştirilecek veri.

dim (`int`, *isteğe bağlı*, varsayılan 0) : Birleştirme işlemi için boyut.

**Dönüş:**

`data` ile aynı veri yapısı, tüm tensörler birleştirilmiş halde.

Aynı şekle sahip tensör listelerinden oluşan iç içe geçmiş bir liste/tuple/sözlükteki tensörleri özyinelemeli olarak birleştirir. Tek bir veri grubu varsa, olduğu gibi döndürülür.

#### accelerate.utils.convert_outputs_to_fp32[[accelerate.utils.convert_outputs_to_fp32]]

```python
accelerate.utils.convert_outputs_to_fp32(model_forward)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L919)

#### accelerate.utils.convert_to_fp32[[accelerate.utils.convert_to_fp32]]

```python
accelerate.utils.convert_to_fp32(tensor)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L872)

**Parametreler:**

tensor (`torch.Tensor` içeren iç içe geçmiş liste/tuple/sözlük) : FP16/BF16'dan FP32'ye dönüştürülecek veri.

**Dönüş:**

`tensor` ile aynı veri yapısı, FP16/BF16 hassasiyetindeki tüm tensörler FP32'ye dönüştürülmüş olarak.

Gömülü liste/tuple/sözlük içindeki tensör elemanlarını FP16/BF16 hassasiyetinden FP32'ye özyinelemeli olarak dönüştürür.

#### accelerate.utils.gather[[accelerate.utils.gather]]

```python
accelerate.utils.gather(tensor)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L414)

**Parametreler:**

tensor (`torch.Tensor` içeren iç içe geçmiş liste/tuple/sözlük) : Toplanacak veri.

**Dönüş:**

`tensor` ile aynı veri yapısı, tüm tensörler uygun cihaza gönderilir.

Tüm cihazlardan, iç içe geçmiş bir liste/tuple/dictionary içindeki tensörleri özyinelemeli olarak topla.

#### accelerate.utils.gather_object[[accelerate.utils.gather_object]]

```python
accelerate.utils.gather_object(object: Any)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L495)

**Parametreler:**

object (nested list/tuple/dictionary of picklable object) : Toplanacak veri.

**Dönüş:**

`object` ile aynı veri yapısı, tüm cihazlara gönderilen tüm nesnelerle birlikte.

Tüm cihazlardan, nesnelerin iç içe geçmiş bir liste/tuple/sözlüğündeki nesneyi özyinelemeli olarak toplayın.

#### accelerate.utils.get_grad_scaler[[accelerate.utils.get_grad_scaler]]

```python
accelerate.utils.get_grad_scaler(distributed_type: DistributedType = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2090)

**Parametreler:**

distributed_type (`DistributedType`, *isteğe bağlı*, varsayılan olarak None) : Dağıtık ortamın türü.

kwargs : Kullanılan `GradScaler` yapıcısı için ek argümanlar.

Ortamın durumuna göre doğru `GradScaler` uygulamasını başlatıp döndüren genel bir yardımcı işlev.

#### accelerate.utils.get_mixed_precision_context_manager[[accelerate.utils.get_mixed_precision_context_manager]]

```python
accelerate.utils.get_mixed_precision_context_manager(native_amp: bool = False, autocast_kwargs: AutocastKwargs = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L2047)

**Parametreler:**

native_amp (`bool`, *isteğe bağlı*, varsayılan olarak False) : Karma hassasiyetin gerçekten etkinleştirilip etkinleştirilmediği.

Karışık hassasiyetin otomatik dökümünü (autocast) için bir bağlam yöneticisi (context manager) döndürür

#### accelerate.utils.listify[[accelerate.utils.listify]]

```python
accelerate.utils.listify(data)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L270)

**Parametreler:**

data (`torch.Tensor` içeren iç içe list/tuple/sözlük) : Normal sayılara dönüştürülecek veri.

**Dönüş:**

`data` ile aynı veri yapısı, ancak `torch.Tensor` yerine sayı listeleri içerir.

İç içe geçmiş bir liste/tuple/sözlük içinde tensörleri özyinelemeli olarak bulur ve bunları sayı listesine dönüştürür.

#### accelerate.utils.pad_across_processes[[accelerate.utils.pad_across_processes]]

```python
accelerate.utils.pad_across_processes(tensor, dim = 0, pad_index = 0, pad_first = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L732)

**Parametreler:**

tensor (`torch.Tensor` içeren iç içe geçmiş liste/tuple/sözlük) : Toplanacak veri.

dim (`int`, *isteğe bağlı*, varsayılan 0) : Dolgu yapılacak boyut.

pad_index (`int`, *isteğe bağlı*, varsayılan 0) : Dolgu için kullanılacak değer.

pad_first (`bool`, *isteğe bağlı*, varsayılan `False`) : Başta mı sonda mı dolgu yapılacağı.

Tüm cihazlardaki iç içe geçmiş liste/tuple/sözlük yapısındaki tensörleri, güvenli bir şekilde toplanabilmeleri için aynı boyuta kadar özyinelemeli olarak dolgu (padding) ile doldurun.

#### accelerate.utils.recursively_apply[[accelerate.utils.recursively_apply]]

```python
accelerate.utils.recursively_apply(func, data, *args, test_type = <function is_torch_tensor at 0x7fe445cc1010>, error_on_other_type = False, **kwargs)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L85)

**Parametreler:**

func (`callable`) : Özyinelemeli olarak uygulanacak işlev.

data (`test_type` tarafından kabul edilen nesnelerin iç içe geçmiş listesi/tuplüsü/sözlüğü) : `func` uygulamasının yapılacağı veri

- ***args** : Paket açılmış verilere uygulandığında `func`'ye iletilecek konumsal argümanlar.

test_type (`Callable[[Any], bool]`, *isteğe bağlı*, varsayılan `is_torch_tensor`) : `func`'ün belirli bir yaprak nesneye uygulanıp uygulanmayacağını belirleyen öngörü.

error_on_other_type (`bool`, *isteğe bağlı*, varsayılan `False`) : `data` açıldıktan sonra, `test_type` fonksiyonunun `False` döndürdüğü bir nesne elde edilirse hata döndürülüp döndürülmeyeceğini belirtir. `False` ise, fonksiyon bu tür nesneleri değiştirmeden bırakır.

- ****kwargs** (ek anahtar kelime argümanları, *isteğe bağlı*) : Paket açılmış verilere uygulandığında `func`'ye iletilecek anahtar kelime argümanları.

**Dönüş:**

`test_type` fonksiyonu `True` dönen her nesneye `func` uygulandığında, `data` ile aynı veri yapısına sahip sonuç.

Belirli bir temel türden oluşan iç içe geçmiş bir liste/tuple/sözlük veri yapısında bir fonksiyonu özyinelemeli olarak uygulayın.

#### accelerate.utils.reduce[[accelerate.utils.reduce]]

```python
accelerate.utils.reduce(tensor, reduction = 'mean', scale = 1.0)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L828)

**Parametreler:**

tensor (`torch.Tensor` içeren iç içe geçmiş liste/tuple/sözlük) : Azaltılacak veri.

reduction (`str`, *isteğe bağlı*, varsayılan `"mean"`) : Bir azaltma yöntemi. "mean", "sum", "max" veya "none" olabilir

scale (`float`, *isteğe bağlı*) : reduce işleminden sonra uygulanacak varsayılan ölçekleme değeri, yalnızca XLA üzerinde geçerlidir.

**Dönüş:**

`data` ile aynı veri yapısı, tüm tensörler indirgenmiş olarak.

Verilen bir işlemin ortalamasıyla, tensör listelerinden oluşan iç içe geçmiş bir liste/tuple/sözlükteki tensörleri tüm süreçler boyunca özyinelemeli olarak indirger.

#### accelerate.utils.send_to_device[[accelerate.utils.send_to_device]]

```python
accelerate.utils.send_to_device(tensor, device, non_blocking = False, skip_keys = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L136)

**Parametreler:**

tensor (`torch.Tensor` içeren iç içe geçmiş liste/tuple/sözlük) : Belirli bir cihaza gönderilecek veri.

device (`torch.device`) : Verinin gönderileceği cihaz.

non_blocking (`bool`, *isteğe bağlı*, varsayılan `False`) : `True` ise, cihaza aktarım asenkron olarak gerçekleştirilir; bu, veri hareketini hesaplama ile eş zamanlı hale getirebilir. Yalnızca cihaz bunu desteklediğinde etkilidir (ör. CUDA).

skip_keys (`str` veya `List[str]`, *isteğe bağlı*) : Değerleri verilen `device`'e gönderilmemesi gereken bir `tensor` sözlüğündeki anahtar veya anahtar listesi. Bu anahtarlara sahip girdiler, orijinal cihazlarında bırakılır.

**Dönüş:**

`tensor` ile aynı veri yapısı, tüm tensörler uygun cihaza gönderilir.

Bir tensör iç içe listesi/tuplü/dizisinin öğelerini verilen bir cihaza özyinelemeli olarak gönderir.

#### accelerate.utils.slice_tensors[[accelerate.utils.slice_tensors]]

```python
accelerate.utils.slice_tensors(data, tensor_slice, process_index = None, num_processes = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/operations.py#L682)

**Parametreler:**

data (`torch.Tensor` içeren iç içe geçmiş liste/tuple/sözlük) : Dilimlenecek veri.

tensor_slice (`slice`) : Alınacak dilim.

**Dönüş:**

`data` ile aynı veri yapısı, tüm tensör dilimleri içerir.

Gömülü bir liste/tuple/tensor sözlüğünde özyinelemeli olarak bir dilim alır.

## Ortam Kontrolleri[[accelerate.utils.is_bf16_available]]

Bu işlevler, işletim sistemi hakkında bilgi, destekleyebildiği özellikler ve belirli bağımlılıkların kurulu olup olmadığı dahil olmak üzere, mevcut çalışma ortamının durumunu kontrol eder.

#### accelerate.utils.is_bf16_available[[accelerate.utils.is_bf16_available]]

```python
accelerate.utils.is_bf16_available(ignore_tpu = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/imports.py#L157)

bf16'nin desteklenip desteklenmediğini kontrol eder, isteğe bağlı olarak TPU'yu yok sayar

#### accelerate.utils.is_mps_available[[accelerate.utils.is_mps_available]]

```python
accelerate.utils.is_mps_available(min_version = '1.12')
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/imports.py#L325)

MPS cihazının kullanılabilir olup olmadığını kontrol eder. Gerekli minimum sürüm 1.12'dir.

#### accelerate.utils.is_npu_available[[accelerate.utils.is_npu_available]]

```python
accelerate.utils.is_npu_available(check_device = False)
```

`torch_npu`'nun yüklü olup olmadığını ve ortamda bir NPU bulunup bulunmadığını kontrol eder

#### accelerate.utils.is_torch_version[[accelerate.utils.is_torch_version]]

```python
accelerate.utils.is_torch_version(operation: str, version: str)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/versions.py#L46)

**Parametreler:**

operation (`str`) : `">"` veya `"<="` gibi bir operatörün dize gösterimi

version (`str`) : PyTorch'un

Mevcut PyTorch sürümünü, bir işlemle verilen bir referansla karşılaştırır.

#### accelerate.utils.is_torch_xla_available[[accelerate.utils.is_torch_xla_available]]

```python
accelerate.utils.is_torch_xla_available(check_is_tpu = False, check_is_gpu = False)
```

`torch_xla`'nın kullanılabilir olup olmadığını kontrol edin. torch xla yüklü bir ortamda yerel bir pytorch işi eğitmek için USE_TORCH_XLA değerini false olarak ayarlayın.

#### accelerate.utils.is_xpu_available[[accelerate.utils.is_xpu_available]]

```python
accelerate.utils.is_xpu_available(check_device = False)
```

Stok PyTorch (>=2.7) üzerinden XPU hızlandırmasının ve ortamda bir XPU'nun mevcut olup olmadığını kontrol eder

## Ortam Manipülasyonu[[accelerate.utils.patch_environment]]

#### accelerate.utils.patch_environment[[accelerate.utils.patch_environment]]

```python
accelerate.utils.patch_environment(**kwargs)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L390)

`os.environ`'a eklenen ve çıkışta kaldırılan her bir anahtar kelime argümanını içeren bir bağlam yöneticisi.

`kwargs` içindeki değerleri dizilere dönüştürür ve tüm anahtarları büyük harfe çevirir.

Örnek:

```python
>>> import os
>>> from accelerate.utils import patch_environment

>>> with patch_environment(FOO="bar"):
...     print(os.environ["FOO"])  # prints "bar"
>>> print(os.environ["FOO"])  # raises KeyError
```

#### accelerate.utils.clear_environment[[accelerate.utils.clear_environment]]

```python
accelerate.utils.clear_environment()
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L355)

Ortam değişkenlerini geçici olarak temizleyecek bir bağlam yöneticisi.

Bu bağlam sonlandığında, önceki ortam değişkenleri geri yüklenecektir.

Örnek:

```python
>>> import os
>>> from accelerate.utils import clear_environment

>>> os.environ["FOO"] = "bar"
>>> with clear_environment():
...     print(os.environ)
...     os.environ["FOO"] = "new_bar"
...     print(os.environ["FOO"])
{}
new_bar

>>> print(os.environ["FOO"])
bar
```

#### accelerate.commands.config.default.write_basic_config[[accelerate.commands.config.default.write_basic_config]]

```python
accelerate.commands.config.default.write_basic_config(mixed_precision = 'no', save_location: str = '/home/runner/.cache/huggingface/accelerate/default_config.yaml')
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/commands/config/default.py#L27)

**Parametreler:**

mixed_precision (`str`, *isteğe bağlı*, varsayılan "no") : Kullanılacak Karma Hassasiyet. "no", "fp16" veya "bf16" değerlerinden biri olmalıdır

save_location (`str`, *isteğe bağlı*, varsayılan `default_json_config_file`) : İsteğe bağlı özel kayıt konumu. `accelerate launch` kullanırken `--config_file` parametresine iletilmelidir. Varsayılan konum huggingface önbellek klasörünün içindedir (`~/.cache/huggingface`) ancak `HF_HOME` ortam değişkeni ayarlanarak ve ardından `accelerate/default_config.yaml` yolu izlenerek değiştirilebilir.

Yerel bir makinede, potansiyel olarak birden çok GPU ile kullanılacak temel bir küme yapılandırması oluşturur ve kaydeder. Yalnızca CPU'ya sahip bir makine ise CPU'yu da ayarlar.

🤗 Accelerate'i ilk kez yapılandırırken, `accelerate config` yerine hızlı yapılandırma için [~utils.write_basic_config] kullanılabilir.

#### accelerate.utils.set_numa_affinity[[accelerate.utils.set_numa_affinity]]

```python
accelerate.utils.set_numa_affinity(local_process_index: int, verbose: bool | None = None)
```

**Parametreler:**

local_process_index (int) : Mevcut sunucudaki mevcut sürecin indeksi.

verbose (bool, *isteğe bağlı*) : Her işlem için yeni cpu çekirdeği atamasını yazdırıp yazdırmayacağını belirtir. `ACCELERATE_DEBUG_MODE` etkinleştirilmişse, varsayılan olarak True olur.

Güncel süreci belirli bir NUMA düğümüne atar. İdeal olarak, en verimli çalışma için her düğümde en az 2 CPU bulunması gerekir.

Bu sonuç, çağrılar arasında önbelleğe alınır. Bunu geçersiz kılmak istiyorsanız, lütfen `accelerate.utils.environment.override_numa_afifnity` kullanın.

#### accelerate.utils.environment.override_numa_affinity[[accelerate.utils.environment.override_numa_affinity]]

```python
accelerate.utils.environment.override_numa_affinity(local_process_index: int, verbose: bool | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L272)

**Parametreler:**

local_process_index (int) : Mevcut sunucudaki mevcut sürecin indeksi.

verbose (bool, *isteğe bağlı*) : Her CPU'nun atamasının günlüğe kaydedilip kaydedilmeyeceğini belirtir. `ACCELERATE_DEBUG_MODE` etkinleştirilmişse, varsayılan olarak True olur.

Mevcut işlem için ayarlanmış NUMA yakınlığını (affinity) geçersiz kılar. Bu işlem çok maliyetlidir ve ayarlanacak yakınlığın yeniden hesaplanmasını gerektirir; ideal olarak bunun yerine `utils.environment.set_numa_affinity` kullanılmalıdır.

#### accelerate.utils.purge_accelerate_environment[[accelerate.utils.purge_accelerate_environment]]

```python
accelerate.utils.purge_accelerate_environment(func_or_cls)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/environment.py#L427)

Dekorated sınıf veya fonksiyon tarafından ayarlanan accelerate ortam değişkenlerini temizlemek için dekoratör.

Bazı durumlarda, belirli sınıfların veya fonksiyonların çağrılması, accelerate ortam değişkenlerinin ayarlanmasına ve sonrasında temizlenmemesine neden olabilir. Bir örnek olarak, şunu çağırdığınızda:

TrainingArguments(fp16=True, ...)

Aşağıdaki ortam değişkeni ayarlanacaktır:

ACCELERATE_MIXED_PRECISION=fp16

Bu durum, ortam değişkeninin TrainingArguments(fp16=False) parametresine öncelik tanıması nedeniyle sonraki kodu etkileyebilir. Bu durum, birim testleri için özellikle önemlidir; çünkü her bir testin diğer testler üzerinde yan etkilere sahip olmasını önlemek isteriz. Her testin ardından ortam değişkenlerinin temizlenmesini sağlamak için birim test fonksiyonunu veya tüm sınıfı bu dekoratörle süsleyin. Bu yöntem hem unittest.TestCase hem de normal sınıflar (pytest) için geçerlidir; üst sınıfı süslerken de çalışır.

## Bellek[[accelerate.find_executable_batch_size]]

#### accelerate.find_executable_batch_size[[accelerate.find_executable_batch_size]]

```python
accelerate.find_executable_batch_size(function: callable | None = None, starting_batch_size: int = 128, reduce_batch_size_fn: callable | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/memory.py#L94)

**Parametreler:**

function (`callable`, *isteğe bağlı*) : Sarılacak bir işlev

starting_batch_size (`int`, *isteğe bağlı*) : Belleğe sığdırılmaya çalışılacak parti boyutu

reduce_batch_size_fn (`callable`, *isteğe bağlı*) : Bellek dışı (out-of-memory) hatası sonrasında yeni batch boyutunu belirlemek için kullanılan bir fonksiyon. Sağlanmazsa, her başarısızlıkta batch boyutu 0,9 ile çarpılır. Fonksiyon argüman almaz ve yeni (azaltılmış) batch boyutunu `int` olarak döndürmelidir.

`function` işlevini çalıştırmaya çalışacak temel bir dekoratör. Bellek dışı (out-of-memory) veya CUDNN ile ilgili istisnalar nedeniyle başarısız olursa, parti boyutu 0,9 ile çarpılır ve `function` işlevine aktarılır.

`function`, ilk argümanı olarak bir `batch_size` parametresi almalıdır.

Örnek:

```python
>>> from accelerate.utils import find_executable_batch_size

>>> @find_executable_batch_size(starting_batch_size=128)
... def train(batch_size, model, optimizer):
...     ...

>>> train(model, optimizer)
```

## Modelleme[[accelerate.utils.calculate_maximum_sizes]]

Bu yardımcılar, PyTorch modelleriyle etkileşime girme işleviyle ilgilidir

#### accelerate.utils.calculate_maximum_sizes[[accelerate.utils.calculate_maximum_sizes]]

```python
accelerate.utils.calculate_maximum_sizes(model: Module)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1048)

Modelin ve en büyük katmanının toplam boyutunu hesaplar

#### accelerate.utils.compute_module_sizes[[accelerate.utils.compute_module_sizes]]

```python
accelerate.utils.compute_module_sizes(model: Module, dtype: str | torch.device | None = None, special_dtypes: dict[str, str | torch.device] | None = None, buffers_only: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L675)

Belirtilen bir modelin her alt modülünün boyutunu hesaplayın.

#### accelerate.utils.extract_model_from_parallel[[accelerate.utils.extract_model_from_parallel]]

```python
accelerate.utils.extract_model_from_parallel(model, keep_fp32_wrapper: bool = True, keep_torch_compile: bool = True, recursive: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L286)

**Parametreler:**

model (`torch.nn.Module`) : Çıkarılacak model.

keep_fp32_wrapper (`bool`, *isteğe bağlı*) : Modelden karma hassasiyet kancalarının kaldırılıp kaldırılmayacağı.

keep_torch_compile (`bool`, *isteğe bağlı*) : Derlenmiş modelin sarmalının açılıp açılmayacağını belirtir.

recursive (`bool`, *isteğe bağlı*, varsayılan `False`) : `model` içindeki `module.module` örneklerinin tümünü özyinelemeli olarak çıkarıp, yalnızca üst düzey dağıtık kapsayıcıları değil, alt katmanları da özyinelemeli olarak sarmalayıp sarmalamayacağını belirtir.

**Dönüş:** `torch.nn.Module`

Çıkarılan model.

Bir modeli dağıtık kapsayıcılarından çıkarın.

#### accelerate.utils.get_balanced_memory[[accelerate.utils.get_balanced_memory]]

```python
accelerate.utils.get_balanced_memory(model: Module, max_memory: dict[int | str, int | str] | None = None, no_split_module_classes: list[str] | None = None, dtype: str | torch.dtype | None = None, special_dtypes: dict[str, str | torch.device] | None = None, low_zero: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L916)

**Parametreler:**

model (`torch.nn.Module`) : Analiz edilecek model.

max_memory (`Dict`, *isteğe bağlı*) : Cihaz tanımlayıcısından maksimum belleğe giden bir sözlük. Ayarlanmazsa, kullanılabilir maksimum belleğe varsayılan olarak ayarlanır. Örnek: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *isteğe bağlı*) : Cihazlar arasında asla bölünmemesi gereken katman sınıf adlarının listesi (örneğin, bir artımsal bağlantıya sahip herhangi bir katman).

dtype (`str` veya `torch.dtype`, *isteğe bağlı*) : Verilirse, ağırlıklar yüklendiğinde bu tipe dönüştürülür.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *isteğe bağlı*) : Verilirse, bazı özel ağırlıklar için dikkate alınacak özel dtypes (tüm ağırlıklar için varsayılan olarak kullanılan dtype'ı geçersiz kılar).

low_zero (`bool`, *isteğe bağlı*) : GPU 0 üzerindeki ağırlık sayısını en aza indirir; bu, GPU 0'un diğer işlemler (Transformers generate fonksiyonu gibi) için kullanılması durumunda kullanışlıdır.

Kullanılabilir her GPU'nun kullanımını dengeleyecek şekilde [infer_auto_device_map()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.infer_auto_device_map) için bir `max_memory` sözlüğü hesaplayın.

Tüm hesaplama, model parametrelerinin boyutları ve dtypes'leri analiz edilerek yapılır. Sonuç olarak, model meta cihazında bulunabilir (`init_empty_weights` bağlam yöneticisi içinde başlatılmış gibi).

#### accelerate.utils.get_max_layer_size[[accelerate.utils.get_max_layer_size]]

```python
accelerate.utils.get_max_layer_size(modules: list[tuple[str, torch.nn.Module]], module_sizes: dict[str, int], no_split_module_classes: list[str])
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L729)

**Parametreler:**

modules (`List[Tuple[str, torch.nn.Module]]`) : Maksimum katman boyutunu belirlemek istediğimiz adlandırılmış modüllerin listesi.

module_sizes (`Dict[str, int]`) : Her katman adını boyutuna eşleyen bir sözlük (`compute_module_sizes` tarafından oluşturulur).

no_split_module_classes (`List[str]`) : Bölünmesini istemediğimiz katmanlar için sınıf adlarının listesi.

**Dönüş:** `Tuple[int, List[str]]`

O maksimum boyutu gerçekleştiren katman adlarının listesiyle birlikte bir katmanın maksimum boyutu.

Adlandırılmış modüllerin listesini tarayacak ve bir tam katman tarafından kullanılan maksimum boyutu döndürecek yardımcı işlev. Bir katmanın tanımı şudur:
- doğrudan alt öğesi olmayan bir modül (yalnızca parametreler ve tamponlar)
- sınıf adı `no_split_module_classes` listesinde yer alan bir modül

#### accelerate.infer_auto_device_map[[accelerate.infer_auto_device_map]]

```python
accelerate.infer_auto_device_map(model: Module, max_memory: dict[int | str, int | str] | None = None, no_split_module_classes: list[str] | None = None, dtype: str | torch.dtype | None = None, special_dtypes: dict[str, str | torch.dtype] | None = None, verbose: bool = False, clean_result: bool = True, offload_buffers: bool = False, fallback_allocation: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1278)

**Parametreler:**

model (`torch.nn.Module`) : Analiz edilecek model.

max_memory (`Dict`, *isteğe bağlı*) : Cihaz tanımlayıcısından maksimum belleğe giden bir sözlük. Ayarlanmazsa, kullanılabilir maksimum belleğe varsayılan olarak ayarlanır. Örnek: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *isteğe bağlı*) : Cihazlar arasında asla bölünmemesi gereken katman sınıf adlarının listesi (örneğin, bir artımsal bağlantıya sahip herhangi bir katman).

dtype (`str` veya `torch.dtype`, *isteğe bağlı*) : Verilirse, ağırlıklar yüklendiğinde bu tipe dönüştürülür.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *isteğe bağlı*) : Verilirse, bazı özel ağırlıklar için dikkate alınacak özel dtypes (tüm ağırlıklar için varsayılan olarak kullanılan dtype'ı geçersiz kılar).

verbose (`bool`, *isteğe bağlı*, varsayılan `False`) : Fonksiyon device_map oluştururken hata ayıklama ifadelerinin sağlanıp sağlanmayacağı.

clean_result (`bool`, *isteğe bağlı*, varsayılan `True`) : Aynı cihaza giden tüm alt modülleri bir araya getirerek sonuçlanan device_map'i temizler.

offload_buffers (`bool`, *isteğe bağlı*, varsayılan `False`) : CPU veya sabit diske aktarılan katmanlarda, parametrelerin yanı sıra tamponların da aktarılıp aktarılmayacağını belirtir.

fallback_allocation (`bool`, *isteğe bağlı*, varsayılan `False`) : Düzenli atama başarısız olduğunda, BFS kullanarak boyut sınırına sığan bir modül atamayı denemek için kullanılır.

Belirli bir model için GPU'lara öncelik vererek, ardından CPU'ya ve son olarak diske taşınacak şekilde bir cihaz haritası hesaplayın, böylece:
- GPU'lardan herhangi birinin kullanılabilir bellek sınırını aşmıyoruz.
- CPU'ya taşınma gerekiyorsa, GPU 0'da, CPU'ya taşınan katmanlar arasında en büyük boyuta sahip olanı geri yerleştirmek için her zaman yer kalır.
- CPU'ya taşınma gerekiyorsa, CPU'da kullanılabilir RAM'i aşmayız.
- disk'e offload yapılması gerekiyorsa, disk'e offload edilen katmanlar arasında en büyük boyuta sahip olanı CPU'ya geri koymak için CPU'da her zaman yer kalır.

Tüm hesaplama, model parametrelerinin boyutları ve dtypes'leri analiz edilerek yapılır. Sonuç olarak, model meta cihazında bulunabilir (`init_empty_weights` bağlam yöneticisi içinde başlatılmış gibi).

#### accelerate.load_checkpoint_in_model[[accelerate.load_checkpoint_in_model]]

```python
accelerate.load_checkpoint_in_model(model: Module, checkpoint: str | os.PathLike, device_map: dict[str, int | str | torch.device] | None = None, offload_folder: str | os.PathLike | None = None, dtype: str | torch.dtype | None = None, offload_state_dict: bool = False, offload_buffers: bool = False, keep_in_fp32_modules: list[str] | None = None, offload_8bit_bnb: bool = False, strict: bool = False, full_state_dict: bool = True, broadcast_from_rank0: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1786)

**Parametreler:**

model (`torch.nn.Module`) : Bir checkpoint yüklemek istediğimiz model.

checkpoint (`str` veya `os.PathLike`) : Yüklenmesi gereken klasör kontrol noktası. Şunlardan biri olabilir: - Tüm model durum sözlüğünü içeren bir dosyanın yolu - Parçalı bir kontrol noktasının dizinini içeren bir `.json` dosyasının yolu - Benzersiz bir `.index.json` dosyasını ve bir kontrol noktasının parçalarını içeren bir klasörün yolu. - Benzersiz bir pytorch_model.bin veya model.safetensors dosyası içeren bir klasörün yolu.

device_map (`Dict[str, Union[int, str, torch.device]]`, *isteğe bağlı*) : Her alt modülün nereye gönderileceğini belirten bir harita. Her parametre/buffer adının ayrı ayrı belirtilmesine gerek yoktur; belirli bir modül adı dahil edildiğinde, onun tüm alt modülleri aynı cihaza gönderilir.

offload_folder (`str` veya `os.PathLike`, *isteğe bağlı*) : `device_map` içinde `"disk"` değeri varsa, ağırlıkların taşınacağı klasör.

dtype (`str` veya `torch.dtype`, *isteğe bağlı*) : Verilirse, ağırlıklar yüklendiğinde bu tipe dönüştürülür.

offload_state_dict (`bool`, *isteğe bağlı*, varsayılan `False`) : `True` ise, CPU durum sözlüğünün ağırlığı + en büyük parça CPU RAM'ine sığmıyorsa, CPU RAM'i dolmaması için CPU durum sözlüğünü geçici olarak sabit diske aktarır.

offload_buffers (`bool`, *isteğe bağlı*, varsayılan `False`) : Disk'e taşınan ağırlıklara tamponların (buffers) dahil edilip edilmeyeceğini belirtir.

keep_in_fp32_modules(`List[str]`, *isteğe bağlı*) : `torch.float32` veri türünde tutulacak modüllerin listesi.

offload_8bit_bnb (`bool`, *isteğe bağlı*) : 8-bit modüllerin cpu/disk'e taşınmasının (offload) etkinleştirilip etkinleştirilmeyeceği.

strict (`bool`, *isteğe bağlı*, varsayılan `False`) : Kontrol noktası state_dict anahtarlarının, modelin state_dict anahtarlarıyla birebir eşleşmesini katı bir şekilde zorlayıp zorlamayacağı.

full_state_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Bu `True` olarak ayarlanırsa, yüklenen state_dict içindeki tüm tensörler toplanır. Yüklenen state_dict içinde ShardedTensor ve DTensor bulunmaz.

broadcast_from_rank0 (`False`, *isteğe bağlı*, varsayılan `False`) : seçenek `True` olduğunda, dağıtık bir `ProcessGroup` başlatılmalıdır. rank0, tam bir state_dict almalı ve state_dict içindeki tensörleri diğer rank'lara tek tek yayınlamalıdır. Diğer rank'lar, tensörleri alır ve modeldeki yerel shard'lara göre (uygulanabilirse) shard'lar.

Bir model içindeki (potansiyel olarak parçalara ayrılmış) kontrol noktasını yükler, ağırlıklar yükendikçe belirli bir cihaza gönderilebilir.

Cihazlar arasında yüklendikten sonra, modelin çalıştırılabilmesi için yine de modelinizde [dispatch_model()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.dispatch_model) çağrısını yapmanız gerekir. Kontrol noktası yükleme ve dağıtım işlemlerini tek bir çağrıda birleştirmek için [load_checkpoint_and_dispatch()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch) kullanın.

#### accelerate.utils.load_offloaded_weights[[accelerate.utils.load_offloaded_weights]]

```python
accelerate.utils.load_offloaded_weights(model, index, offload_folder)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L875)

**Parametreler:**

model (`torch.nn.Module`) : Ağırlıkların yükleneceği model.

index (`dict`) : Modelden taşınan her parametre için parametre adını ve ilgili metadata'yı içeren bir sözlük.

offload_folder (`str`) : Taşıtılan ağırlıkların saklandığı klasör.

Ağırlıkları offload klasöründen modele yükler.

#### accelerate.utils.load_state_dict[[accelerate.utils.load_state_dict]]

```python
accelerate.utils.load_state_dict(checkpoint_file, device_map = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1620)

**Parametreler:**

checkpoint_file (`str`) : Yüklenmesi istenen kontrol noktasının yolu.

device_map (`Dict[str, Union[int, str, torch.device]]`, *isteğe bağlı*) : Her alt modülün nereye gönderileceğini belirten bir harita. Her parametre/buffer adının ayrı ayrı belirtilmesine gerek yoktur; belirli bir modül adı dahil edildiğinde, onun tüm alt modülleri aynı cihaza gönderilir.

Belirtilen dosyadan bir kontrol noktası yükleyin. Kontrol noktası safetensors biçimindeyse ve bir cihaz haritası geçiriliyorsa, ağırlıklar doğrudan GPU üzerinde hızlı bir şekilde yüklenebilir.

#### accelerate.utils.offload_state_dict[[accelerate.utils.offload_state_dict]]

```python
accelerate.utils.offload_state_dict(save_dir: str | os.PathLike, state_dict: dict[str, torch.Tensor])
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/offload.py#L94)

**Parametreler:**

save_dir (`str` veya `os.PathLike`) : state dict'in taşınacağı dizin.

state_dict (`Dict[str, torch.Tensor]`) : Offload edilecek tensörlerin sözlüğü.

Belirtilen klasörde bir durum sözlüğünü (state dict) dışa aktarın.

#### accelerate.utils.retie_parameters[[accelerate.utils.retie_parameters]]

```python
accelerate.utils.retie_parameters(model, tied_params)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L633)

**Parametreler:**

model (`torch.nn.Module`) : Parametrelerin yeniden bağlanacağı model.

tied_params (`List[List[str]]`) : `find_tied_parameters` tarafından elde edilen, eşlenmiş parametre adını parametre adına eşleyen bir haritalama.

Reties, verilen bir modelde bağlantı kopmuşsa (örneğin hook'lar eklenirken) bağlı parametreleri yeniden bağlar.

#### accelerate.utils.set_module_tensor_to_device[[accelerate.utils.set_module_tensor_to_device]]

```python
accelerate.utils.set_module_tensor_to_device(module: Module, tensor_name: str, device: int | str | torch.device, value: torch.Tensor | None = None, dtype: str | torch.dtype | None = None, fp16_statistics: torch.HalfTensor | None = None, tied_params_map: dict[int, dict[torch.device, torch.Tensor]] | None = None, non_blocking: bool = False, clear_cache: bool = True)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L226)

**Parametreler:**

module (`torch.nn.Module`) : Taşınmak istediğimiz tensörün içinde bulunduğu modül.

tensor_name (`str`) : Parametre/buffer'ın tam adı.

device (`int`, `str` veya `torch.device`) : Tensörün ayarlanacağı cihaz.

value (`torch.Tensor`, *isteğe bağlı*) : Tensörün değeri (meta cihazından başka herhangi bir cihaza geçiş yaparken kullanışlıdır).

dtype (`torch.dtype`, *isteğe bağlı*) : Verilirse, parametrenin değeri bu `dtype`'e dönüştürülür. Aksi takdirde, `value`, modeldeki mevcut parametrenin dtype'una dönüştürülür.

fp16_statistics (`torch.HalfTensor`, *opsiyonel*) : Modül üzerinde ayarlanacak fp16 istatistiklerinin listesi, 8 bit model serileştirmesi için kullanılır.

tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], *opsiyonel*, varsayılan olarak `None`) : Güncel veri işaretçilerinin, zaten dağıtılmış bağlı ağırlıkların cihazlara ait sözlüklerine giden bir harita. Belirli bir yürütme cihazı için, bu parametre, belleği çoğaltmak yerine, paylaşılan bir ağırlığın cihazdaki ilk kullanılabilir işaretçisini diğer tüm ağırlıklar için yeniden kullanmak üzere faydalıdır.

non_blocking (`bool`, *isteğe bağlı*, varsayılan `False`) : `True` ise, mümkünse cihaz aktarımı ana bilgisayara göre asenkron olacaktır.

clear_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Tensör cihazda ayarlandıktan sonra cihaz önbelleğinin temizlenip temizlenmeyeceği.

Bir modülün belirli bir cihazda verilen tensörünü (parametre veya tampon) ayarlamak için yardımcı bir işlev (not: `param.to(device)` parametreye bağlı olmayan yeni bir tensör oluşturduğundan, bu işleve ihtiyacımız var).

#### accelerate.utils.get_module_children_bottom_up[[accelerate.utils.get_module_children_bottom_up]]

```python
accelerate.utils.get_module_children_bottom_up(model: Module, return_fqns: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L605)

**Parametreler:**

model (`torch.nn.Module`) : çocuklarının alınacağı model

**Dönüş:** `list[torch.nn.Module]`

`model`'in alt modüllerinin alttan üste sıralı listesi. Son eleman, `model`'in kendisidir.

Modeli alttan üste sırayla gezin ve çocuk modülleri bu sırada döndür.

## Paralel[[accelerate.utils.extract_model_from_parallel]]

Bunlar, paralel çalışırken kullanılması gereken genel yardımcılar arasında yer alır.

#### accelerate.utils.extract_model_from_parallel[[accelerate.utils.extract_model_from_parallel]]

```python
accelerate.utils.extract_model_from_parallel(model, keep_fp32_wrapper: bool = True, keep_torch_compile: bool = True, recursive: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L286)

**Parametreler:**

model (`torch.nn.Module`) : Çıkarılacak model.

keep_fp32_wrapper (`bool`, *isteğe bağlı*) : Modelden karma hassasiyet kancalarının kaldırılıp kaldırılmayacağı.

keep_torch_compile (`bool`, *isteğe bağlı*) : Derlenmiş modelin sarmalının açılıp açılmayacağını belirtir.

recursive (`bool`, *isteğe bağlı*, varsayılan `False`) : `model` içindeki `module.module` örneklerinin tümünü özyinelemeli olarak çıkarıp, yalnızca üst düzey dağıtık kapsayıcıları değil, alt katmanları da özyinelemeli olarak sarmalayıp sarmalamayacağını belirtir.

**Dönüş:** `torch.nn.Module`

Çıkarılan model.

Bir modeli dağıtık kapsayıcılarından çıkarın.

#### accelerate.utils.save[[accelerate.utils.save]]

```python
accelerate.utils.save(obj, f, save_on_each_node: bool = False, safe_serialization: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L424)

**Parametreler:**

obj : Kaydedilecek veri

f : Verileri kaydetmek için kullanılacak dosya (veya dosya benzeri nesne)

save_on_each_node (`bool`, *isteğe bağlı*, varsayılan `False`) : Yalnızca küresel ana süreçte kaydetmek için

safe_serialization (`bool`, *isteğe bağlı*, varsayılan `False`) : `obj`'nin `safetensors` ile mi yoksa geleneksel PyTorch yöntemiyle (bu yöntem `pickle` kullanır) mı kaydedileceğini belirtir.

Verileri diske kaydedin. `torch.save()` yerine kullanın.

#### accelerate.utils.load[[accelerate.utils.load]]

```python
accelerate.utils.load(f, map_location = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L474)

**Parametreler:**

f : Verileri yüklemek için kullanılacak dosya (veya dosya benzeri nesne)

map_location : bir fonksiyon, `torch.device`, string veya depolama konumlarının nasıl yeniden eşleneceğini belirten bir sözlük

- ****kwargs** : `torch.load()` fonksiyonuna iletilecek ek anahtar kelime argümanları.

`torch.load()` ile uyumlu, `torch` sürümü 2.4.0 veya daha yüksekse `weights_only` parametresinin kullanılmasına olanak tanıyan doğrudan ikame. Aksi halde bu parametre yok sayılır.

Ayrıca numpy dizileri için bir istisna ekleyecek (ve ardından kaldıracak)

#### accelerate.utils.wait_for_everyone[[accelerate.utils.wait_for_everyone]]

```python
accelerate.utils.wait_for_everyone()
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/other.py#L376)

Betik içinde bir blokaj noktası tanıtır ve devam etmeden önce tüm süreçlerin bu noktaya ulaştığından emin olur.

Tüm süreçlerin bu talimata ulaşacağından emin olun, aksi takdirde süreçlerinizden biri sonsuza kadar beklemeye geçer.

## Rastgele[[accelerate.utils.set_seed]]

Bu yardımcılar, tüm rastgele durumların ayarlanması ve senkronize edilmesiyle ilgilidir.

#### accelerate.utils.set_seed[[accelerate.utils.set_seed]]

```python
accelerate.utils.set_seed(seed: int, device_specific: bool = False, deterministic: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L34)

**Parametreler:**

seed (`int`) : Ayarlanacak tohum.

device_specific (`bool`, *isteğe bağlı*, varsayılan `False`) : `self.process_index` ile her cihazda tohumu (seed) hafifçe farklılaştırmak için.

deterministic (`bool`, *isteğe bağlı*, varsayılan `False`) : Kullanılabilirse deterministik algoritmaların kullanılıp kullanılmayacağını belirtir. Eğitimi yavaşlatabilir.

`random`, `numpy` ve `torch` içinde tohumu ayarlamak için tekrarlanabilir davranış sağlayan yardımcı işlev.

#### accelerate.utils.synchronize_rng_state[[accelerate.utils.synchronize_rng_state]]

```python
accelerate.utils.synchronize_rng_state(rng_type: str | accelerate.utils.dataclasses.RNGType, generator: torch.Generator | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L63)

Cihaz türüyle tanımlanan yerleşik bir RNG veya mevcut hızlandırıcının RNG'sini senkronize edin.

#### accelerate.synchronize_rng_states[[accelerate.synchronize_rng_states]]

```python
accelerate.synchronize_rng_states(rng_types: list[str | accelerate.utils.dataclasses.RNGType], generator: torch.Generator | None = None)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/random.py#L128)

## PyTorch XLA[[accelerate.utils.install_xla]]

Bunlar, PyTorch'u XLA ile kullanırken faydalı olan yardımcılar arasında yer alır.

#### accelerate.utils.install_xla[[accelerate.utils.install_xla]]

```python
accelerate.utils.install_xla(upgrade: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/torch_xla.py#L20)

**Parametreler:**

upgrade (`bool`, *isteğe bağlı*, varsayılan `False`) : `torch`'ün yükseltilip en son `torch_xla` tekerleklerinin kurulup kurulmayacağını belirtir.

Google Colaboratory'de `torch` sürümüne göre uygun xla tekerleklerini (wheels) yüklemek için yardımcı işlev.

Örnek:

```python
>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)
```

## Model ağırlıklarını yükleme[[accelerate.load_checkpoint_in_model]]

Bunlar, kontrol noktalarını yüklemek için faydalı olan yardımcılar arasında yer alır.

#### accelerate.load_checkpoint_in_model[[accelerate.load_checkpoint_in_model]]

```python
accelerate.load_checkpoint_in_model(model: Module, checkpoint: str | os.PathLike, device_map: dict[str, int | str | torch.device] | None = None, offload_folder: str | os.PathLike | None = None, dtype: str | torch.dtype | None = None, offload_state_dict: bool = False, offload_buffers: bool = False, keep_in_fp32_modules: list[str] | None = None, offload_8bit_bnb: bool = False, strict: bool = False, full_state_dict: bool = True, broadcast_from_rank0: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/modeling.py#L1786)

**Parametreler:**

model (`torch.nn.Module`) : Bir checkpoint yüklemek istediğimiz model.

checkpoint (`str` veya `os.PathLike`) : Yüklenmesi gereken klasör kontrol noktası. Şunlardan biri olabilir: - Tüm model durum sözlüğünü içeren bir dosyanın yolu - Parçalı bir kontrol noktasının dizinini içeren bir `.json` dosyasının yolu - Benzersiz bir `.index.json` dosyasını ve bir kontrol noktasının parçalarını içeren bir klasörün yolu. - Benzersiz bir pytorch_model.bin veya model.safetensors dosyası içeren bir klasörün yolu.

device_map (`Dict[str, Union[int, str, torch.device]]`, *isteğe bağlı*) : Her alt modülün nereye gönderileceğini belirten bir harita. Her parametre/buffer adının ayrı ayrı belirtilmesine gerek yoktur; belirli bir modül adı dahil edildiğinde, onun tüm alt modülleri aynı cihaza gönderilir.

offload_folder (`str` veya `os.PathLike`, *isteğe bağlı*) : `device_map` içinde `"disk"` değeri varsa, ağırlıkların taşınacağı klasör.

dtype (`str` veya `torch.dtype`, *isteğe bağlı*) : Verilirse, ağırlıklar yüklendiğinde bu tipe dönüştürülür.

offload_state_dict (`bool`, *isteğe bağlı*, varsayılan `False`) : `True` ise, CPU durum sözlüğünün ağırlığı + en büyük parça CPU RAM'ine sığmıyorsa, CPU RAM'i dolmaması için CPU durum sözlüğünü geçici olarak sabit diske aktarır.

offload_buffers (`bool`, *isteğe bağlı*, varsayılan `False`) : Disk'e taşınan ağırlıklara tamponların (buffers) dahil edilip edilmeyeceğini belirtir.

keep_in_fp32_modules(`List[str]`, *isteğe bağlı*) : `torch.float32` veri türünde tutulacak modüllerin listesi.

offload_8bit_bnb (`bool`, *isteğe bağlı*) : 8-bit modüllerin cpu/disk'e taşınmasının (offload) etkinleştirilip etkinleştirilmeyeceği.

strict (`bool`, *isteğe bağlı*, varsayılan `False`) : Kontrol noktası state_dict anahtarlarının, modelin state_dict anahtarlarıyla birebir eşleşmesini katı bir şekilde zorlayıp zorlamayacağı.

full_state_dict (`bool`, *isteğe bağlı*, varsayılan `True`) : Bu `True` olarak ayarlanırsa, yüklenen state_dict içindeki tüm tensörler toplanır. Yüklenen state_dict içinde ShardedTensor ve DTensor bulunmaz.

broadcast_from_rank0 (`False`, *isteğe bağlı*, varsayılan `False`) : seçenek `True` olduğunda, dağıtık bir `ProcessGroup` başlatılmalıdır. rank0, tam bir state_dict almalı ve state_dict içindeki tensörleri diğer rank'lara tek tek yayınlamalıdır. Diğer rank'lar, tensörleri alır ve modeldeki yerel shard'lara göre (uygulanabilirse) shard'lar.

Bir model içindeki (potansiyel olarak parçalara ayrılmış) kontrol noktasını yükler, ağırlıklar yükendikçe belirli bir cihaza gönderilebilir.

Cihazlar arasında yüklendikten sonra, modelin çalıştırılabilmesi için yine de modelinizde [dispatch_model()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.dispatch_model) çağrısını yapmanız gerekir. Kontrol noktası yükleme ve dağıtım işlemlerini tek bir çağrıda birleştirmek için [load_checkpoint_and_dispatch()](/docs/accelerate/main/tr/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch) kullanın.

## Kantizasyon[[accelerate.utils.load_and_quantize_model]]

Bunlar, modelin kuantize edilmesi için faydalı olan yardımcılar arasında yer alır.

#### accelerate.utils.load_and_quantize_model[[accelerate.utils.load_and_quantize_model]]

```python
accelerate.utils.load_and_quantize_model(model: Module, bnb_quantization_config: BnbQuantizationConfig, weights_location: str | os.PathLike | None = None, device_map: dict[str, int | str | torch.device] | None = None, no_split_module_classes: list[str] | None = None, max_memory: dict[int | str, int | str] | None = None, offload_folder: str | os.PathLike | None = None, offload_state_dict: bool = False)
```

[Kaynak](https://github.com/huggingface/accelerate/blob/main/src/accelerate/utils/bnb.py#L44)

**Parametreler:**

model (`torch.nn.Module`) : Girdi modeli. Model zaten yüklü olabilir veya meta cihazda olabilir

bnb_quantization_config (`BnbQuantizationConfig`) : bitsandbytes kuantizasyon parametreleri

weights_location (`str` veya `os.PathLike`) : Yüklenecek weights_location klasörü. Şunlardan biri olabilir: - Tüm model durum sözlüğünü içeren bir dosyanın yolu - Parçalı bir kontrol noktasının indeksini içeren bir `.json` dosyasının yolu - Benzersiz bir `.index.json` dosyasını ve bir kontrol noktasının parçalarını içeren bir klasörün yolu. - Benzersiz bir pytorch_model.bin dosyası içeren bir klasörün yolu.

device_map (`Dict[str, Union[int, str, torch.device]]`, *isteğe bağlı*) : Her alt modülün nereye gönderileceğini belirten bir harita. Her parametre/buffer adının ayrı ayrı belirtilmesine gerek yoktur; belirli bir modül adı dahil edildiğinde, onun tüm alt modülleri aynı cihaza gönderilir.

no_split_module_classes (`List[str]`, *isteğe bağlı*) : Cihazlar arasında asla bölünmemesi gereken katman sınıf adlarının listesi (örneğin, bir artımsal bağlantıya sahip herhangi bir katman).

max_memory (`Dict`, *isteğe bağlı*) : Cihaz tanımlayıcısından maksimum belleğe giden bir sözlük. Ayarlanmazsa, kullanılabilir maksimum belleğe varsayılan olarak ayarlanır.

offload_folder (`str` veya `os.PathLike`, *isteğe bağlı*) : `device_map` içinde `"disk"` değeri varsa, ağırlıkların taşınacağı klasör.

offload_state_dict (`bool`, *isteğe bağlı*, varsayılan `False`) : `True` ise, CPU durum sözlüğünün ağırlığı + en büyük parça CPU RAM'ine sığmıyorsa, CPU RAM'i dolmaması için CPU durum sözlüğünü geçici olarak sabit diske aktarır.

**Dönüş:** `torch.nn.Module`

Kantize edilmiş model

Bu fonksiyon, `bnb_quantization_config` ile iletilen ilgili yapılandırma ile girdi modelini nicemler. Model meta cihazındaysa, ağırlıklar `device_map` ile iletilene göre yüklenir ve dağıtılır. Model zaten yüklendiyse, model nicellenir ve GPU'ya yerleştirilir,

