Accelerate 文件

實用函式和類

Accelerate

加入 Hugging Face 社群

並獲得增強的文件體驗

在模型、資料集和 Spaces 上進行協作

透過加速推理獲得更快的示例

切換文件主題

開始使用

實用函式和類

下面是 🤗 Accelerate 提供的各種實用函式，按用例分類。

常量

在 🤗 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() 時使用的常量

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 中使用的基本資料類，它們可以作為引數傳遞。

獨立

這些是用於檢查的獨立資料類，例如正在使用的分散式系統的型別

class accelerate.utils.ComputeEnvironment

( value names = None module = None qualname = None type = None start = 1 )

表示計算環境的型別。

數值

LOCAL_MACHINE — 私有/自定義叢集硬體。
AMAZON_SAGEMAKER — 作為計算環境的 Amazon SageMaker。

class accelerate.DistributedType

( value names = None module = None qualname = None type = None start = 1 )

表示分散式環境的型別。

數值

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 上分散式執行。
DEEPSPEED — 使用 DeepSpeed。
XLA — 使用 TorchXLA。

class accelerate.utils.DynamoBackend

( value names = None module = None qualname = None type = None start = 1 )

表示 dynamo 後端（參見 https://pytorch.org/docs/stable/torch.compiler.html）。

數值

NO — 不使用 torch dynamo。
EAGER — 使用 PyTorch 執行提取的 GraphModule。這在除錯 TorchDynamo 問題時非常有用。
AOT_EAGER — 使用 AotAutograd，但沒有編譯器，即只使用 PyTorch eager 來處理 AotAutograd 提取的前向和後向圖。這對於除錯很有用，但不太可能提供加速。
INDUCTOR — 使用 TorchInductor 後端，結合 AotAutograd 和 cudagraphs，利用程式碼生成的 Triton 核心。瞭解更多
AOT_TS_NVFUSER — 結合 AotAutograd/TorchScript 的 nvFuser。瞭解更多
NVPRIMS_NVFUSER — 結合 PrimTorch 的 nvFuser。瞭解更多
CUDAGRAPHS — 結合 AotAutograd 的 cudagraphs。瞭解更多
OFI — 使用 Torchscript optimize_for_inference。僅用於推理。瞭解更多
FX2TRT — 使用 Nvidia TensorRT 進行推理最佳化。僅用於推理。瞭解更多
ONNXRT — 使用 ONNXRT 在 CPU/GPU 上進行推理。僅用於推理。瞭解更多
TENSORRT — 使用 ONNXRT 執行 TensorRT 進行推理最佳化。瞭解更多
AOT_TORCHXLA_TRACE_ONCE — 使用 Pytorch/XLA 和 TorchDynamo 最佳化進行訓練。瞭解更多
TORCHXLA_TRACE_ONCE — 使用 Pytorch/XLA 和 TorchDynamo 最佳化進行推理。瞭解更多
IPEX — 使用 IPEX 在 CPU 上進行推理。僅用於推理。瞭解更多。
TVM — 使用 Apache TVM 進行推理最佳化。瞭解更多
HPU_BACKEND — 使用 HPU 後端進行推理最佳化。

class accelerate.utils.LoggerType

( value names = None module = None qualname = None type = None start = 1 )

表示支援的實驗追蹤器的型別

數值

ALL — 環境中所有支援的可用追蹤器
TENSORBOARD — TensorBoard 作為實驗追蹤器
WANDB — wandb 作為實驗追蹤器
TRACKIO — trackio 作為實驗追蹤器
COMETML — comet_ml 作為實驗追蹤器
MLFLOW — mlflow 作為實驗追蹤器
CLEARML — clearml 作為實驗追蹤器
DVCLIVE — dvclive 作為實驗追蹤器
SWANLAB — swanlab 作為實驗追蹤器

class accelerate.utils.PrecisionType

( value names = None module = None qualname = None type = None start = 1 )

表示用於浮點值的精度型別

數值

NO — 使用全精度 (FP32)
FP16 — 使用半精度
BF16 — 使用腦浮點精度

class accelerate.utils.RNGType

( value names = None module = None qualname = None type = None start = 1 )

一個列舉。

class accelerate.utils.SageMakerDistributedType

( value names = None module = None qualname = None type = None start = 1 )

表示分散式環境的型別。

數值

NO — 不是分散式環境，只是單個程序。
DATA_PARALLEL — 使用 SageMaker 分散式資料並行。
MODEL_PARALLEL — 使用 SageMaker 分散式模型並行。

關鍵字引數

這些是用於特定互動的可配置引數，這些互動在 PyTorch 生態系統中由 Accelerate 在幕後處理。

class accelerate.AutocastKwargs

( enabled: bool = True cache_enabled: bool = None )

在您的 Accelerator 中使用此物件來自定義 torch.autocast 的行為。有關每個引數的更多資訊，請參閱此上下文管理器的文件。

示例

from accelerate import Accelerator
from accelerate.utils import AutocastKwargs

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

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

在您的 Accelerator 中使用此物件，來自定義您的模型如何被包裝在 torch.nn.parallel.DistributedDataParallel 中。有關每個引數的更多資訊，請參閱此包裝器的文件。

gradient_as_bucket_view 僅在 PyTorch 1.7.0 及更高版本中可用。

static_graph 僅在 PyTorch 1.11.0 及更高版本中可用。

示例

from accelerate import Accelerator
from accelerate.utils import DistributedDataParallelKwargs

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

class accelerate.utils.FP8RecipeKwargs

