# Fungsi dan kelas utilitas

Berikut adalah berbagai fungsi utilitas yang disediakan oleh 🤗 Accelerate, dikelompokkan berdasarkan kasus penggunaan.

## Konstanta

Konstanta yang digunakan di seluruh 🤗 Accelerate sebagai referensi

Berikut adalah konstanta yang digunakan saat memanfaatkan [Accelerator.save_state()](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator.save_state)

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

Berikut adalah konstanta yang digunakan saat memanfaatkan [Accelerator.save_model()](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator.save_model)

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

## Kelas Data

Ini adalah dataclass dasar yang digunakan di seluruh 🤗 Accelerate dan dapat diteruskan sebagai parameter.

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

Ini adalah dataclass mandiri yang digunakan untuk pemeriksaan, seperti jenis sistem distribusi yang digunakan

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L595)

Mewakili tipe dari lingkungan komputasi.

Nilai:

- **LOCAL_MACHINE** -- perangkat keras klaster privat/kustom.
- **AMAZON_SAGEMAKER** -- Amazon SageMaker sebagai lingkungan komputasi.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L524)

Mewakili jenis lingkungan terdistribusi.

Nilai:

- **TIDAK** -- Bukan lingkungan terdistribusi, hanya satu proses.
- **MULTI_CPU** -- Terdistribusi di beberapa node CPU.
- **MULTI_GPU** -- Terdistribusi di beberapa GPU.
- **MULTI_MLU** -- Terdistribusi di beberapa MLU.
- **MULTI_SDAA** -- Terdistribusi di beberapa SDAA.
- **MULTI_MUSA** -- Terdistribusi di beberapa MUSA.
- **MULTI_NPU** -- Terdistribusi di beberapa NPU.
- **MULTI_XPU** -- Terdistribusi di beberapa XPU.
- **MULTI_HPU** -- Terdistribusi di beberapa HPU.
- **MULTI_NEURON** -- Terdistribusi di beberapa core Neuron.
- **DEEPSPEED** -- Menggunakan DeepSpeed.
- **FSDP** -- Menggunakan Fully Sharded Data Parallelism (FSDP).
- **XLA** -- Menggunakan TorchXLA.
- **MEGATRON_LM** -- Menggunakan Megatron-LM.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L610)

Mewakili backend dynamo (lihat https://pytorch.org/docs/stable/torch.compiler.html).

Nilai:

- **TIDAK** -- Jangan gunakan torch dynamo.
- **EAGER** -- Menggunakan PyTorch untuk menjalankan GraphModule yang diekstrak. Ini sangat berguna dalam debugging masalah TorchDynamo.
- **AOT_EAGER** -- Menggunakan AotAutograd tanpa compiler, yaitu hanya menggunakan PyTorch eager untuk graf forward dan backward yang diekstrak oleh AotAutograd. Ini berguna untuk debugging, dan kecil kemungkinannya memberikan peningkatan kecepatan.
- **INDUCTOR** -- Menggunakan backend TorchInductor dengan AotAutograd dan cudagraphs dengan memanfaatkan kernel Triton yang dibuat melalui codegen. [Baca selengkapnya](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747)
- **AOT_TS_NVFUSER** -- nvFuser dengan AotAutograd/TorchScript. [Baca selengkapnya](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **NVPRIMS_NVFUSER** -- nvFuser dengan PrimTorch. [Baca selengkapnya](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **CUDAGRAPHS** -- cudagraphs dengan AotAutograd. [Baca selengkapnya](https://github.com/pytorch/torchdynamo/pull/757)
- **OFI** -- Menggunakan Torchscript optimize_for_inference. Hanya untuk inferensi. [Baca selengkapnya](https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html)
- **FX2TRT** -- Menggunakan Nvidia TensorRT untuk optimasi inferensi. Hanya untuk inferensi. [Baca selengkapnya](https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst)
- **ONNXRT** -- Menggunakan ONNXRT untuk inferensi pada CPU/GPU. Hanya inferensi. [Baca selengkapnya](https://onnxruntime.ai/)
- **TENSORRT** -- Menggunakan ONNXRT untuk menjalankan TensorRT guna optimasi inferensi. [Baca selengkapnya](https://github.com/onnx/onnx-tensorrt)
- **AOT_TORCHXLA_TRACE_ONCE** -- Menggunakan Pytorch/XLA dengan optimasi TorchDynamo, untuk pelatihan. [Baca selengkapnya](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TORCHXLA_TRACE_ONCE** -- Menggunakan Pytorch/XLA dengan optimasi TorchDynamo, untuk inferensi. [Baca selengkapnya](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TVM** -- Menggunakan Apache TVM untuk optimasi inferensi. [Baca selengkapnya](https://tvm.apache.org/)
- **HPU_BACKEND** -- Menggunakan backend HPU untuk optimasi inferensi.
- **NEURON** -- Menggunakan backend AWS Neuron untuk Trainium/Inferentia.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L665)

Mewakili jenis pelacak eksperimen yang didukung

Nilai:

- **SEMUA** -- semua pelacak yang tersedia di lingkungan yang didukung
- **TENSORBOARD** -- TensorBoard sebagai pelacak eksperimen
- **WANDB** -- wandb sebagai pelacak eksperimen
- **TRACKIO** -- trackio sebagai pelacak eksperimen
- **COMETML** -- comet_ml sebagai pelacak eksperimen
- **MLFLOW** -- mlflow sebagai pelacak eksperimen
- **CLEARML** -- clearml sebagai pelacak eksperimen
- **DVCLIVE** -- dvclive sebagai pelacak eksperimen
- **SWANLAB** -- swanlab sebagai pelacak eksperimen

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L693)

Mewakili jenis presisi yang digunakan pada nilai floating point

Nilai:

- **TIDAK** -- menggunakan presisi penuh (FP32)
- **FP16** -- menggunakan presisi setengah
- **BF16** -- menggunakan presisi brain floating point

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L709)

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L563)

Mewakili jenis lingkungan terdistribusi.

Nilai:

- **TIDAK** -- Bukan lingkungan terdistribusi, hanya satu proses.
- **DATA_PARALLEL** -- menggunakan sagemaker distributed data parallelism.
- **MODEL_PARALLEL** -- menggunakan sagemaker distributed model parallelism.

### Kwargs[[accelerate.AutocastKwargs]]

Ini adalah argumen yang dapat dikonfigurasi untuk interaksi spesifik di seluruh ekosistem PyTorch yang ditangani oleh Accelerate di balik layar.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L104)

Gunakan objek ini di [Accelerator](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator) Anda untuk menyesuaikan perilaku `torch.autocast`. Silakan merujuk ke dokumentasi [context manager](https://pytorch.org/docs/stable/amp.html#torch.autocast) ini untuk informasi lebih lanjut tentang setiap argumen.

Contoh:

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L146)

Gunakan objek ini di [Accelerator](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator) Anda untuk menyesuaikan cara model Anda dibungkus dalam `torch.nn.parallel.DistributedDataParallel`. Silakan merujuk ke dokumentasi [wrapper](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) ini untuk informasi lebih lanjut tentang setiap argumen.

Contoh:

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L224)

Gunakan objek ini di [Accelerator](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator) Anda untuk menyesuaikan perilaku presisi campuran, khususnya bagaimana `torch.amp.GradScaler` atau `torch.cuda.amp.GradScaler` yang digunakan dibuat. Silakan merujuk ke dokumentasi [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) ini untuk informasi lebih lanjut tentang setiap argumen.

Contoh:

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L249)

Gunakan objek ini di [Accelerator](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator) Anda untuk menyesuaikan inisialisasi proses terdistribusi. Silakan merujuk ke dokumentasi [method](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) ini untuk informasi lebih lanjut tentang setiap argumen.

Catatan: Jika `timeout` diatur ke `None`, nilai default akan didasarkan pada pengaturan `backend`.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L59)

Mixin internal yang mengimplementasikan metode `to_kwargs()` untuk dataclass.

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

```python
to_kwargs()
```

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L67)

Mengembalikan kamus yang berisi atribut dengan nilai yang berbeda dari nilai bawaan kelas ini.

## Plugin[[accelerate.DeepSpeedPlugin]]

Ini adalah plugin yang dapat diteruskan ke objek [Accelerator](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator). Meskipun didefinisikan di bagian lain dalam dokumentasi, untuk kenyamanan, semuanya tersedia untuk dilihat di sini:

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1042)

