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_MUSA — 分布在多个 MUSA 上。
MULTI_NPU — 分布在多个 NPU 上。
MULTI_XPU — 分布在多个 XPU 上。
DEEPSPEED — 使用 DeepSpeed。
XLA — 使用 TorchXLA。

class accelerate.utils.DynamoBackend

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

表示 dynamo 后端 (请参阅 https://pytorch.ac.cn/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 — 使用带有 TorchDynamo 优化的 Pytorch/XLA，用于训练。阅读更多
TORCHXLA_TRACE_ONCE — 使用带有 TorchDynamo 优化的 Pytorch/XLA，用于推理。阅读更多
IPEX — 使用 IPEX 在 CPU 上进行推理。仅用于推理。阅读更多。
TVM — 使用 Apach TVM 进行推理优化。阅读更多

class accelerate.utils.LoggerType

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

表示受支持的实验跟踪器的类型

值

ALL — 环境中所有可用的受支持跟踪器
TENSORBOARD — TensorBoard 作为实验跟踪器
WANDB — wandb 作为实验跟踪器
COMETML — comet_ml 作为实验跟踪器
DVCLIVE — dvclive 作为实验跟踪器

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 分布式模型并行。

Kwargs

这些是 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: Literal = <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

( backend: Literal = None use_autocast_during_eval: bool = None opt_level: Literal = None margin: int = None interval: int = None fp8_format: Literal = None amax_history_len: int = None amax_compute_algo: Literal = None override_linear_precision: Tuple = None )

参数

backend (str, 可选) — 要使用的 FP8 引擎。必须是 "msamp" (MS-AMP) 或 "te" (TransformerEngine) 之一。如果未传递，将使用环境中可用的引擎，优先使用 MS-AMP。
use_autocast_during_eval (bool, 可选, 默认为 False) — 是否在评估模式期间使用 FP8 autocast。通常，当此项为 False 时，可以找到更好的指标。
margin (int, 可选, 默认为 0) — 用于梯度缩放的边距。
interval (int, 可选, 默认为 1) — 用于重新计算缩放因子的频率间隔。
fp8_format (str, 可选, 默认为 “HYBRID”) — 用于 FP8 配方的格式。必须是 HYBRID 或 E4M3 之一。（通常训练使用 HYBRID，评估使用 E4M3）
amax_history_len (int, 可选, 默认为 1024) — 用于缩放因子计算的历史记录长度
amax_compute_algo (str, 可选, 默认为 “most_recent”) — 用于缩放因子计算的算法。必须是 max 或 most_recent 之一。
override_linear_precision (三个 bool 的 tuple, 可选, 默认为 (False, False, False)) — 是否以更高的精度执行 fprop, dgrad 和 wgrad GEMMS。
optimization_level (str), O1, O2 之一。（默认为 O2）— MS-AMP 应该使用哪种级别的 8 位集合通信。一般来说：
- O1: 权重梯度和 all_reduce 通信以 fp8 完成，从而减少 GPU 内存使用和通信带宽
- O2: 一阶优化器状态为 8 位，二阶状态为 FP16。仅在使用 Adam 或 AdamW 时可用。这保持了准确性，并有可能节省最高的内存。
- 03: 专门用于 DeepSpeed，实现模型权重和主权重存储在 FP8 中的功能。如果选择了 fp8 并且启用了 deepspeed，则默认使用。（目前不可用）。

在你的 Accelerator 中使用此对象来自定义使用 transformer-engine 或 ms-amp 进行 FP8 混合精度训练的配方初始化。

有关 transformer-engine 参数的更多信息，请参阅 API 文档。

有关 ms-amp 参数的更多信息，请参阅优化级别文档。

from accelerate import Accelerator
from accelerate.utils import FP8RecipeKwargs

kwargs = FP8RecipeKwargs(backend="te", fp8_format="HYBRID")
accelerator = Accelerator(mixed_precision="fp8", kwargs_handlers=[kwargs])

要使用 MS-AMP 作为引擎，请传递 backend="msamp" 和 optimization_level

kwargs = FP8RecipeKwargs(backend="msamp", optimization_level="02")

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.cuda.amp.GradScaler。请参考此 scaler 的文档，以获取有关每个参数的更多信息。

GradScaler 仅在 PyTorch 1.5.0 及更高版本中可用。

示例

from accelerate import Accelerator
from accelerate.utils import GradScalerKwargs

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

class accelerate.InitProcessGroupKwargs

( backend: Optional = 'nccl' init_method: Optional = None timeout: Optional = 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: 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: Optional = None )

参数

hf_ds_config (Any, defaults to None) — DeepSpeed 配置文件或字典的路径，或 accelerate.utils.deepspeed.HfDeepSpeedConfig 类的对象。
gradient_accumulation_steps (int, defaults to None) — 在更新优化器状态之前累积梯度的步数。如果未设置，将直接使用 Accelerator 中的值。
gradient_clipping (float, defaults to None) — 启用梯度裁剪，并指定值。
zero_stage (int, defaults to None) — 可选值为 0、1、2、3。默认值将从环境变量中获取。
is_train_batch_min (bool, defaults to True) — 如果同时指定了训练和评估数据加载器，这将决定 train_batch_size。
offload_optimizer_device (str, defaults to None) — 可选值为 none|cpu|nvme。仅适用于 ZeRO Stage 2 和 3。
offload_param_device (str, defaults to None) — 可选值为 none|cpu|nvme。仅适用于 ZeRO Stage 3。
offload_optimizer_nvme_path (str, defaults to None) — 可选值为 /nvme|/local_nvme。仅适用于 ZeRO Stage 3。
offload_param_nvme_path (str, defaults to None) — 可选值为 /nvme|/local_nvme。仅适用于 ZeRO Stage 3。
zero3_init_flag (bool, defaults to None) — 标志，指示是否保存 16 位模型。仅适用于 ZeRO Stage-3。
zero3_save_16bit_model (bool, defaults to None) — 标志，指示是否保存 16 位模型。仅适用于 ZeRO Stage-3。
transformer_moe_cls_names (str, defaults to None) — Transformer MoE 层类名（区分大小写）的逗号分隔列表。例如，MixtralSparseMoeBlock, Qwen2MoeSparseMoeBlock, JetMoEAttention, JetMoEBlock 等。
enable_msamp (bool, defaults to None) — 标志，指示是否为 FP8 训练启用 MS-AMP 后端。
msasmp_opt_level (Optional[Literal["O1", "O2"]], defaults to None) — MS-AMP 的优化级别（默认为 ‘O1’）。仅当 enable_msamp 为 True 时适用。应为 [‘O1’ 或 ‘O2’] 之一。

此插件用于集成 DeepSpeed。

deepspeed_config_process

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

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

select

( _from_accelerator_state: bool = False )

设置 HfDeepSpeedWeakref 以使用当前的 deepspeed 插件配置。

class accelerate.FullyShardedDataParallelPlugin

( sharding_strategy: Union = None backward_prefetch: Union = None mixed_precision_policy: Union = None auto_wrap_policy: Union = None cpu_offload: Union = None ignored_modules: Optional = None state_dict_type: Union = None state_dict_config: Union = None optim_state_dict_config: Union = None limit_all_gathers: bool = True use_orig_params: bool = None param_init_fn: Optional = None sync_module_states: bool = None forward_prefetch: bool = None activation_checkpointing: bool = None cpu_ram_efficient_loading: bool = None transformer_cls_names_to_wrap: Optional = None min_num_params: Optional = None )

参数

sharding_strategy (Union[str, torch.distributed.fsdp.ShardingStrategy], defaults to 'FULL_SHARD') — 要使用的分片策略。应为 str 或 torch.distributed.fsdp.fully_sharded_data_parallel.ShardingStrategy 的实例。
backward_prefetch (Union[str, torch.distributed.fsdp.BackwardPrefetch], defaults to 'NO_PREFETCH') — 要使用的后向预取策略。应为 str 或 torch.distributed.fsdp.fully_sharded_data_parallel.BackwardPrefetch 的实例。
mixed_precision_policy (Optional[Union[dict, torch.distributed.fsdp.MixedPrecision]], defaults to None) — 用于启用 FullyShardedDataParallel 的混合精度训练的配置。如果传入 dict，则应具有以下键：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) -- 指定策略以使用 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], defaults to False) — 是否将参数卸载到 CPU。应为 bool 或 torch.distributed.fsdp.fully_sharded_data_parallel.CPUOffload 的实例。
ignored_modules (Optional[Iterable[torch.nn.Module]], defaults to None) — 使用 FSDP 包装时要忽略的模块列表。
state_dict_type (Union[str, torch.distributed.fsdp.StateDictType], defaults to '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], defaults to None) — 要使用的状态字典配置。如果未传入，则根据 state_dict_type 确定。
optim_state_dict_config (Optional[Union[torch.distributed.fsdp.FullOptimStateDictConfig, torch.distributed.fsdp.ShardedOptimStateDictConfig], defaults to None) — 要使用的 Optim 状态字典配置。如果未传入，则根据 state_dict_type 确定。
limit_all_gathers (bool, defaults to True) — 是否让 FSDP 显式同步 CPU 线程，以防止过多的飞行中 all-gather 操作。此布尔值仅影响计划 all-gather 操作的分片策略。启用此功能可以帮助减少 CUDA malloc 重试的次数。
use_orig_params (bool, defaults to False) — 是否对优化器使用原始参数。
param_init_fn (Optional[Callable[[torch.nn.Module], None], 默认为 None) — 一个 Callable[torch.nn.Module] -> None，用于指定当前位于 meta 设备上的模块应如何初始化到实际设备上。仅当 sync_module_states 为 True 时适用。默认情况下是一个 lambda 函数，它在模块上调用 to_empty。
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 配置。

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) — 是否在数据加载器结束时同步设置梯度。
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: Optional = None scale_lr_cond: Optional = 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: 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 custom_get_batch_function: Optional = None custom_loss_function: Optional = None other_megatron_args: Optional = 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) — 编码器和解码器应该分割的等级。
num_layers_per_virtual_pipeline_stage (int, 默认为 None) — 每个虚拟流水线阶段的层数。
is_train_batch_min (str, 默认为 True) — 如果同时指定了训练和评估数据加载器，这将决定 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) — 学习率衰减的迭代次数。如果为 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 调用相同的顺序消耗的样本数。
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 训练/验证/测试数据集提供函数。
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: Any = None disable: bool = False )