( opt_level: typing.Literal['O1', 'O2'] = None use_autocast_during_eval: bool = None margin: int = None interval: int = None fp8_format: typing.Literal['HYBRID', 'E4M3', 'E5M2'] = None amax_history_len: int = None amax_compute_algo: typing.Literal['max', 'most_recent'] = None override_linear_precision: tuple = None backend: typing.Literal['MSAMP', 'TE'] = None )

已棄用。請改用適當的 FP8 配方 kwargs 類，例如 `TERecipeKwargs` 或 `MSAMPRecipeKwargs`。

class accelerate.GradScalerKwargs

( init_scale: float = 65536.0 growth_factor: float = 2.0 backoff_factor: float = 0.5 growth_interval: int = 2000 enabled: bool = True )

在您的 Accelerator 中使用此物件來自定義混合精度的行為，特別是如何建立 torch.amp.GradScaler 或 torch.cuda.amp.GradScaler。有關每個引數的更多資訊，請參閱此scaler的文件。

torch.cuda.amp.GradScaler 僅在 PyTorch 1.5.0 及更高版本中可用，而 torch.amp.GradScaler 僅在 PyTorch 2.4.0 及更高版本中可用。

示例

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

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

class accelerate.utils.InitProcessGroupKwargs

( backend: typing.Optional[str] = 'nccl' init_method: typing.Optional[str] = None timeout: typing.Optional[datetime.timedelta] = None )

在您的 Accelerator 中使用此物件來自定義分散式程序的初始化。有關每個引數的更多資訊，請參閱此方法的文件。

注意：如果 timeout 設定為 None，預設值將根據 backend 的設定而定。

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

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

class accelerate.utils.KwargsHandler

( )

內部混入類，為資料類實現一個 to_kwargs() 方法。

to_kwargs

( )

返回一個字典，其中包含與此類預設值不同的屬性及其值。

外掛

這些是可以傳遞給 Accelerator 物件的外掛。雖然它們在文件的其他地方有定義，但為了方便起見，這裡列出了所有外掛。

class accelerate.DeepSpeedPlugin

( hf_ds_config: typing.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 enable_msamp: bool = None msamp_opt_level: typing.Optional[typing.Literal['O1', 'O2']] = None )

引數

hf_ds_config (Any, 預設為 None) — DeepSpeed 配置檔案路徑、字典或 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_batch_size。
offload_optimizer_device (str, 預設為 None) — 可選項為 none|cpu|nvme。僅適用於 ZeRO Stages 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 等。
enable_msamp (bool, 預設為 None) — 指示是否為 FP8 訓練啟用 MS-AMP 後端的標誌。
msasmp_opt_level (Optional[Literal["O1", "O2"]], 預設為 None) — MS-AMP 的最佳化級別（預設為 'O1'）。僅當 enable_msamp 為 True 時適用。應為 ['O1' 或 'O2'] 之一。

此外掛用於整合 DeepSpeed。

deepspeed_config_process

( prefix = '' mismatches = None config = None must_match = True **kwargs )

使用 kwargs 中的值處理 DeepSpeed 配置。

選擇

( _from_accelerator_state: bool = False )

設定 HfDeepSpeedWeakref 以使用當前的 DeepSpeed 外掛配置

class accelerate.FullyShardedDataParallelPlugin

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