**Parameter:**

hf_ds_config (`Any`, defaultnya `None`) : Path ke file konfigurasi DeepSpeed atau dict atau objek dari kelas `accelerate.utils.deepspeed.HfDeepSpeedConfig`.

gradient_accumulation_steps (`int`, defaultnya `None`) : Jumlah langkah untuk mengakumulasi gradien sebelum memperbarui status optimizer. Jika tidak diatur, akan menggunakan nilai dari `Accelerator` secara langsung.

gradient_clipping (`float`, defaultnya `None`) : Aktifkan pemotongan gradien dengan nilai.

zero_stage (`int`, defaultnya `None`) : Opsi yang mungkin adalah 0, 1, 2, 3. Nilai default akan diambil dari variabel lingkungan.

is_train_batch_min (`bool`, defaultnya `True`) : Jika kedua dataloader train & eval ditentukan, ini akan menentukan `train_batch_size`.

offload_optimizer_device (`str`, defaultnya `None`) : Opsi yang tersedia adalah none|cpu|nvme. Hanya berlaku dengan ZeRO Stages 2 dan 3.

offload_param_device (`str`, defaultnya `None`) : Opsi yang tersedia adalah none|cpu|nvme. Hanya berlaku dengan ZeRO Stage 3.

offload_optimizer_nvme_path (`str`, defaultnya `None`) : Opsi yang tersedia adalah /nvme|/local_nvme. Hanya berlaku dengan ZeRO Stage 3.

offload_param_nvme_path (`str`, defaultnya `None`) : Opsi yang tersedia adalah /nvme|/local_nvme. Hanya berlaku dengan ZeRO Stage 3.

zero3_init_flag (`bool`, defaultnya `None`) : Flag untuk menunjukkan apakah model 16-bit akan disimpan. Hanya berlaku dengan ZeRO Stage-3.

zero3_save_16bit_model (`bool`, defaultnya `None`) : Flag untuk menunjukkan apakah model 16-bit akan disimpan. Hanya berlaku dengan ZeRO Stage-3.

transformer_moe_cls_names (`str`, defaultnya `None`) : Daftar nama kelas layer MoE Transformers yang dipisahkan koma (peka huruf besar/kecil). Misalnya, `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention`, `JetMoEBlock`, dan sebagainya.

Plugin ini digunakan untuk mengintegrasikan DeepSpeed.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1278)

Proses konfigurasi DeepSpeed dengan nilai dari kwargs.

#### pilih[[accelerate.DeepSpeedPlugin.select]]

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1433)

Mengatur HfDeepSpeedWeakref untuk menggunakan konfigurasi plugin deepspeed saat ini

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1465)

**Parameter:**

fsdp_version (`int`, defaultnya `1`) : Versi FSDP yang akan digunakan. Defaultnya 1. Jika diatur ke 2, launcher mengharapkan konfigurasi dikonversi ke format FSDP2.

sharding_strategy (`Union[str, torch.distributed.fsdp.ShardingStrategy]`, defaultnya `'FULL_SHARD'`) : Strategi sharding yang akan digunakan. Harus berupa `str` atau instance dari `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`. Sudah tidak disarankan, gunakan `reshard_after_forward` sebagai gantinya.

reshard_after_forward (`Union[str, torch.distributed.fsdp.ShardingStrategy, bool]`, defaultnya `'FULL_SHARD'` untuk `fsdp_version=1` dan `True` untuk `fsdp_version=2`) : Strategi sharding yang akan digunakan. Harus berupa bool jika `fsdp_version` diatur ke 2, selain itu harus berupa `str` atau instance dari `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`.

backward_prefetch (`Union[str, torch.distributed.fsdp.BackwardPrefetch]`, defaultnya `'NO_PREFETCH'`) : Strategi backward prefetch yang akan digunakan. Harus berupa `str` atau instance dari `torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch`.

