# Các hàm và lớp tiện ích

Dưới đây là một số hàm tiện ích mà 🤗 Accelerate cung cấp, được phân loại theo trường hợp sử dụng.

## Hằng số

Các hằng số được sử dụng xuyên suốt 🤗 Accelerate để tham chiếu

Dưới đây là các hằng số được sử dụng khi sử dụng [Accelerator.save_state()](/docs/accelerate/v1.16.0/vi/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`

Dưới đây là các hằng số được sử dụng khi sử dụng [Accelerator.save_model()](/docs/accelerate/v1.16.0/vi/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"`

## Lớp Dữ liệu

Đây là các dataclass cơ bản được sử dụng xuyên suốt trong 🤗 Accelerate và chúng có thể được truyền vào dưới dạng tham số.

### Độc lập[[accelerate.utils.ComputeEnvironment]]

Đây là các dataclass độc lập được sử dụng cho các kiểm tra, chẳng hạn như loại hệ thống phân tán đang được sử dụng

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

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

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

Đại diện cho một kiểu của môi trường tính toán.

Giá trị:

- **LOCAL_MACHINE** -- phần cứng cụm máy riêng/tùy chỉnh.
- **AMAZON_SAGEMAKER** -- Amazon SageMaker làm môi trường tính toán.

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

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

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

Đại diện cho một kiểu môi trường phân tán.

Giá trị:

- **NO** -- Không phải môi trường phân tán, chỉ là một tiến trình duy nhất.
- **MULTI_CPU** -- Phân tán trên nhiều nút CPU.
- **MULTI_GPU** -- Phân tán trên nhiều GPU.
- **MULTI_MLU** -- Phân tán trên nhiều MLU.
- **MULTI_SDAA** -- Phân tán trên nhiều SDAAs.
- **MULTI_MUSA** -- Phân tán trên nhiều MUSA.
- **MULTI_NPU** -- Phân tán trên nhiều NPU.
- **MULTI_XPU** -- Phân tán trên nhiều XPU.
- **MULTI_HPU** -- Phân tán trên nhiều HPU.
- **MULTI_NEURON** -- Phân tán trên nhiều lõi Neuron.
- **DEEPSPEED** -- Sử dụng DeepSpeed.
- **FSDP** -- Sử dụng Fully Sharded Data Parallelism (FSDP).
- **XLA** -- Sử dụng TorchXLA.
- **MEGATRON_LM** -- Sử dụng Megatron-LM.

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

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

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

Đại diện cho một backend dynamo (xem https://pytorch.org/docs/stable/torch.compiler.html).

Giá trị:

- **KHÔNG** -- Không sử dụng torch dynamo.
- **EAGER** -- Sử dụng PyTorch để chạy GraphModule đã trích xuất. Cách này khá hữu ích khi gỡ lỗi các vấn đề của TorchDynamo.
- **AOT_EAGER** -- Sử dụng AotAutograd mà không có trình biên dịch, tức là chỉ dùng PyTorch eager cho các đồ thị forward và backward được trích xuất bởi AotAutograd. Điều này hữu ích để gỡ lỗi và khó có thể mang lại tốc độ nhanh hơn.
- **INDUCTOR** -- Sử dụng backend TorchInductor với AotAutograd và cudagraphs bằng cách tận dụng các Triton kernel được codegen. [Đọc thêm](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747)
- **AOT_TS_NVFUSER** -- nvFuser với AotAutograd/TorchScript. [Đọc thêm](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **NVPRIMS_NVFUSER** -- nvFuser với PrimTorch. [Đọc thêm](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **CUDAGRAPHS** -- cudagraphs với AotAutograd. [Đọc thêm](https://github.com/pytorch/torchdynamo/pull/757)
- **OFI** -- Sử dụng Torchscript optimize_for_inference. Chỉ dành cho suy luận. [Đọc thêm](https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html)
- **FX2TRT** -- Sử dụng Nvidia TensorRT để tối ưu hóa suy luận. Chỉ dành cho suy luận. [Đọc thêm](https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst)
- **ONNXRT** -- Sử dụng ONNXRT để suy luận trên CPU/GPU. Chỉ dành cho suy luận. [Đọc thêm](https://onnxruntime.ai/)
- **TENSORRT** -- Sử dụng ONNXRT để chạy TensorRT cho các tối ưu hóa suy luận. [Đọc thêm](https://github.com/onnx/onnx-tensorrt)
- **AOT_TORCHXLA_TRACE_ONCE** -- Sử dụng Pytorch/XLA với tối ưu hóa TorchDynamo, dành cho huấn luyện. [Đọc thêm](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TORCHXLA_TRACE_ONCE** -- Sử dụng Pytorch/XLA với tối ưu hóa TorchDynamo, dành cho suy luận. [Đọc thêm](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TVM** -- Sử dụng Apache TVM để tối ưu hóa suy luận. [Đọc thêm](https://tvm.apache.org/)
- **HPU_BACKEND** -- Sử dụng HPU backend cho các tối ưu hóa suy luận.
- **NEURON** -- Sử dụng backend AWS Neuron cho Trainium/Inferentia.

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

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

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

Đại diện cho một loại trình theo dõi thí nghiệm được hỗ trợ

Giá trị:

- **TẤT CẢ** -- tất cả các trình theo dõi khả dụng trong môi trường được hỗ trợ
- **TENSORBOARD** -- TensorBoard như một công cụ theo dõi thí nghiệm
- **WANDB** -- wandb như một công cụ theo dõi thí nghiệm
- **TRACKIO** -- trackio như một công cụ theo dõi thí nghiệm
- **COMETML** -- comet_ml như một trình theo dõi thí nghiệm
- **MLFLOW** -- mlflow như một trình theo dõi thí nghiệm
- **CLEARML** -- clearml như một công cụ theo dõi thí nghiệm
- **DVCLIVE** -- dvclive như một công cụ theo dõi thí nghiệm
- **SWANLAB** -- swanlab như một công cụ theo dõi thí nghiệm

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

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

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

Đại diện cho một kiểu độ chính xác được sử dụng cho các giá trị số dấu phẩy động

Giá trị:

- **KHÔNG** -- sử dụng độ chính xác đầy đủ (FP32)
- **FP16** -- sử dụng độ chính xác nửa
- **BF16** -- sử dụng độ chính xác brain floating point

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

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

[Nguồn](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)
```

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

Đại diện cho một kiểu môi trường phân tán.

Giá trị:

- **NO** -- Không phải môi trường phân tán, chỉ là một tiến trình duy nhất.
- **DATA_PARALLEL** -- sử dụng sagemaker distributed data parallelism.
- **MODEL_PARALLEL** -- sử dụng song song hóa mô hình phân tán của sagemaker.

### Kwargs[[accelerate.AutocastKwargs]]

Đây là các đối số cấu hình được dành cho các tương tác cụ thể trong hệ sinh thái PyTorch mà Accelerate xử lý ở phía sau.

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

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

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

Sử dụng đối tượng này trong [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) của bạn để tùy chỉnh cách `torch.autocast` hoạt động. Vui lòng tham khảo tài liệu của [context manager](https://pytorch.org/docs/stable/amp.html#torch.autocast) này để biết thêm thông tin về từng đối số.

Ví dụ:

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

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

Sử dụng đối tượng này trong [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) của bạn để tùy chỉnh cách mô hình của bạn được bọc trong `torch.nn.parallel.DistributedDataParallel`. Vui lòng tham khảo tài liệu của [wrapper](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html) này để biết thêm thông tin về từng đối số.

Ví dụ:

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

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

Sử dụng đối tượng này trong [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) của bạn để tùy chỉnh hành vi của độ chính xác hỗn hợp, cụ thể là cách tạo ra `torch.amp.GradScaler` hoặc `torch.cuda.amp.GradScaler` được sử dụng. Vui lòng tham khảo tài liệu của [scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler) này để biết thêm thông tin về từng đối số.

Ví dụ:

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

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

Sử dụng đối tượng này trong [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator) của bạn để tùy chỉnh việc khởi tạo các tiến trình phân tán. Vui lòng tham khảo tài liệu của [phương thức](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) này để biết thêm thông tin về từng đối số.

Lưu ý: Nếu `timeout` được đặt thành `None`, giá trị mặc định sẽ dựa trên cách `backend` được cấu hình.

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

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

Mixin nội bộ triển khai phương thức `to_kwargs()` cho một dataclass.

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

```python
to_kwargs()
```

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

Trả về một từ điển chứa các thuộc tính có giá trị khác với giá trị mặc định của lớp này.

## Plugins[[accelerate.DeepSpeedPlugin]]

Đây là các plugin có thể được truyền vào đối tượng [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator). Mặc dù chúng được định nghĩa ở các phần khác trong tài liệu, nhưng để tiện lợi, tất cả đều có thể xem tại đây:

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

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

**Tham số:**

hf_ds_config (`Any`, mặc định là `None`) : Đường dẫn đến tệp cấu hình DeepSpeed hoặc dict hoặc một đối tượng của lớp `accelerate.utils.deepspeed.HfDeepSpeedConfig`.

gradient_accumulation_steps (`int`, mặc định là `None`) : Số bước để tích lũy gradient trước khi cập nhật trạng thái của optimizer. Nếu không được đặt, sẽ sử dụng giá trị từ `Accelerator` trực tiếp.

gradient_clipping (`float`, mặc định là `None`) : Bật cắt gradient với giá trị.

zero_stage (`int`, mặc định là `None`) : Các tùy chọn có thể là 0, 1, 2, 3. Giá trị mặc định sẽ được lấy từ biến môi trường.

is_train_batch_min (`bool`, mặc định là `True`) : Nếu cả train & eval dataloaders đều được chỉ định, tham số này sẽ quyết định `train_batch_size`.

offload_optimizer_device (`str`, mặc định là `None`) : Các tùy chọn khả dụng là none|cpu|nvme. Chỉ áp dụng với ZeRO Stages 2 và 3.

offload_param_device (`str`, mặc định là `None`) : Các tùy chọn khả dụng là none|cpu|nvme. Chỉ áp dụng với ZeRO Stage 3.

offload_optimizer_nvme_path (`str`, mặc định là `None`) : Các tùy chọn khả dụng là /nvme|/local_nvme. Chỉ áp dụng với ZeRO Stage 3.

offload_param_nvme_path (`str`, mặc định là `None`) : Các tùy chọn khả dụng là /nvme|/local_nvme. Chỉ áp dụng với ZeRO Stage 3.

zero3_init_flag (`bool`, mặc định là `None`) : Cờ để chỉ định có lưu mô hình 16-bit hay không. Chỉ áp dụng với ZeRO Stage-3.

zero3_save_16bit_model (`bool`, mặc định là `None`) : Cờ để chỉ định có lưu mô hình 16-bit hay không. Chỉ áp dụng với ZeRO Stage-3.

transformer_moe_cls_names (`str`, mặc định là `None`) : Danh sách các tên lớp MoE layer của Transformers, phân tách bằng dấu phẩy (phân biệt hoa thường). Ví dụ: `MixtralSparseMoeBlock`, `Qwen2MoeSparseMoeBlock`, `JetMoEAttention`, `JetMoEBlock`, v.v.

Plugin này được sử dụng để tích hợp DeepSpeed.

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

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

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

Xử lý cấu hình DeepSpeed với các giá trị từ kwargs.

#### chọn[[accelerate.DeepSpeedPlugin.select]]

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

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

Đặt HfDeepSpeedWeakref để sử dụng cấu hình deepspeed plugin hiện tại

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

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

**Tham số:**

fsdp_version (`int`, mặc định là `1`) : Phiên bản của FSDP cần sử dụng. Mặc định là 1. Nếu đặt thành 2, trình khởi chạy sẽ kỳ vọng cấu hình đã được chuyển đổi sang định dạng FSDP2.

sharding_strategy (`Union[str, torch.distributed.fsdp.ShardingStrategy]`, mặc định là `'FULL_SHARD'`) : Chiến lược sharding cần sử dụng. Phải là một `str` hoặc một instance của `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`. Đã bị thay thế bởi `reshard_after_forward`.

reshard_after_forward (`Union[str, torch.distributed.fsdp.ShardingStrategy, bool]`, mặc định là `'FULL_SHARD'` cho `fsdp_version=1` và `True` cho `fsdp_version=2`) : Chiến lược sharding cần sử dụng. Phải là một bool nếu `fsdp_version` được đặt thành 2, ngược lại phải là một `str` hoặc một instance của `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`.

backward_prefetch (`Union[str, torch.distributed.fsdp.BackwardPrefetch]`, mặc định là `'NO_PREFETCH'`) : Chiến lược prefetch ngược (backward prefetch) cần sử dụng. Phải là một `str` hoặc một instance của `torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch`.

mixed_precision_policy (`Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]`, mặc định là `None`) : Cấu hình để bật huấn luyện độ chính xác hỗn hợp với FullyShardedDataParallel. Nếu truyền vào một `dict`, nó phải có các khóa sau: `param_dtype`, `reduce_dtype` và `buffer_dtype`, có thể là một instance của `torch.distributed.fsdp.MixedPrecisionPolicy` nếu `fsdp_version` được đặt thành 2. Nếu truyền vào một `str`, nó phải là một trong các giá trị sau: fp8, fp16, bf16, fp32, và được dùng để đặt `param_dtype`, `reduce_dtype` và `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]`, mặc định là `False`) : Có nên offload tham số sang CPU hay không. Giá trị phải là `bool` hoặc một instance của `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload` hoặc `torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy` nếu `fsdp_version` được đặt thành 2.

ignored_modules (`Optional[Union[Iterable[torch.nn.Module], str]]`, mặc định là `None`) : Một danh sách các module cần bỏ qua khi bọc bằng FSDP. Khi truyền một chuỗi, các module sẽ được khớp theo tên bằng regex fullmatch. Nếu `fsdp_version` được đặt thành 2, các module sẽ được chuyển thành các tham số và được sử dụng.

state_dict_type (`Union[str, torch.distributed.fsdp.StateDictType]`, mặc định là `'FULL_STATE_DICT'`) : Kiểu state dict cần sử dụng. Nếu là chuỗi, nó phải là một trong `full_state_dict`, `local_state_dict`, hoặc `sharded_state_dict`.

state_dict_config (`Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]`, mặc định là `None`) : Cấu hình state dict cần sử dụng. Nếu không được truyền vào, giá trị này sẽ được xác định dựa trên `state_dict_type`.

optim_state_dict_config (`Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]`, mặc định là `None`) : Cấu hình state dict của optimizer cần sử dụng. Được xác định dựa trên `state_dict_type` nếu không được truyền vào.

limit_all_gathers (`bool`, mặc định là `True`) : Xác định có để FSDP đồng bộ hóa rõ ràng luồng CPU để ngăn quá nhiều all-gather đang chạy hay không. Giá trị bool này chỉ ảnh hưởng đến các chiến lược phân mảnh (sharded) có lịch trình all-gather. Bật tùy chọn này có thể giúp giảm số lần thử lại (retries) của CUDA malloc.

use_orig_params (`bool`, mặc định là `False`) : Có sử dụng các tham số gốc cho bộ tối ưu hay không.

param_init_fn (`Optional[Callable[[torch.nn.Module], None]`, mặc định là `None`) : Một `Callable[torch.nn.Module] -> None` quy định cách khởi tạo các module hiện đang trên thiết bị meta lên một thiết bị thực. Chỉ áp dụng khi `sync_module_states` là `True`. Mặc định là một `lambda` gọi `to_empty` trên module.

sync_module_states (`bool`, mặc định là `False`) : Xác định xem mỗi đơn vị FSDP được bọc riêng lẻ có nên phát trực tiếp (broadcast) các tham số module từ rank 0 để đảm bảo chúng giống nhau trên tất cả các rank sau khi khởi tạo hay không. Mặc định là `False` trừ khi `cpu_ram_efficient_loading` là `True`, khi đó tùy chọn này sẽ được bật bắt buộc.

forward_prefetch (`bool`, mặc định là `False`) : Xác định việc FSDP có lấy trước (prefetch) thao tác all-gather tiếp theo trong khi thực hiện bước truyền xuôi (forward pass) hay không. Chỉ sử dụng với đồ thị tĩnh (Static graphs).

activation_checkpointing (`bool`, mặc định là `False`) : Một kỹ thuật để giảm mức sử dụng bộ nhớ bằng cách xóa các kích hoạt của một số lớp nhất định và tính toán lại chúng trong quá trình truyền ngược. Về cơ bản, kỹ thuật này đánh đổi thêm thời gian tính toán để giảm mức sử dụng bộ nhớ.

cpu_ram_efficient_loading (`bool`, mặc định là `None`) : Nếu là True, chỉ tiến trình đầu tiên tải checkpoint mô hình được huấn luyện trước, trong khi tất cả các tiến trình khác có trọng số rỗng. Chỉ áp dụng cho Transformers. Khi sử dụng điều này, `sync_module_states` cần phải là `True`.

transformer_cls_names_to_wrap (`Optional[List[str]]`, mặc định là `None`) : Một danh sách tên lớp của các tầng transformer cần bọc. Chỉ áp dụng khi `auto_wrap_policy` là `transformer_based_wrap`.

min_num_params (`Optional[int]`, mặc định là `None`) : Số lượng tham số tối thiểu mà một module phải có để được bọc. Chỉ áp dụng khi `auto_wrap_policy` là `size_based_wrap`.

Plugin này được sử dụng để bật song song dữ liệu phân mảnh hoàn toàn.

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

```python
set_auto_wrap_policy(model)
```

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

Với `model`, tạo một `auto_wrap_policy` dựa trên chính sách được truyền vào và nếu chúng ta có thể sử dụng `transformer_cls_to_wrap`

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

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

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

Đặt chính sách độ chính xác hỗn hợp cho FSDP

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

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

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

Đặt cấu hình state dict dựa trên `StateDictType`.

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

```python
validate_mixed_precision_policy()
```

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

Kiểm tra chính sách độ chính xác hỗn hợp, được trừu tượng hóa để không đưa các lệnh import vào nếu không cần thiết.

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

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

**Tham số:**

num_steps (`int`) : Số bước để tích lũy gradient.

adjust_scheduler (`bool`, *tùy chọn*, mặc định là `True`) : Có điều chỉnh các bước của trình lập lịch để tính đến số bước đang được tích lũy hay không. Nên đặt là `True` nếu trình lập lịch được sử dụng chưa được điều chỉnh cho việc tích lũy gradient.

sync_with_dataloader (`bool`, *tùy chọn*, mặc định là `True`) : Có đồng bộ hóa việc đặt gradient khi đến cuối dataloader hay không.

sync_each_batch (`bool`, *tùy chọn*) : Có đồng bộ hóa việc đặt gradient ở mỗi lô dữ liệu hay không. Đặt thành `True` có thể giảm yêu cầu về bộ nhớ khi sử dụng tích lũy gradient với huấn luyện phân tán, với cái giá là tốc độ.

Một plugin để cấu hình hành vi tích lũy gradient. Bạn chỉ có thể truyền một trong `gradient_accumulation_plugin` hoặc `gradient_accumulation_steps` cho [Accelerator](/docs/accelerate/v1.16.0/vi/package_reference/accelerator#accelerate.Accelerator). Truyền cả hai sẽ gây ra lỗi.

Ví dụ:

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

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

**Tham số:**

tp_degree (`int`, mặc định là `None`) : Độ song song tensor.

pp_degree (`int`, mặc định là `None`) : Độ song song của pipeline.

num_micro_batches (`int`, mặc định là `None`) : Số lượng micro-batch.

gradient_clipping (`float`, mặc định là `None`) : Giá trị cắt gradient dựa trên chuẩn L2 toàn cục (0 để tắt).

sequence_parallelism (`bool`, mặc định là `None`) : Bật song song chuỗi.

recompute_activations (`bool`, mặc định là `None`) : Bật tính toán lại kích hoạt có chọn lọc.

use_distributed_optimizer (`bool`, mặc định là `None`) : Bật bộ tối ưu phân tán.

pipeline_model_parallel_split_rank (`int`, mặc định là `None`) : Rank nơi encoder và decoder nên được tách ra.

num_layers_per_virtual_pipeline_stage (`int`, mặc định là `None`) : Số lượng lớp cho mỗi giai đoạn pipeline ảo.

is_train_batch_min (`str`, mặc định là `True`) : Nếu cả tran & eval dataloaders đều được chỉ định, tham số này sẽ quyết định `micro_batch_size`.

train_iters (`int`, mặc định là `None`) : Tổng số mẫu để huấn luyện trên tất cả các lần chạy huấn luyện. Lưu ý rằng khi sử dụng `MegatronLMDummyScheduler`, bạn cần cung cấp train-iters hoặc train-samples.

train_samples (`int`, mặc định là `None`) : Tổng số mẫu để huấn luyện trên tất cả các lần chạy huấn luyện. Lưu ý rằng khi sử dụng `MegatronLMDummyScheduler`, bạn cần cung cấp train-iters hoặc train-samples.

weight_decay_incr_style (`str`, mặc định là `'constant'`) : Hàm tăng dần hệ số suy giảm trọng số. Các lựa chọn=["constant", "linear", "cosine"].

start_weight_decay (`float`, mặc định là `None`) : Hệ số suy giảm trọng số ban đầu cho quy tắc hóa L2.

end_weight_decay (`float`, mặc định là `None`) : Hệ số suy giảm trọng số cuối của quá trình chạy cho quy tắc hóa L2.

lr_decay_style (`str`, mặc định là `'linear'`) : Hàm suy giảm tốc độ học. choices=['constant', 'linear', 'cosine'].

lr_decay_iters (`int`, mặc định là `None`) : Số lần lặp cho việc suy giảm tốc độ học. Nếu là None, mặc định sẽ là `train_iters`.

lr_decay_samples (`int`, mặc định là `None`) : Số lượng mẫu cho việc suy giảm tốc độ học. Nếu là None, mặc định sẽ là `train_samples`.

lr_warmup_iters (`int`, mặc định là `None`) : Số lần lặp để tăng tuyến tính tốc độ học (learning rate) trong giai đoạn khởi động (warmup).

lr_warmup_samples (`int`, mặc định là `None`) : Số lượng mẫu để làm nóng tuyến tính tốc độ học.

lr_warmup_fraction (`float`, mặc định là `None`) : Tỉ lệ của lr-warmup-(iters/samples) để làm nóng dần (warmup) tuyến tính tốc độ học (learning rate).

min_lr (`float`, mặc định là `0`) : Giá trị tối thiểu cho learning rate. Scheduler sẽ cắt các giá trị thấp hơn ngưỡng này.

consumed_samples (`List`, mặc định là `None`) : Số lượng mẫu được tiêu thụ theo cùng thứ tự với các dataloader trong lời gọi `accelerator.prepare`.

no_wd_decay_cond (`Optional`, mặc định là `None`) : Điều kiện để vô hiệu hóa suy giảm trọng số.

scale_lr_cond (`Optional`, mặc định là `None`) : Điều kiện để điều chỉnh tốc độ học.

lr_mult (`float`, mặc định là `1.0`) : Hệ số nhân tốc độ học.

megatron_dataset_flag (`bool`, mặc định là `False`) : Xác định xem định dạng của tập dữ liệu có tuân theo định dạng Indexed/Cached/MemoryMapped của Megatron-LM hay không.

seq_length (`int`, mặc định là `None`) : Độ dài tối đa của chuỗi cần xử lý.

encoder_seq_length (`int`, mặc định là `None`) : Độ dài tối đa của chuỗi để xử lý cho bộ mã hóa.

decoder_seq_length (`int`, mặc định là `None`) : Độ dài tối đa của chuỗi để xử lý cho bộ giải mã.

tensorboard_dir (`str`, mặc định là `None`) : Đường dẫn để lưu các log tensorboard.

set_all_logging_options (`bool`, mặc định là `False`) : Xác định có thiết lập tất cả các tùy chọn ghi log hay không.

eval_iters (`int`, mặc định là `100`) : Số lần lặp chạy cho đánh giá kiểm tra/xác thực.

eval_interval (`int`, mặc định là `1000`) : Khoảng thời gian giữa các lần chạy đánh giá trên tập kiểm tra.

return_logits (`bool`, mặc định là `False`) : Có trả về logits từ mô hình hay không.

custom_train_step_class (`Optional`, mặc định là `None`) : Lớp bước huấn luyện tùy chỉnh.

custom_train_step_kwargs (`Optional`, mặc định là `None`) : Các tham số kwargs tùy chỉnh cho bước huấn luyện.

custom_model_provider_function (`Optional`, mặc định là `None`) : Hàm cung cấp model tùy chỉnh.

custom_prepare_model_function (`Optional`, mặc định là `None`) : Hàm chuẩn bị mô hình tùy chỉnh.

custom_megatron_datasets_provider_function (`Optional`, mặc định là `None`) : Hàm cung cấp bộ dữ liệu train_valid_test megatron tùy chỉnh.

custom_get_batch_function (`Optional`, mặc định là `None`) : Hàm lấy batch tùy chỉnh.

custom_loss_function (`Optional`, mặc định là `None`) : Hàm mất mát tùy chỉnh.

other_megatron_args (`Optional`, mặc định là `None`) : Các đối số Megatron-LM khác. Vui lòng tham khảo Megatron-LM.

Plugin cho Megatron-LM để kích hoạt song song hóa tensor, pipeline, sequence và dữ liệu. Đồng thời kích hoạt tính toán lại kích hoạt có chọn lọc và các kernel hợp nhất được tối ưu hóa.

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

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

**Tham số:**

backend (`DynamoBackend`, mặc định là `None`) : Một Dynamo backend hợp lệ. Xem https://pytorch.org/docs/stable/torch.compiler.html để biết thêm chi tiết.

mode (`str`, mặc định là `None`) : Các tùy chọn khả dụng là 'default', 'reduce-overhead' hoặc 'max-autotune'.

fullgraph (`bool`, mặc định là `None`) : Cho phép tách mô hình thành nhiều đồ thị con hay không.

dynamic (`bool`, mặc định là `None`) : Có sử dụng hình dạng động cho việc theo dõi hay không.

options (`Any`, mặc định là `None`) : Một từ điển các tùy chọn để truyền cho backend.

disable (`bool`, mặc định là `False`) : Biến torch.compile() thành một thao tác không làm gì (no-op) để kiểm thử

use_regional_compilation (`bool`, mặc định là `None`) : Sử dụng để giảm thời gian biên dịch khởi động lạnh của torch.compile() bằng cách nhắm vào các khối lặp lại của cùng một lớp và biên dịch chúng tuần tự để tận dụng bộ nhớ đệm của trình biên dịch. Ví dụ, trong `GPT2LMHeadModel`, khối/lớp lặp lại là `GPT2Block`, và có thể truy cập bằng `model.transformer.h[0]`. Phần còn lại của mô hình (ví dụ model.lm_head) được biên dịch riêng biệt.

Plugin này được sử dụng để biên dịch một mô hình với PyTorch 2.0

## Cấu hình[[accelerate.utils.BnbQuantizationConfig]]

Đây là các lớp có thể được cấu hình và truyền qua đến tích hợp phù hợp

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

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

**Tham số:**

load_in_8bit (`bool`, mặc định là `False`) : Bật lượng tử hóa 8bit.

llm_int8_threshold (`float`, mặc định là `6.0`) : Giá trị của ngưỡng outliner. Chỉ có liên quan khi `load_in_8bit=True`.

load_in_4bit (`bool`, mặc định là `False`) : Bật lượng tử hóa 4 bit.

bnb_4bit_quant_type (`str`, mặc định là `fp4`) : Đặt kiểu dữ liệu lượng tử hóa trong các lớp `bnb.nn.Linear4Bit`. Các tùy chọn là {'fp4','np4'}.

bnb_4bit_use_double_quant (`bool`, mặc định là `False`) : Bật lượng tử hóa lồng nhau, trong đó các hằng số lượng tử hóa từ lần lượng tử hóa đầu tiên sẽ được lượng tử hóa lại.

bnb_4bit_compute_dtype (`bool`, mặc định là `fp16`) : Tham số này thiết lập kiểu tính toán, có thể khác với kiểu dữ liệu đầu vào. Ví dụ, đầu vào có thể là fp32, nhưng phép tính có thể được đặt thành bf16 để tăng tốc. Các tùy chọn là {'fp32','fp16','bf16'}.

torch_dtype (`torch.dtype`, mặc định là `None`) : Tham số này thiết lập dtype của các lớp chưa được lượng tử hóa còn lại. Thư viện `bitsandbytes` khuyến nghị đặt giá trị thành `torch.float16` cho mô hình 8 bit và sử dụng cùng dtype với dtype tính toán cho mô hình 4 bit.

skip_modules (`List[str]`, mặc định là `None`) : Một danh sách rõ ràng các module mà chúng ta không lượng tử hóa. dtype của các module này sẽ là `torch_dtype`.

keep_in_fp32_modules (`List`, mặc định là `None`) : Một danh sách rõ ràng các module mà chúng ta không lượng tử hóa. Chúng ta giữ chúng ở `torch.float32`.

Một plugin để bật lượng tử hóa 4 bit và 8 bit của 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)
```

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

**Tham số:**

split_batches (`bool`, mặc định là `False`) : Xác định xem accelerator có nên chia các batch do các dataloader tạo ra giữa các thiết bị hay không. Nếu `True`, kích thước batch thực tế được sử dụng sẽ giống nhau trên mọi loại tiến trình phân tán, nhưng nó phải là bội số nguyên của `num_processes` mà bạn đang sử dụng. Nếu `False`, kích thước batch thực tế được sử dụng sẽ là giá trị được đặt trong script của bạn nhân với số lượng tiến trình.

dispatch_batches (`bool`, mặc định là `None`) : Nếu được đặt thành `True`, dataloader được chuẩn bị bởi Accelerator chỉ được lặp qua trên tiến trình chính, sau đó các batch sẽ được chia và phát sóng đến từng tiến trình. Giá trị mặc định sẽ là `True` đối với `DataLoader` có dataset nền tảng là `IterableDataset`, `False` trong các trường hợp khác.

even_batches (`bool`, mặc định là `True`) : Nếu được đặt thành `True`, trong các trường hợp tổng kích thước lô (batch size) trên tất cả các tiến trình không chia hết chính xác cho bộ dữ liệu, các mẫu ở đầu bộ dữ liệu sẽ được nhân bản để lô có thể được chia đều cho tất cả các worker.

use_seedable_sampler (`bool`, mặc định là `False`) : Có sử dụng bộ lấy mẫu ngẫu nhiên có thể đặt hạt hoàn toàn (`data_loader.SeedableRandomSampler`) hay không. Đảm bảo kết quả huấn luyện hoàn toàn có thể tái tạo được bằng cách sử dụng kỹ thuật lấy mẫu khác. Mặc dù kết quả giữa các lần đặt hạt có thể khác nhau, nhưng trung bình sự khác biệt là không đáng kể khi sử dụng nhiều hạt khác nhau để so sánh. Cũng nên chạy cùng với [set_seed()](/docs/accelerate/v1.16.0/vi/package_reference/utilities#accelerate.utils.set_seed) để đạt kết quả tốt nhất.

data_seed (`int`, mặc định là `None`) : Hạt giống (seed) được sử dụng cho bộ tạo (generator) bên dưới khi dùng `use_seedable_sampler`. Nếu là `None`, bộ tạo sẽ sử dụng hạt giống mặc định hiện tại từ torch.

non_blocking (`bool`, mặc định là `False`) : Nếu được đặt thành `True`, dataloader được chuẩn bị bởi Accelerator sẽ sử dụng các thao tác chuyển dữ liệu từ host sang thiết bị không chặn, cho phép chồng chéo tốt hơn giữa việc truyền thông của dataloader và tính toán. Khuyến nghị rằng dataloader đã được chuẩn bị cần đặt `pin_memory` thành `True` để hoạt động đúng.

use_stateful_dataloader (`bool`, mặc định là `False`) : Nếu được đặt thành `True`, dataloader được chuẩn bị bởi Accelerator sẽ được hỗ trợ bởi [torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader). Điều này yêu cầu phải cài đặt `torchdata` phiên bản 0.8.0 trở lên, hỗ trợ StatefulDataLoader.

Cấu hình cho các mục liên quan đến dataloader khi gọi `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)
```

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

**Tham số:**

project_dir (`str`, mặc định là `None`) : Đường dẫn đến một thư mục để lưu trữ dữ liệu.

logging_dir (`str`, mặc định là `None`) : Đường dẫn đến một thư mục để lưu trữ nhật ký của các trình ghi nhật ký tương thích cục bộ. Nếu là None, mặc định là `project_dir`.

automatic_checkpoint_naming (`bool`, mặc định là `False`) : Xác định xem các trạng thái được lưu có nên được đặt tên tự động theo cách lặp lại hay không.

total_limit (`int`, mặc định là `None`) : Số lượng tối đa của các trạng thái đã lưu cần giữ lại.

iteration (`int`, mặc định là `0`) : Lặp lưu hiện tại.

save_on_each_node (`bool`, mặc định là `False`) : Khi thực hiện huấn luyện phân tán đa nút, có nên lưu các mô hình và checkpoint trên mỗi nút hay chỉ trên nút chính.

Cấu hình cho đối tượng Accelerator dựa trên nhu cầu của dự án bên trong.

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

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

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

Đặt `self.project_dir` và `self.logging_dir` thành các giá trị phù hợp.

## Biến môi trường

Đây là các biến môi trường có thể được bật cho các trường hợp sử dụng khác nhau

* `ACCELERATE_DEBUG_MODE` (`str`): Xác định có chạy accelerate ở chế độ gỡ lỗi hay không. Thông tin chi tiết có tại [đây](../basic_tutorials/troubleshooting#hanging-code-and-timeout-errors).

## Xử lý và Thao tác Dữ liệu[[accelerate.utils.broadcast]]

Các thao tác này bao gồm các thao tác dữ liệu mô phỏng các op `torch` tương tự nhưng có thể được sử dụng trên các tiến trình phân tán.

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

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

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

**Tham số:**

tensor (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần thu thập.

from_process (`int`, *tuỳ chọn*, mặc định là 0) : Tiến trình để gửi dữ liệu

**Trả về:**

Cấu trúc dữ liệu giống hệt với `tensor` nhưng tất cả các tensor đã được broadcast đến thiết bị phù hợp.

Phát sóng đệ quy tensor trong danh sách/bộ/bộ từ điển lồng nhau của tensor đến tất cả các thiết bị.

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

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

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

**Tham số:**

object_list (list of picklable objects) : Danh sách các đối tượng cần phát sóng. Danh sách này sẽ bị thay đổi tại chỗ (inplace).

from_process (`int`, *tuỳ chọn*, mặc định là 0) : Tiến trình để gửi dữ liệu.

**Trả về:**

Cùng danh sách chứa các đối tượng từ tiến trình 0.

Phát trực tiếp một danh sách các đối tượng có thể picklable từ một tiến trình sang các tiến trình khác.

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

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

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

**Tham số:**

data (danh sách/bộ tuple/từ điển lồng nhau của các danh sách tensor `torch.Tensor`) : Dữ liệu cần nối.

dim (`int`, *optional*, mặc định là 0) : Chiều để ghép nối.

**Trả về:**

Cấu trúc dữ liệu giống hệt với `data` nhưng tất cả các tensor đã được nối lại với nhau.

Nối đệ quy các tensor trong một danh sách/bộ/bộ từ điển lồng nhau chứa các danh sách tensor có cùng hình dạng. Nếu chỉ có một lô dữ liệu duy nhất, nó sẽ được trả về nguyên vẹn.

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

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

[Nguồn](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)
```

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

**Tham số:**

tensor (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần chuyển đổi từ FP16/BF16 sang FP32.

**Trả về:**

Cấu trúc dữ liệu giống hệt với `tensor` nhưng tất cả các tensor ở độ chính xác FP16/BF16 đã được chuyển đổi sang FP32.

Chuyển đệ quy các phần tử trong danh sách/bộ/đệ quy của các tensor ở độ chính xác FP16/BF16 sang FP32.

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

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

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

**Tham số:**

tensor (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần thu thập.

**Trả về:**

Cấu trúc dữ liệu giống hệt với `tensor` nhưng tất cả các tensor đã được chuyển đến thiết bị phù hợp.

Thu thập đệ quy tensor trong một danh sách/bộ/bộ từ điển lồng nhau của các tensor từ tất cả các thiết bị.

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

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

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

**Tham số:**

object (nested list/tuple/dictionary of picklable object) : Dữ liệu cần thu thập.

**Trả về:**

Cấu trúc dữ liệu giống như `object` với tất cả các đối tượng được gửi đến mọi thiết bị.

Thu thập đệ quy đối tượng trong danh sách/bộ/bộ từ điển lồng nhau của các đối tượng từ tất cả các thiết bị.

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

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

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

**Tham số:**

distributed_type (`DistributedType`, *tùy chọn*, mặc định là None) : Kiểu của môi trường phân tán.

kwargs : Các đối số bổ sung cho bộ khởi tạo `GradScaler` được sử dụng.

Một hàm trợ giúp chung sẽ khởi tạo đúng triển khai `GradScaler` dựa trên môi trường và trả về nó.

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

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

**Tham số:**

native_amp (`bool`, *tùy chọn*, mặc định là False) : Xác định xem độ chính xác hỗn hợp có thực sự được bật hay không.

Trả về một trình quản lý ngữ cảnh cho việc tự động chuyển đổi độ chính xác hỗn hợp

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

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

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

**Tham số:**

data (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu để chuyển đổi thành các số thông thường.

**Trả về:**

Cấu trúc dữ liệu giống như `data` nhưng dùng các danh sách số thay vì `torch.Tensor`.

Tìm đệ quy các tensor trong danh sách/bộ/bộ từ điển lồng nhau và chuyển đổi chúng thành danh sách các số.

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

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

**Tham số:**

tensor (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần thu thập.

dim (`int`, *optional*, mặc định là 0) : Chiều cần đệm.

pad_index (`int`, *tuỳ chọn*, mặc định là 0) : Giá trị dùng để đệm.

pad_first (`bool`, *tùy chọn*, mặc định là `False`) : Có nên đệm ở đầu hay ở cuối không.

Đệm đệ quy các tensor trong danh sách/bộ/bộ từ điển lồng nhau của các tensor từ tất cả các thiết bị để chúng có cùng kích thước, nhằm có thể thu thập chúng một cách an toàn.

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

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

**Tham số:**

func (`callable`) : Hàm cần áp dụng đệ quy.

data (danh sách/bộ tuple/từ điển lồng nhau các đối tượng được chấp nhận bởi `test_type`) : Dữ liệu để áp dụng `func`

- ***args** : Các đối số vị trí sẽ được truyền vào `func` khi áp dụng trên dữ liệu đã được giải nén.

test_type (`Callable[[Any], bool]`, *tùy chọn*, mặc định là `is_torch_tensor`) : Điều kiện quyết định xem có nên áp dụng `func` cho một đối tượng lá cụ thể hay không.

error_on_other_type (`bool`, *tùy chọn*, mặc định là `False`) : Có nên trả về lỗi hay không nếu sau khi giải nén `data`, chúng ta nhận được một đối tượng mà `test_type` trả về `False`. Nếu `False`, hàm sẽ giữ nguyên các đối tượng như vậy.

- ****kwargs** (các đối số từ khóa bổ sung, *tùy chọn*) : Các đối số từ khóa sẽ được truyền đến `func` khi được áp dụng lên dữ liệu đã được giải nén.

**Trả về:**

Cấu trúc dữ liệu giống như `data` với `func` được áp dụng cho mọi đối tượng mà `test_type` trả về `True`.

Áp dụng đệ quy một hàm lên một cấu trúc dữ liệu là danh sách/bộ/bộ từ điển lồng nhau của một kiểu cơ sở cho trước.

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

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

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

**Tham số:**

tensor (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần giảm.

reduction (`str`, *tùy chọn*, mặc định là `"mean"`) : Một phương pháp giảm. Có thể là "mean", "sum", "max" hoặc "none"

scale (`float`, *tuỳ chọn*) : Giá trị tỷ lệ mặc định được áp dụng sau khi thực hiện reduce, chỉ có hiệu lực trên XLA.

**Trả về:**

Cấu trúc dữ liệu giống như `data` với tất cả các tensor đã được giảm.

Giảm đệ quy các tensor trong một danh sách/bộ/bộ từ điển lồng nhau chứa các danh sách tensor trên tất cả các tiến trình bằng trung bình của một thao tác cho trước.

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

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

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

**Tham số:**

tensor (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần gửi đến một thiết bị nhất định.

device (`torch.device`) : Thiết bị để gửi dữ liệu đến.

non_blocking (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, quá trình chuyển đến thiết bị sẽ được thực hiện bất đồng bộ, cho phép chồng chéo việc di chuyển dữ liệu với tính toán. Chỉ có hiệu lực khi thiết bị hỗ trợ (ví dụ: CUDA).

skip_keys (`str` hoặc `List[str]`, *tùy chọn*) : Một khóa hoặc danh sách các khóa trong từ điển `tensor` mà giá trị của chúng không nên được gửi đến `device` đã cho. Các mục có những khóa này sẽ được giữ lại trên thiết bị ban đầu của chúng.

**Trả về:**

Cấu trúc dữ liệu giống hệt với `tensor` nhưng tất cả các tensor đã được chuyển đến thiết bị phù hợp.

Gửi đệ quy các phần tử trong một danh sách/bộ/bộ từ điển lồng nhau của các tensor đến một thiết bị được chỉ định.

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

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

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

**Tham số:**

data (danh sách/bộ tuple/từ điển lồng nhau của `torch.Tensor`) : Dữ liệu cần cắt.

tensor_slice (`slice`) : Phần lát cần lấy.

**Trả về:**

Cấu trúc dữ liệu giống như `data` với tất cả các lát tensor.

Lấy một lát cắt đệ quy trong danh sách/bộ/bộ từ điển lồng nhau của các tensor.

## Kiểm tra môi trường[[accelerate.utils.is_bf16_available]]

Các chức năng này kiểm tra trạng thái của môi trường làm việc hiện tại, bao gồm thông tin về chính hệ điều hành, những gì nó có thể hỗ trợ và các phụ thuộc cụ thể đã được cài đặt hay chưa.

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

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

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

Kiểm tra xem bf16 có được hỗ trợ hay không, tùy chọn bỏ qua TPU

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

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

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

Kiểm tra xem thiết bị MPS có khả dụng hay không. Phiên bản tối thiểu yêu cầu là 1.12.

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

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

Kiểm tra xem `torch_npu` đã được cài đặt hay chưa và có thể kiểm tra xem môi trường có NPU hay không

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

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

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

**Tham số:**

operation (`str`) : Một chuỗi đại diện cho một toán tử, chẳng hạn như `">"` hoặc `"<="`

version (`str`) : Phiên bản chuỗi của PyTorch

So sánh phiên bản PyTorch hiện tại với một tham chiếu đã cho bằng một phép toán.

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

Kiểm tra xem `torch_xla` có khả dụng hay không. Để huấn luyện một tác vụ pytorch thuần trong môi trường đã cài đặt torch xla, hãy đặt USE_TORCH_XLA thành false.

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

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

Kiểm tra xem tăng tốc XPU có khả dụng thông qua PyTorch chuẩn (>=2.7) và có thể kiểm tra xem có XPU trong môi trường hay không

## Thao tác Môi trường[[accelerate.utils.patch_environment]]

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

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

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

Một trình quản lý ngữ cảnh sẽ thêm mỗi đối số từ khóa được truyền vào `os.environ` và xóa chúng khi thoát.

Sẽ chuyển các giá trị trong `kwargs` thành chuỗi và viết hoa tất cả các khóa.

Ví dụ:

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

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

Một trình quản lý ngữ cảnh sẽ tạm thời xóa các biến môi trường.

Khi ngữ cảnh này kết thúc, các biến môi trường trước đó sẽ được khôi phục.

Ví dụ:

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

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

**Tham số:**

mixed_precision (`str`, *tùy chọn*, mặc định là "no") : Độ chính xác hỗn hợp (Mixed Precision) cần sử dụng. Phải là một trong "no", "fp16" hoặc "bf16"

save_location (`str`, *tùy chọn*, mặc định là `default_json_config_file`) : Vị trí lưu tùy chỉnh tùy chọn. Cần được truyền vào `--config_file` khi sử dụng `accelerate launch`. Vị trí mặc định nằm trong thư mục cache của huggingface (`~/.cache/huggingface`) nhưng có thể ghi đè bằng cách đặt biến môi trường `HF_HOME`, sau đó là `accelerate/default_config.yaml`.

Tạo và lưu cấu hình cụm cơ bản để sử dụng trên máy cục bộ, có thể có nhiều GPU. Đồng thời sẽ thiết lập CPU nếu đó là máy chỉ có CPU.

Khi thiết lập 🤗 Accelerate lần đầu tiên, thay vì chạy `accelerate config`, [~utils.write_basic_config] có thể được sử dụng như một phương án thay thế để cấu hình nhanh.

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

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

**Tham số:**

local_process_index (int) : Chỉ mục của tiến trình hiện tại trên máy chủ hiện tại.

verbose (bool, *optional*) : Có in ra phân bổ lõi CPU mới cho từng tiến trình hay không. Nếu `ACCELERATE_DEBUG_MODE` được bật, giá trị mặc định sẽ là True.

Gán tiến trình hiện tại cho một nút NUMA cụ thể. Hiệu quả nhất khi mỗi nút có ít nhất 2 cpu.

Kết quả này được lưu đệm giữa các lần gọi. Nếu bạn muốn ghi đè lên nó, vui lòng sử dụng `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)
```

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

**Tham số:**

local_process_index (int) : Chỉ mục của tiến trình hiện tại trên máy chủ hiện tại.

verbose (bool, *optional*) : Có nên ghi log việc phân bổ cho từng CPU hay không. Nếu `ACCELERATE_DEBUG_MODE` được bật, giá trị mặc định sẽ là True.

Ghi đè bất kỳ NUMA affinity nào được đặt cho tiến trình hiện tại. Thao tác này rất tốn kém và yêu cầu tính toán lại affinity cần đặt, lý tưởng nhất là bạn nên sử dụng `utils.environment.set_numa_affinity` thay thế.

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

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

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

Decorator để dọn dẹp các biến môi trường của accelerate được đặt bởi lớp hoặc hàm được trang trí.

Trong một số trường hợp, việc gọi một số lớp hoặc hàm nhất định có thể dẫn đến việc các biến môi trường của accelerate được đặt và không được dọn dẹp sau đó. Ví dụ, khi gọi:

TrainingArguments(fp16=True, ...)

Biến môi trường sau sẽ được đặt:

ACCELERATE_MIXED_PRECISION=fp16

Điều này có thể ảnh hưởng đến các đoạn mã tiếp theo, vì biến môi trường có độ ưu tiên cao hơn so với TrainingArguments(fp16=False). Điều này đặc biệt quan trọng trong kiểm thử đơn vị, nơi chúng ta muốn tránh việc các bài kiểm thử riêng lẻ gây ra các tác dụng phụ lẫn nhau. Trang trí hàm kiểm thử đơn vị hoặc toàn bộ lớp bằng bộ trang trí này để đảm bảo rằng sau mỗi bài kiểm thử, các biến môi trường được dọn dẹp. Cách này hoạt động cho cả unittest.TestCase và các lớp thông thường (pytest); nó cũng hoạt động khi trang trí lớp cha.

## Bộ nhớ[[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)
```

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

**Tham số:**

function (`callable`, *tùy chọn*) : Một hàm để bọc

starting_batch_size (`int`, *tùy chọn*) : Kích thước lô (batch size) cần cố gắng đưa vào bộ nhớ

reduce_batch_size_fn (`callable`, *tùy chọn*) : Một hàm để xác định kích thước lô mới sau một lỗi hết bộ nhớ. Nếu không được cung cấp, kích thước lô sẽ được nhân với 0.9 sau mỗi lần thất bại. Hàm này không nhận đối số và phải trả về kích thước lô mới (đã giảm) dưới dạng `int`.

Một decorator cơ bản sẽ cố gắng thực thi `function`. Nếu thất bại do các ngoại lệ liên quan đến hết bộ nhớ hoặc CUDNN, kích thước lô sẽ được nhân với 0.9 và được truyền vào `function`

`function` phải nhận tham số `batch_size` làm đối số đầu tiên.

Ví dụ:

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

## Mô hình hóa[[accelerate.utils.calculate_maximum_sizes]]

Các tiện ích này liên quan đến việc tương tác với các mô hình PyTorch

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

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

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

Tính toán kích thước tổng của mô hình và lớp lớn nhất của nó

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

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

Tính kích thước của từng mô-đun con của một mô hình cho trước.

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

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần trích xuất.

keep_fp32_wrapper (`bool`, *tùy chọn*) : Có gỡ bỏ các hook độ chính xác hỗn hợp khỏi mô hình hay không.

keep_torch_compile (`bool`, *tùy chọn*) : Có nên gỡ bọc mô hình đã biên dịch hay không.

recursive (`bool`, *tùy chọn*, mặc định là `False`) : Có nên trích xuất đệ quy tất cả các trường hợp của `module.module` từ `model` cũng như mở bọc đệ quy các lớp con trực thuộc, chứ không chỉ các container phân phối ở cấp cao nhất hay không.

**Trả về:** `torch.nn.Module`

Mô hình đã được trích xuất.

Trích xuất một mô hình từ các container phân tán của 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)
```

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần phân tích.

max_memory (`Dict`, *tùy chọn*) : Một từ điển ánh xạ định danh thiết bị đến bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng. Ví dụ: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *tùy chọn*) : Một danh sách tên lớp (layer) không bao giờ được chia cắt giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư - residual connection).

dtype (`str` hoặc `torch.dtype`, *tùy chọn*) : Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi được nạp.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *tùy chọn*) : Nếu được cung cấp, các dtype đặc biệt cần xem xét cho một số trọng số cụ thể (sẽ ghi đè dtype được dùng làm mặc định cho tất cả các trọng số).

low_zero (`bool`, *tùy chọn*) : Tối thiểu hóa số lượng trọng số trên GPU 0, rất tiện lợi khi GPU này được dùng cho các thao tác khác (chức năng generate của Transformers).

Tính toán từ điển `max_memory` cho [infer_auto_device_map()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.infer_auto_device_map) để cân bằng việc sử dụng mỗi GPU khả dụng.

Toàn bộ phép tính được thực hiện bằng cách phân tích kích thước và dtype của các tham số mô hình. Do đó, mô hình có thể nằm trên thiết bị meta (như khi được khởi tạo bên trong trình quản lý ngữ cảnh `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])
```

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

**Tham số:**

modules (`List[Tuple[str, torch.nn.Module]]`) : Danh sách các module có tên mà chúng ta muốn xác định kích thước lớp tối đa.

module_sizes (`Dict[str, int]`) : Một từ điển ánh xạ mỗi tên lớp đến kích thước của nó (được tạo bởi `compute_module_sizes`).

no_split_module_classes (`List[str]`) : Một danh sách tên lớp cho các lớp mà chúng ta không muốn tách.

**Trả về:** `Tuple[int, List[str]]`

Kích thước tối đa của một lớp kèm theo danh sách tên các lớp đạt được kích thước tối đa đó.

Hàm tiện ích sẽ quét một danh sách các module có tên và trả về kích thước tối đa được sử dụng bởi một lớp đầy đủ. Định nghĩa của một lớp là:
- một module không có con trực tiếp (chỉ có tham số và bộ đệm)
- một module có tên lớp nằm trong danh sách `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)
```

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần phân tích.

max_memory (`Dict`, *tùy chọn*) : Một từ điển ánh xạ định danh thiết bị đến bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng. Ví dụ: `max_memory={0: "1GB"}`.

no_split_module_classes (`List[str]`, *tùy chọn*) : Một danh sách tên lớp (layer) không bao giờ được chia cắt giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư - residual connection).

dtype (`str` hoặc `torch.dtype`, *tùy chọn*) : Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi được nạp.

special_dtypes (`Dict[str, Union[str, torch.device]]`, *tùy chọn*) : Nếu được cung cấp, các dtype đặc biệt cần xem xét cho một số trọng số cụ thể (sẽ ghi đè dtype được dùng làm mặc định cho tất cả các trọng số).

verbose (`bool`, *tùy chọn*, mặc định là `False`) : Có cung cấp các câu lệnh gỡ lỗi khi hàm xây dựng device_map hay không.

clean_result (`bool`, *tùy chọn*, mặc định là `True`) : Làm sạch device_map kết quả bằng cách nhóm tất cả các submodule chạy trên cùng một thiết bị lại với nhau.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Trong các lớp được offload lên CPU hoặc ổ cứng, có offload cả buffers cùng với các tham số hay không.

fallback_allocation (`bool`, *tùy chọn*, mặc định là `False`) : Khi phân bổ thông thường thất bại, hãy thử phân bổ một module phù hợp với giới hạn kích thước bằng BFS.

Tính toán bản đồ thiết bị cho một mô hình đã cho, ưu tiên sử dụng GPU, sau đó offload sang CPU và cuối cùng offload sang đĩa, sao cho:
- chúng ta không vượt quá bộ nhớ khả dụng của bất kỳ GPU nào.
- nếu cần offload sang CPU, luôn còn chỗ trống trên GPU 0 để đưa lại lớp có kích thước lớn nhất đã được offload sang CPU.
- nếu cần offload sang CPU, chúng ta sẽ không vượt quá bộ nhớ RAM khả dụng trên CPU.
- nếu cần offload ra đĩa, luôn còn chỗ trống trên CPU để đưa lại lớp có kích thước lớn nhất đã được offload ra đĩa.

Toàn bộ phép tính được thực hiện bằng cách phân tích kích thước và dtype của các tham số mô hình. Do đó, mô hình có thể nằm trên thiết bị meta (như khi được khởi tạo bên trong trình quản lý ngữ cảnh `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)
```

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình mà chúng ta muốn nạp checkpoint vào.

checkpoint (`str` hoặc `os.PathLike`) : Thư mục checkpoint cần tải. Có thể là: - đường dẫn đến tệp chứa toàn bộ state dict của model - đường dẫn đến tệp `.json` chứa index của checkpoint dạng sharded - đường dẫn đến thư mục chứa tệp `.index.json` duy nhất và các shard của checkpoint. - đường dẫn đến thư mục chứa tệp pytorch_model.bin hoặc model.safetensors duy nhất.

device_map (`Dict[str, Union[int, str, torch.device]]`, *tùy chọn*) : Một bản đồ chỉ định vị trí mà mỗi submodule nên được đặt. Không cần phải chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một device.

offload_folder (`str` hoặc `os.PathLike`, *tùy chọn*) : Nếu `device_map` chứa bất kỳ giá trị nào là `"disk"`, đây là thư mục nơi chúng ta sẽ offload các trọng số.

dtype (`str` hoặc `torch.dtype`, *tùy chọn*) : Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi được nạp.

offload_state_dict (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có bao gồm các buffer trong các trọng số được chuyển xuống đĩa hay không.

keep_in_fp32_modules(`List[str]`, *tuỳ chọn*) : Một danh sách các module mà chúng ta giữ ở kiểu dữ liệu `torch.float32`.

offload_8bit_bnb (`bool`, *tùy chọn*) : Có bật offload các module 8-bit lên cpu/disk hay không.

strict (`bool`, *tùy chọn*, mặc định là `False`) : Có nên thực thi nghiêm ngặt việc các khóa trong state_dict của checkpoint khớp với các khóa của state_dict của mô hình hay không.

full_state_dict (`bool`, *tùy chọn*, mặc định là `True`) : nếu giá trị này được đặt thành `True`, tất cả các tensor trong state_dict đã tải sẽ được gom lại. state_dict đã tải sẽ không chứa ShardedTensor và DTensor.

broadcast_from_rank0 (`False`, *tùy chọn*, mặc định là `False`) : khi tùy chọn này là `True`, một `ProcessGroup` phân tán phải được khởi tạo. rank0 sẽ nhận một state_dict đầy đủ và sẽ broadcast các tensor trong state_dict lần lượt đến các rank khác. Các rank khác sẽ nhận các tensor và chia nhỏ (nếu áp dụng) theo các shard cục bộ trong mô hình.

Tải một checkpoint (có thể được chia mảnh) bên trong một model, đồng thời có thể gửi các trọng số đến một thiết bị đã chỉ định trong quá trình tải.

Sau khi tải lên các thiết bị, bạn vẫn cần gọi [dispatch_model()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.dispatch_model) trên mô hình của mình để nó có thể chạy. Để nhóm việc tải checkpoint và dispatch vào một lần gọi duy nhất, hãy sử dụng [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/vi/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)
```

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình để nạp trọng số vào.

index (`dict`) : Một từ điển chứa tên tham số và các siêu dữ liệu của nó cho từng tham số đã được offload khỏi mô hình.

offload_folder (`str`) : Thư mục nơi các trọng số bị đẩy xuống (offloaded) được lưu trữ.

Tải trọng số từ thư mục offload vào mô hình.

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

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

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

**Tham số:**

checkpoint_file (`str`) : Đường dẫn đến checkpoint cần tải.

device_map (`Dict[str, Union[int, str, torch.device]]`, *tùy chọn*) : Một bản đồ chỉ định vị trí mà mỗi submodule nên được đặt. Không cần phải chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một device.

Tải checkpoint từ một tệp được chỉ định. Nếu checkpoint ở định dạng safetensors và một device map được truyền vào, các trọng số có thể được tải nhanh trực tiếp trên 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])
```

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

**Tham số:**

save_dir (`str` hoặc `os.PathLike`) : Thư mục để offload state dict.

state_dict (`Dict[str, torch.Tensor]`) : Từ điển các tensor cần offload.

Tải xuống một state dict vào một thư mục đã cho.

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

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

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình mà bạn muốn gắn lại các tham số.

tied_params (`List[List[str]]`) : Tham số ánh xạ từ tên tham số đến tên tham số liên kết, được lấy từ `find_tied_parameters`.

Thiết lập lại các tham số bị ràng buộc trong một mô hình đã cho nếu liên kết bị hỏng (ví dụ khi thêm các 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)
```

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

**Tham số:**

module (`torch.nn.Module`) : Module chứa tensor mà chúng ta muốn di chuyển.

tensor_name (`str`) : Tên đầy đủ của tham số/buffer.

device (`int`, `str` hoặc `torch.device`) : Thiết bị để đặt tensor.

value (`torch.Tensor`, *tùy chọn*) : Giá trị của tensor (hữu ích khi chuyển từ thiết bị meta sang bất kỳ thiết bị nào khác).

dtype (`torch.dtype`, *tùy chọn*) : Nếu được truyền vào, giá trị của tham số sẽ được chuyển đổi sang `dtype` này. Nếu không, `value` sẽ được chuyển đổi sang dtype của tham số hiện có trong mô hình.

fp16_statistics (`torch.HalfTensor`, *tuỳ chọn*) : Danh sách các thống kê fp16 cần thiết lập cho module, được dùng để xuất mô hình 8 bit.

tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], *tuỳ chọn*, mặc định là `None`) : Một bản đồ ánh xạ các con trỏ dữ liệu hiện tại tới các từ điển ánh xạ thiết bị tới các trọng số liên kết đã được điều phối. Đối với một thiết bị thực thi nhất định, tham số này hữu ích để tái sử dụng con trỏ khả dụng đầu tiên của một trọng số dùng chung trên thiết bị cho tất cả các trọng số khác, thay vì sao chép bộ nhớ.