引數

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，則應為布林值，否則應為 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, torch.distributed.fsdp.MixedPrecision, torch.distributed.fsdp.MixedPrecisionPolicy]], 預設為 None) — 用於啟用 FullyShardedDataParallel 混合精度訓練的配置。如果傳入 dict，它應包含以下鍵：param_dtype、reduce_dtype 和 buffer_dtype。如果 fsdp_version 設定為 2，則可以是 torch.distributed.fsdp.MixedPrecisionPolicy 的例項。
auto_wrap_policy (Optional(Union[Callable, Literal["transformer_based_wrap", "size_based_wrap", "no_wrap"]]), 預設為 NO_WRAP) — 指定遞迴地用 FSDP 包裝層的策略，可以是可呼叫物件或字串。如果為字串，則必須是 transformer_based_wrap、size_based_wrap 或 no_wrap 之一。有關其具體形式，請參閱 torch.distributed.fsdp.wrap.size_based_wrap_policy。
cpu_offload (Union[bool, torch.distributed.fsdp.CPUOffload, torch.distributed.fsdp.CPUOffloadPolicy], 預設為 False) — 是否將引數解除安裝到 CPU。如果 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 按名稱匹配模組。
state_dict_type (Union[str, torch.distributed.fsdp.StateDictType], 預設為 'FULL_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_type 確定。
optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], 預設為 None) — 要使用的最佳化器狀態字典配置。如果未傳入，則根據 state_dict_type 確定。
limit_all_gathers (bool, 預設為 True) — 是否讓 FSDP 顯式同步 CPU 執行緒，以防止過多的正在進行的 all-gather 操作。此布林值僅影響排程 all-gather 的分片策略。啟用此選項有助於減少 CUDA malloc 重試的次數。
use_orig_params (bool, 預設為 False) — 是否為最佳化器使用原始引數。
param_init_fn (Optional[Callable[[torch.nn.Module], None], 預設為 None) — 一個 Callable[torch.nn.Module] -> None，用於指定當前在元裝置上的模組應如何初始化到實際裝置上。僅當 sync_module_states 為 True 時適用。預設是一個在模組上呼叫 to_empty 的 lambda 函式。
sync_module_states (bool, 預設為 False) — 每個單獨包裝的 FSDP 單元是否應從 rank 0 廣播模組引數，以確保它們在初始化後在所有 rank 上都相同。預設為 False，除非 cpu_ram_efficient_loading 為 True，此時將被強制啟用。
forward_prefetch (bool, 預設為 False) — 是否讓 FSDP 在前向傳播執行時顯式預取下一個即將到來的 all-gather 操作。僅與靜態圖一起使用。
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

( model )

給定 model，根據傳入的策略以及是否可以使用 transformer_cls_to_wrap 建立一個 auto_wrap_policy。

set_mixed_precision

( mixed_precision buffer_autocast = False override = False )

為 FSDP 設定混合精度策略

set_state_dict_type

( state_dict_type = None )

根據 `StateDictType` 設定 state dict 配置。

validate_mixed_precision_policy

( )

驗證混合精度策略，抽象出來以避免在不需要時引入匯入。

class accelerate.utils.GradientAccumulationPlugin

( num_steps: int = None adjust_scheduler: bool = True sync_with_dataloader: bool = True sync_each_batch: bool = False )

引數

num_steps (int) — 累積梯度的步數。
adjust_scheduler (bool, 可選, 預設為 True) — 是否調整排程器的步數以考慮累積的步數。如果使用的排程器未針對梯度累積進行調整，則應為 True。
sync_with_dataloader (bool, 可選, 預設為 True) — 是否在 dataloader 結束時同步設定梯度。
sync_each_batch (bool, 可選) — 是否在每個資料批次同步設定梯度。設定為 True 可能會在分散式訓練中使用梯度累積時減少記憶體需求，但會犧牲速度。

一個用於配置梯度累積行為的外掛。您只能將 gradient_accumulation_plugin 或 gradient_accumulation_steps 中的一個傳遞給 Accelerator。同時傳遞兩者會引發錯誤。

示例

from accelerate.utils import GradientAccumulationPlugin

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

class accelerate.utils.MegatronLMPlugin

( tp_degree: int = None pp_degree: int = 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 = None no_wd_decay_cond: typing.Optional[typing.Callable] = None scale_lr_cond: typing.Optional[typing.Callable] = 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.Optional[typing.Any] = None custom_train_step_kwargs: typing.Optional[dict[str, typing.Any]] = None custom_model_provider_function: typing.Optional[typing.Callable] = None custom_prepare_model_function: typing.Optional[typing.Callable] = None custom_megatron_datasets_provider_function: typing.Optional[typing.Callable] = None custom_get_batch_function: typing.Optional[typing.Callable] = None custom_loss_function: typing.Optional[typing.Callable] = None other_megatron_args: typing.Optional[dict[str, typing.Any]] = None )

引數

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_optimizr (bool, 預設為 None) — 啟用分散式最佳化器。
pipeline_model_parallel_split_rank (int, 預設為 None) — 編碼器和解碼器應被拆分的 rank。
num_layers_per_virtual_pipeline_stage (int, 預設為 None) — 每個虛擬流水線階段的層數。
is_train_batch_min (str, 預設為 True) — 如果同時指定了訓練和評估 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') — 權重衰減增量函式。可選值=[“constant”, “linear”, “cosine”]。
start_weight_decay (float, 預設為 None) — L2 正則化的初始權重衰減係數。
end_weight_decay (float, 預設為 None) — 執行結束時 L2 正則化的權重衰減係數。
lr_decay_style (str, 預設為 'linear') — 學習率衰減函式。可選值=[‘constant’, ‘linear’, ‘cosine’]。
lr_decay_iters (int, 預設為 None) — 學習率衰減的迭代次數。如果為 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-(迭代次數/樣本數) 的比例。
min_lr (float，預設為 0) — 學習率的最小值。排程器會將低於此閾值的值進行裁剪。
consumed_samples (List，預設為 None) — 已消耗的樣本數量，順序與傳遞給 accelerator.prepare 呼叫的 dataloaders 相同。
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) — 自定義訓練步驟的關鍵字引數。
custom_model_provider_function (Optional，預設為 None) — 自定義模型提供函式。
custom_prepare_model_function (Optional，預設為 None) — 自定義模型準備函式。
custom_megatron_datasets_provider_function (Optional，預設為 None) — 自定義 megatron 訓練/驗證/測試資料集提供函式。
custom_get_batch_function (Optional，預設為 None) — 自定義獲取批次函式。
custom_loss_function (Optional，預設為 None) — 自定義損失函式。
other_megatron_args (Optional，預設為 None) — 其他 Megatron-LM 引數。請參考 Megatron-LM。

用於 Megatron-LM 的外掛，以啟用張量、流水線、序列和資料並行。還可啟用選擇性啟用重計算和最佳化的融合核心。

class accelerate.utils.TorchDynamoPlugin

( backend: DynamoBackend = None mode: str = None fullgraph: bool = None dynamic: bool = None options: typing.Any = None disable: bool = False use_regional_compilation: bool = None )

引數

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() 變為空操作，用於測試。
use_regional_compilation (bool，預設為 None) — 使用此選項可減少 torch.compile() 的冷啟動編譯時間，透過針對相同類的重複塊並順序編譯它們來命中編譯器快取。例如，在 GPT2LMHeadModel 中，重複的塊/類是 GPT2Block，可以透過 model.transformer.h[0] 訪問。模型的其餘部分（例如 model.lm_head）將單獨編譯。

此外掛用於使用 PyTorch 2.0 編譯模型

配置

這些是可以配置並傳遞給相應整合的類

class 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 = None keep_in_fp32_modules: list = None )

引數