mixed_precision_policy (`Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]`, defaultnya `None`) : Konfigurasi untuk mengaktifkan pelatihan presisi campuran dengan FullyShardedDataParallel. Jika memasukkan `dict`, harus memiliki kunci berikut: `param_dtype`, `reduce_dtype`, dan `buffer_dtype`, dapat berupa instance dari `torch.distributed.fsdp.MixedPrecisionPolicy` jika `fsdp_version` diatur ke 2. Jika memasukkan `str`, harus salah satu dari nilai berikut: fp8, fp16, bf16, fp32, dan digunakan untuk mengatur `param_dtype`, `reduce_dtype`, dan `buffer_dtype`.

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]`, defaultnya `False`) : Apakah akan meng-offload parameter ke CPU. Harus berupa `bool` atau instance dari `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload` atau `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy` jika `fsdp_version` diatur ke 2.

ignored_modules (`Optional[Union[Iterable[torch.nn.Module], str]]`, defaultnya `None`) : Daftar modul yang diabaikan saat membungkus dengan FSDP. Saat meneruskan string, modul akan dicocokkan berdasarkan nama menggunakan regex fullmatch. Jika `fsdp_version` diatur ke 2, modul dikonversi menjadi parameter dan digunakan.

state_dict_type (`Union[str, torch.distributed.fsdp.StateDictType]`, defaultnya `'FULL_STATE_DICT'`) : Jenis state dict yang akan digunakan. Jika berupa string, harus salah satu dari `full_state_dict`, `local_state_dict`, atau `sharded_state_dict`.

state_dict_config (`Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]`, defaultnya `None`) : Konfigurasi state dict yang akan digunakan. Ditentukan berdasarkan `state_dict_type` jika tidak diberikan.

optim_state_dict_config (`Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]`, defaultnya `None`) : Konfigurasi state dict optim yang akan digunakan. Ditentukan berdasarkan `state_dict_type` jika tidak diberikan.

limit_all_gathers (`bool`, defaultnya `True`) : Apakah FSDP akan secara eksplisit menyinkronkan thread CPU untuk mencegah terlalu banyak all-gather yang sedang berjalan. Bool ini hanya memengaruhi strategi sharded yang menjadwalkan all-gather. Mengaktifkan ini dapat membantu mengurangi jumlah retry malloc CUDA.

use_orig_params (`bool`, defaultnya `False`) : Apakah akan menggunakan parameter asli untuk optimizer.

param_init_fn (`Optional[Callable[[torch.nn.Module], None]`, defaultnya `None`) : Sebuah `Callable[torch.nn.Module] -> None` yang menentukan bagaimana modul yang saat ini berada di perangkat meta harus diinisialisasi ke perangkat aktual. Hanya berlaku ketika `sync_module_states` adalah `True`. Secara default, ini adalah `lambda` yang memanggil `to_empty` pada modul.

sync_module_states (`bool`, defaultnya `False`) : Apakah setiap unit FSDP yang dibungkus secara individual harus melakukan broadcast parameter modul dari rank 0 untuk memastikan parameter tersebut sama di semua rank setelah inisialisasi. Defaultnya `False` kecuali `cpu_ram_efficient_loading` adalah `True`, maka akan dipaksa diaktifkan.

forward_prefetch (`bool`, defaultnya `False`) : Apakah FSDP akan secara eksplisit melakukan prefetch untuk all-gather berikutnya yang akan datang saat dieksekusi dalam forward pass. Hanya gunakan dengan Static graphs.

activation_checkpointing (`bool`, defaultnya `False`) : Teknik untuk mengurangi penggunaan memori dengan membersihkan aktivasi dari lapisan tertentu dan menghitungnya ulang selama backward pass. Secara efektif, ini menukar waktu komputasi tambahan dengan penggunaan memori yang lebih rendah.

cpu_ram_efficient_loading (`bool`, defaultnya `None`) : Jika True, hanya proses pertama yang memuat checkpoint model pretrained, sementara semua proses lainnya memiliki bobot kosong. Hanya berlaku untuk Transformers. Saat menggunakan ini, `sync_module_states` harus `True`.

transformer_cls_names_to_wrap (`Optional[List[str]]`, defaultnya `None`) : Daftar nama kelas lapisan transformer yang akan dibungkus. Hanya berlaku ketika `auto_wrap_policy` adalah `transformer_based_wrap`.

min_num_params (`Optional[int]`, defaultnya `None`) : Jumlah parameter minimum yang harus dimiliki sebuah modul agar dapat dibungkus. Hanya berlaku ketika `auto_wrap_policy` adalah `size_based_wrap`.

Plugin ini digunakan untuk mengaktifkan fully sharded data parallelism.

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

```python
set_auto_wrap_policy(model)
```

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1941)

Diberikan `model`, membuat `auto_wrap_policy` berdasarkan kebijakan yang diberikan dan apakah kita dapat menggunakan `transformer_cls_to_wrap`

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1981)

Menetapkan kebijakan presisi campuran untuk FSDP

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L1896)

Atur konfigurasi state dict berdasarkan `StateDictType`.

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

```python
validate_mixed_precision_policy()
```

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L2029)

Memvalidasi kebijakan presisi campuran, yang diabstraksikan agar tidak membawa impor jika tidak diperlukan.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L901)

**Parameter:**

num_steps (`int`) : Jumlah langkah untuk mengakumulasi gradien.

adjust_scheduler (`bool`, *opsional*, defaultnya `True`) : Apakah langkah scheduler akan disesuaikan untuk memperhitungkan jumlah langkah yang diakumulasi. Sebaiknya `True` jika scheduler yang digunakan tidak disesuaikan untuk akumulasi gradien.

sync_with_dataloader (`bool`, *opsional*, defaultnya `True`) : Apakah akan menyinkronkan pengaturan gradien saat berada di akhir dataloader.

sync_each_batch (`bool`, *opsional*) : Apakah akan menyinkronkan pengaturan gradien pada setiap batch data. Mengatur ke `True` dapat mengurangi kebutuhan memori saat menggunakan akumulasi gradien dengan pelatihan terdistribusi, dengan mengorbankan kecepatan.

Plugin untuk mengatur perilaku akumulasi gradien. Anda hanya dapat meneruskan salah satu dari `gradient_accumulation_plugin` atau `gradient_accumulation_steps` ke [Accelerator](/docs/accelerate/v1.16.0/id/package_reference/accelerator#accelerate.Accelerator). Meneruskan keduanya akan memicu error.

Contoh:

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L2211)

**Parameter:**

tp_degree (`int`, defaultnya `None`) : Derajat parallelism tensor.

pp_degree (`int`, defaultnya `None`) : Derajat paralelisme pipeline.

num_micro_batches (`int`, defaultnya `None`) : Jumlah micro-batch.

gradient_clipping (`float`, defaultnya `None`) : Nilai pemotongan gradien berdasarkan L2 Norm global (0 untuk menonaktifkan).

sequence_parallelism (`bool`, defaultnya `None`) : Aktifkan paralelisme urutan.

recompute_activations (`bool`, defaultnya `None`) : Aktifkan rekomputasi aktivasi selektif.

use_distributed_optimizer (`bool`, defaultnya `None`) : Aktifkan distributed optimizer.

pipeline_model_parallel_split_rank (`int`, defaultnya `None`) : Rank tempat encoder dan decoder harus dipisahkan.

num_layers_per_virtual_pipeline_stage (`int`, defaultnya `None`) : Jumlah lapisan per tahap pipeline virtual.

is_train_batch_min (`str`, defaultnya `True`) : Jika kedua tran & eval dataloaders ditentukan, ini akan menentukan `micro_batch_size`.

train_iters (`int`, defaultnya `None`) : Total jumlah sampel untuk dilatih di seluruh jalankan pelatihan. Perhatikan bahwa salah satu dari train-iters atau train-samples harus disediakan saat menggunakan `MegatronLMDummyScheduler`.

train_samples (`int`, defaultnya `None`) : Total jumlah sampel untuk dilatih di seluruh jalankan pelatihan. Perhatikan bahwa salah satu dari train-iters atau train-samples harus disediakan saat menggunakan `MegatronLMDummyScheduler`.

weight_decay_incr_style (`str`, defaultnya `'constant'`) : Fungsi inkrementasi weight decay. choices=["constant", "linear", "cosine"].

start_weight_decay (`float`, defaultnya `None`) : Koefisien peluruhan bobot awal untuk regularisasi L2.

end_weight_decay (`float`, defaultnya `None`) : Koefisien peluruhan bobot akhir untuk regularisasi L2.

lr_decay_style (`str`, defaultnya `'linear'`) : Fungsi peluruhan laju belajar. pilihan=['constant', 'linear', 'cosine'].

lr_decay_iters (`int`, defaultnya `None`) : Jumlah iterasi untuk peluruhan laju belajar. Jika None, defaultnya adalah `train_iters`.

lr_decay_samples (`int`, defaultnya `None`) : Jumlah sampel untuk peluruhan laju belajar. Jika None, defaultnya adalah `train_samples`.

lr_warmup_iters (`int`, defaultnya `None`) : Jumlah iterasi untuk melakukan pemanasan linier laju pembelajaran.

lr_warmup_samples (`int`, defaultnya `None`) : Jumlah sampel untuk pemanasan linier laju pembelajaran.

lr_warmup_fraction (`float`, defaultnya `None`) : Fraksi dari lr-warmup-(iters/samples) untuk melakukan pemanasan linear learning rate.

min_lr (`float`, defaultnya `0`) : Nilai minimum untuk learning rate. Scheduler memotong nilai di bawah ambang batas ini.

consumed_samples (`List`, defaultnya `None`) : Jumlah sampel yang dikonsumsi dengan urutan yang sama seperti dataloaders untuk panggilan `accelerator.prepare`.

no_wd_decay_cond (`Optional`, defaults to `None`) : Kondisi untuk menonaktifkan weight decay.

scale_lr_cond (`Optional`, defaults to `None`) : Kondisi untuk menskalakan learning rate.

lr_mult (`float`, defaultnya `1.0`) : Pengali laju pembelajaran.

megatron_dataset_flag (`bool`, defaultnya `False`) : Apakah format dataset mengikuti format Indexed/Cached/MemoryMapped Megatron-LM.

seq_length (`int`, defaultnya `None`) : Panjang maksimum urutan yang akan diproses.

encoder_seq_length (`int`, defaultnya `None`) : Panjang maksimum urutan untuk diproses oleh encoder.

decoder_seq_length (`int`, defaultnya `None`) : Panjang maksimum urutan untuk diproses oleh decoder.

tensorboard_dir (`str`, defaultnya `None`) : Path untuk menyimpan log tensorboard.

set_all_logging_options (`bool`, defaultnya `False`) : Apakah akan mengatur semua opsi log.

eval_iters (`int`, defaultnya `100`) : Jumlah iterasi yang dijalankan untuk evaluasi validasi/tes.

eval_interval (`int`, defaultnya `1000`) : Interval antara menjalankan evaluasi pada set validasi.

return_logits (`bool`, defaultnya `False`) : Apakah akan mengembalikan logits dari model.

custom_train_step_class (`Optional`, defaultnya `None`) : Kelas langkah pelatihan kustom.

custom_train_step_kwargs (`Optional`, defaultnya `None`) : kwargs langkah pelatihan kustom.

custom_model_provider_function (`Optional`, defaultnya `None`) : Fungsi penyedia model kustom.

custom_prepare_model_function (`Optional`, defaultnya `None`) : Fungsi prepare model kustom.

custom_megatron_datasets_provider_function (`Optional`, defaults to `None`) : Fungsi penyedia dataset megatron train_valid_test kustom.

custom_get_batch_function (`Optional`, defaultnya `None`) : Fungsi get batch kustom.

custom_loss_function (`Optional`, defaults to `None`) : Fungsi loss kustom.

other_megatron_args (`Optional`, defaultnya `None`) : Argumen Megatron-LM lainnya. Silakan merujuk ke Megatron-LM.

Plugin untuk Megatron-LM guna memungkinkan paralelisme tensor, pipeline, urutan, dan data. Juga untuk memungkinkan rekomputasi aktivasi selektif dan kernel terpadu yang dioptimalkan.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L953)

**Parameter:**

backend (`DynamoBackend`, defaultnya `None`) : Backend Dynamo yang valid. Lihat https://pytorch.org/docs/stable/torch.compiler.html untuk detail lebih lanjut.

mode (`str`, defaultnya `None`) : Opsi yang mungkin adalah 'default', 'reduce-overhead' atau 'max-autotune'.

fullgraph (`bool`, defaultnya `None`) : Apakah diperbolehkan untuk memecah model menjadi beberapa subgraf.

dynamic (`bool`, defaultnya `None`) : Apakah akan menggunakan bentuk dinamis untuk pelacakan.

options (`Any`, defaultnya `None`) : Kamus opsi untuk diteruskan ke backend.

disable (`bool`, defaultnya `False`) : Mengubah torch.compile() menjadi no-op untuk pengujian

use_regional_compilation (`bool`, defaultnya `None`) : Gunakan ini untuk mengurangi waktu kompilasi cold start dari torch.compile() dengan menargetkan blok berulang dari kelas yang sama dan mengompilasinya secara berurutan untuk memanfaatkan cache compiler. Misalnya, pada `GPT2LMHeadModel`, blok/kelas yang berulang adalah `GPT2Block`, dan dapat diakses sebagai `model.transformer.h[0]`. Sisa model (misalnya model.lm_head) dikompilasi secara terpisah.

Plugin ini digunakan untuk mengompilasi model dengan PyTorch 2.0

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

Ini adalah kelas yang dapat dikonfigurasi dan diteruskan ke integrasi yang sesuai

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L2950)

**Parameter:**

load_in_8bit (`bool`, defaultnya `False`) : Aktifkan kuantisasi 8bit.

llm_int8_threshold (`float`, defaultnya `6.0`) : Nilai ambang batas outliner. Hanya relevan ketika `load_in_8bit=True`.

load_in_4bit (`bool`, defaultnya `False`) : Aktifkan kuantisasi 4bit.

bnb_4bit_quant_type (`str`, defaultnya `fp4`) : Menetapkan tipe data kuantisasi pada lapisan `bnb.nn.Linear4Bit`. Opsinya adalah {'fp4','np4'}.

bnb_4bit_use_double_quant (`bool`, defaultnya `False`) : Mengaktifkan kuantisasi bersarang, di mana konstanta kuantisasi dari kuantisasi pertama dikuantisasi ulang.

bnb_4bit_compute_dtype (`bool`, defaultnya `fp16`) : Ini mengatur tipe komputasi yang mungkin berbeda dari tipe input. Misalnya, input mungkin fp32, tetapi komputasi dapat diatur ke bf16 untuk percepatan. Opsi yang tersedia adalah {'fp32','fp16','bf16'}.

torch_dtype (`torch.dtype`, defaultnya `None`) : Ini mengatur dtype dari lapisan non-kuantisasi yang tersisa. Perpustakaan `bitsandbytes` menyarankan untuk mengatur nilainya ke `torch.float16` untuk model 8 bit dan menggunakan dtype yang sama dengan dtype komputasi untuk model 4 bit.

skip_modules (`List[str]`, defaultnya `None`) : Daftar eksplisit modul yang tidak kami kuantisasi. dtype dari modul-modul ini akan menjadi `torch_dtype`.

keep_in_fp32_modules (`List`, defaultnya `None`) : Daftar eksplisit modul yang tidak kami kuantisasi. Kami menjaganya dalam `torch.float32`.

Plugin untuk mengaktifkan kuantisasi 4bit dan 8bit BitsAndBytes

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L743)

**Parameter:**

split_batches (`bool`, defaultnya `False`) : Apakah accelerator harus membagi batch yang dihasilkan oleh dataloaders di antara perangkat. Jika `True`, ukuran batch aktual yang digunakan akan sama di semua jenis proses terdistribusi, tetapi harus berupa kelipatan bulat dari `num_processes` yang Anda gunakan. Jika `False`, ukuran batch aktual yang digunakan akan menjadi yang diatur di skrip Anda dikalikan dengan jumlah proses.

dispatch_batches (`bool`, defaultnya `None`) : Jika diatur ke `True`, dataloader yang disiapkan oleh Accelerator hanya diiterasi pada proses utama, kemudian batch dipecah dan disiarkan ke setiap proses. Akan default ke `True` untuk `DataLoader` yang dataset dasarnya adalah `IterableDataset`, `False` selain itu.

even_batches (`bool`, defaultnya `True`) : Jika diset ke `True`, dalam kasus di mana ukuran batch total di seluruh proses tidak membagi dataset secara tepat, sampel di awal dataset akan diduplikasi agar batch dapat dibagi secara merata di antara semua worker.

use_seedable_sampler (`bool`, defaultnya `False`) : Apakah akan menggunakan sampler acak yang sepenuhnya dapat di-seed (`data_loader.SeedableRandomSampler`). Memastikan hasil pelatihan sepenuhnya dapat direproduksi menggunakan teknik sampling yang berbeda. Meskipun hasil antar-seed mungkin berbeda, rata-rata perbedaannya dapat diabaikan ketika menggunakan beberapa seed yang berbeda untuk perbandingan. Sebaiknya juga dijalankan dengan [set_seed()](/docs/accelerate/v1.16.0/id/package_reference/utilities#accelerate.utils.set_seed) untuk hasil terbaik.

data_seed (`int`, defaultnya `None`) : Seed yang akan digunakan untuk generator dasar saat menggunakan `use_seedable_sampler`. Jika `None`, generator akan menggunakan seed default saat ini dari torch.

non_blocking (`bool`, defaultnya `False`) : Jika diatur ke `True`, dataloader yang disiapkan oleh Accelerator akan memanfaatkan transfer host-ke-perangkat non-blocking, memungkinkan overlap yang lebih baik antara komunikasi dataloader dan komputasi. Disarankan agar dataloader yang disiapkan memiliki `pin_memory` yang diatur ke `True` agar berfungsi dengan baik.

use_stateful_dataloader (`bool`, defaultnya `False`) : Jika diatur ke `True`, dataloader yang disiapkan oleh Accelerator akan didukung oleh [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader). Hal ini memerlukan instalasi `torchdata` versi 0.8.0 atau lebih tinggi yang mendukung StatefulDataLoader.

Konfigurasi untuk item terkait dataloader saat memanggil `accelerator.prepare`.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L838)

**Parameter:**

project_dir (`str`, defaultnya `None`) : Path ke direktori untuk menyimpan data.

logging_dir (`str`, defaultnya `None`) : Path ke direktori untuk menyimpan log dari logger yang kompatibel secara lokal. Jika None, defaultnya adalah `project_dir`.

automatic_checkpoint_naming (`bool`, defaultnya `False`) : Apakah state yang disimpan harus diberi nama secara iteratif secara otomatis.

total_limit (`int`, defaultnya `None`) : Jumlah maksimum total state yang disimpan untuk dipertahankan.

iteration (`int`, defaultnya `0`) : Iterasi simpan saat ini.

save_on_each_node (`bool`, defaultnya `False`) : Saat melakukan pelatihan terdistribusi multi-node, apakah model dan checkpoint disimpan di setiap node, atau hanya di node utama.

Konfigurasi untuk objek Accelerator berdasarkan kebutuhan proyek internal.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/dataclasses.py#L890)

Mengatur `self.project_dir` dan `self.logging_dir` ke nilai yang sesuai.

## Variabel Lingkungan

Ini adalah variabel lingkungan yang dapat diaktifkan untuk berbagai kasus penggunaan

* `ACCELERATE_DEBUG_MODE` (`str`): Apakah akan menjalankan accelerate dalam mode debug. Informasi lebih lanjut tersedia [di sini](../basic_tutorials/troubleshooting#hanging-code-and-timeout-errors).

## Manipulasi dan Operasi Data[[accelerate.utils.broadcast]]

Termasuk di dalamnya adalah operasi data yang meniru operasi `torch` yang sama tetapi dapat digunakan pada proses terdistribusi.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L583)

**Parameter:**

tensor (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan dikumpulkan.

from_process (`int`, *opsional*, default 0) : Proses yang mengirim data

**Mengembalikan:**

Struktur data yang sama seperti `tensor` dengan semua tensor yang telah di-broadcast ke perangkat yang sesuai.

Broadcast tensor secara rekursif dalam list/tuple/dictionary tensor bersarang ke semua perangkat.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L658)

**Parameter:**

object_list (list of picklable objects) : Daftar objek yang akan disiarkan. Daftar ini akan dimodifikasi secara inplace.

from_process (`int`, *opsional*, default 0) : Proses yang mengirim data.

**Mengembalikan:**

Daftar yang sama yang berisi objek dari proses 0.

Broadcast daftar objek yang dapat di-pickle dari satu proses ke proses lainnya.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L702)

**Parameter:**

data (daftar/tuple/kamus bersarang berisi daftar tensor `torch.Tensor`) : Data yang akan digabungkan.

dim (`int`, *opsional*, default 0) : Dimensi tempat penggabungan (concatenate) dilakukan.

**Mengembalikan:**

Struktur data yang sama dengan `data` dengan semua tensor yang digabungkan.

Menghubungkan tensor secara rekursif dalam daftar/tuple/dictionary bersarang dari daftar tensor dengan bentuk yang sama. Jika hanya ada satu batch data, data tersebut dikembalikan apa adanya.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L922)

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L872)

**Parameter:**

tensor (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan dikonversi dari FP16/BF16 ke FP32.

**Mengembalikan:**

Struktur data yang sama dengan `tensor` dengan semua tensor yang berada dalam presisi FP16/BF16 dikonversi ke FP32.

Mengonversi secara rekursif elemen-elemen dalam daftar/tuple/dictionary tensor yang bersarang dari presisi FP16/BF16 ke FP32.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L414)

**Parameter:**

tensor (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan dikumpulkan.

**Mengembalikan:**

Struktur data yang sama seperti `tensor` dengan semua tensor dikirim ke perangkat yang tepat.

Kumpulkan tensor secara rekursif dalam daftar/tuple/dictionary tensor bersarang dari semua perangkat.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L495)

**Parameter:**

object (nested list/tuple/dictionary of picklable object) : Data yang akan dikumpulkan.

**Mengembalikan:**

Struktur data yang sama seperti `object` dengan semua objek yang dikirim ke setiap perangkat.

Kumpulkan objek secara rekursif dalam daftar/tuple/dictionary objek bersarang dari semua perangkat.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L2089)

**Parameter:**

distributed_type (`DistributedType`, *opsional*, defaultnya None) : Jenis lingkungan terdistribusi.

kwargs : Argumen tambahan untuk konstruktor `GradScaler` yang digunakan.

Helper generik yang akan menginisialisasi implementasi `GradScaler` yang benar berdasarkan lingkungan dan mengembalikannya.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L2047)

**Parameter:**

native_amp (`bool`, *opsional*, defaultnya False) : Apakah presisi campuran benar-benar diaktifkan.

Kembalikan context manager untuk autocasting presisi campuran

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L270)

**Parameter:**

data (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan dikonversi menjadi angka biasa.

**Mengembalikan:**

Struktur data yang sama seperti `data` dengan daftar angka alih-alih `torch.Tensor`.

Mencari tensor secara rekursif dalam list/tuple/dictionary bersarang dan mengonversinya menjadi list angka.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L732)

**Parameter:**

tensor (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan dikumpulkan.

dim (`int`, *opsional*, default 0) : Dimensi yang akan di-pad.

pad_index (`int`, *opsional*, default 0) : Nilai yang digunakan untuk padding.

pad_first (`bool`, *opsional*, defaultnya `False`) : Apakah akan melakukan padding di awal atau di akhir.

Pad tensor secara rekursif dalam daftar/tupel/dictionary bertingkat dari tensor di semua perangkat hingga ukuran yang sama agar dapat dikumpulkan dengan aman.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L85)

**Parameter:**

func (`callable`) : Fungsi yang akan diterapkan secara rekursif.

data (daftar/tuple/kamus bersarang dari objek yang diterima oleh `test_type`) : Data yang akan diterapkan `func`

- ***args** : Argumen posisional yang akan diteruskan ke `func` saat diterapkan pada data yang telah diurai.

test_type (`Callable[[Any], bool]`, *opsional*, defaultnya `is_torch_tensor`) : Predikat yang menentukan apakah `func` harus diterapkan pada objek daun tertentu.

error_on_other_type (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengembalikan error atau tidak jika setelah unpacking `data`, kita mendapatkan objek yang mana `test_type` mengembalikan `False`. Jika `False`, fungsi akan membiarkan objek semacam itu tetap tidak berubah.

- ****kwargs** (argumen kata kunci tambahan, *opsional*) : Argumen kata kunci yang akan diteruskan ke `func` saat diterapkan pada data yang telah diurai.

**Mengembalikan:**

Struktur data yang sama seperti `data` dengan `func` diterapkan ke setiap objek yang mana `test_type` mengembalikan `True`.

Terapkan fungsi secara rekursif pada struktur data berupa daftar/tuple/dictionary bersarang dari tipe dasar tertentu.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L828)

**Parameter:**

tensor (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan direduksi.

reduction (`str`, *opsional*, defaultnya `"mean"`) : Metode reduksi. Bisa berupa "mean", "sum", "max", atau "none"

scale (`float`, *opsional*) : Nilai penskalaan default yang diterapkan setelah reduce, hanya valid di XLA.

**Mengembalikan:**

Struktur data yang sama dengan `data` dengan semua tensor yang telah dikurangi.

Kurangi secara rekursif tensor dalam daftar/tuple/dictionary bersarang dari daftar tensor di semua proses dengan rata-rata dari operasi yang diberikan.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L136)

**Parameter:**

tensor (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan dikirim ke perangkat tertentu.

device (`torch.device`) : Perangkat untuk mengirim data.

non_blocking (`bool`, *opsional*, defaultnya `False`) : Jika `True`, transfer ke perangkat dilakukan secara asinkron, yang dapat menumpuk pergerakan data dengan komputasi. Hanya efektif jika perangkat mendukungnya (mis. CUDA).

skip_keys (`str` atau `List[str]`, *opsional*) : Kunci atau daftar kunci dalam kamus `tensor` yang nilainya tidak boleh dikirim ke `device` yang diberikan. Entri dengan kunci-kunci ini tetap berada di perangkat aslinya.

**Mengembalikan:**

Struktur data yang sama seperti `tensor` dengan semua tensor dikirim ke perangkat yang tepat.

Mengirim elemen-elemen dalam list/tuple/dictionary tensor bersarang secara rekursif ke perangkat yang ditentukan.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/operations.py#L682)

**Parameter:**

data (nested list/tuple/dictionary of `torch.Tensor`) : Data yang akan dipotong.

tensor_slice (`slice`) : Slice yang akan diambil.

**Mengembalikan:**

Struktur data yang sama dengan `data` dengan semua irisan tensor.

Mengambil potongan secara rekursif dalam daftar/tuple/dictionary tensor yang bersarang.

## Periksa Lingkungan[[accelerate.utils.is_bf16_available]]

Fungsionalitas ini memeriksa status lingkungan kerja saat ini, termasuk informasi tentang sistem operasi itu sendiri, apa yang dapat didukungnya, dan apakah dependensi tertentu sudah terinstal.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/imports.py#L157)

Memeriksa apakah bf16 didukung, dengan opsi untuk mengabaikan TPU

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/imports.py#L325)

Memeriksa apakah perangkat MPS tersedia. Versi minimum yang diperlukan adalah 1.12.

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

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

Memeriksa apakah `torch_npu` terinstal dan, jika perlu, apakah ada NPU di lingkungan

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/versions.py#L46)

**Parameter:**

operation (`str`) : Representasi string dari sebuah operator, seperti `">"` atau `"<="`

version (`str`) : Versi string dari PyTorch

Membandingkan versi PyTorch saat ini dengan referensi tertentu menggunakan operasi.

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

Periksa apakah `torch_xla` tersedia. Untuk melatih tugas pytorch native di lingkungan dengan torch xla yang terinstal, atur USE_TORCH_XLA ke false.

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

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

Memeriksa apakah akselerasi XPU tersedia melalui PyTorch standar (>=2.7) dan, jika ada, apakah XPU ada di lingkungan

## Manipulasi Lingkungan[[accelerate.utils.patch_environment]]

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L380)

Manajer konteks yang akan menambahkan setiap argumen kata kunci yang diteruskan ke `os.environ` dan menghapusnya saat keluar.

Akan mengonversi nilai dalam `kwargs` menjadi string dan mengubah semua kunci menjadi huruf kapital.

Contoh:

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L345)

Manajer konteks yang akan menghapus variabel lingkungan secara sementara.

Saat konteks ini keluar, variabel lingkungan sebelumnya akan kembali.

Contoh:

```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')
```

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

**Parameter:**

mixed_precision (`str`, *opsional*, defaultnya "no") : Mixed Precision yang akan digunakan. Harus salah satu dari "no", "fp16", atau "bf16"

save_location (`str`, *opsional*, defaultnya `default_json_config_file`) : Lokasi penyimpanan kustom opsional. Seharusnya diteruskan ke `--config_file` saat menggunakan `accelerate launch`. Lokasi default berada di dalam folder cache huggingface (`~/.cache/huggingface`) tetapi dapat ditimpa dengan mengatur variabel lingkungan `HF_HOME`, diikuti oleh `accelerate/default_config.yaml`.

Membuat dan menyimpan konfigurasi cluster dasar untuk digunakan pada mesin lokal dengan kemungkinan beberapa GPU. Juga akan mengatur CPU jika mesin tersebut hanya memiliki CPU.

Saat mengatur 🤗 Accelerate untuk pertama kali, alih-alih menjalankan `accelerate config`, [~utils.write_basic_config] dapat digunakan sebagai alternatif untuk konfigurasi cepat.

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

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

**Parameter:**

local_process_index (int) : Indeks proses saat ini pada server saat ini.

verbose (bool, *opsional*) : Apakah akan mencetak penugasan inti cpu baru untuk setiap proses. Jika `ACCELERATE_DEBUG_MODE` diaktifkan, nilai default akan menjadi True.

Menugaskan proses saat ini ke node NUMA tertentu. Paling efisien secara ideal jika memiliki setidaknya 2 cpu per node.

Hasil ini di-cache di antara pemanggilan. Jika Anda ingin menimpanya, silakan gunakan `accelerate.utils.environment.override_numa_afifnity`.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L262)

**Parameter:**

local_process_index (int) : Indeks proses saat ini pada server saat ini.

verbose (bool, *opsional*) : Apakah akan mencatat penugasan setiap CPU. Jika `ACCELERATE_DEBUG_MODE` diaktifkan, nilai default akan menjadi True.

Menimpa afinitas NUMA apa pun yang disetel untuk proses saat ini. Hal ini sangat membebani dan memerlukan perhitungan ulang afinitas yang akan disetel; sebaiknya gunakan `utils.environment.set_numa_affinity` sebagai gantinya.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/environment.py#L417)

Decorator untuk membersihkan variabel lingkungan accelerate yang disetel oleh kelas atau fungsi yang didekorasi.

Dalam beberapa situasi, pemanggilan kelas atau fungsi tertentu dapat menyebabkan variabel lingkungan accelerate diset dan tidak dibersihkan setelahnya. Sebagai contoh, saat memanggil:

TrainingArguments(fp16=True, ...)

Variabel lingkungan berikut akan disetel:

ACCELERATE_MIXED_PRECISION=fp16

Hal ini dapat memengaruhi kode berikutnya, karena variabel lingkungan memiliki prioritas lebih tinggi daripada TrainingArguments(fp16=False). Hal ini terutama relevan untuk pengujian unit, di mana kita ingin menghindari agar pengujian individual tidak memiliki efek samping satu sama lain. Hiasi fungsi pengujian unit atau seluruh kelas dengan dekorator ini untuk memastikan bahwa setelah setiap pengujian, variabel lingkungan dibersihkan. Ini berfungsi untuk unittest.TestCase dan kelas normal (pytest); ini juga berfungsi saat menghiasi kelas induk.

## Memori[[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)
```

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/memory.py#L94)

**Parameter:**

function (`callable`, *opsional*) : Fungsi untuk dibungkus

starting_batch_size (`int`, *opsional*) : Ukuran batch yang akan dicoba untuk muat ke dalam memori

reduce_batch_size_fn (`callable`, *opsional*) : Fungsi untuk menentukan ukuran batch baru setelah terjadi kesalahan out-of-memory. Jika tidak disediakan, ukuran batch akan dikalikan dengan 0,9 pada setiap kegagalan. Fungsi ini tidak mengambil argumen dan harus mengembalikan ukuran batch baru (yang dikurangi) sebagai `int`.

Decorator dasar yang akan mencoba mengeksekusi `function`. Jika gagal karena pengecualian yang terkait dengan out-of-memory atau CUDNN, ukuran batch dikalikan dengan 0,9 dan diteruskan ke `function`

`function` harus menerima parameter `batch_size` sebagai argumen pertamanya.

Contoh:

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

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

Utilitas ini berkaitan dengan interaksi dengan model PyTorch

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1048)