参数

backend (DynamoBackend, 默认为 None) — 有效的 Dynamo 后端。详见 https://pytorch.ac.cn/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) 以进行测试

此插件用于使用 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: bool = '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 non_blocking: bool = False use_stateful_dataloader: bool = False )

参数

split_batches (bool, 默认为 False) — 加速器是否应跨设备拆分数据加载器产生的批次。如果为 True，则在任何类型的分布式进程中使用的实际批次大小都将相同，但它必须是您正在使用的 num_processes 的整数倍。如果为 False，则使用的实际批次大小将是脚本中设置的批次大小乘以进程数。
dispatch_batches (bool, 默认为 None) — 如果设置为 True，则由 Accelerator 准备的数据加载器仅在主进程上迭代，然后批次被拆分并广播到每个进程。对于底层数据集是 IterableDataset 的 DataLoader 将默认为 True，否则为 False。
even_batches (bool, defaults to True) — 如果设置为 True，在所有进程的总批次大小不能完全整除数据集的情况下，将复制数据集开始处的样本，以便批次可以在所有工作进程之间平均分配。
use_seedable_sampler (bool, defaults to False) — 是否使用完全可种子化的随机采样器 (data_loader.SeedableRandomSampler)。确保使用不同的采样技术时，训练结果是完全可重现的。虽然种子到种子的结果可能有所不同，但在使用多个不同的种子进行比较时，平均差异可以忽略不计。还应与 set_seed() 一起运行以获得最佳结果。
non_blocking (bool, defaults to False) — 如果设置为 True，Accelerator 准备的数据加载器将使用非阻塞的主机到设备传输，从而更好地重叠数据加载器通信和计算。建议准备好的数据加载器将 pin_memory 设置为 True 以正常工作。
use_stateful_dataloader (bool, defaults to False) — 如果设置为 True，则 Accelerator 准备的数据加载器将由 torchdata.StatefulDataLoader 支持。这需要安装支持 StatefulDataLoader 的 torchdata 版本 0.8.0 或更高版本。