load_in_8bit (bool，預設為 False) — 啟用 8 位量化。
llm_int8_threshold (float，預設為 6.0) — 離群值閾值。僅在 load_in_8bit=True 時相關。
load_in_4_bit (bool，預設為 False) — 啟用 4 位量化。
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 4 位和 8 位量化的外掛

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

引數

split_batches (bool，預設為 False) — 加速器是否應將 dataloader 產生的批次在裝置間進行拆分。如果為 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() 一起執行。
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 支援。這需要安裝支援 StatefulDataLoader 的 torchdata 0.8.0 或更高版本。

呼叫 accelerator.prepare 時與 dataloader 相關的專案的配置。

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

引數

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

( project_dir: str = None )

將 self.project_dir 和 self.logging_dir 設定為適當的值。

環境變數

這些是可以為不同用例啟用的環境變數

ACCELERATE_DEBUG_MODE (str): 是否以除錯模式執行 accelerate。更多資訊請參見此處。

資料操作與運算

這些資料操作與 torch 中的操作類似，但可以在分散式程序上使用。

accelerate.utils.broadcast

( tensor from_process: int = 0 )

引數

tensor (巢狀的 list/tuple/dictionary of torch.Tensor) — 要收集的資料。
from_process (int, 可選, 預設為 0) — 傳送資料的程序。

遞迴地將巢狀的 list/tuple/dictionary 中的張量廣播到所有裝置。

accelerate.utils.broadcast_object_list

( object_list from_process: int = 0 )

引數

object_list (list of picklable objects) — 要廣播的物件列表。該列表將被原地修改。
from_process (int, 可選, 預設為 0) — 傳送資料的程序。

將一個可序列化物件列表從一個程序廣播到其他程序。

accelerate.utils.concatenate

( data dim = 0 )

引數

data (巢狀的 list/tuple/dictionary of lists of tensors torch.Tensor) — 要連線的資料。
dim (int, 可選, 預設為 0) — 連線的維度。

遞迴地連線巢狀的 list/tuple/dictionary 中的張量列表，這些張量具有相同的形狀。

accelerate.utils.convert_outputs_to_fp32

( model_forward )

accelerate.utils.convert_to_fp32

( tensor )

引數

tensor (巢狀的 list/tuple/dictionary of torch.Tensor) — 要從 FP16/BF16 轉換為 FP32 的資料。

遞迴地將巢狀的 list/tuple/dictionary 中 FP16/BF16 精度的張量元素轉換為 FP32。

accelerate.utils.gather

( tensor )

引數

tensor (巢狀的 list/tuple/dictionary of torch.Tensor) — 要收集的資料。

遞迴地從所有裝置收集巢狀的 list/tuple/dictionary 中的張量。

accelerate.utils.gather_object

( object: typing.Any )

引數

object (巢狀的 list/tuple/dictionary of picklable object) — 要收集的資料。

遞迴地從所有裝置收集巢狀的 list/tuple/dictionary 中的物件。

accelerate.utils.get_grad_scaler

( distributed_type: DistributedType = None **kwargs )

引數

distributed_type (DistributedType, 可選, 預設為 None) — 分散式環境的型別。
kwargs — 用於 GradScaler 建構函式的附加引數。

一個通用的輔助函式，它將根據環境初始化正確的 GradScaler 實現並返回它。

accelerate.utils.get_mixed_precision_context_manager

( native_amp: bool = False autocast_kwargs: AutocastKwargs = None )

引數

native_amp (bool, 可選, 預設為 False) — 是否實際啟用混合精度。
cache_enabled (bool, 可選, 預設為 True) — 是否應啟用 autocast 內部的權重快取。

返回一個用於自動轉換混合精度的上下文管理器

accelerate.utils.listify

( data )

引數

data (巢狀的 list/tuple/dictionary of torch.Tensor) — 要轉換為常規數字的資料。

遞迴地在巢狀的 list/tuple/dictionary 中查詢張量，並將它們轉換為數字列表。

accelerate.utils.pad_across_processes

( tensor dim = 0 pad_index = 0 pad_first = False )

引數

tensor (巢狀的 list/tuple/dictionary of torch.Tensor) — 要收集的資料。
dim (int, 可選, 預設為 0) — 填充的維度。
pad_index (int, 可選, 預設為 0) — 用於填充的值。
pad_first (bool, 可選, 預設為 False) — 是在開頭還是在末尾填充。

遞迴地將來自所有裝置的巢狀 list/tuple/dictionary 中的張量填充到相同的大小，以便它們可以安全地被收集。

accelerate.utils.recursively_apply

( func data *args test_type = <function is_torch_tensor at 0x7f9bc05c5360> error_on_other_type = False **kwargs )

引數

func (callable) — 要遞迴應用的函式。
data (巢狀的 list/tuple/dictionary of main_type) — 要應用 func 的資料
*args — 將傳遞給 func 的位置引數，應用於解包後的資料。
main_type (type, 可選, 預設為 torch.Tensor) — 應用 func 的物件的基礎型別。
error_on_other_type (bool, 可選, 預設為 False) — 解包 data 後，如果遇到非 main_type 型別的物件，是否返回錯誤。如果為 False，函式將保持非 main_type 型別的物件不變。
**kwargs (附加關鍵字引數, 可選) — 將傳遞給 func 的關鍵字引數，應用於解包後的資料。

在巢狀的 list/tuple/dictionary 資料結構上遞迴地應用一個函式，該資料結構具有給定的基礎型別。

accelerate.utils.reduce

( tensor reduction = 'mean' scale = 1.0 )

引數