Menghitung ukuran total model dan lapisan terbesarnya

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L675)

Hitung ukuran setiap submodul dari model tertentu.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L286)

**Parameter:**

model (`torch.nn.Module`) : Model yang akan diekstrak.

keep_fp32_wrapper (`bool`, *opsional*) : Apakah akan menghapus hook presisi campuran dari model.

keep_torch_compile (`bool`, *opsional*) : Apakah akan membuka bungkus model yang dikompilasi.

recursive (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengekstrak secara rekursif semua kasus `module.module` dari `model` serta membuka bungkus sublayer anak secara rekursif, bukan hanya kontainer terdistribusi tingkat atas.

**Mengembalikan:** `torch.nn.Module`

Model yang diekstrak.

Ekstrak model dari kontainer distribusinya.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L916)

**Parameter:**

model (`torch.nn.Module`) : Model yang akan dianalisis.

max_memory (`Dict`, *opsional*) : Kamus pengidentifikasi perangkat ke memori maksimum. Akan menggunakan memori maksimum yang tersedia jika tidak diatur. Contoh: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *opsional*) : Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual).

dtype (`str` atau `torch.dtype`, *opsional*) : Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *opsional*) : Jika disediakan, dtype khusus yang dipertimbangkan untuk beberapa bobot tertentu (akan menimpa dtype yang digunakan sebagai default untuk semua bobot).

