# ユーティリティ関数とクラス

以下に、ユースケース別に分類された、🤗 Accelerate が提供するさまざまなユーティリティ関数を紹介します。

## 定数

🤗 Accelerate全体で参照用に使用される定数

[Accelerator.save_state()](/docs/accelerate/v1.16.0/ja/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`

[Accelerator.save_model()](/docs/accelerate/v1.16.0/ja/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"`

## データクラス

これらは🤗 Accelerate全体で使用される基本的なdataclassであり、パラメータとして渡すことができます。

### スタンドアロン[[accelerate.utils.ComputeEnvironment]]

これらは、使用されている分散システムの種類などのチェックに使用される独立したデータクラスです

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

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

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

計算環境の型を表します。

値:

- **LOCAL_MACHINE** -- プライベート/カスタムクラスタのハードウェア。
- **AMAZON_SAGEMAKER** -- Amazon SageMaker を計算環境として使用します。

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

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

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

分散環境のタイプを表します。

値:

- **NO** -- 分散環境ではなく、単一プロセスのみです。
- **MULTI_CPU** -- 複数のCPUノードに分散します。
- **MULTI_GPU** -- 複数のGPUに分散配置します。
- **MULTI_MLU** -- 複数のMLUに分散配置。
- **MULTI_SDAA** -- 複数のSDAAに分散配置。
- **MULTI_MUSA** -- 複数のMUSA上で分散実行。
- **MULTI_NPU** -- 複数のNPUに分散配置します。
- **MULTI_XPU** -- 複数のXPUに分散配置。
- **MULTI_HPU** -- 複数のHPUに分散配置します。
- **MULTI_NEURON** -- 複数のNeuronコアに分散配置します。
- **DEEPSPEED** -- DeepSpeedの使用。
- **FSDP** -- Fully Sharded Data Parallelism (FSDP) の使用。
- **XLA** -- TorchXLAの使用。
- **MEGATRON_LM** -- Megatron-LMを使用します。

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

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

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

dynamo バックエンドを表します（https://pytorch.org/docs/stable/torch.compiler.html を参照）。

値:

- **いいえ** -- torch dynamo は使用しないでください。
- **EAGER** -- PyTorchを使用して抽出されたGraphModuleを実行します。TorchDynamoの問題のデバッグに非常に役立ちます。
- **AOT_EAGER** -- コンパイラを使用せずにAotAutogradを使用します。つまり、AotAutogradによって抽出されたフォワードグラフとバックワードグラフに対して、PyTorchのイージーマークのみを使用します。これはデバッグに有用ですが、高速化が得られる可能性は低いです。
- **INDUCTOR** -- コード生成されたTritonカーネルを活用し、AotAutogradとcudagraphsを用いたTorchInductorバックエンドを使用します。[詳細はこちら](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747)
- **AOT_TS_NVFUSER** -- AotAutograd/TorchScript 付きの nvFuser。[詳細はこちら](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **NVPRIMS_NVFUSER** -- PrimTorch 対応の nvFuser。[詳細はこちら](https://dev-discuss.pytorch.org/t/tracing-with-primitives-update-1-nvfuser-and-its-primitives/593)
- **CUDAGRAPHS** -- AotAutograd による cudagraphs。[詳細はこちら](https://github.com/pytorch/torchdynamo/pull/757)
- **OFI** -- Torchscriptのoptimize_for_inferenceを使用します。推論専用です。[詳細はこちら](https://pytorch.org/docs/stable/generated/torch.jit.optimize_for_inference.html)
- **FX2TRT** -- 推論の最適化にNvidia TensorRTを使用します。推論のみに対応しています。[詳細はこちら](https://github.com/pytorch/TensorRT/blob/master/docsrc/tutorials/getting_started_with_fx_path.rst)
- **ONNXRT** -- CPU/GPUでの推論にONNXRTを使用します。推論のみに対応しています。[詳細はこちら](https://onnxruntime.ai/)
- **TENSORRT** -- ONNXRTを使用してTensorRTを実行し、推論の最適化を行います。[詳細はこちら](https://github.com/onnx/onnx-tensorrt)
- **AOT_TORCHXLA_TRACE_ONCE** -- 学習用に、TorchDynamo最適化を備えたPytorch/XLAを使用します。[詳細はこちら](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TORCHXLA_TRACE_ONCE** -- 推論用に、TorchDynamo最適化を適用したPytorch/XLAを使用します。[詳細はこちら](https://github.com/pytorch/xla/blob/r2.0/docs/dynamo.md)
- **TVM** -- Apache TVM を推論の最適化に使用します。[詳細はこちら](https://tvm.apache.org/)
- **HPU_BACKEND** -- 推論の最適化にHPUバックエンドを使用します。
- **NEURON** -- Trainium/Inferentia用のAWS Neuronバックエンドを使用します。

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

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

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

サポートされている実験トラッカーの種類を表します

値:

- **ALL** -- 環境内で利用可能かつサポートされているすべてのトラッカー
- **TENSORBOARD** -- 実験トラッカーとしてのTensorBoard
- **WANDB** -- wandb を実験トラッカーとして
- **TRACKIO** -- 実験トラッカーとしてのtrackio
- **COMETML** -- comet_ml を実験トラッカーとして
- **MLFLOW** -- 実験トラッカーとしての mlflow
- **CLEARML** -- clearml を実験トラッカーとして
- **DVCLIVE** -- dvclive を実験トラッカーとして
- **SWANLAB** -- swanlab を実験トラッカーとして

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

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

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

浮動小数点数値に使用される精度の種類を表します

値:

- **いいえ** -- 完全精度（FP32）を使用
- **FP16** -- 半精度を使用
- **BF16** -- ブレイン浮動小数点精度を使用

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

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

[ソース](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)
```

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

分散環境のタイプを表します。

値:

- **NO** -- 分散環境ではなく、単一プロセスのみです。
- **DATA_PARALLEL** -- sagemakerの分散データ並列性を使用します。
- **MODEL_PARALLEL** -- sagemakerの分散モデル並列性を使用します。

### Kwargs[[accelerate.AutocastKwargs]]

これらは、Accelerate が内部で処理する、PyTorch エコシステム全体における特定のインタラクションに関する設定可能な引数です。

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

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

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

このオブジェクトを[Accelerator](/docs/accelerate/v1.16.0/ja/package_reference/accelerator#accelerate.Accelerator)で使用して、`torch.autocast`の動作をカスタマイズします。各引数に関する詳細は、この[context manager](https://pytorch.org/docs/stable/amp.html#torch.autocast)のドキュメントを参照してください。

例:

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

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

このオブジェクトを[Accelerator](/docs/accelerate/v1.16.0/ja/package_reference/accelerator#accelerate.Accelerator)で使用して、モデルが`torch.nn.parallel.DistributedDataParallel`でラップされる方法をカスタマイズします。各引数に関する詳細は、この[wrapper](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)のドキュメントを参照してください。

例:

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

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

このオブジェクトを[Accelerator](/docs/accelerate/v1.16.0/ja/package_reference/accelerator#accelerate.Accelerator)で使用して、混合精度の動作、特に使用される`torch.amp.GradScaler`または`torch.cuda.amp.GradScaler`の作成方法をカスタマイズします。各引数に関する詳細は、この[scaler](https://pytorch.org/docs/stable/amp.html?highlight=gradscaler)のドキュメントを参照してください。

例:

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

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

このオブジェクトを[Accelerator](/docs/accelerate/v1.16.0/ja/package_reference/accelerator#accelerate.Accelerator)で使用して、分散プロセスの初期化をカスタマイズします。各引数に関する詳細は、この[メソッド](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group)のドキュメントを参照してください。

注: `timeout`が`None`に設定されている場合、デフォルト値は`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()
```

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

`to_kwargs()`メソッドを実装するdataclass用の内部ミックスインです。

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

```python
to_kwargs()
```

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

このクラスのデフォルト値と異なる値を持つ属性を格納した辞書を返します。

## プラグイン[[accelerate.DeepSpeedPlugin]]

これらは[Accelerator](/docs/accelerate/v1.16.0/ja/package_reference/accelerator#accelerate.Accelerator)オブジェクトに渡すことができるプラグインです。ドキュメントの他の場所で定義されていますが、利便性のため、ここではすべて確認できます。

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

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

**パラメータ:**

hf_ds_config (`Any`、デフォルトは`None`) : DeepSpeed設定ファイルへのパス、dict、または`accelerate.utils.deepspeed.HfDeepSpeedConfig`クラスのオブジェクト。

gradient_accumulation_steps (`int`、デフォルトは`None`) : オプティマイザの状態を更新する前に勾配を累積するステップ数。設定されていない場合、`Accelerator`の値を直接使用します。

gradient_clipping (`float`、デフォルトは`None`) : 指定した値で勾配クリッピングを有効にします。

zero_stage (`int`、デフォルトは`None`) : 選択可能なオプションは 0、1、2、3 です。デフォルト値は環境変数から取得されます。

is_train_batch_min (`bool`、デフォルトは`True`) : trainおよびevalの両方のdataloaderが指定されている場合、`train_batch_size`を決定します。

offload_optimizer_device (`str`、デフォルトは`None`) : 選択可能なオプションは none|cpu|nvme です。ZeRO Stage 2 と 3 の場合にのみ適用されます。

offload_param_device (`str`、デフォルトは`None`) : 選択可能なオプションはnone|cpu|nvmeです。ZeRO Stage 3でのみ適用されます。

offload_optimizer_nvme_path (`str`、デフォルトは`None`) : 選択可能なオプションは/nvme|/local_nvmeです。ZeRO Stage 3でのみ適用されます。

offload_param_nvme_path (`str`、デフォルトは`None`) : 選択可能なオプションは/nvme|/local_nvmeです。ZeRO Stage 3でのみ適用されます。

zero3_init_flag (`bool`、デフォルトは`None`) : 16ビットモデルを保存するかどうかを示すフラグ。ZeRO Stage-3でのみ適用されます。

zero3_save_16bit_model (`bool`、デフォルトは`None`) : 16ビットモデルを保存するかどうかを示すフラグ。ZeRO Stage-3でのみ適用されます。

transformer_moe_cls_names (`str`、デフォルトは`None`) : Transformers の MoE レイヤーのクラス名のカンマ区切りリスト（大文字と小文字を区別します）。例えば、`MixtralSparseMoeBlock`、`Qwen2MoeSparseMoeBlock`、`JetMoEAttention`、`JetMoEBlock` など。

このプラグインは、DeepSpeed を統合するために使用されます。

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

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

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

kwargs の値で DeepSpeed の設定を処理します。

#### 選択[[accelerate.DeepSpeedPlugin.select]]

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

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

現在のdeepspeedプラグイン設定を使用するようにHfDeepSpeedWeakrefを設定します

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

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

**パラメータ:**

fsdp_version (`int`、デフォルトは`1`) : 使用するFSDPのバージョンです。デフォルトは1です。2に設定すると、ランチャーは設定がFSDP2形式に変換されていることを期待します。

sharding_strategy (`Union[str, torch.distributed.fsdp.ShardingStrategy]`、デフォルトは`'FULL_SHARD'`) : 使用するシャーディング戦略。`str`または`torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy`のインスタンスである必要があります。`reshard_after_forward`に置き換えられました。

reshard_after_forward (`Union[str, torch.distributed.fsdp.ShardingStrategy, bool]`、`fsdp_version=1` の場合は `'FULL_SHARD'`、`fsdp_version=2` の場合は `True` がデフォルト) : 使用するシャーディング戦略。`fsdp_version` が 2 に設定されている場合は bool 型、それ以外の場合は `str` または `torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy` のインスタンスである必要があります。

backward_prefetch (`Union[str, torch.distributed.fsdp.BackwardPrefetch]`、デフォルトは`'NO_PREFETCH'`) : 使用するバックワードプリフェッチ戦略。`str`または`torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch`のインスタンスである必要があります。

mixed_precision_policy (`Optional[Union[dict, str, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]]`、デフォルトは`None`) : FullyShardedDataParallelによる混合精度学習を有効にするための設定です。`dict`を渡す場合は、`param_dtype`、`reduce_dtype`、`buffer_dtype`のキーを持つ必要があります。`fsdp_version`が2に設定されている場合、`torch.distributed.fsdp.MixedPrecisionPolicy`のインスタンスを渡すこともできます。`str`を渡す場合は、fp8、fp16、bf16、fp32のいずれかの値である必要があり、`param_dtype`、`reduce_dtype`、`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]`、デフォルトは`False`) : パラメータをCPUにオフロードするかどうか。`bool`、または`fsdp_version`が2に設定されている場合は`torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload`または`torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffloadPolicy`のインスタンスである必要があります。

ignored_modules (`Optional[Union[Iterable[torch.nn.Module], str]]`、デフォルトは`None`) : FSDPでラップする際に無視するモジュールのリストです。文字列を渡す場合、正規表現のfullmatchを使用してモジュール名に一致させます。`fsdp_version`が2に設定されている場合、モジュールはパラメータに変換されて使用されます。

state_dict_type (`Union[str, torch.distributed.fsdp.StateDictType]`、デフォルトは`'FULL_STATE_DICT'`) : 使用する state dict の種類です。文字列の場合、`full_state_dict`、`local_state_dict`、または`sharded_state_dict`のいずれかである必要があります。

state_dict_config (`Optional[Union[torch.distributed.fsdp.FullStateDictConfig, torch.distributed.fsdp.ShardedStateDictConfig]`、デフォルトは`None`) : 使用する state dict の設定です。指定されない場合は、`state_dict_type`に基づいて決定されます。

optim_state_dict_config (`Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig]`、デフォルトは`None`) : 使用する Optim state dict の設定です。指定されない場合、`state_dict_type`に基づいて決定されます。

limit_all_gathers (`bool`、デフォルトは`True`) : FSDPがCPUスレッドを明示的に同期し、進行中のall-gatherが過多になるのを防ぐかどうかを指定します。このbool値は、all-gatherをスケジュールするシャーディング戦略にのみ影響します。これを有効にすると、CUDA mallocのリトライ回数を減らすのに役立つ場合があります。

use_orig_params (`bool`、デフォルトは`False`) : オプティマイザーに元のパラメータを使用するかどうか。

param_init_fn (`Optional[Callable[[torch.nn.Module], None]`、デフォルトは`None`) : 現在 meta デバイスにあるモジュールを実際のデバイスに初期化する方法を指定する`Callable[torch.nn.Module] -> None`。`sync_module_states`が`True`の場合にのみ適用されます。デフォルトでは、モジュールに対して`to_empty`を呼び出す`lambda`です。

sync_module_states (`bool`、デフォルトは`False`) : 個別にラップされた各FSDPユニットが、初期化後にすべてのランクでモジュールのパラメータが同一であることを保証するために、ランク0からモジュールのパラメータをブロードキャストすべきかどうかを指定します。`cpu_ram_efficient_loading`が`True`でない限り、デフォルトは`False`です。`cpu_ram_efficient_loading`が`True`の場合、強制的に有効になります。

forward_prefetch (`bool`、デフォルトは`False`) : FSDPがフォワードパスの実行中に、次のall-gatherを明示的にプリフェッチするかどうか。Static graphsでのみ使用してください。

activation_checkpointing (`bool`、デフォルトは`False`) : 特定のレイヤーのアクティベーションをクリアし、バックワードパス時に再計算することでメモリ使用量を削減する技術です。これにより、メモリ使用量の削減と引き換えに、追加の計算時間が発生します。

cpu_ram_efficient_loading (`bool`、デフォルトは`None`) : True の場合、最初のプロセスのみが事前学習済みモデルのチェックポイントをロードし、他のすべてのプロセスは重みが空になります。Transformers にのみ適用されます。これを使用する場合は、`sync_module_states` を `True` にする必要があります。

transformer_cls_names_to_wrap (`Optional[List[str]]`、デフォルトは`None`) : ラップするtransformerレイヤーのクラス名のリスト。`auto_wrap_policy`が`transformer_based_wrap`の場合にのみ適用されます。

min_num_params (`Optional[int]`、デフォルトは`None`) : モジュールがラップされるために必要な最小のパラメータ数。`auto_wrap_policy`が`size_based_wrap`の場合にのみ適用されます。

このプラグインは、フルシャードデータ並列性を有効にするために使用されます。

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

```python
set_auto_wrap_policy(model)
```

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

`model`が与えられた場合、渡されたポリシーに基づいて`auto_wrap_policy`を作成し、`transformer_cls_to_wrap`を使用できるかどうかを判断します。

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

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

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

FSDPの混合精度ポリシーを設定します

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

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

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

`StateDictType`に基づいてステートディクトの構成を設定します。

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

```python
validate_mixed_precision_policy()
```

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

を検証します。必要ない場合はインポートを持ち込まないよう、抽象化されています。

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

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

**パラメータ:**

num_steps (`int`) : グラデーションを累積するステップ数。

adjust_scheduler (`bool`、*任意*、デフォルトは`True`) : 累積されるステップ数を考慮してスケジューラのステップを調整するかどうか。使用しているスケジューラが勾配の累積用に調整されていない場合は、`True`にすべきです。

sync_with_dataloader (`bool`、*任意*、デフォルトは`True`) : データローダーの末尾で勾配の設定を同期するかどうか。

sync_each_batch (`bool`, *任意*) : 各データバッチごとに勾配の設定を同期するかどうか。`True` に設定すると、分散学習で勾配蓄積を使用する場合にメモリ要件を削減できますが、速度が犠牲になります。

勾配蓄積の動作を設定するためのプラグインです。[Accelerator](/docs/accelerate/v1.16.0/ja/package_reference/accelerator#accelerate.Accelerator)には、`gradient_accumulation_plugin`と`gradient_accumulation_steps`のどちらか一方のみを渡すことができます。両方を渡すとエラーが発生します。

例:

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

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

**パラメータ:**

tp_degree (`int`、デフォルトは`None`) : テンソル並列度。

pp_degree (`int`、デフォルトは`None`) : パイプライン並列度。

num_micro_batches (`int`、デフォルトは`None`) : マイクロバッチの数。

gradient_clipping (`float`、デフォルトは`None`) : グローバルL2ノルムに基づく勾配クリッピングの値（無効にする場合は0）。

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およびevalの両方のdataloaderが指定されている場合、`micro_batch_size`を決定します。

train_iters (`int`、デフォルトは`None`) : 全トレーニング実行にわたって学習するサンプルの総数。`MegatronLMDummyScheduler`を使用する場合は、train-itersまたはtrain-samplesのいずれかを指定する必要があります。

train_samples (`int`、デフォルトは`None`) : 全トレーニング実行にわたって学習するサンプルの総数。`MegatronLMDummyScheduler`を使用する場合は、train-itersまたはtrain-samplesのいずれかを指定する必要があります。

weight_decay_incr_style (`str`、デフォルトは`'constant'`) : 重み減衰の増分関数。choices=["constant", "linear", "cosine"]。

start_weight_decay (`float`、デフォルトは`None`) : L2正則化の初期ウェイト減衰係数。

end_weight_decay (`float`、デフォルトは`None`) : L2正則化のラン終了時の重み減衰係数。

lr_decay_style (`str`、デフォルトは`'linear'`) : 学習率の減衰関数。choices=['constant', 'linear', 'cosine']。

lr_decay_iters (`int`、デフォルトは`None`) : 学習率の減衰を行う反復回数。`train_iters`がNoneの場合、デフォルトで`train_iters`になります。

lr_decay_samples (`int`、デフォルトは`None`) : 学習率の減衰に使用するサンプル数。None の場合は`train_samples`がデフォルトになります。

lr_warmup_iters (`int`、デフォルトは`None`) : 学習率を線形ウォームアップさせる反復回数。

lr_warmup_samples (`int`、デフォルトは`None`) : 学習率を線形ウォームアップするサンプル数。

lr_warmup_fraction (`float`、デフォルトは`None`) : 学習率を線形ウォームアップさせるlr-warmup-(iters/samples)の割合。

min_lr (`float`、デフォルトは`0`) : 学習率の最小値です。スケジューラは、この閾値を下回る値をクリップします。

consumed_samples (`List`、デフォルトは`None`) : `accelerator.prepare`の呼び出しで、dataloaderと同じ順序で消費されるサンプルの数。

no_wd_decay_cond (`Optional`、デフォルトは`None`) : 重み減衰を無効にする条件。

scale_lr_cond (`Optional`、デフォルトは`None`) : 学習率をスケーリングするための条件。

lr_mult (`float`、デフォルトは`1.0`) : 学習率の乗数。

megatron_dataset_flag (`bool`、デフォルトは`False`) : データセットの形式がMegatron-LMのIndexed/Cached/MemoryMapped形式に従っているかどうか。

seq_length (`int`、デフォルトは`None`) : 処理するシーケンスの最大長。

encoder_seq_length (`int`、デフォルトは`None`) : エンコーダーで処理するシーケンスの最大長。

decoder_seq_length (`int`、デフォルトは`None`) : デコーダーで処理するシーケンスの最大長。

tensorboard_dir (`str`、デフォルトは`None`) : tensorboardログを保存するパス。

set_all_logging_options (`bool`、デフォルトは`False`) : すべてのログ出力オプションを設定するかどうか。

eval_iters (`int`、デフォルトは`100`) : 評価用の検証/テストを実行する反復回数。

eval_interval (`int`、デフォルトは`1000`) : 検証セットで評価を実行する間隔。

return_logits (`bool`、デフォルトは`False`) : モデルからlogitsを返すかどうか。

custom_train_step_class (`Optional`、デフォルトは`None`) : カスタムの学習ステップクラス。

custom_train_step_kwargs (`Optional`、デフォルトは`None`) : カスタムな学習ステップのkwargs。

custom_model_provider_function (`Optional`、デフォルトは`None`) : カスタムモデルプロバイダー関数。

custom_prepare_model_function (`Optional`、デフォルトは`None`) : カスタムのモデル準備関数。

custom_megatron_datasets_provider_function (`Optional`、デフォルトは`None`) : カスタムのmegatron train_valid_testデータセットプロバイダー関数。

custom_get_batch_function (`Optional`、デフォルトは`None`) : カスタムのバッチ取得関数。

custom_loss_function (`Optional`、デフォルトは`None`) : カスタム損失関数。

other_megatron_args (`Optional`、デフォルトは`None`) : その他のMegatron-LM引数。Megatron-LMを参照してください。

Megatron-LM用のプラグイン。テンソル並列、パイプライン並列、シーケンス並列、データ並列を有効にします。また、選択的なアクティベーション再計算と最適化された融合カーネルも有効にします。

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

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

**パラメータ:**

backend (`DynamoBackend`、デフォルトは`None`) : 有効なDynamoバックエンドです。詳細はhttps://pytorch.org/docs/stable/torch.compiler.htmlを参照してください。

mode (`str`、デフォルトは`None`) : 選択肢は 'default'、'reduce-overhead'、または 'max-autotune' です。

fullgraph (`bool`、デフォルトは`None`) : モデルを複数のサブグラフに分割しても問題ないかどうか。

dynamic (`bool`、デフォルトは`None`) : トレーシングに動的な形状を使用するかどうか。

options (`Any`、デフォルトは`None`) : バックエンドに渡すオプションの辞書。

disable (`bool`、デフォルトは`False`) : テスト用にtorch.compile()を何もしない操作（no-op）にします

use_regional_compilation (`bool`、デフォルトは`None`) : `GPT2LMHeadModel`のように、同じクラスの繰り返しブロックを対象としてそれらを順次コンパイルすることでコンパイラのキャッシュにヒットさせ、torch.compile()のコールドスタート時のコンパイル時間を短縮するために使用します。例えば、`GPT2LMHeadModel`では繰り返しブロック/クラスは`GPT2Block`であり、`model.transformer.h[0]`としてアクセスできます。モデルの残りの部分（例: model.lm_head）は別途コンパイルされます。

このプラグインは、PyTorch 2.0 でモデルをコンパイルするために使用されます。

## 設定[[accelerate.utils.BnbQuantizationConfig]]

これらは、設定して適切な統合に渡すことができるクラスです

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

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

**パラメータ:**

load_in_8bit (`bool`、デフォルトは`False`) : 8bit量子化を有効にします。

llm_int8_threshold (`float`、デフォルトは`6.0`) : アウトラインしきい値の値。`load_in_8bit=True`の場合のみ関連します。

load_in_4bit (`bool`、デフォルトは`False`) : 4bit量子化を有効にします。

bnb_4bit_quant_type (`str`、デフォルトは`fp4`) : `bnb.nn.Linear4Bit`レイヤーの量子化データ型を設定します。オプションは{'fp4','np4'}です。

bnb_4bit_use_double_quant (`bool`、デフォルトは`False`) : 最初の量子化から得られた量子化定数をさらに量子化することで、ネストされた量子化を有効にします。

bnb_4bit_compute_dtype (`bool`、デフォルトは`fp16`) : 入力時の型とは異なる計算型を設定します。例えば、入力がfp32であっても、高速化のために計算をbf16に設定できます。オプションは{'fp32','fp16','bf16'}です。

torch_dtype (`torch.dtype`、デフォルトは`None`) : 残りの非量子化レイヤーのdtypeを設定します。`bitsandbytes`ライブラリでは、8ビットモデルの場合は値を`torch.float16`に設定し、4ビットモデルの場合は計算用のdtypeと同じdtypeを使用することを推奨しています。

skip_modules (`List[str]`、デフォルトは`None`) : 量子化しないモジュールの明示的なリストです。これらのモジュールのdtypeは`torch_dtype`になります。

keep_in_fp32_modules (`List`、デフォルトは`None`) : 量子化しないモジュールの明示的なリストです。これらは`torch.float32`のまま保持されます。

BitsAndBytesの4bitおよび8bit量子化を有効にするプラグイン

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

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

**パラメータ:**

split_batches (`bool`、デフォルトは`False`) : アクセラレータが、データローダーによって生成されるバッチをデバイス間で分割すべきかどうかを指定します。`True`の場合、実際のバッチサイズはあらゆる種類の分散プロセスで同じになりますが、使用している`num_processes`の整数倍である必要があります。`False`の場合、実際のバッチサイズは、スクリプトで設定した値にプロセス数を掛けたものになります。

dispatch_batches (`bool`、デフォルトは`None`) : `True`に設定すると、Acceleratorによって準備されたdataloaderはメインプロセスでのみ反復され、その後バッチが分割されて各プロセスにブロードキャストされます。基礎となるデータセットが`IterableDataset`である`DataLoader`の場合はデフォルトで`True`、それ以外は`False`になります。

even_batches (`bool`、デフォルトは`True`) : `True`に設定されている場合、すべてのプロセスにわたるバッチサイズ合計がデータセットを正確に割り切れない場合、すべてのワーカー間でバッチを均等に分割できるように、データセットの先頭にあるサンプルが重複して使用されます。

use_seedable_sampler (`bool`、デフォルトは`False`) : 完全にシード可能なランダムサンプラー(`data_loader.SeedableRandomSampler`)を使用するかどうか。異なるサンプリング手法を用いることで、トレーニング結果が完全に再現可能であることを保証します。シード間の結果には差が生じる場合がありますが、複数の異なるシードで比較した場合、平均的な差は無視できるほど小さいです。最適な結果を得るには、[set_seed()](/docs/accelerate/v1.16.0/ja/package_reference/utilities#accelerate.utils.set_seed)も併せて実行する必要があります。

data_seed (`int`、デフォルトは`None`) : `use_seedable_sampler`を使用する場合に、基となるジェネレーターで使用するシードです。`None`の場合、ジェネレーターはtorchの現在のデフォルトのシードを使用します。

non_blocking (`bool`、デフォルトは`False`) : `True`に設定すると、Acceleratorによって準備されたdataloaderは非ブロッキングなホストからデバイスへの転送を利用し、dataloaderの通信と計算のオーバーラップを改善できます。正常に動作させるには、準備されたdataloaderの`pin_memory`を`True`に設定することを推奨します。

use_stateful_dataloader (`bool`、デフォルトは`False`) : `True`に設定すると、Acceleratorによって準備されたdataloaderは[torchdata.StatefulDataLoader](https://github.com/pytorch/data/tree/main/torchdata/stateful_dataloader)によってサポートされます。これには、StatefulDataLoaderをサポートする`torchdata`のバージョン0.8.0以上がインストールされている必要があります。

`accelerator.prepare`を呼び出す際の、dataloader関連の項目の設定です。

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

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

**パラメータ:**

project_dir (`str`、デフォルトは`None`) : データを保存するディレクトリへのパス。

logging_dir (`str`、デフォルトは`None`) : ローカル互換ロガーのログを保存するためのディレクトリへのパスです。None の場合、デフォルトで`project_dir`になります。

automatic_checkpoint_naming (`bool`、デフォルトは`False`) : 保存された状態に自動的に反復的な名前を付けるかどうか。

total_limit (`int`、デフォルトは`None`) : 保持する保存状態の総数の最大値。

iteration (`int`、デフォルトは`0`) : 現在の保存イテレーション。

save_on_each_node (`bool`、デフォルトは`False`) : マルチノード分散学習を行う際、モデルとチェックポイントを各ノードに保存するか、メインノードのみに保存するかを指定します。

内部プロジェクトの要件に基づいたAcceleratorオブジェクトの設定。

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

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

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

`self.project_dir` と `self.logging_dir` を適切な値に設定します。

## 環境変数

これらは、異なるユースケースに対して有効化できる環境変数です

* `ACCELERATE_DEBUG_MODE` (`str`): accelerate をデバッグモードで実行するかどうか。[こちら](../basic_tutorials/troubleshooting#hanging-code-and-timeout-errors)に詳細があります。

## データ操作と演算[[accelerate.utils.broadcast]]

これには、`torch` のオペレーションと同じ動作を模倣するデータ操作が含まれており、分散プロセスで使用できます。

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

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

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

**パラメータ:**

tensor (ネストされたリスト/タプル/辞書の`torch.Tensor`) : 収集するデータ。

from_process (`int`、*optional*、デフォルトは 0) : データを送信するプロセス

**戻り値:**

`tensor`と同じデータ構造で、すべてのテンソルが適切なデバイスにブロードキャストされています。

Recursively broadcast tensor in a nested list/tuple/dictionary of tensors to all devices.

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

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

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

**パラメータ:**

object_list (list of picklable objects) : 配信するオブジェクトのリストです。このリストはインプレースで変更されます。

from_process (`int`、*optional*、デフォルトは 0) : データを送信するプロセス。

**戻り値:**

プロセス 0 のオブジェクトを含む同じリスト。

picklableオブジェクトのリストを、1つのプロセスから他のプロセスへブロードキャストします。

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

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

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

**パラメータ:**

data (テンソルのリストのネストされたリスト/タプル/辞書 `torch.Tensor`) : 連結するデータ。

dim (`int`, *optional*, デフォルトは 0) : 連結を行う次元。

**戻り値:**

`data`と同じデータ構造で、すべてのテンソルが連結されたもの。

同じ形状のテンソルのリストからなるネストされたリスト/タプル/辞書のテンソルを再帰的に連結します。データが単一のバッチしかない場合は、そのまま返されます。

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

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

[ソース](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)
```

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

**パラメータ:**

tensor （`torch.Tensor` のネストされたリスト/タプル/辞書）: FP16/BF16 から FP32 へ変換するデータ。

**戻り値:**

`tensor`と同じデータ構造で、FP16/BF16精度だったすべてのテンソルがFP32に変換されています。

FP16/BF16精度のテンソルからなるネストされたリスト/タプル/辞書の要素を、再帰的にFP32に変換します。

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

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

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

**パラメータ:**

tensor (ネストされたリスト/タプル/辞書の`torch.Tensor`) : 収集するデータ。

**戻り値:**

`tensor`と同じデータ構造で、すべてのテンソルが適切なデバイスに送信されます。

Recursively gather tensor in a nested list/tuple/dictionary of tensors from all devices.

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

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

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

**パラメータ:**

object (nested list/tuple/dictionary of picklable object) : 収集するデータ。

**戻り値:**

`object` と同じデータ構造で、すべてのデバイスに送信されたオブジェクトがすべて含まれています。

…

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

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

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

**パラメータ:**

distributed_type (`DistributedType`、*任意*、デフォルトは None) : 分散環境のタイプ。

kwargs : 使用される`GradScaler`コンストラクタの追加引数。

環境に基づいて適切な`GradScaler`実装を初期化して返す汎用的なヘルパーです。

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

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

**パラメータ:**

native_amp (`bool`、*任意*、デフォルトは False) : 混合精度が実際に有効化されているかどうか。

混合精度のオートキャスティング用のコンテキストマネージャーを返します

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

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

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

**パラメータ:**

data (nested list/tuple/dictionary of `torch.Tensor`) : 通常の数値に変換する元のデータ。

**戻り値:**

`data` と同じデータ構造ですが、`torch.Tensor` の代わりに数値のリストを使用します。

ネストされたリスト/タプル/辞書内のテンソルを再帰的に検索し、数値のリストに変換します。

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

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

**パラメータ:**

tensor (ネストされたリスト/タプル/辞書の`torch.Tensor`) : 収集するデータ。

dim (`int`、*optional*、デフォルトは 0) : パディングを行う次元。

pad_index (`int`、*任意*、デフォルトは 0) : パディングに使用する値。

pad_first (`bool`、*任意*、デフォルトは`False`) : 先頭または末尾にパディングを行うかどうか。

…

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

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

**パラメータ:**

func (`callable`) : 再帰的に適用する関数。

data `test_type`が受け入れるオブジェクトのネストされたリスト/タプル/辞書) : `func`を適用する対象のデータ

- ***args** : 展開されたデータに `func` を適用する際に、`func` に渡される位置引数。

test_type (`Callable[[Any], bool]`、*任意*、デフォルトは`is_torch_tensor`) : 与えられたリーフオブジェクトに対して`func`を適用すべきかどうかを判定する述語。

error_on_other_type (`bool`、*任意*、デフォルトは`False`) : `data`をアンパックした後に、`test_type`が`False`を返すオブジェクトが得られた場合に、エラーを返すかどうかを指定します。`False`の場合、関数はそのようなオブジェクトを変更せずにそのまま返します。

- ****kwargs** (追加のキーワード引数、*任意*) : 展開されたデータに `func` を適用する際に、`func` に渡されるキーワード引数です。

**戻り値:**

`test_type`が`True`を返すすべてのオブジェクトに`func`を適用した、`data`と同じデータ構造です。

…

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

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

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

**パラメータ:**

tensor (ネストされたリスト/タプル/辞書の`torch.Tensor`) : 集約するデータ。

reduction (`str`、*任意*、デフォルトは`"mean"`) : 集約方法。"mean"、"sum"、"max"、"none"のいずれか

scale (`float`, *任意*) : reduce の後に適用されるデフォルトのスケーリング値です。XLA のみ有効です。

**戻り値:**

`data`と同じデータ構造で、すべてのテンソルが縮小されたものです。

…

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

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

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

**パラメータ:**

tensor (ネストされたリスト/タプル/辞書の`torch.Tensor`) : 指定されたデバイスに送信するデータ。

device (`torch.device`) : データを送信するデバイス。

non_blocking (`bool`、*任意*、デフォルトは`False`) : `True`の場合、デバイスへの転送が非同期で実行され、データの移動と計算をオーバーラップさせることができます。デバイスがサポートしている場合のみ有効です（例: CUDA）。

skip_keys (`str` または `List[str]`、*省略可能*) : 値を指定された `device` に送信すべきでない辞書 `tensor` のキー、またはキーのリスト。これらのキーを持つエントリは、元のデバイスに保持されます。

**戻り値:**

`tensor`と同じデータ構造で、すべてのテンソルが適切なデバイスに送信されます。

テンソルのネストされたリスト/タプル/辞書の要素を、指定されたデバイスへ再帰的に送信します。

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

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

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

**パラメータ:**

data (ネストされたリスト/タプル/辞書の`torch.Tensor`) : スライスするデータ。

tensor_slice (`slice`) : 取得するスライス。

**戻り値:**

`data`と同じデータ構造で、すべてのテンソルがスライスされています。

Recursively takes a slice in a nested list/tuple/dictionary of tensors.

## 環境チェック[[accelerate.utils.is_bf16_available]]

これらの機能は、現在の作業環境の状態を確認します。これには、オペレーティングシステム自体の情報、そのサポート可能な機能、および特定の依存関係がインストールされているかどうかが含まれます。

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

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

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

bf16がサポートされているかどうかを確認します。必要に応じてTPUを無視できます。

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

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

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

MPSデバイスが利用可能かどうかを確認します。必要な最低バージョンは1.12です。

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

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

`torch_npu`がインストールされているか、また環境にNPUが存在する可能性があるかをチェックします

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

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

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

**パラメータ:**

operation (`str`) : `">"` や `"<="` のような演算子の文字列表現

version (`str`) : PyTorchの文字列形式

現在のPyTorchバージョンを、指定された参照値と演算子で比較します。

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

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

`torch_xla` が利用可能かどうかを確認します。torch xla がインストールされた環境でネイティブの pytorch ジョブをトレーニングするには、USE_TORCH_XLA を false に設定してください。

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

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

stock PyTorch (>=2.7) 経由で XPU アクセラレーションが利用可能かどうか、および環境に XPU が存在する可能性があるかどうかを確認します

## 環境の操作[[accelerate.utils.patch_environment]]

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

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

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

`os.environ` に渡された各キーワード引数を追加し、終了時にそれらを削除するコンテキストマネージャーです。

`kwargs`内の値を文字列に変換し、すべてのキーを大文字に変換します。

例:

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

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

環境変数を一時的にクリアするコンテキストマネージャーです。

このコンテキストが終了すると、以前の環境変数が復元されます。

例:

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

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

**パラメータ:**

mixed_precision (`str`、*任意*、デフォルトは "no") : 使用する混合精度。"no"、"fp16"、"bf16" のいずれかである必要があります。

save_location (`str`、*任意*、デフォルトは`default_json_config_file`) : 任意のカスタム保存先。`accelerate launch`を使用する場合は、`--config_file`に渡す必要があります。デフォルトの保存先は huggingface のキャッシュフォルダ内(`~/.cache/huggingface`)ですが、`HF_HOME`環境変数を設定することで上書きでき、その場合は`accelerate/default_config.yaml`が使用されます。

ローカルマシン（複数のGPUを備える可能性あり）で使用する基本的なクラスター設定を作成して保存します。CPU専用のマシンである場合は、CPUも設定します。

🤗 Accelerate を初めてセットアップする際、`accelerate config` を実行する代わりに、[~utils.write_basic_config] を使用して素早く設定を行うことができます。

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

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

**パラメータ:**

local_process_index (int) : 現在のサーバー上の現在のプロセスのインデックス。

verbose (bool, *optional*) : 各プロセスに対する新しい CPU コア割り当てを出力するかどうか。`ACCELERATE_DEBUG_MODE` が有効な場合、デフォルトで True になります。

現在のプロセスを特定のNUMAノードに割り当てます。各ノードに少なくとも2つのCPUがある場合、最も効率的に動作します。

この結果は呼び出し間でキャッシュされます。上書きする場合は、`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)
```

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

**パラメータ:**

local_process_index (int) : 現在のサーバー上の現在のプロセスのインデックス。

verbose (bool, *optional*) : 各 CPU の割り当てをログ出力するかどうか。`ACCELERATE_DEBUG_MODE` が有効な場合、デフォルトで True になります。

現在のプロセスに設定されているNUMAアフィニティをオーバーライドします。この処理は非常に負荷が大きく、設定するアフィニティの再計算を必要とするため、理想としては代わりに`utils.environment.set_numa_affinity`を使用してください。

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

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

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

デコレーター。装飾されたクラスまたは関数によって設定されたaccelerateの環境変数をクリーンアップします。

特定の状況下では、特定のクラスや関数を呼び出すと、accelerate の環境変数が設定され、その後クリーンアップされないことがあります。例えば、以下を呼び出した場合:

TrainingArguments(fp16=True, ...)

以下の環境変数が設定されます:

ACCELERATE_MIXED_PRECISION=fp16

This can affect subsequent code, since the env var takes precedence over TrainingArguments(fp16=False). This is especially relevant for unit testing, where we want to avoid the individual tests to have side effects on one another. Decorate the unit test function or whole class with this decorator to ensure that after each test, the env vars are cleaned up. This works for both unittest.TestCase and normal classes (pytest); it also works when decorating the parent class.

## メモリ[[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)
```

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

**パラメータ:**

function (`callable`、*任意*) : ラップする関数

starting_batch_size (`int`, *任意*) : メモリに収まるよう試みるバッチサイズ

reduce_batch_size_fn (`callable`、*optional*) : メモリ不足エラーが発生した後の新しいバッチサイズを決定する関数です。指定しない場合、各失敗時にバッチサイズが0.9倍になります。この関数は引数を受け取らず、新しい（縮小された）バッチサイズを`int`として返す必要があります。

`function`の実行を試みる基本的なデコレーターです。メモリ不足やCUDNNに関連する例外が発生して失敗した場合、バッチサイズを0.9倍にして`function`に渡します。

`function`は、最初の引数として`batch_size`パラメータを受け取る必要があります。

例:

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

## モデリング[[accelerate.utils.calculate_maximum_sizes]]

これらのユーティリティは、PyTorchモデルとのインタラクションに関連しています

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

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

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

モデルの総サイズと最大レイヤーのサイズを計算します

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

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

指定されたモデルの各サブモジュールのサイズを計算します。

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

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

**パラメータ:**

model (`torch.nn.Module`) : 抽出するモデル。

keep_fp32_wrapper (`bool`, *任意*) : モデルから混合精度フックを削除するかどうか。

keep_torch_compile (`bool`, *任意*) : コンパイル済みモデルをアンラップするかどうか。

recursive (`bool`、*任意*、デフォルトは`False`) : `model`から`module.module`のすべてのケースを再帰的に抽出し、トップレベルの分散コンテナだけでなく、子サブレイヤーも再帰的にアンラップするかどうか。

**戻り値:** `torch.nn.Module`

抽出されたモデル。

分散コンテナからモデルを抽出します。

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

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

**パラメータ:**

model (`torch.nn.Module`) : 解析対象のモデル。

max_memory (`Dict`, *任意*) : デバイス識別子から最大メモリ量への辞書です。未設定の場合は、利用可能な最大メモリがデフォルトとして使用されます。例: `max_memory={0: "1GB"}`。

no_split_module_classes (`List[str]`, *任意*) : デバイス間で分割すべきでないレイヤーのクラス名のリスト（残差接続を持つレイヤーなど）。

dtype (`str` または `torch.dtype`、*省略可能*) : 指定された場合、読み込み時に重みがその型に変換されます。

special_dtypes (`Dict[str, Union[str, torch.device]]`、*任意*) : 指定した場合、一部の特定の重みに適用する特殊な dtype です（すべての重みにデフォルトとして使用される dtype を上書きします）。

low_zero (`bool`、*省略可能*) : GPU 0 上の重みの数を最小化します。Transformers の generate 関数など、他の操作に GPU 0 を使用する場合に便利です。

利用可能な各GPUの使用をバランスよく調整するために、[infer_auto_device_map()](/docs/accelerate/v1.16.0/ja/package_reference/big_modeling#accelerate.infer_auto_device_map)用の`max_memory`辞書を計算します。

すべての計算は、モデルパラメータのサイズとdtypeを解析することによって行われます。その結果、モデルはmetaデバイス上に配置できます（`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])
```

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

**パラメータ:**

modules (`List[Tuple[str, torch.nn.Module]]`) : 最大レイヤーサイズを決定したい名前付きモジュールのリスト。

module_sizes (`Dict[str, int]`) : 各レイヤー名をそのサイズ(`compute_module_sizes`によって生成される)にマッピングする辞書。

no_split_module_classes (`List[str]`) : 分割したくないレイヤーのクラス名のリスト。

**戻り値:** `Tuple[int, List[str]]`

その最大サイズを実現するレイヤー名のリスト付きの、レイヤーの最大サイズ。

…のリストをスキャンし、1つの完全なレイヤーが使用する最大サイズを返すユーティリティ関数です。ここで、レイヤーの定義は以下の通りです。
- 直接の子モジュールを持たないモジュール（パラメータとバッファのみ）
- クラス名が`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)
```

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

**パラメータ:**

model (`torch.nn.Module`) : 解析対象のモデル。

max_memory (`Dict`, *任意*) : デバイス識別子から最大メモリ量への辞書です。未設定の場合は、利用可能な最大メモリがデフォルトとして使用されます。例: `max_memory={0: "1GB"}`。

no_split_module_classes (`List[str]`, *任意*) : デバイス間で分割すべきでないレイヤーのクラス名のリスト（残差接続を持つレイヤーなど）。

dtype (`str` または `torch.dtype`、*省略可能*) : 指定された場合、読み込み時に重みがその型に変換されます。

special_dtypes (`Dict[str, Union[str, torch.device]]`、*任意*) : 指定した場合、一部の特定の重みに適用する特殊な dtype です（すべての重みにデフォルトとして使用される dtype を上書きします）。

verbose (`bool`、*任意*、デフォルトは`False`) : device_map を構築する際に、デバッグ文を提供するかどうか。

clean_result (`bool`、*任意*、デフォルトは`True`) : 結果のdevice_mapを、同じデバイスに配置されるすべてのサブモジュールをグループ化して整理します。

offload_buffers (`bool`、*任意*、デフォルトは`False`) : CPUまたはハードドライブにオフロードされるレイヤーにおいて、パラメータだけでなくバッファもオフロードするかどうか。

fallback_allocation (`bool`, *任意*, デフォルトは `False`) : 通常の割り当てが失敗した場合、BFS を使用してサイズ制限内に収まるモジュールの割り当てを試みます。

GPUを優先し、次にCPU、最後にディスクへオフロードするよう、指定されたモデルのデバイスマップを計算します。
- どの GPU の利用可能なメモリも超過しないようにします。
- CPUへのオフロードが必要な場合、GPU 0には常に空き領域が残っており、CPUにオフロードされた層のうち最もサイズが大きいものを再度配置できます。
- CPUへのオフロードが必要な場合、CPUで利用可能なRAMを超えないようにします。
- ディスクへのオフロードが必要な場合、CPUには常に空き領域が残っており、ディスクにオフロードされた層のうち最もサイズが大きいものをCPUに戻すことができます。

すべての計算は、モデルパラメータのサイズとdtypeを解析することによって行われます。その結果、モデルはmetaデバイス上に配置できます（`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)
```

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

**パラメータ:**

model (`torch.nn.Module`) : チェックポイントを読み込みたいモデル。

checkpoint (`str` または `os.PathLike`) : 読み込むフォルダのチェックポイントです。以下のいずれかです: - モデル全体の state dict を含むファイルへのパス - シャード化されたチェックポイントのインデックスを含む `.json` ファイルへのパス - 一意の `.index.json` ファイルとチェックポイントのシャードを含むフォルダへのパス - 一意の pytorch_model.bin または model.safetensors ファイルを含むフォルダへのパス

device_map (`Dict[str, Union[int, str, torch.device]]`, *省略可*) : 各サブモジュールをどのデバイスに配置するかを指定するマップです。各パラメータやバッファの名前まで細かく指定する必要はなく、特定のモジュール名が指定に含まれている場合、そのモジュールのすべてのサブモジュールが同じデバイスに送信されます。

offload_folder (`str` または `os.PathLike`、*任意*) : `device_map` に `"disk"` という値が含まれている場合、重みをオフロードするフォルダを指定します。

dtype (`str` または `torch.dtype`、*省略可能*) : 指定された場合、読み込み時に重みがその型に変換されます。

offload_state_dict (`bool`、*任意*、デフォルトは`False`) : `True`の場合、CPU RAMを使い切らないように、CPU state dictの重さと最大のシャードの合計が収まらない場合に、CPU state dictをハードドライブに一時的にオフロードします。

offload_buffers (`bool`, *任意*, デフォルトは `False`) : ディスクにオフロードされる重みにバッファを含めるかどうか。

keep_in_fp32_modules(`List[str]`, *任意*) : `torch.float32` dtypeで保持するモジュールのリスト。

offload_8bit_bnb (`bool`, *任意*) : 8ビットモジュールのCPU/ディスクへのオフロードを有効にするかどうか。

strict (`bool`、*任意*、デフォルトは`False`) : チェックポイントのstate_dictのキーが、モデルのstate_dictのキーと厳密に一致することを強制するかどうか。

full_state_dict (`bool`、*任意*、デフォルトは`True`) : `True`に設定されている場合、読み込まれたstate_dict内のすべてのテンソルが集約されます。読み込まれたstate_dictには、ShardedTensorやDTensorは含まれません。

broadcast_from_rank0 (`False`, *任意*、デフォルトは `False`) : このオプションが `True` の場合、分散 `ProcessGroup` を初期化する必要があります。rank0 は完全な state_dict を受信し、state_dict 内のテンソルを他の rank に1つずつブロードキャストします。他の rank はテンソルを受信し、モデル内のローカルシャードに応じてシャード化（該当する場合）します。

モデル内の（シャード化された可能性のある）チェックポイントをロードし、ロードされる際に重みを指定されたデバイスに送信する可能性があります。

Once loaded across devices, you still need to call [dispatch_model()](/docs/accelerate/v1.16.0/ja/package_reference/big_modeling#accelerate.dispatch_model) on your model to make it able to run. To group the checkpoint loading and dispatch in one single call, use [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/ja/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)
```

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

**パラメータ:**

model (`torch.nn.Module`) : 重みをロードする対象のモデル。

index (`dict`) : モデルからオフロードされた各パラメータのパラメータ名とそのメタデータを含む辞書。

offload_folder (`str`) : オフロードされた重みが保存されるフォルダ。

オフロードフォルダから重みをモデルに読み込みます。

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

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

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

**パラメータ:**

checkpoint_file (`str`) : 読み込むチェックポイントへのパス。

device_map (`Dict[str, Union[int, str, torch.device]]`, *省略可*) : 各サブモジュールをどのデバイスに配置するかを指定するマップです。各パラメータやバッファの名前まで細かく指定する必要はなく、特定のモジュール名が指定に含まれている場合、そのモジュールのすべてのサブモジュールが同じデバイスに送信されます。

…のファイルからチェックポイントを読み込みます。チェックポイントがsafetensors形式であり、デバイスマップが渡されている場合、重みを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])
```

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

**パラメータ:**

save_dir (`str` または `os.PathLike`) : state dict をオフロードするディレクトリ。

state_dict (`Dict[str, torch.Tensor]`) : オフロードするテンソルの辞書。

指定されたフォルダにステートディクトをオフロードします。

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

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

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

**パラメータ:**

model (`torch.nn.Module`) : パラメータを再結合する対象のモデル。

tied_params (`List[List[str]]`) : `find_tied_parameters` によって取得される、マッピングパラメータ名からタイドパラメータ名への対応。

リンクが切断された場合（フックの追加時など）、指定されたモデル内のタイドパラメータを再設定します。

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

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

**パラメータ:**

module (`torch.nn.Module`) : 移動したいテンソルが格納されているモジュール。

tensor_name (`str`) : パラメータ/バッファの完全な名前。

device (`int`、`str` または `torch.device`) : テンソルを設定するデバイス。

value (`torch.Tensor`, *任意*) : テンソルの値（meta デバイスから他のデバイスへの移動時に有用です）。

dtype (`torch.dtype`、*任意*) : 値が渡された場合、パラメータの値はこの`dtype`にキャストされます。それ以外の場合、`value`はモデル内の既存のパラメータのdtypeにキャストされます。

fp16_statistics (`torch.HalfTensor`, *任意*) : モジュールに設定する fp16 統計情報のリスト。8 ビットモデルのシリアライズに使用されます。

tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], *optional*、デフォルトは`None`) : 現在のデータポインタから、デバイスへのディスパッチ済みの共有重みの辞書へのマップ。特定の実行デバイスに対して、このパラメータは、メモリを重複させる代わりに、デバイス上の共有重みの最初の利用可能なポインタを他のすべての重みで再利用するために役立ちます。

non_blocking (`bool`、*任意*、デフォルトは`False`) : `True`の場合、可能な限り、デバイスへの転送はホストに対して非同期になります。

clear_cache (`bool`、*任意*、デフォルトは`True`) : テンソルをデバイスに設定した後に、デバイスキャッシュをクリアするかどうか。

モジュールの特定のテンソル（パラメータまたはバッファ）を指定されたデバイスに設定するためのヘルパー関数です（`param.to(device)` を実行するとパラメータにリンクされない新しいテンソルが作成されるため、この関数が必要になります）。

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

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

**パラメータ:**

model (`torch.nn.Module`) : 子を取得する対象のモデル

**戻り値:** `list[torch.nn.Module]`

`model`の子モジュールのリスト（下から上への順序）。最後の要素は`model`自体です。

モデルをボトムアップの順序で走査し、その順序で子モジュールを返します。

## 並列[[accelerate.utils.extract_model_from_parallel]]

これには、並列処理を行う際に使用すべき一般的なユーティリティが含まれます。

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

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

**パラメータ:**

model (`torch.nn.Module`) : 抽出するモデル。

keep_fp32_wrapper (`bool`, *任意*) : モデルから混合精度フックを削除するかどうか。

keep_torch_compile (`bool`, *任意*) : コンパイル済みモデルをアンラップするかどうか。

recursive (`bool`、*任意*、デフォルトは`False`) : `model`から`module.module`のすべてのケースを再帰的に抽出し、トップレベルの分散コンテナだけでなく、子サブレイヤーも再帰的にアンラップするかどうか。

**戻り値:** `torch.nn.Module`

抽出されたモデル。

分散コンテナからモデルを抽出します。

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

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

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

**パラメータ:**

obj : 保存するデータ

f : データを保存するために使用するファイル（またはファイルライクオブジェクト）

save_on_each_node (`bool`, *任意*, デフォルトは `False`) : グローバルメインプロセスでのみ保存するかどうか

safe_serialization (`bool`、*任意*、デフォルトは`False`) : `obj`を`safetensors`で保存するか、従来のPyTorchの方式（`pickle`を使用）で保存するかどうか。

データをディスクに保存します。`torch.save()`の代わりに使用します。

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

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

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

**パラメータ:**

f : データの読み込みに使用するファイル（またはファイルライクオブジェクト）

map_location : 関数、`torch.device`、文字列、またはストレージの場所をどのようにリマップするかを指定する辞書

- ****kwargs** : `torch.load()`に渡す追加のキーワード引数。

`torch.load()`の互換性のあるドロップイン代替実装です。`torch`のバージョンが2.4.0以上の場合、`weights_only`を使用できます。それ以外の場合は、このキーワード引数は無視されます。

NumPy配列に対する例外も追加（その後削除）します

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

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

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

スクリプトにブロッキングポイントを導入し、すべてのプロセスがこの地点に到達したことを確認してから処理を続行します。

すべてのプロセスがこの指示に到達するようにしてください。そうしないと、プロセスの1つが永久にハングしたままになります。

## ランダム[[accelerate.utils.set_seed]]

これらのユーティリティは、すべてのランダム状態の設定と同期に関連しています。

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

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

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

**パラメータ:**

seed (`int`) : 設定するシード。

device_specific (`bool`、*任意*、デフォルトは`False`) : `self.process_index`によって、各デバイスのシードをわずかに変えるかどうか。

deterministic (`bool`、*任意*、デフォルトは`False`) : 利用可能な場合、決定論的アルゴリズムを使用するかどうかを示します。トレーニングが遅くなる可能性があります。

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

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

デバイスタイプで識別される組み込みRNGまたは現在のアクセラレータのRNGを同期します。

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

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

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

これには、PyTorchをXLAと併用する際に便利なユーティリティが含まれます。

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

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

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

**パラメータ:**

upgrade (`bool`、*任意*、デフォルトは`False`) : `torch`をアップグレードし、最新の`torch_xla`のwheelsをインストールするかどうか。

Google Colaboratory において、`torch` のバージョンに基づいて適切な xla wheels をインストールするためのヘルパー関数です。

例:

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

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

## モデルの重みの読み込み[[accelerate.load_checkpoint_in_model]]

これには、チェックポイントの読み込みに役立つユーティリティが含まれます。

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

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

**パラメータ:**

model (`torch.nn.Module`) : チェックポイントを読み込みたいモデル。

checkpoint (`str` または `os.PathLike`) : 読み込むフォルダのチェックポイントです。以下のいずれかです: - モデル全体の state dict を含むファイルへのパス - シャード化されたチェックポイントのインデックスを含む `.json` ファイルへのパス - 一意の `.index.json` ファイルとチェックポイントのシャードを含むフォルダへのパス - 一意の pytorch_model.bin または model.safetensors ファイルを含むフォルダへのパス

device_map (`Dict[str, Union[int, str, torch.device]]`, *省略可*) : 各サブモジュールをどのデバイスに配置するかを指定するマップです。各パラメータやバッファの名前まで細かく指定する必要はなく、特定のモジュール名が指定に含まれている場合、そのモジュールのすべてのサブモジュールが同じデバイスに送信されます。

offload_folder (`str` または `os.PathLike`、*任意*) : `device_map` に `"disk"` という値が含まれている場合、重みをオフロードするフォルダを指定します。

dtype (`str` または `torch.dtype`、*省略可能*) : 指定された場合、読み込み時に重みがその型に変換されます。

offload_state_dict (`bool`、*任意*、デフォルトは`False`) : `True`の場合、CPU RAMを使い切らないように、CPU state dictの重さと最大のシャードの合計が収まらない場合に、CPU state dictをハードドライブに一時的にオフロードします。

offload_buffers (`bool`, *任意*, デフォルトは `False`) : ディスクにオフロードされる重みにバッファを含めるかどうか。

keep_in_fp32_modules(`List[str]`, *任意*) : `torch.float32` dtypeで保持するモジュールのリスト。

offload_8bit_bnb (`bool`, *任意*) : 8ビットモジュールのCPU/ディスクへのオフロードを有効にするかどうか。

strict (`bool`、*任意*、デフォルトは`False`) : チェックポイントのstate_dictのキーが、モデルのstate_dictのキーと厳密に一致することを強制するかどうか。

full_state_dict (`bool`、*任意*、デフォルトは`True`) : `True`に設定されている場合、読み込まれたstate_dict内のすべてのテンソルが集約されます。読み込まれたstate_dictには、ShardedTensorやDTensorは含まれません。

broadcast_from_rank0 (`False`, *任意*、デフォルトは `False`) : このオプションが `True` の場合、分散 `ProcessGroup` を初期化する必要があります。rank0 は完全な state_dict を受信し、state_dict 内のテンソルを他の rank に1つずつブロードキャストします。他の rank はテンソルを受信し、モデル内のローカルシャードに応じてシャード化（該当する場合）します。

モデル内の（シャード化された可能性のある）チェックポイントをロードし、ロードされる際に重みを指定されたデバイスに送信する可能性があります。

Once loaded across devices, you still need to call [dispatch_model()](/docs/accelerate/v1.16.0/ja/package_reference/big_modeling#accelerate.dispatch_model) on your model to make it able to run. To group the checkpoint loading and dispatch in one single call, use [load_checkpoint_and_dispatch()](/docs/accelerate/v1.16.0/ja/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch).

## 量子化[[accelerate.utils.load_and_quantize_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)
```

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

**パラメータ:**

model (`torch.nn.Module`) : 入力モデル。モデルは既に読み込まれているか、meta デバイス上に存在している可能性があります。

bnb_quantization_config (`BnbQuantizationConfig`) : bitsandbytes量子化のパラメータ

weights_location (`str` または `os.PathLike`) : 読み込むフォルダの weights_location です。以下のいずれかです: - モデル全体の state dict を含むファイルへのパス - シャード化されたチェックポイントのインデックスを含む `.json` ファイルへのパス - 一意の `.index.json` ファイルとチェックポイントのシャードを含むフォルダへのパス - 一意の pytorch_model.bin ファイルを含むフォルダへのパス

device_map (`Dict[str, Union[int, str, torch.device]]`, *省略可*) : 各サブモジュールをどのデバイスに配置するかを指定するマップです。各パラメータやバッファの名前まで細かく指定する必要はなく、特定のモジュール名が指定に含まれている場合、そのモジュールのすべてのサブモジュールが同じデバイスに送信されます。

no_split_module_classes (`List[str]`, *任意*) : デバイス間で分割すべきでないレイヤーのクラス名のリスト（残差接続を持つレイヤーなど）。

max_memory (`Dict`, *任意*) : デバイス識別子から最大メモリ量への辞書。未設定の場合は、利用可能な最大メモリがデフォルトとして使用されます。

offload_folder (`str` または `os.PathLike`、*任意*) : `device_map` に `"disk"` という値が含まれている場合、重みをオフロードするフォルダを指定します。

offload_state_dict (`bool`、*任意*、デフォルトは`False`) : `True`の場合、CPU RAMを使い切らないように、CPU state dictの重さと最大のシャードの合計が収まらない場合に、CPU state dictをハードドライブに一時的にオフロードします。

**戻り値:** `torch.nn.Module`

量子化されたモデル

この関数は、`bnb_quantization_config` に渡された関連する設定を使用して、入力モデルを量子化します。モデルがメタデバイスにある場合、渡された `device_map` に従って重みをロードおよびディスパッチします。モデルがすでにロードされている場合、モデルを量子化して GPU に配置します。