tensor (巢狀的 list/tuple/dictionary of torch.Tensor) — 要歸約的資料。
reduction (str, 可選, 預設為 "mean") — 一種歸約方法。可以是“mean”、“sum”或“none”。
scale (float, 可選) — 歸約後應用的預設縮放值，僅在 XLA 上有效。

透過給定操作的均值，遞迴地歸約所有程序中巢狀的 list/tuple/dictionary 中的張量列表。

accelerate.utils.send_to_device

( tensor device non_blocking = False skip_keys = None )

引數

tensor (torch.Tensor 的巢狀列表/元組/字典) — 要傳送到指定裝置的資料。
device (torch.device) — 要將資料傳送到的裝置。

以遞迴方式將巢狀列表/元組/字典中的張量元素髮送到指定裝置。

accelerate.utils.slice_tensors

( data tensor_slice process_index = None num_processes = None )

引數

data (torch.Tensor 的巢狀列表/元組/字典) — 要切片的資料。
tensor_slice (slice) — 要進行的切片操作。

遞迴地對巢狀列表/元組/字典中的張量進行切片。

環境檢查

這些功能用於檢查當前工作環境的狀態，包括作業系統本身的資訊、其支援的功能以及是否安裝了特定的依賴項。

accelerate.utils.is_bf16_available

( ignore_tpu = False )

檢查是否支援bf16，可選擇忽略TPU

accelerate.utils.is_ipex_available

( )

檢查ipex是否已安裝。

accelerate.utils.is_mps_available

( min_version = '1.12' )

檢查MPS裝置是否可用。最低版本要求為1.12。

accelerate.utils.is_npu_available

( check_device = False )

檢查 `torch_npu` 是否已安裝，並可能檢查環境中是否存在 NPU。

accelerate.utils.is_torch_version

( operation: str version: str )

引數

operation (str) — 運算子的字串表示，例如 `">"` 或 `"<="`
version (str) — PyTorch 的字串版本號

使用給定的運算子，將當前 PyTorch 版本與參考版本進行比較。

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

( check_device = False )

檢查 XPU 加速是否可用，可以是 `intel_extension_for_pytorch` 或原生 PyTorch (>=2.4)，並可能檢查環境中是否存在 XPU。

環境操作

accelerate.utils.patch_environment

( **kwargs )

一個上下文管理器，它會將每個傳入的關鍵字引數新增到 `os.environ` 中，並在退出時將其移除。

會將 `kwargs` 中的值轉換為字串，並將所有鍵轉換為大寫。

示例

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

( )

一個上下文管理器，它會臨時清除環境變數。

當此上下文退出時，之前的環境變數將被恢復。

示例

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

( mixed_precision = 'no' save_location: str = '/github/home/.cache/huggingface/accelerate/default_config.yaml' )

引數

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 時，可以使用 [~utils.write_basic_config] 作為快速配置的替代方案，而不是執行 `accelerate config`。

accelerate.utils.set_numa_affinity

( local_process_index: int verbose: typing.Optional[bool] = None )

引數

local_process_index (int) — 當前伺服器上當前程序的索引。
verbose (bool, 可選) — 是否為每個程序列印新的 CPU 核心分配。如果啟用了 `ACCELERATE_DEBUG_MODE`，則預設為 True。

將當前程序分配給特定的 NUMA 節點。理想情況下，每個節點至少有 2 個 CPU 時效率最高。

此結果在呼叫之間會被快取。如果要覆蓋它，請使用 `accelerate.utils.environment.override_numa_afifnity`。

accelerate.utils.environment.override_numa_affinity

( local_process_index: int verbose: typing.Optional[bool] = None )

引數

local_process_index (int) — 當前伺服器上當前程序的索引。
verbose (bool, 可選) — 是否列印每個 CPU 的分配情況。如果啟用了 `ACCELERATE_DEBUG_MODE`，則預設為 True。

覆蓋為當前程序設定的任何 NUMA 親和性。這個操作非常耗費資源，需要重新計算親和性來設定，理想情況下應使用 `utils.environment.set_numa_affinity` 代替。

accelerate.utils.purge_accelerate_environment

( func_or_cls )

用於清理由被裝飾的類或函式設定的 accelerate 環境變數的裝飾器。

在某些情況下，呼叫特定的類或函式可能會導致 accelerate 環境變數被設定，並且之後沒有被清理。例如，當呼叫

TrainingArguments(fp16=True, …)

將設定以下環境變數

ACCELERATE_MIXED_PRECISION=fp16

這可能會影響後續程式碼，因為環境變數的優先順序高於 TrainingArguments(fp16=False)。這對於單元測試尤其重要，我們希望避免各個測試之間產生副作用。用此裝飾器裝飾單元測試函式或整個類，以確保每次測試後環境變數都被清理。這適用於 unittest.TestCase 和普通類 (pytest)；當裝飾父類時也有效。

記憶體

accelerate.find_executable_batch_size

( function: <built-in function callable> = None starting_batch_size: int = 128 reduce_batch_size_fn: <built-in function callable> = None )

引數

function (callable, 可選) — 要包裝的函式
starting_batch_size (int, 可選) — 嘗試放入記憶體的批處理大小

一個基本的裝飾器，它會嘗試執行 `function`。如果因記憶體不足或 CUDNN 相關的異常而失敗，批處理大小將乘以 0.9 並傳遞給 `function`。

`function` 必須接受一個 `batch_size` 引數作為其第一個引數。

示例

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

模型

這些工具與 PyTorch 模型的互動有關

accelerate.utils.calculate_maximum_sizes

( model: Module )

計算模型的總大小及其最大層的尺寸