low_zero (`bool`, *opsional*) : Meminimalkan jumlah bobot pada GPU 0, yang berguna ketika GPU tersebut digunakan untuk operasi lain (seperti fungsi generate dari Transformers).

Hitung kamus `max_memory` untuk [infer_auto_device_map()](/docs/accelerate/v1.16.0/id/package_reference/big_modeling#accelerate.infer_auto_device_map) yang akan menyeimbangkan penggunaan setiap GPU yang tersedia.

Semua komputasi dilakukan dengan menganalisis ukuran dan dtype dari parameter model. Akibatnya, model dapat berada pada perangkat meta (seperti yang akan terjadi jika diinisialisasi di dalam context manager `init_empty_weights`).

#### 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])
```

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L729)

**Parameter:**

modules (`List[Tuple[str, torch.nn.Module]]`) : Daftar modul bernama tempat kita ingin menentukan ukuran lapisan maksimum.

module_sizes (`Dict[str, int]`) : Kamus yang memetakan setiap nama layer ke ukurannya (seperti yang dihasilkan oleh `compute_module_sizes`).

no_split_module_classes (`List[str]`) : Daftar nama kelas untuk lapisan yang tidak ingin dipecah.

**Mengembalikan:** `Tuple[int, List[str]]`

Ukuran maksimum dari sebuah layer beserta daftar nama layer yang mencapai ukuran maksimum tersebut.

Fungsi utilitas yang akan memindai daftar modul bernama dan mengembalikan ukuran maksimum yang digunakan oleh satu lapisan penuh. Definisi lapisan adalah:
- modul tanpa anak langsung (hanya parameter dan buffer)
- modul yang nama kelasnya ada dalam daftar `no_split_module_classes`

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1278)

**Parameter:**

model (`torch.nn.Module`) : Model yang akan dianalisis.

max_memory (`Dict`, *opsional*) : Kamus pengidentifikasi perangkat ke memori maksimum. Akan menggunakan memori maksimum yang tersedia jika tidak diatur. Contoh: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *opsional*) : Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual).

dtype (`str` atau `torch.dtype`, *opsional*) : Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *opsional*) : Jika disediakan, dtype khusus yang dipertimbangkan untuk beberapa bobot tertentu (akan menimpa dtype yang digunakan sebagai default untuk semua bobot).

verbose (`bool`, *opsional*, defaultnya `False`) : Apakah akan memberikan pernyataan debugging saat fungsi membangun device_map.

clean_result (`bool`, *opsional*, defaultnya `True`) : Bersihkan device_map yang dihasilkan dengan mengelompokkan semua submodul yang berada di perangkat yang sama.

offload_buffers (`bool`, *opsional*, defaultnya `False`) : Pada lapisan yang di-offload ke CPU atau hard drive, apakah buffer juga akan di-offload bersama dengan parameter.

fallback_allocation (`bool`, *opsional*, defaultnya `False`) : Ketika alokasi reguler gagal, coba alokasikan modul yang muat dalam batas ukuran menggunakan BFS.

Hitung peta perangkat untuk model tertentu dengan memberikan prioritas pada GPU, kemudian offload ke CPU dan akhirnya offload ke disk, sehingga:
- kami tidak melebihi memori yang tersedia pada GPU mana pun.
- jika offload ke CPU diperlukan, selalu ada ruang tersisa di GPU 0 untuk mengembalikan layer yang di-offload ke CPU dengan ukuran terbesar.
- jika offload ke CPU diperlukan, kami tidak melebihi RAM yang tersedia di CPU.
- jika offload ke disk diperlukan, selalu ada ruang tersisa di CPU untuk mengembalikan layer yang di-offload ke disk dengan ukuran terbesar.

Semua komputasi dilakukan dengan menganalisis ukuran dan dtype dari parameter model. Akibatnya, model dapat berada pada perangkat meta (seperti yang akan terjadi jika diinisialisasi di dalam context manager `init_empty_weights`).

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1786)

**Parameter:**

model (`torch.nn.Module`) : Model tempat kita ingin memuat checkpoint.

checkpoint (`str` atau `os.PathLike`) : Folder checkpoint yang akan dimuat. Bisa berupa: - path ke file yang berisi state dict model utuh - path ke file `.json` yang berisi indeks untuk checkpoint yang dipecah (sharded) - path ke folder yang berisi file `.index.json` unik dan shard dari checkpoint. - path ke folder yang berisi file pytorch_model.bin atau model.safetensors yang unik.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opsional*) : Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Tidak perlu dirinci hingga nama setiap parameter/buffer; begitu nama modul tertentu ada di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama.

offload_folder (`str` atau `os.PathLike`, *opsional*) : Jika `device_map` berisi nilai `"disk"`, folder tempat bobot akan di-offload.

dtype (`str` atau `torch.dtype`, *opsional*) : Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.

offload_state_dict (`bool`, *opsional*, defaultnya `False`) : Jika `True`, state dict CPU akan di-offload sementara ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar tidak muat.

offload_buffers (`bool`, *opsional*, defaultnya `False`) : Apakah buffer akan disertakan dalam bobot yang di-offload ke disk.

keep_in_fp32_modules(`List[str]`, *opsional*) : Daftar modul yang dipertahankan dalam dtype `torch.float32`.

offload_8bit_bnb (`bool`, *opsional*) : Apakah akan mengaktifkan offload modul 8-bit ke cpu/disk.

strict (`bool`, *opsional*, defaultnya `False`) : Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model.

full_state_dict (`bool`, *opsional*, defaultnya `True`) : jika ini diatur ke `True`, semua tensor dalam state_dict yang dimuat akan dikumpulkan. Tidak akan ada ShardedTensor dan DTensor dalam state_dict yang dimuat.

broadcast_from_rank0 (`False`, *opsional*, defaultnya `False`) : ketika opsi ini `True`, sebuah `ProcessGroup` terdistribusi harus diinisialisasi. rank0 harus menerima state_dict lengkap dan akan melakukan broadcast tensor dalam state_dict satu per satu ke rank lainnya. Rank lainnya akan menerima tensor tersebut dan melakukan sharding (jika berlaku) sesuai dengan shard lokal dalam model.

Memuat checkpoint (yang mungkin terbagi) di dalam model, dengan kemungkinan mengirim bobot ke perangkat tertentu saat dimuat.

Setelah dimuat di seluruh perangkat, Anda masih perlu memanggil [dispatch_model()](/docs/accelerate/v1.16.0/id/package_reference/big_modeling#accelerate.dispatch_model) pada model Anda agar model tersebut dapat dijalankan. Untuk mengelompokkan pemuatan checkpoint dan dispatch dalam satu panggilan tunggal, gunakan [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/id/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L875)

**Parameter:**

model (`torch.nn.Module`) : Model tempat bobot akan dimuat.

index (`dict`) : Kamus yang berisi nama parameter dan metadata-nya untuk setiap parameter yang di-offload dari model.

offload_folder (`str`) : Folder tempat bobot yang di-offload disimpan.

Memuat bobot dari folder offload ke dalam model.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1620)

**Parameter:**

checkpoint_file (`str`) : Path ke checkpoint yang akan dimuat.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opsional*) : Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Tidak perlu dirinci hingga nama setiap parameter/buffer; begitu nama modul tertentu ada di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama.

Muat checkpoint dari file yang diberikan. Jika checkpoint dalam format safetensors dan device map diteruskan, bobot dapat dimuat dengan cepat langsung di GPU.

#### 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])
```

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/offload.py#L94)

**Parameter:**

save_dir (`str` atau `os.PathLike`) : Direktori tempat state dict di-offload.

state_dict (`Dict[str, torch.Tensor]`) : Kamus tensor untuk di-offload.

Offload state dict di folder yang ditentukan.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L633)