non_blocking (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, việc chuyển thiết bị sẽ diễn ra bất đồng bộ so với host, nếu có thể.

clear_cache (`bool`, *tùy chọn*, mặc định là `True`) : Có xóa bộ nhớ đệm của thiết bị sau khi đặt tensor trên thiết bị hay không.

Một hàm trợ giúp để đặt một tensor (tham số hoặc buffer) nhất định của một module lên một thiết bị cụ thể (lưu ý rằng việc thực hiện `param.to(device)` sẽ tạo ra một tensor mới không liên kết với tham số, đó là lý do chúng ta cần hàm này).

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

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

**Tham số:**

model (`torch.nn.Module`) : mô hình cần lấy các phần tử con

**Trả về:** `list[torch.nn.Module]`

một danh sách các module con của `model` theo thứ tự từ dưới lên trên. Phần tử cuối cùng chính là `model`.

Duyệt mô hình theo thứ tự từ dưới lên và trả về các module con theo thứ tự đó.

## Song song[[accelerate.utils.extract_model_from_parallel]]

Những tiện ích này bao gồm các tiện ích chung nên được sử dụng khi làm việc song song.

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

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình cần trích xuất.

keep_fp32_wrapper (`bool`, *tùy chọn*) : Có gỡ bỏ các hook độ chính xác hỗn hợp khỏi mô hình hay không.

keep_torch_compile (`bool`, *tùy chọn*) : Có nên gỡ bọc mô hình đã biên dịch hay không.

recursive (`bool`, *tùy chọn*, mặc định là `False`) : Có nên trích xuất đệ quy tất cả các trường hợp của `module.module` từ `model` cũng như mở bọc đệ quy các lớp con trực thuộc, chứ không chỉ các container phân phối ở cấp cao nhất hay không.

**Trả về:** `torch.nn.Module`

Mô hình đã được trích xuất.

Trích xuất một mô hình từ các container phân tán của nó.

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

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

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

**Tham số:**

obj : Dữ liệu cần lưu

f : Tệp (hoặc đối tượng giống tệp) được sử dụng để lưu trữ dữ liệu

save_on_each_node (`bool`, *tùy chọn*, mặc định là `False`) : Có chỉ lưu trên tiến trình chính toàn cục hay không

safe_serialization (`bool`, *tùy chọn*, mặc định là `False`) : Có nên lưu `obj` bằng `safetensors` hay theo cách truyền thống của PyTorch (sử dụng `pickle`) hay không.

Lưu dữ liệu xuống đĩa. Sử dụng thay cho `torch.save()`.

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

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

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

**Tham số:**

f : Tệp (hoặc đối tượng giống tệp) được sử dụng để tải dữ liệu

map_location : một hàm, `torch.device`, chuỗi hoặc dict chỉ định cách ánh xạ lại các vị trí lưu trữ

- ****kwargs** : Các đối số từ khóa bổ sung để truyền cho `torch.load()`.

Thay thế tương thích hoàn toàn cho `torch.load()`, cho phép sử dụng `weights_only` nếu phiên bản `torch` là 2.4.0 trở lên. Ngược lại, tham số này sẽ bị bỏ qua.

Cũng sẽ thêm (và sau đó gỡ bỏ) một ngoại lệ cho mảng numpy

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

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

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

Giới thiệu một điểm chặn trong script, đảm bảo tất cả các tiến trình đã đạt đến điểm này trước khi tiếp tục.

Hãy đảm bảo tất cả các tiến trình đều thực hiện đến chỉ lệnh này, nếu không một trong các tiến trình của bạn sẽ treo vĩnh viễn.

## Ngẫu nhiên[[accelerate.utils.set_seed]]

Các tiện ích này liên quan đến việc thiết lập và đồng bộ hóa tất cả các trạng thái ngẫu nhiên.

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

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

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

**Tham số:**

seed (`int`) : Hạt giống cần thiết lập.

device_specific (`bool`, *tùy chọn*, mặc định là `False`) : Có nên làm cho seed khác nhau một chút trên mỗi thiết bị bằng `self.process_index` hay không.

deterministic (`bool`, *tùy chọn*, mặc định là `False`) : Có sử dụng các thuật toán tất định khi có sẵn hay không. Có thể làm chậm quá trình huấn luyện.

Hàm phụ trợ cho hành vi có thể tái lập để đặt hạt giống trong `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)
```

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

Đồng bộ hóa RNG tích hợp sẵn hoặc RNG của bộ tăng tốc hiện tại, được xác định bởi loại thiết bị của nó.

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

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

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

Những tiện ích này bao gồm các công cụ hữu ích khi sử dụng PyTorch với XLA.

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

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

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

**Tham số:**

upgrade (`bool`, *tùy chọn*, mặc định là `False`) : Có nâng cấp `torch` và cài đặt các bánh xe `torch_xla` mới nhất hay không.

Hàm phụ trợ để cài đặt các bánh xe xla phù hợp dựa trên phiên bản `torch` trong Google Colaboratory.

Ví dụ:

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

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

## Tải trọng số mô hình[[accelerate.load_checkpoint_in_model]]

Những tiện ích này bao gồm các công cụ hữu ích để tải 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)
```

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình mà chúng ta muốn nạp checkpoint vào.

checkpoint (`str` hoặc `os.PathLike`) : Thư mục checkpoint cần tải. Có thể là: - đường dẫn đến tệp chứa toàn bộ state dict của model - đường dẫn đến tệp `.json` chứa index của checkpoint dạng sharded - đường dẫn đến thư mục chứa tệp `.index.json` duy nhất và các shard của checkpoint. - đường dẫn đến thư mục chứa tệp pytorch_model.bin hoặc model.safetensors duy nhất.

device_map (`Dict[str, Union[int, str, torch.device]]`, *tùy chọn*) : Một bản đồ chỉ định vị trí mà mỗi submodule nên được đặt. Không cần phải chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một device.

offload_folder (`str` hoặc `os.PathLike`, *tùy chọn*) : Nếu `device_map` chứa bất kỳ giá trị nào là `"disk"`, đây là thư mục nơi chúng ta sẽ offload các trọng số.

dtype (`str` hoặc `torch.dtype`, *tùy chọn*) : Nếu được cung cấp, trọng số sẽ được chuyển đổi sang kiểu đó khi được nạp.

offload_state_dict (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa.

offload_buffers (`bool`, *tùy chọn*, mặc định là `False`) : Có bao gồm các buffer trong các trọng số được chuyển xuống đĩa hay không.

keep_in_fp32_modules(`List[str]`, *tuỳ chọn*) : Một danh sách các module mà chúng ta giữ ở kiểu dữ liệu `torch.float32`.

offload_8bit_bnb (`bool`, *tùy chọn*) : Có bật offload các module 8-bit lên cpu/disk hay không.

strict (`bool`, *tùy chọn*, mặc định là `False`) : Có nên thực thi nghiêm ngặt việc các khóa trong state_dict của checkpoint khớp với các khóa của state_dict của mô hình hay không.

full_state_dict (`bool`, *tùy chọn*, mặc định là `True`) : nếu giá trị này được đặt thành `True`, tất cả các tensor trong state_dict đã tải sẽ được gom lại. state_dict đã tải sẽ không chứa ShardedTensor và DTensor.

broadcast_from_rank0 (`False`, *tùy chọn*, mặc định là `False`) : khi tùy chọn này là `True`, một `ProcessGroup` phân tán phải được khởi tạo. rank0 sẽ nhận một state_dict đầy đủ và sẽ broadcast các tensor trong state_dict lần lượt đến các rank khác. Các rank khác sẽ nhận các tensor và chia nhỏ (nếu áp dụng) theo các shard cục bộ trong mô hình.

Tải một checkpoint (có thể được chia mảnh) bên trong một model, đồng thời có thể gửi các trọng số đến một thiết bị đã chỉ định trong quá trình tải.

Sau khi tải lên các thiết bị, bạn vẫn cần gọi [dispatch_model()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.dispatch_model) trên mô hình của mình để nó có thể chạy. Để nhóm việc tải checkpoint và dispatch vào một lần gọi duy nhất, hãy sử dụng [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/vi/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

## Lượng tử hóa[[accelerate.utils.load_and_quantize_model]]

Những tiện ích này bao gồm các công cụ hữu ích để lượng tử hóa mô hình.

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

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

**Tham số:**

model (`torch.nn.Module`) : Mô hình đầu vào. Mô hình có thể đã được tải hoặc đang trên thiết bị meta

bnb_quantization_config (`BnbQuantizationConfig`) : Các tham số lượng tử hóa bitsandbytes

weights_location (`str` hoặc `os.PathLike`) : Thư mục weights_location để tải. Có thể là: - đường dẫn đến tệp chứa toàn bộ state dict của model - đường dẫn đến tệp `.json` chứa index của checkpoint dạng sharded - đường dẫn đến thư mục chứa tệp `.index.json` duy nhất và các shard của checkpoint. - đường dẫn đến thư mục chứa tệp pytorch_model.bin duy nhất.

device_map (`Dict[str, Union[int, str, torch.device]]`, *tùy chọn*) : Một bản đồ chỉ định vị trí mà mỗi submodule nên được đặt. Không cần phải chi tiết đến tên của từng parameter/buffer, một khi tên của một module đã được đưa vào, mọi submodule của nó sẽ được gửi đến cùng một device.

no_split_module_classes (`List[str]`, *tùy chọn*) : Một danh sách tên lớp (layer) không bao giờ được chia cắt giữa các thiết bị (ví dụ bất kỳ lớp nào có kết nối dư - residual connection).

max_memory (`Dict`, *tùy chọn*) : Một từ điển ánh xạ định danh thiết bị đến bộ nhớ tối đa. Nếu không được đặt, giá trị mặc định sẽ là bộ nhớ tối đa khả dụng.

offload_folder (`str` hoặc `os.PathLike`, *tùy chọn*) : Nếu `device_map` chứa bất kỳ giá trị nào là `"disk"`, đây là thư mục nơi chúng ta sẽ offload các trọng số.

offload_state_dict (`bool`, *tùy chọn*, mặc định là `False`) : Nếu `True`, sẽ tạm thời offload state dict CPU xuống ổ cứng để tránh hết RAM CPU nếu trọng số của state dict CPU + shard lớn nhất không vừa.

**Trả về:** `torch.nn.Module`

Mô hình đã lượng tử hóa

Hàm này sẽ lượng tử hóa mô hình đầu vào với cấu hình liên quan được truyền vào `bnb_quantization_config`. Nếu mô hình đang ở trên thiết bị meta, chúng tôi sẽ tải và phân phối các trọng số theo `device_map` được truyền. Nếu mô hình đã được tải, chúng tôi sẽ lượng tử hóa mô hình và đặt mô hình lên GPU,