accelerate.utils.compute_module_sizes

( model: Module dtype: typing.Union[torch.device, str, NoneType] = None special_dtypes: typing.Optional[dict[str, typing.Union[str, torch.device]]] = None buffers_only: bool = False )

計算給定模型的每個子模組的大小。

accelerate.utils.extract_model_from_parallel

( model keep_fp32_wrapper: bool = True keep_torch_compile: bool = True recursive: bool = False ) → torch.nn.Module

引數

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

( model: Module max_memory: typing.Optional[dict[typing.Union[int, str], typing.Union[int, str]]] = None no_split_module_classes: typing.Optional[list[str]] = None dtype: typing.Union[str, torch.dtype, NoneType] = None special_dtypes: typing.Optional[dict[str, typing.Union[str, torch.device]]] = None low_zero: bool = False )

引數

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）。
low_zero (bool, 可選) — 最小化 GPU 0 上的權重數量，這在 GPU 0 用於其他操作（如 Transformers 的 generate 函式）時很方便。

為 infer_auto_device_map() 計算一個 `max_memory` 字典，該字典將平衡每個可用 GPU 的使用。

所有計算都是透過分析模型引數的大小和資料型別來完成的。因此，模型可以位於元裝置上（就像在 `init_empty_weights` 上下文管理器中初始化時一樣）。

accelerate.utils.get_max_layer_size

( modules: list module_sizes: dict no_split_module_classes: list ) → Tuple[int, List[str]]

引數

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]]

層的最大大小以及實現該最大大小的層名稱列表。

一個工具函式，它將掃描命名模組列表並返回一個完整層所使用的最大大小。層的定義為

沒有直接子模組（只有引數和緩衝區）的模組
其類名在 `no_split_module_classes` 列表中的模組

accelerate.infer_auto_device_map

( model: Module max_memory: typing.Optional[dict[typing.Union[int, str], typing.Union[int, str]]] = None no_split_module_classes: typing.Optional[list[str]] = None dtype: typing.Union[str, torch.dtype, NoneType] = None special_dtypes: typing.Optional[dict[str, typing.Union[str, torch.dtype]]] = None verbose: bool = False clean_result: bool = True offload_buffers: bool = False fallback_allocation: bool = False )

引數

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）。
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 上始終留有空間來放回解除安裝到磁碟的最大尺寸的層。

所有計算都是透過分析模型引數的大小和資料型別來完成的。因此，模型可以位於元裝置上（就像在 `init_empty_weights` 上下文管理器中初始化時一樣）。

accelerate.load_checkpoint_in_model

( model: Module checkpoint: typing.Union[str, os.PathLike] device_map: typing.Optional[dict[str, typing.Union[int, str, torch.device]]] = None offload_folder: typing.Union[str, os.PathLike, NoneType] = None dtype: typing.Union[str, torch.dtype, NoneType] = None offload_state_dict: bool = False offload_buffers: bool = False keep_in_fp32_modules: list = None offload_8bit_bnb: bool = False strict: bool = False full_state_dict: bool = True broadcast_from_rank0: bool = False )

引數

model (torch.nn.Module) — 我們希望載入檢查點的模型。
checkpoint (str or os.PathLike) — 要載入的檢查點資料夾。它可以是：
- 包含整個模型狀態字典的檔案的路徑
- 包含分片檢查點索引的 .json 檔案的路徑
- 包含一個唯一的 .index.json 檔案和檢查點分片的資料夾路徑
- 包含一個唯一的 pytorch_model.bin 或 model.safetensors 檔案的資料夾路徑。
device_map (Dict[str, Union[int, str, torch.device]], 可選) — 一個指定每個子模組應放置位置的對映。它不需要細化到每個引數/緩衝區名稱，一旦給定的模組名稱在其中，其所有子模組都將被髮送到同一裝置。
offload_folder (str or os.PathLike, 可選) — 如果 device_map 包含任何值 "disk"，則為我們將解除安裝權重的資料夾。
dtype (str or torch.dtype, 可選) — 如果提供，權重在載入時將被轉換為該型別。
offload_state_dict (bool, 可選, 預設為 False) — 如果為 True，將臨時將 CPU 狀態字典解除安裝到硬碟，以避免在 CPU 狀態字典的權重 + 最大分片的權重不適合時耗盡 CPU RAM。
offload_buffers (bool, 可選, 預設為 False) — 是否將緩衝區包含在解除安裝到磁碟的權重中。
keep_in_fp32_modules(List[str], 可選) — 保持 torch.float32 dtype 的模組列表。
offload_8bit_bnb (bool, 可選) — 是否啟用在 cpu/磁碟上解除安裝 8-bit 模組。
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，並將其中的張量逐個廣播到其他 rank。其他 rank 將接收張量，並根據模型中的本地分片進行分片（如果適用）。

將一個（可能分片的）檢查點載入到模型中，可能會在載入時將權重發送到給定的裝置。

在跨裝置載入後，您仍需要在模型上呼叫 dispatch_model() 以使其能夠執行。要將檢查點載入和排程組合成一個單一呼叫，請使用 load_checkpoint_and_dispatch()。

accelerate.utils.load_offloaded_weights

( model index offload_folder )

引數

model (torch.nn.Module) — 要載入權重的模型。
index (dict) — 一個字典，包含從模型解除安裝的每個引數的引數名稱及其元資料。
offload_folder (str) — 儲存解除安裝權重的資料夾。

將解除安裝資料夾中的權重載入到模型中。

accelerate.utils.load_state_dict

( checkpoint_file device_map = None )