调用 accelerator.prepare 时，用于数据加载器相关项的配置。

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, defaults to None) — 用于存储数据的目录路径。
logging_dir (str, defaults to None) — 用于存储本地兼容记录器的日志的目录路径。如果为 None，则默认为 project_dir。
automatic_checkpoint_naming (bool, defaults to False) — 是否应自动迭代命名保存的状态。
total_limit (int, defaults to None) — 要保留的最大保存状态总数。
iteration (int, defaults to 0) — 当前保存迭代次数。
save_on_each_node (bool, defaults to False) — 当进行多节点分布式训练时，是否在每个节点上保存模型和检查点，还是仅在主节点上保存。

基于项目内部需求加速器对象的配置。

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 (torch.Tensor 的嵌套列表/元组/字典) — 要收集的数据。
from_process (int, 可选, 默认为 0) — 发送数据的进程

递归地将张量广播到嵌套的张量列表/元组/字典中的所有设备。

accelerate.utils.broadcast_object_list

( object_list from_process: int = 0 )

参数

object_list (可 pickle 对象的列表) — 要广播的对象列表。此列表将被就地修改。
from_process (int, 可选, 默认为 0) — 从哪个进程发送数据。

将可 pickle 对象列表从一个进程广播到其他进程。

accelerate.utils.concatenate