**Parameter:**

model (`torch.nn.Module`) : Model tempat parameter diikat ulang.

tied_params (`List[List[str]]`) : Pemetaan nama parameter ke nama parameter yang terikat, sebagaimana diperoleh oleh `find_tied_parameters`.

Reties parameter yang terikat pada model tertentu jika tautannya terputus (misalnya saat menambahkan hook).

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L226)

**Parameter:**

module (`torch.nn.Module`) : Modul tempat tensor yang ingin dipindahkan berada.

tensor_name (`str`) : Nama lengkap parameter/buffer.

device (`int`, `str` atau `torch.device`) : Perangkat tempat tensor disetel.

value (`torch.Tensor`, *opsional*) : Nilai dari tensor (berguna saat berpindah dari perangkat meta ke perangkat lain).

dtype (`torch.dtype`, *opsional*) : Jika diberikan, nilai parameter akan di-cast ke `dtype` ini. Jika tidak, `value` akan di-cast ke dtype dari parameter yang sudah ada di model.

fp16_statistics (`torch.HalfTensor`, *opsional*) : Daftar statistik fp16 yang akan disetel pada modul, digunakan untuk serialisasi model 8 bit.

tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], *opsional*, defaultnya `None`) : Pemetaan dari pointer data saat ini ke kamus perangkat ke bobot terikat yang sudah didispatch. Untuk perangkat eksekusi tertentu, parameter ini berguna untuk menggunakan ulang pointer pertama yang tersedia dari bobot bersama di perangkat tersebut untuk semua lainnya, alih-alih menduplikasi memori.