引數

checkpoint_file (str) — 要載入的檢查點路徑。
device_map (Dict[str, Union[int, str, torch.device]], 可選) — 一個指定每個子模組應放置位置的對映。它不需要細化到每個引數/緩衝區名稱，一旦給定的模組名稱在其中，其所有子模組都將被髮送到同一裝置。

從給定檔案載入檢查點。如果檢查點是 safetensors 格式並且傳遞了裝置對映，權重可以快速直接載入到 GPU 上。

accelerate.utils.offload_state_dict

( save_dir: typing.Union[str, os.PathLike] state_dict: dict )

引數

save_dir (str or os.PathLike) — 解除安裝狀態字典的目錄。
state_dict (Dict[str, torch.Tensor]) — 要解除安裝的張量字典。

在給定資料夾中解除安裝狀態字典。

accelerate.utils.retie_parameters

( model tied_params )

引數

model (torch.nn.Module) — 要重新繫結引數的模型。
tied_params (List[List[str]]) — 透過 find_tied_parameters 獲得的引數名稱到繫結引數名稱的對映。

如果連結被破壞（例如在新增鉤子時），則在給定模型中重新繫結引數。

accelerate.utils.set_module_tensor_to_device

( module: Module tensor_name: str device: typing.Union[int, str, torch.device] value: typing.Optional[torch.Tensor] = None dtype: typing.Union[str, torch.dtype, NoneType] = None fp16_statistics: typing.Optional[torch.HalfTensor] = None tied_params_map: typing.Optional[dict[int, dict[torch.device, torch.Tensor]]] = None non_blocking: bool = False clear_cache: bool = True )

引數

module (torch.nn.Module) — 我們要移動的張量所在的模組。
tensor_name (str) — 引數/緩衝區的全名。
device (int, str or torch.device) — 設定張量的裝置。
value (torch.Tensor, 可選) — 張量的值（在從元裝置移動到任何其他裝置時很有用）。
dtype (torch.dtype, 可選) — 如果與引數值一起傳遞，引數的值將被轉換為此 dtype。否則，value 將被轉換為模型中現有引數的 dtype。
fp16_statistics (torch.HalfTensor, 可選) — 要在模組上設定的 fp16 統計資訊列表，用於 8 位模型序列化。
tied_params_map (Dict[int, Dict[torch.device, torch.Tensor]], 可選, 預設為 None) — 當前資料指標到已排程繫結權重的裝置字典的對映。對於給定的執行裝置，此引數有助於重用裝置上共享權重的第一個可用指標，而不是複製記憶體。
non_blocking (bool, 可選, 預設為 False) — 如果為 True，裝置傳輸將相對於主機非同步進行（如果可能）。
clear_cache (bool, 可選, 預設為 True) — 在裝置上設定張量後是否清除裝置快取。

一個輔助函式，用於將模組的給定張量（引數或緩衝區）設定到特定裝置上（請注意，執行 param.to(device) 會建立一個與引數不關聯的新張量，這就是為什麼我們需要這個函式）。

accelerate.utils.get_module_children_bottom_up

( model: Module return_fqns: bool = False ) → list[torch.nn.Module]

引數

model (torch.nn.Module) — 要獲取其子模組的模型

返回

list[torch.nn.Module]

一個按自下而上順序排列的 model 的子模組列表。最後一個元素是 model 本身。

按自下而上的順序遍歷模型，並按該順序返回子模組。

並行

這些包括在並行工作時應使用的通用工具。

accelerate.utils.extract_model_from_parallel

( model keep_fp32_wrapper: bool = True keep_torch_compile: bool = True recursive: bool = False ) → torch.nn.Module

引數

model (torch.nn.Module) — 要提取的模型。
keep_fp32_wrapper (bool, 可選) — 是否從模型中移除混合精度鉤子。
keep_torch_compile (bool, 可選) — 是否解包已編譯的模型。
recursive (bool, 可選, 預設為 False) — 是否遞迴提取 `model` 中所有的 `module.module` 例項，以及遞迴解包子層，而不僅僅是頂層的分散式容器。

返回

torch.nn.Module

提取出的模型。

從其分散式容器中提取模型。

accelerate.utils.save

( obj f save_on_each_node: bool = False safe_serialization: bool = False )

引數

obj — 要儲存的資料
f — 用於儲存資料的檔案（或類檔案物件）
save_on_each_node (bool, 可選, 預設為 False) — 是否僅在全域性主程序上儲存
safe_serialization (bool, 可選, 預設為 False) — 是否使用 safetensors 或傳統的 PyTorch 方式（使用 pickle）儲存 obj。

將資料儲存到磁碟。代替 torch.save() 使用。

accelerate.utils.load

( f map_location = None **kwargs )

引數

f — 用於載入資料的檔案（或類檔案物件）
map_location — 一個函式、torch.device、字串或指定如何重新對映儲存位置的字典
**kwargs — 傳遞給 torch.load() 的額外關鍵字引數。

torch.load() 的相容性替代品，如果 torch 版本為 2.4.0 或更高，則允許使用 weights_only。否則將忽略該關鍵字引數。

還會為 numpy 陣列新增（然後移除）一個異常處理

accelerate.utils.wait_for_everyone

( )

在指令碼中引入一個阻塞點，確保所有程序在繼續之前都已達到此點。

請確保所有程序都會到達此指令，否則您的某個程序將永遠掛起。

隨機

這些工具與設定和同步所有隨機狀態有關。

accelerate.utils.set_seed

( seed: int device_specific: bool = False deterministic: bool = False )

引數