( data dim = 0 )

参数

data (torch.Tensor 列表的嵌套列表/元组/字典) — 要连接的数据。
dim (int, 可选, 默认为 0) — 连接的维度。

递归地连接形状相同的张量嵌套列表/元组/字典中的张量列表。

accelerate.utils.convert_outputs_to_fp32

( model_forward )

accelerate.utils.convert_to_fp32

( tensor )

参数

tensor (嵌套列表/元组/字典，元素为 torch.Tensor) — 要从 FP16/BF16 转换为 FP32 的数据。

递归地将嵌套列表/元组/字典中的张量元素从 FP16/BF16 精度转换为 FP32。

accelerate.utils.gather

( tensor )

参数

tensor (嵌套列表/元组/字典，元素为 torch.Tensor) — 要收集的数据。

递归地从所有设备收集嵌套列表/元组/字典中的张量。

accelerate.utils.gather_object

( object: Any )

参数

object (嵌套列表/元组/字典，元素为可 pickle 的对象) — 要收集的数据。

递归地从所有设备收集嵌套列表/元组/字典中的对象。

accelerate.utils.listify

( data )

参数

data (嵌套列表/元组/字典，元素为 torch.Tensor) — 要从中转换为常规数字的数据。

递归地查找嵌套列表/元组/字典中的张量，并将它们转换为数字列表。

accelerate.utils.pad_across_processes

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

参数

tensor (嵌套列表/元组/字典，元素为 torch.Tensor) — 要收集的数据。
dim (int, *可选*, 默认为 0) — 要在其上进行填充的维度。
pad_index (int, *可选*, 默认为 0) — 用于填充的值。
pad_first (bool, *可选*, 默认为 False) — 是否在开头或结尾填充。