non_blocking (`bool`, *opsional*, defaultnya `False`) : Jika `True`, transfer perangkat akan bersifat asinkron terhadap host, jika memungkinkan.

clear_cache (`bool`, *opsional*, defaultnya `True`) : Apakah cache perangkat akan dibersihkan setelah tensor disetel pada perangkat.

Fungsi bantu untuk mengatur tensor tertentu (parameter atau buffer) dari sebuah modul pada perangkat spesifik (perhatikan bahwa melakukan `param.to(device)` akan membuat tensor baru yang tidak terhubung ke parameter, itulah mengapa kita membutuhkan fungsi ini).

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L605)

**Parameter:**

model (`torch.nn.Module`) : model yang akan diambil anak-anaknya

**Mengembalikan:** `list[torch.nn.Module]`

daftar modul anak dari `model` dalam urutan bottom-up. Elemen terakhir adalah `model` itu sendiri.

Telusuri model dalam urutan dari bawah ke atas dan kembalikan modul anak dalam urutan tersebut.

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

Ini mencakup utilitas umum yang harus digunakan saat bekerja secara paralel.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L286)

**Parameter:**

model (`torch.nn.Module`) : Model yang akan diekstrak.

keep_fp32_wrapper (`bool`, *opsional*) : Apakah akan menghapus hook presisi campuran dari model.

keep_torch_compile (`bool`, *opsional*) : Apakah akan membuka bungkus model yang dikompilasi.

recursive (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengekstrak secara rekursif semua kasus `module.module` dari `model` serta membuka bungkus sublayer anak secara rekursif, bukan hanya kontainer terdistribusi tingkat atas.

**Mengembalikan:** `torch.nn.Module`

Model yang diekstrak.

Ekstrak model dari kontainer distribusinya.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L424)