seed (int) — 要設定的種子。
device_specific (bool, 可選, 預設為 False) — 是否根據 self.process_index 在每個裝置上略微區分種子。
deterministic (bool, 可選, 預設為 False) — 在可用時是否使用確定性演算法。可能會減慢訓練速度。

用於設定 random、numpy、torch 中種子的輔助函式，以實現可復現的行為。

accelerate.utils.synchronize_rng_state

( rng_type: typing.Optional[accelerate.utils.dataclasses.RNGType] = None generator: typing.Optional[torch._C.Generator] = None )

accelerate.synchronize_rng_states

( rng_types: list generator: typing.Optional[torch._C.Generator] = None )

PyTorch XLA

這些是使用 PyTorch with XLA 時有用的實用工具。

accelerate.utils.install_xla

( upgrade: bool = False )

引數

upgrade (bool, 可選, 預設為 False) — 是否升級 torch 並安裝最新的 torch_xla wheels。

根據 Google Colaboratory 中的 torch 版本安裝合適的 xla wheels 的輔助函式。

示例

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

載入模型權重

這些包括載入檢查點時有用的實用工具。

accelerate.load_checkpoint_in_model

( model: Module checkpoint: typing.Union[str, os.PathLike] device_map: typing.Optional[dict[str, typing.Union[int, str, torch.device]]] = None offload_folder: typing.Union[str, os.PathLike, NoneType] = None dtype: typing.Union[str, torch.dtype, NoneType] = None offload_state_dict: bool = False offload_buffers: bool = False keep_in_fp32_modules: list = None offload_8bit_bnb: bool = False strict: bool = False full_state_dict: bool = True broadcast_from_rank0: bool = False )

引數

model (torch.nn.Module) — 我們希望載入檢查點的模型。
checkpoint (str or os.PathLike) — 要載入的檢查點資料夾。它可以是：
- 包含整個模型狀態字典的檔案的路徑
- 包含分片檢查點索引的 .json 檔案的路徑
- 包含一個唯一的 .index.json 檔案和檢查點分片的資料夾路徑
- 包含一個唯一的 pytorch_model.bin 或 model.safetensors 檔案的資料夾路徑。
device_map (Dict[str, Union[int, str, torch.device]], 可選) — 一個指定每個子模組應放置位置的對映。它不需要細化到每個引數/緩衝區名稱，一旦給定的模組名稱在其中，其所有子模組都將被髮送到同一裝置。
offload_folder (str or os.PathLike, 可選) — 如果 device_map 包含任何值 "disk"，則為我們將解除安裝權重的資料夾。
dtype (str or torch.dtype, 可選) — 如果提供，權重在載入時將被轉換為該型別。
offload_state_dict (bool, 可選, 預設為 False) — 如果為 True，將臨時將 CPU 狀態字典解除安裝到硬碟，以避免在 CPU 狀態字典的權重 + 最大分片的權重不適合時耗盡 CPU RAM。
offload_buffers (bool, 可選, 預設為 False) — 是否將緩衝區包含在解除安裝到磁碟的權重中。
keep_in_fp32_modules(List[str], 可選) — 保持 torch.float32 dtype 的模組列表。
offload_8bit_bnb (bool, 可選) — 是否啟用在 cpu/磁碟上解除安裝 8-bit 模組。
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，並將其中的張量逐個廣播到其他 rank。其他 rank 將接收張量，並根據模型中的本地分片進行分片（如果適用）。

將一個（可能分片的）檢查點載入到模型中，可能會在載入時將權重發送到給定的裝置。

在跨裝置載入後，您仍需要在模型上呼叫 dispatch_model() 以使其能夠執行。要將檢查點載入和排程組合成一個單一呼叫，請使用 load_checkpoint_and_dispatch()。

量化

這些包括用於量化模型的實用工具。

accelerate.utils.load_and_quantize_model

( model: Module bnb_quantization_config: BnbQuantizationConfig weights_location: typing.Union[str, os.PathLike] = None device_map: typing.Optional[dict[str, typing.Union[int, str, torch.device]]] = None no_split_module_classes: typing.Optional[list[str]] = None max_memory: typing.Optional[dict[typing.Union[int, str], typing.Union[int, str]]] = None offload_folder: typing.Union[str, os.PathLike, NoneType] = None offload_state_dict: bool = False ) → torch.nn.Module

引數

model (torch.nn.Module) — 輸入模型。模型可以已載入或在元裝置（meta device）上。
bnb_quantization_config (BnbQuantizationConfig) — bitsandbytes 量化引數。
weights_location (str or os.PathLike) — 要載入的權重資料夾。它可以是：
- 包含整個模型狀態字典的檔案的路徑
- 指向分片檢查點索引的 .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 or os.PathLike, 可選) — 如果 device_map 包含任何 "disk" 值，則為我們將解除安裝權重的資料夾。
offload_state_dict (bool, 可選, 預設為 False) — 如果為 True，則會臨時將 CPU 狀態字典解除安裝到硬碟上，以避免在 CPU 狀態字典的權重 + 最大分片的權重不適合時耗盡 CPU RAM。

返回

torch.nn.Module

量化後的模型

此函式將使用在 bnb_quantization_config 中傳遞的關聯配置對輸入模型進行量化。如果模型在元裝置中，我們將根據傳遞的 device_map 載入和分派權重。如果模型已載入，我們將對模型進行量化並將模型放在 GPU 上。

< > 在 GitHub 上更新

←FP8 Megatron-LM 實用工具→

© . This site is unofficial and not affiliated with Hugging Face, Inc.