递归地填充来自所有设备的嵌套列表/元组/字典中的张量，使它们具有相同的大小，以便可以安全地收集它们。

accelerate.utils.recursively_apply

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

参数

func (callable) — 要递归应用的函数。
data (嵌套列表/元组/字典，元素为 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` 的关键字参数。

递归地将函数应用于数据结构，该数据结构是给定基本类型的嵌套列表/元组/字典。

accelerate.utils.reduce

( tensor reduction = 'mean' scale = 1.0 )

参数

tensor (嵌套列表/元组/字典，元素为 torch.Tensor) — 要归约的数据。
reduction (str, *可选*, 默认为 "mean") — 一种归约方法。可以是 “mean”（均值）、“sum”（求和）或 “none”（无）。
scale (float, *可选*) — 归约后应用的默认缩放值，仅在 XLA 上有效。

递归地通过给定操作的均值来归约所有进程中嵌套列表/元组/字典中的张量列表。

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 )

检查是否可以通过 intel_extension_for_pytorch 或通过 stock PyTorch (>=2.4) 使用 XPU 加速，并可能检查环境中是否存在 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' use_xpu: bool = False )

参数

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。
use_xpu (bool, 可选, 默认为 False) — 是否在可用时使用 XPU。

创建并保存基本集群配置，以在可能具有多个 GPU 的本地计算机上使用。如果它是仅 CPU 计算机，还将设置 CPU。

首次设置 🤗 Accelerate 时，与其运行 accelerate config，不如使用 [~utils.write_basic_config] 作为快速配置的替代方法。

accelerate.utils.set_numa_affinity

( local_process_index: int verbose: Optional = None )

参数

local_process_index (int) — 当前进程在当前服务器上的索引。
verbose (bool, 可选) — 是否打印每个进程的新 cpu 核心分配。如果启用了 ACCELERATE_DEBUG_MODE，则默认为 True。

将当前进程分配给特定的 NUMA 节点。当每个节点至少有两个 cpu 时，效果最佳。

此结果在调用之间缓存。如果要覆盖它，请使用 accelerate.utils.environment.override_numa_afifnity。

accelerate.utils.environment.override_numa_affinity

( local_process_index: int verbose: Optional = None )

参数

local_process_index (int) — 当前进程在当前服务器上的索引。
verbose (bool, 可选) — 是否记录每个 CPU 的分配。如果启用了 ACCELERATE_DEBUG_MODE，则默认为 True。

覆盖为当前进程设置的任何 NUMA 亲和性。这非常耗费资源，需要重新计算要设置的亲和性，理想情况下，您应该改用 utils.environment.set_numa_affinity。

内存

accelerate.find_executable_batch_size

( function: callable = None starting_batch_size: int = 128 )

参数

function (callable, 可选) — 要包装的函数
starting_batch_size (int, 可选) — 要尝试放入内存的批处理大小

一个基本的装饰器，它将尝试执行 function。如果因与内存不足或 CUDNN 相关的异常而失败，则批处理大小将减半并传递给 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: Union = None special_dtypes: Optional = None buffers_only: bool = False )

计算给定模型的每个子模块的大小。

accelerate.utils.extract_model_from_parallel

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

参数

model (torch.nn.Module) — 要提取的模型。
keep_fp32_wrapper (bool, 可选) — 是否从模型中移除混合精度钩子。
recursive (bool, 可选, 默认为 False) — 是否递归地从 model 中提取所有 module.module 的情况，并递归地解包子层，而不仅仅是顶级的分布式容器。

返回：

torch.nn.Module

提取的模型。

从模型的分布式容器中提取模型。

accelerate.utils.get_balanced_memory

( model: Module max_memory: Optional = None no_split_module_classes: Optional = None dtype: Union = None special_dtypes: Optional = 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]], 可选) — 如果提供，则为某些特定权重考虑特殊的数据类型（将覆盖用作所有权重的默认数据类型）。
low_zero (bool, 可选) — 最小化 GPU 0 上的权重数量，这在 GPU 0 用于其他操作（例如 Transformers generate 函数）时非常方便。

为 infer_auto_device_map() 计算一个 max_memory 字典，该字典将平衡每个可用 GPU 的使用。

所有计算都通过分析模型参数的大小和数据类型来完成。因此，模型可以在 meta 设备上（就像在 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: Optional = None no_split_module_classes: Optional = None dtype: Union = None special_dtypes: Optional = None verbose: bool = False clean_result: bool = True offload_buffers: 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]], 可选) — 如果提供，则为某些特定权重考虑特殊的数据类型（将覆盖用作所有权重的默认数据类型）。
verbose (bool, 可选, 默认为 False) — 是否在函数构建 device_map 时提供调试语句。
clean_result (bool, 可选, 默认为 True) — 通过将所有位于同一设备上的子模块分组在一起来清理生成的 device_map。
offload_buffers (bool, 可选, 默认为 False) — 在 CPU 或硬盘上卸载的层中，是否也卸载缓冲区以及参数。

为给定模型计算设备映射，优先考虑 GPU，然后卸载到 CPU，最后卸载到磁盘，以便：

我们不会超过任何 GPU 的可用内存。
如果需要卸载到 CPU，GPU 0 上总是有剩余空间，以放回卸载到 CPU 且尺寸最大的层。
如果需要卸载到 CPU，我们不会超过 CPU 上的可用 RAM。
如果需要卸载到磁盘，CPU 上总是有剩余空间，以放回卸载到磁盘且尺寸最大的层。

所有计算都通过分析模型参数的大小和数据类型来完成。因此，模型可以在 meta 设备上（就像在 init_empty_weights 上下文管理器中初始化一样）。

accelerate.load_checkpoint_in_model

( model: Module checkpoint: Union device_map: Optional = None offload_folder: Union = None dtype: Union = None offload_state_dict: bool = False offload_buffers: bool = False keep_in_fp32_modules: List = None offload_8bit_bnb: bool = False strict: bool = False )

参数

model (torch.nn.Module) — 我们想要在其中加载检查点的模型。
checkpoint (str 或 os.PathLike) — 要加载的文件夹检查点。它可以是：
- 包含整个模型状态字典的文件的路径
- 包含分片检查点索引的 .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 状态字典卸载到硬盘上，以避免在 CPU 状态字典的权重 + 最大分片不适合时超出 CPU RAM。
offload_buffers (bool, 可选, 默认为 False) — 是否将缓冲区包含在卸载到磁盘的权重中。
keep_in_fp32_modules(List[str], 可选) — 我们保持在 torch.float32 数据类型中的模块列表。
offload_8bit_bnb (bool, 可选) — 是否在 cpu/磁盘上启用 8 位模块的卸载。
strict (bool, 可选, 默认为 False) — 是否严格强制检查点 state_dict 中的键与模型的 state_dict 的键匹配。

在模型内部加载（可能是分片的）检查点，可能会在加载时将权重发送到给定的设备。

一旦跨设备加载，您仍然需要在您的模型上调用 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: Union state_dict: Dict )

参数

save_dir (str 或 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: Union value: Optional = None dtype: Union = None fp16_statistics: Optional = None tied_params_map: Optional = None )

参数

module (torch.nn.Module) — 我们想要移动的张量所在的模块。
tensor_name (str) — 参数/缓冲区的完整名称。
device (int, str 或 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) — 当前数据指针到设备字典的映射，用于已经分发的绑定权重。对于给定的执行设备，此参数可用于重用设备上共享权重的第一个可用指针，而不是复制内存。

一个辅助函数，用于将模块的给定张量（参数或缓冲区）设置在特定设备上（请注意，执行 param.to(device) 会创建一个新的张量，该张量未链接到参数，这就是我们需要此函数的原因）。

并行

这些包括在并行工作时应使用的一般实用程序。

accelerate.utils.extract_model_from_parallel

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

参数

model (torch.nn.Module) — 要提取的模型。
keep_fp32_wrapper (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 )

参数

save_on_each_node (bool, 可选, 默认为 False) — 是否仅在全局主进程上保存
safe_serialization (bool, 可选, 默认为 False) — 是否使用 safetensors 或传统的 PyTorch 方式 (使用 pickle) 保存 obj。

将数据保存到磁盘。代替 torch.save() 使用。

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: Optional = None generator: Optional = None )

accelerate.synchronize_rng_states

( rng_types: List generator: Optional = None )

PyTorch XLA

这些包括在使用 PyTorch 和 XLA 时有用的实用程序。

accelerate.utils.install_xla

( upgrade: bool = False )

参数

upgrade (bool, 可选, 默认为 False) — 是否升级 torch 并安装最新的 torch_xla wheel 包。

辅助函数，用于根据 Google Colaboratory 中的 torch 版本安装适当的 xla wheel 包。

示例

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

加载模型权重

这些包括用于加载检查点的实用程序。

accelerate.load_checkpoint_in_model

( model: Module checkpoint: Union device_map: Optional = None offload_folder: Union = None dtype: Union = None offload_state_dict: bool = False offload_buffers: bool = False keep_in_fp32_modules: List = None offload_8bit_bnb: bool = False strict: bool = False )

参数

model (torch.nn.Module) — 我们想要在其中加载检查点的模型。
checkpoint (str 或 os.PathLike) — 要加载的文件夹检查点。它可以是：
- 包含整个模型状态字典的文件的路径
- 包含分片检查点索引的 .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 状态字典卸载到硬盘上，以避免在 CPU 状态字典的权重 + 最大分片不适合时超出 CPU RAM。
offload_buffers (bool, 可选, 默认为 False) — 是否将缓冲区包含在卸载到磁盘的权重中。
keep_in_fp32_modules(List[str], 可选) — 我们保持在 torch.float32 数据类型中的模块列表。
offload_8bit_bnb (bool, 可选) — 是否在 cpu/磁盘上启用 8 位模块的卸载。
strict (bool, 可选, 默认为 False) — 是否严格强制检查点 state_dict 中的键与模型的 state_dict 的键匹配。

在模型内部加载（可能是分片的）检查点，可能会在加载时将权重发送到给定的设备。

一旦跨设备加载，您仍然需要在您的模型上调用 dispatch_model() 以使其能够运行。要将检查点加载和分发分组到一个调用中，请使用 load_checkpoint_and_dispatch()。

量化

这些包括用于量化模型的实用程序。

accelerate.utils.load_and_quantize_model

( model: Module bnb_quantization_config: BnbQuantizationConfig weights_location: Union = None device_map: Optional = None no_split_module_classes: Optional = None max_memory: Optional = None offload_folder: Union = None offload_state_dict: bool = False ) → torch.nn.Module

参数

model (torch.nn.Module) — 输入模型。该模型可以是已加载的，也可以在 meta 设备上
bnb_quantization_config (BnbQuantizationConfig) — bitsandbytes 量化参数
weights_location (str 或 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 或 os.PathLike, 可选) — 如果 device_map 包含任何值 "disk"，则为我们将要卸载权重的文件夹。
offload_state_dict (bool, 可选, 默认为 False) — 如果为 True，则会将 CPU 状态字典临时卸载到硬盘驱动器上，以避免在 CPU 状态字典的权重 + 最大的分片不适合时耗尽 CPU RAM。

返回：

torch.nn.Module

量化模型

此函数将使用 bnb_quantization_config 中传递的相关配置来量化输入模型。如果模型位于 meta 设备中，我们将根据传递的 device_map 加载和分发权重。如果模型已加载，我们将量化模型并将模型放在 GPU 上，

< > 在 GitHub 上更新

←FP8 Megatron-LM 实用程序→