**Parameter:**

obj : Data yang akan disimpan

f : File (atau objek serupa file) yang akan digunakan untuk menyimpan data

save_on_each_node (`bool`, *opsional*, defaultnya `False`) : Apakah hanya menyimpan pada proses utama global

safe_serialization (`bool`, *opsional*, defaultnya `False`) : Apakah menyimpan `obj` menggunakan `safetensors` atau cara tradisional PyTorch (yang menggunakan `pickle`).

Simpan data ke disk. Gunakan sebagai pengganti `torch.save()`.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L474)

**Parameter:**

f : File (atau objek serupa file) yang akan digunakan untuk memuat data

map_location : sebuah fungsi, `torch.device`, string, atau dict yang menentukan cara memetakan ulang lokasi penyimpanan

- ****kwargs** : Argumen kata kunci tambahan untuk diteruskan ke `torch.load()`.

Pengganti drop-in yang kompatibel untuk `torch.load()` yang memungkinkan penggunaan `weights_only` jika versi `torch` adalah 2.4.0 atau lebih tinggi. Jika tidak, kwarg akan diabaikan.

Juga akan menambahkan (lalu menghapus) pengecualian untuk array numpy

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/other.py#L376)

Memperkenalkan titik pemblokiran dalam skrip, memastikan semua proses telah mencapai titik ini sebelum melanjutkan.

Pastikan semua proses akan mencapai instruksi ini, jika tidak salah satu proses Anda akan menggantung selamanya.

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

Utilitas ini berkaitan dengan pengaturan dan sinkronisasi semua keadaan acak.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/random.py#L34)

**Parameter:**

seed (`int`) : Benih yang akan disetel.

device_specific (`bool`, *opsional*, defaultnya `False`) : Apakah akan membedakan seed di setiap perangkat sedikit dengan `self.process_index`.

deterministic (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan algoritma deterministik jika tersedia. Dapat memperlambat pelatihan.

Fungsi bantu untuk perilaku yang dapat direproduksi guna mengatur seed di `random`, `numpy`, `torch`.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/random.py#L63)

Sinkronkan RNG bawaan atau RNG akselerator saat ini, yang diidentifikasi berdasarkan tipe perangkatnya.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/random.py#L127)

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

Termasuk di dalamnya adalah utilitas yang berguna saat menggunakan PyTorch dengan XLA.

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

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/torch_xla.py#L20)

**Parameter:**

upgrade (`bool`, *opsional*, defaultnya `False`) : Apakah akan meng-upgrade `torch` dan menginstal roda `torch_xla` terbaru.

Fungsi bantu untuk menginstal roda xla yang sesuai berdasarkan versi `torch` di Google Colaboratory.

Contoh:

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

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

## Memuat bobot model[[accelerate.load_checkpoint_in_model]]

Termasuk di dalamnya adalah utilitas yang berguna untuk memuat checkpoint.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/modeling.py#L1786)

**Parameter:**

model (`torch.nn.Module`) : Model tempat kita ingin memuat checkpoint.

checkpoint (`str` atau `os.PathLike`) : Folder checkpoint yang akan dimuat. Bisa berupa: - path ke file yang berisi state dict model utuh - path ke file `.json` yang berisi indeks untuk checkpoint yang dipecah (sharded) - path ke folder yang berisi file `.index.json` unik dan shard dari checkpoint. - path ke folder yang berisi file pytorch_model.bin atau model.safetensors yang unik.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opsional*) : Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Tidak perlu dirinci hingga nama setiap parameter/buffer; begitu nama modul tertentu ada di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama.

offload_folder (`str` atau `os.PathLike`, *opsional*) : Jika `device_map` berisi nilai `"disk"`, folder tempat bobot akan di-offload.

dtype (`str` atau `torch.dtype`, *opsional*) : Jika diberikan, bobot akan dikonversi ke tipe tersebut saat dimuat.

offload_state_dict (`bool`, *opsional*, defaultnya `False`) : Jika `True`, state dict CPU akan di-offload sementara ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar tidak muat.

offload_buffers (`bool`, *opsional*, defaultnya `False`) : Apakah buffer akan disertakan dalam bobot yang di-offload ke disk.

keep_in_fp32_modules(`List[str]`, *opsional*) : Daftar modul yang dipertahankan dalam dtype `torch.float32`.

offload_8bit_bnb (`bool`, *opsional*) : Apakah akan mengaktifkan offload modul 8-bit ke cpu/disk.

strict (`bool`, *opsional*, defaultnya `False`) : Apakah akan secara ketat menegakkan bahwa kunci dalam state_dict checkpoint harus cocok dengan kunci dari state_dict model.

full_state_dict (`bool`, *opsional*, defaultnya `True`) : jika ini diatur ke `True`, semua tensor dalam state_dict yang dimuat akan dikumpulkan. Tidak akan ada ShardedTensor dan DTensor dalam state_dict yang dimuat.

broadcast_from_rank0 (`False`, *opsional*, defaultnya `False`) : ketika opsi ini `True`, sebuah `ProcessGroup` terdistribusi harus diinisialisasi. rank0 harus menerima state_dict lengkap dan akan melakukan broadcast tensor dalam state_dict satu per satu ke rank lainnya. Rank lainnya akan menerima tensor tersebut dan melakukan sharding (jika berlaku) sesuai dengan shard lokal dalam model.

Memuat checkpoint (yang mungkin terbagi) di dalam model, dengan kemungkinan mengirim bobot ke perangkat tertentu saat dimuat.

Setelah dimuat di seluruh perangkat, Anda masih perlu memanggil [dispatch_model()](/docs/accelerate/v1.16.0/id/package_reference/big_modeling#accelerate.dispatch_model) pada model Anda agar model tersebut dapat dijalankan. Untuk mengelompokkan pemuatan checkpoint dan dispatch dalam satu panggilan tunggal, gunakan [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/id/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

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

Termasuk di dalamnya adalah utilitas yang berguna untuk mengkuantisasi model.

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

[Sumber](https://github.com/huggingface/accelerate/blob/v1.16.0/src/accelerate/utils/bnb.py#L44)

**Parameter:**

model (`torch.nn.Module`) : Model input. Model dapat sudah dimuat atau berada di perangkat meta

bnb_quantization_config (`BnbQuantizationConfig`) : Parameter kuantisasi bitsandbytes

weights_location (`str` atau `os.PathLike`) : Lokasi folder weights_location untuk dimuat. Dapat berupa: - path ke file yang berisi state dict model lengkap - path ke file `.json` yang berisi indeks untuk checkpoint yang dipecah (sharded) - path ke folder yang berisi file `.index.json` unik dan shard dari checkpoint. - path ke folder yang berisi file pytorch_model.bin unik.

device_map (`Dict[str, Union[int, str, torch.device]]`, *opsional*) : Peta yang menentukan ke perangkat mana setiap submodul harus ditempatkan. Tidak perlu dirinci hingga nama setiap parameter/buffer; begitu nama modul tertentu ada di dalamnya, semua submodul di bawahnya akan dikirim ke perangkat yang sama.

no_split_module_classes (`List[str]`, *opsional*) : Daftar nama kelas layer yang tidak boleh dipecah antar perangkat (misalnya layer apa pun yang memiliki koneksi residual).

max_memory (`Dict`, *opsional*) : Kamus pengidentifikasi perangkat ke memori maksimum. Akan menggunakan memori maksimum yang tersedia jika tidak diatur.

offload_folder (`str` atau `os.PathLike`, *opsional*) : Jika `device_map` berisi nilai `"disk"`, folder tempat bobot akan di-offload.

offload_state_dict (`bool`, *opsional*, defaultnya `False`) : Jika `True`, state dict CPU akan di-offload sementara ke hard drive untuk menghindari kehabisan RAM CPU jika bobot state dict CPU + shard terbesar tidak muat.

**Mengembalikan:** `torch.nn.Module`

Model terkuantisasi

Fungsi ini akan mengkuantisasi model input dengan konfigurasi terkait yang diteruskan dalam `bnb_quantization_config`. Jika model berada di perangkat meta, kami akan memuat dan mendistribusikan bobot sesuai dengan `device_map` yang diteruskan. Jika model sudah dimuat, kami akan mengkuantisasi model dan menempatkan model di GPU,

