加速文档

实用工具

Hugging Face's logo
加入Hugging Face社区

并获得增强的文档体验

开始使用

有用的工具

以下是🤗 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中使用的基数据类,可以作为参数传递。

独立

这些是用于检查的独立数据类,例如正在使用的分布式系统的类型

accelerate.utils.ComputeEnvironment

< >

( names = None 模块 = None qualname = None 类型 = None 开始 = 1 )

表示计算环境的一种类型。

  • LOCAL_MACHINE — 私有/定制集群硬件。
  • AMAZON_SAGEMAKER — 以 Amazon SageMaker 作为计算环境。

accelerate.DistributedType

< >

( names = None 模块 = None qualname = None 类型 = None 开始 = 1 )

代表分布式环境类型。

  • NO — 非分布式环境,仅单个进程。
  • MULTI_CPU — 分布在多个CPU节点上。
  • MULTI_GPU — 分布在多个GPU上。
  • MULTI_MLU — 分布在多个MLU上。
  • MULTI_MUSA — 分布在多个MUSA上。
  • MULTI_NPU — 分布在多个NPU上。
  • MULTI_XPU — 分布在多个XPU上。
  • DEEPSPEED — 使用DeepSpeed。
  • XLA — 使用TorchXLA。
  • TPU — 此字段将在v0.27.0版本中弃用。请使用XLA代替。

class accelerate.utils.DynamoBackend

< >

( names = None 模块 = None qualname = None 类型 = None 开始 = 1 )

代表dynamo后端(见https://pytorch.ac.cn/docs/stable/torch.compiler.html)。

  • NO — 不使用torch dynamo。
  • EAGER — 使用PyTorch运行提取的GraphModule。这在调试TorchDynamo问题时非常有用。
  • AOT_EAGER — 使用AotAutograd无编译器,即仅使用PyTorch eager的前向和反向图。这对于调试非常有用,但不太可能提供速度提升。
  • INDUCTOR — 使用TorchInductor后端和AotAutograd、cudagraphs,通过利用代码生成的Triton内核。了解更多信息
  • AOT_TS_NVFUSER — nvFuser与AotAutograd/TorchScript。了解更多信息
  • NVPRIMS_NVFUSER — nvFuser与PrimTorch。了解更多信息
  • CUDAGRAPHS — cudagraphs与AotAutograd。了解更多信息
  • 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进行推理优化。了解更多

accelerate.utils.LoggerType

< >

( names = None 模块 = None qualname = None 类型 = None 开始 = 1 )

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

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

accelerate.utils.PrecisionType

< >

( names = None 模块 = None qualname = None 类型 = None 开始 = 1 )

表示用于浮点值的精度类型

  • NO — 使用全精度(FP32)
  • FP16 — 使用半精度
  • BF16 — 使用大脑浮点精度

accelerate.utils.RNGType

< >

( names = None 模块 = None qualname = None 类型 = None 开始 = 1 )

枚举类型。

class accelerate.utils.SageMakerDistributedType

< >

( names = None 模块 = None qualname = None 类型 = None 开始 = 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])

accelerate.utils.FP8RecipeKwargs

< >

( backend: Literal = 'MSAMP' opt_level: Literal = 'O2' margin: int = 0 interval: int = 1 fp8_format: Literal = 'E4M3' amax_history_len: int = 1 amax_compute_algo: Literal = 'most_recent' override_linear_precision: Tuple = (False, False, False) )

参数

  • backend (str, 可选,默认为“msamp”) — 使用哪个FP8引擎。必须是"msamp" (MS-AMP)"te" (TransformerEngine)之一。
  • marginint可选,默认为0) — 用于梯度缩放的参数。
  • interval (int, 可选,默认为1) —— 重新计算缩放因子所用的时间间隔。
  • fp8_format (str, 可选,默认为“E4M3”) —— 用于FP8方案的格式。必须是E4M3HYBRID之一。
  • amax_history_len (int, 可选,默认为1024) —— 用于缩放因子计算的记录长度
  • amax_compute_algo (str, 可选,默认为“most_recent”) —— 用于缩放因子计算的算法。必须是maxmost_recent之一。
  • override_linear_precision (三 bool 的元组,可选,默认为 (False, False, False)) — 是否在更高的精度下执行 fpropdgradwgrad GEMMS。
  • optimization_levelstr),可以是 O1O2。(默认为 O2)—— 在 MS-AMP 中使用的 8 位集体通信的级别。一般来说:
    • O1:权重梯度和 all_reduce 通信在 fp8 中进行,减少 GPU 内存使用和通信带宽
    • O2:一阶优化器状态在 8 位,二阶状态在 FP16。仅在 Adam 或 AdamW 中可用。这保持了精度,并可能节省最高的内存。
    • 03:特别为 DeepSpeed 实现,将模型的权重和主权重存储在 FP8 中。如果选择 fp8 并启用 deepspeed,将默认使用。(目前不可用)

使用此对象在你的 Accelerator 中自定义使用 transformer-enginems-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 )

将此对象用于您的 加速器 以自定义混合精度的行为,具体是创建 torch.cuda.amp.GradScaler 时使用的方法。有关各参数的更多信息,请参阅此 缩放器 的文档。

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

加速器.InitProcessGroupKwargs

< >

( backend: Optional = 'nccl' init_method: Optional = None timeout: Optional = None )

使用此对象在您的加速器中来自定义分布式进程的初始化。有关每个参数的更多信息,请参阅此方法的文档。

注意:如果将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])

accelerate.utils.KwargsHandler

< >

( )

实现一个用于数据类的to_kwargs()方法的内部混入类。

to_kwargs

< >

( )

返回一个字典,包含与此类默认值不同的属性值。

插件

这些插件可以传递给加速器对象。虽然它们在文档的其它地方定义,但为了方便,这里提供了所有插件

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 )

此插件用于集成DeepSpeed。

deepspeed_config处理

< >

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

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

class accelerate.FullyShardedDataParallelPlugin

< >

sharding_strategy: typing.Any = None backward_prefetch: typing.Any = None mixed_precision_policy: typing.Any = None auto_wrap_policy: Optional = None cpu_offload: typing.Any = None ignored_modules: Optional = None state_dict_type: typing.Any = None state_dict_config: typing.Any = None optim_state_dict_config: typing.Any = None limit_all_gathers: bool = True use_orig_params: bool = True param_init_fn: Optional = None sync_module_states: bool = True forward_prefetch: bool = False activation_checkpointing: bool = False

此插件用于启用全分片数据并行。

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, optional) — 是否在每个数据批次时同步设置梯度。设置为 True 可能在使用梯度累积的分布式训练时减少内存需求,但会牺牲速度。

一个配置梯度累积行为的插件。您只能向 Accelerator 传递 gradient_accumulation_plugingradient_accumulation_steps 中的一个。传递两个都会引发错误。

示例

from accelerate.utils import GradientAccumulationPlugin

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

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 )

Megatron-LM 的插件,用于启用张量、管道、序列和数据并行。还用于启用可选激活重计算和优化融合内核。

accelerate.utils.TorchDynamoPlugin

< >

( 后端: DynamoBackend = None 模式: str = None 全图: bool = None 动态: bool = None 选项: Any = None 禁用: bool = False )

本插件用于使用 PyTorch 2.0 编译模型

配置

这些是可以配置并通过相应的集成传递的类

accelerate.utils.BnbQuantizationConfig

< >

( load_in_8bit: 布尔类型 = False llm_int8_threshold: 浮点数 = 6.0 load_in_4bit: 布尔类型 = False bnb_4bit_quant_type: 字符串类型 = 'fp4' bnb_4bit_use_double_quant: 布尔类型 = False bnb_4bit_compute_dtype: 字符串类型 = 'fp16' torch_dtype: 数据类型 = None skip_modules: 列表 = None keep_in_fp32_modules: 列表 = None )

一个启用BitsAndBytes 4位和8位量化的插件

accelerate.DataLoaderConfiguration

< >

( split_batches: 布尔类型 = False dispatch_batches: 可选布尔类型 = None even_batches: 布尔类型 = True use_seedable_sampler: 布尔类型 = False non_blocking: 布尔类型 = False )

调用accelerate.prepare时,与数据加载器相关项的配置。

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 )

根据内部项目需求设置Accelerator对象的配置。

set_directories

< >

( project_dir: str = None )

将 self.project_dir 和 self.logging_dir 设置为适当的值。

环境变量

以下是可以针对不同使用案例启用的环境变量

  • ACCELERATE_DEBUG_MODE (str):是否以调试模式运行加速。更多信息可参阅此处

数据操作和操作

这些包括在分布式进程中使用的,模仿相同 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 (可序列化对象列表) — 要广播的对象列表。此列表将就地修改。
  • from_process (整数,可选,默认值为0) — 从该进程发送数据。

将一个进程的可序列化对象列表广播到其他进程。

accelerate.utils.concatenate

< >

( data dim = 0 )

参数

  • 数据 (张量列表/元组/字典的嵌套列表 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 )

参数

  • 张量 (嵌套列表/元组/字典的 torch.Tensor) — 要收集的数据。

从所有设备上的嵌套列表/元组/字典的梯子中递归收集梯子。

accelerate.utils.gather_object

< >

( 对象: 任何 )

参数

  • 对象 (可Pickle对象的嵌套列表/元组/字典) — 要收集的数据。

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

accelerate.utils.listify

< >

( 数据 )

参数

  • 数据 (嵌套列表/元组/字典的 torch.Tensor) — 要转换成常规数字的数据。

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

accelerate.utils.pad_across_processes

< >

( 张量 dim = 0 填充索引 = 0 是否在前面填充 = 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 0x7fb387603490> error_on_other_type = False **kwargs )

参数

  • func (callable) — 应用递归的函数。
  • data (嵌套列表/元组/字典的 main_type) — 在其上应用 func 的数据 *args — 当在展开的数据上应用 func 时传递给 func 的位置参数。
  • 基础类型 main_type (type, 可选,默认为 torch.Tensor) — 应用 func 的对象的基础类型。
  • error_on_other_type (bool, 可选,默认为 False) — 在解开 data 之后,如果得到的对象不是类型 main_type,是否返回错误。如果为 False,函数将保持不同于 main_type 的类型的对象不变。
  • 其他关键字参数 *kwargs (可选) — 当对解包的数据应用 func 时将传递给 func 的关键字参数。

在给定的基础类型嵌套列表/元组/字典的数据结构上递归应用一个函数。

accelerate.utils.reduce

< >

( tensor reduction = 'mean' scale = 1.0 )

参数

  • tensor (嵌套列表/元组/字典的 torch.Tensor) — 要进行约简的数据。
  • reduction (str, 可选, 默认为 "mean") — 约简方法。可以是“mean”,“sum”或“none”
  • scale (float, 可选) — 在reduce操作之后应用默认缩放值,只在XLA中有效。

通过给定的操作递归地将嵌套列表/tuple/dictionary中所有进程的Tensor的均值减少。

accelerate.utils.send_to_device

< >

( tensor device non_blocking = False skip_keys = None )

参数

  • tensor (嵌套 torch.Tensor 的列表/tuple/dictionary) — 要发送到指定设备的数据。
  • 设备 (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

< >

( )

accelerate.utils.is_mps_available

< >

( min_version = '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 或通过标准 PyTorch (>=2.4) 以及在环境中可能存在的 XPU 来提供 XPU 加速。

环境操作

accelerate.utils.patch_environment

一个上下文管理器,将在退出时添加传递给 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时,可以使用[~utils.write_basic_config]作为accelerate 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节点。当每个节点至少有2个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: 可调用 = 无 starting_batch_size: int = 128 )

参数

  • function(《可调用》 可选) —— 一个用于包装的函数
  • 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: 模块 )

计算模型及其最大层的总大小

accelerate.utils.compute_module_sizes

< >

( model: 模块 dtype: 联合类型 = None special_dtypes: 可选类型 = None buffers_only: 布尔值 = 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: 模块 max_memory: 可选(默认为None) no_split_module_classes: 可选(默认为None) dtype: 组合(默认为None) special_dtypes: 可选(默认为None) low_zero: 布尔类型 = False )

参数

  • model (torch.nn.Module) — 要分析的模型。
  • max_memory (字典, 可选) — 设备标识符与最大内存的字典。如果未设置,将默认为可用最大内存。示例:`max_memory={0: "1GB"}`。
  • no_split_module_classesList[str]可选) — 应该永远不会在整个设备上拆分的层类名列表(例如具有残差连接的任何层)。
  • dtypestrtorch.dtype可选) — 如果提供,则在加载时将权重转换为该类型。
  • special_dtypesDict[str, Union[str, torch.device]]可选) — 如果提供,则为一些特定的权重考虑特殊数据类型(将覆盖用于所有权重的默认数据类型)。
  • low_zerobool可选) — 最小化 GPU 0 上的权重数量,当它用于其他操作(如 Transformers generate 函数)时方便。

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

所有计算都是通过分析模型参数的大小和dtypes来完成的。因此,模型可以位于元设备(就像它在init_empty_weights上下文中初始化时那样)。

accelerate.utils.get_max_layer_size

< >

( modules: 列表 module_sizes: 字典 no_split_module_classes: 列表 ) Tuple[int, List[str]]

参数

  • modules (List[Tuple[str, torch.nn.Module]]) — 我们想要确定最大层大小的命名模块列表。
  • module_sizes (Dict[str, int]) — 将每个层名映射到其大小(通过compute_module_sizes生成)。
  • no_split_module_classes (列表[str]) — 我们不希望拆分的层的类名列表。

返回值

元组[int, 列表[str]]

实现最大大小的层的列表,包括层名称。

帮助函数,将扫描命名的模块列表并返回一个完整层使用的最大大小。层的定义是

  • 没有直接子模块(只有参数和缓冲区)的模块
  • 类名在列表 no_split_module_classes 中的模块

accelerate.infer_auto_device_map

< >

( model: 模块(Module) max_memory: 可选 = None no_split_module_classes: 可选 = None dtype: 联合 = None special_dtypes: 可选 = None verbose: bool = False clean_result: bool = True offload_buffers: bool = False )

参数

  • 模型 (torch.nn.Module) — 要分析的模型。
  • 最大内存 (Dict, 可选) — 设备标识符到最大内存的字典。如果未设置,将默认为最大可用内存。例如:max_memory={0: "1GB"}
  • 不允许拆分的模块类 (List[str], 可选) — 一些层类的名称列表,这类层不应该跨设备拆分(例如任何具有残差连接的层)。
  • 数据类型 (strtorch.dtype, 可选) — 如果提供了,加载时将权重转换为该类型。
  • special_dtypes (Dict[str, Union[str, torch.device]], 可选) — 如果提供,则为某些特定权重考虑的特殊数据类型(将覆盖所有权重使用的默认数据类型)。
  • verbose (bool, 可选, 默认值为 False) — 在函数构建 device_map 时不提供调试语句。
  • clean_result (bool, 可选, 默认值为 True) — 通过将所有放置在同一设备上的子模块分组,清洁生成的 device_map。
  • offload_buffers (bool, optional, defaults to False) — 在CPU或硬盘上卸载的层中,是否卸载缓冲区以及参数。

为给定的模型计算设备图,优先使用GPU,然后卸载到CPU,最后卸载到硬盘,以确保

  • 不超出任何GPU可用的内存。
  • 如果需要卸载到CPU,GPU 0上始终有空间放置从CPU卸载的最大的层。
  • 如果需要卸载到CPU,不要超过CPU上可用的RAM。
  • 如果需要卸载到硬盘,CPU上始终有空间放置从硬盘卸载的最大的层。

所有计算都是通过分析模型参数的大小和dtypes来完成的。因此,模型可以位于元设备(就像它在init_empty_weights上下文中初始化时那样)。

accelerate.load_checkpoint_in_model

< >

( model: 模块 checkpoint: 联合 device_map: 可选 = None offload_folder: 联合 = None dtype: 联合 = None offload_state_dict: 布尔 = False offload_buffers: 布尔 = False keep_in_fp32_modules: 列表 = None offload_8bit_bnb: 布尔 = False strict: 布尔 = False )

参数

  • model (torch.nn.Module) — 我们想要在其中加载检查点的模型。
  • checkpoint (stros.PathLike) — 要加载的检查点文件夹。它可以是:
    • 包含整个模型状态字典的文件的路径
    • 包含分片检查点索引的.json文件的路径
    • 包含唯一的.index.json文件和检查点分片的文件夹的路径。
    • 包含唯一的pytorch_model.bin或model.safetensors文件的文件夹的路径。
  • device_map (Dict[str, Union[int, str, torch.device]], 可选) — 一个指定每个子模块应该去哪里的映射。它不需要细化到每个参数/缓冲区名称,一旦给定模块名称在其中,它所有的子模块都将发送到同一个设备。
  • offload_folder (stros.PathLike, 可选) — 如果 device_map 包含任何值 "disk",则会将该文件夹用于卸载权重。
  • dtype (strtorch.dtype, 可选) — 如果提供,会在加载时将权重转换为该类型。
  • 卸载_state_dict (bool, 可选, 默认为 False) — 如果为 True,将暂时将 CPU 状态字典卸载到硬盘上,以避免如果 CPU 状态字典的重量加上最大的碎片不适合,就会超出 CPU RAM。
  • 卸载_buffers (bool, 可选, 默认为 False) — 是否包括在卸载到磁盘上的权重中的缓冲区。
  • keep_in_fp32_modules (List[str], 可选) — 我们保留在 torch.float32 数据类型中的模块的列表。
  • 卸载_8bit_bnb (bool, 可选) — 是否在 cpu/磁盘上启用 8 位模块的卸载。
  • 严格bool可选,默认为 False) — 是否严格确保检查点状态字典中的键与模型状态字典中的键相匹配。

在模型内加载(可能已分片)的检查点,在加载过程中可能将权重发送到指定的设备。

在跨设备加载后,您仍然需要在您的模型上调用 dispatch_model() 以使其能够运行。要在一个单独的调用中合并检查点加载和分发,请使用 load_checkpoint_and_dispatch()

accelerate.utils.load_offloaded_weights

< >

( model index offload_folder )

参数

  • 模型torch.nn.Module) — 将权重加载到其中的模型。
  • index (dict) — 包含从模型卸载的每个参数的参数名及其元数据的字典。
  • offload_folder (str) — 存储卸载权重的文件夹。

将卸载文件夹中的权重加载到模型中。

accelerate.utils.load_state_dict

< >

( checkpoint_file device_map = None )

参数

  • 检查点文件 (str) — 加载检查点的路径。
  • device_map (Dict[str, Union[int, str, torch.device]], 可选) — 指定每个子模块应去哪里的映射。它不需要细分到每个参数/缓冲区名,一旦给定模块名在其中,它的所有子模块都将发送到相同的设备。

从给定文件中加载检查点。如果检查点处于safetensors格式并且传递了设备映射,则可以直接在GPU上快速加载权重。

accelerate.utils.offload_state_dict

< >

( 保存目录: Union 状态字典: Dict )

参数

  • save_dir (stros.PathLike) — 要卸载状态字典的目录。
  • state_dict (Dict[str, torch.Tensor]) — 要卸载的张量字典。

在给定的文件夹中卸载状态字典。

accelerate.utils.restore_parameters

< >

( 模型 附加参数 )

参数

  • 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, strtorch.device) — 设置张量的设备。
  • value (torch.Tensor, 可选) — 矩阵的值(在从元设备转移到任何其他设备时很有用)。
  • dtype (torch.dtype, 可选) — 如果传递了参数值,则会将其转换为此 dtype。否则,value 将转换为模型中现有参数的数据类型。
  • fp16_statistics (torch HFastTensor, 可选) — 寄存器上的fp16统计信息列表,用于8位模型序列化。

accelerate.utils.shard_checkpoint

( state_dict: Dict max_shard_size: Union = '10GB' weights_name: str = 'pytorch_model.bin' )

参数

  • max_shard_size (整数或字符串,可选,默认为 "10GB") — 每个子检查点的最大大小。如果表示为字符串,则需要是数字后跟单位(如 "5MB")。
  • weights_name (字符串,可选,默认为 "pytorch_model.bin") — 模型保存文件的名称。

将模型状态字典拆分为子检查点,使每个子检查点的最终大小不超过给定的大小。

子检查点通过按照其键的顺序遍历 state_dict 来确定,因此没有优化以使每个子检查点尽可能接近传递的最大大小。例如,如果限制为 10GB,并且我们有大小为 [6GB, 6GB, 2GB, 6GB, 2GB, 2GB] 的权重,它们将分配为 [6GB],[6+2GB],[6+2+2GB],而不是 [6+2+2GB],[6+2GB],[6GB]。

如果模型的一个权重超过 max_sahrd_size,它将单独存储在一个子检查点中,该子检查点的大小将大于 max_shard_size

Parallel

包括在并行工作时应使用的一般实用工具。

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) — 在可能的情况下是否使用确定性算法。可能会减慢训练速度。

用于在 randomnumpytorch 中设置种子的可重复行为辅助函数。

accelerate.utils.synchronize_rng_state

< >

( rng_type: 可选 = None generator: 可选 = None )

accelerate.synchronize_rng_states

< >

( rng_types: 列表 generator: 可选 = None )

PyTorch XLA

这些是在使用PyTorch与XLA时有用的一些实用程序。

accelerate.utils.install_xla

< >

( 升级: 布尔 = False )

参数

  • 升级 (布尔, 可选, 默认为 False) — 是否升级 torch 并安装最新的 torch_xla 轮子。

基于 Google Colaboratory 中 torch 版本的适当 xla 轮子安装的辅助函数。

示例

>>> from accelerate.utils import install_xla

>>> install_xla(upgrade=True)

加载模型权重

这包括一些用于加载检查点的实用工具。

accelerate.load_checkpoint_in_model

< >

( model: 模块 checkpoint: 联合 device_map: 可选 = None offload_folder: 联合 = None dtype: 联合 = None offload_state_dict: 布尔 = False offload_buffers: 布尔 = False keep_in_fp32_modules: 列表 = None offload_8bit_bnb: 布尔 = False strict: 布尔 = False )

参数

  • model (torch.nn.Module) — 我们想要在其中加载检查点的模型。
  • checkpoint (stros.PathLike) — 要加载的检查点文件夹。它可以是:
    • 包含整个模型状态字典的文件的路径
    • 包含分片检查点索引的.json文件的路径
    • 包含唯一的.index.json文件和检查点分片的文件夹的路径。
    • 包含唯一的pytorch_model.bin或model.safetensors文件的文件夹的路径。
  • device_map (Dict[str, Union[int, str, torch.device]], 可选) — 一个指定每个子模块应该去哪里的映射。它不需要细化到每个参数/缓冲区名称,一旦给定模块名称在其中,它所有的子模块都将发送到同一个设备。
  • offload_folder (stros.PathLike, 可选) — 如果 device_map 包含任何值 "disk",则会将该文件夹用于卸载权重。
  • dtype (strtorch.dtype, 可选) — 如果提供,会在加载时将权重转换为该类型。
  • 卸载_state_dict (bool, 可选, 默认为 False) — 如果为 True,将暂时将 CPU 状态字典卸载到硬盘上,以避免如果 CPU 状态字典的重量加上最大的碎片不适合,就会超出 CPU RAM。
  • 卸载_buffers (bool, 可选, 默认为 False) — 是否包括在卸载到磁盘上的权重中的缓冲区。
  • keep_in_fp32_modules (List[str], 可选) — 我们保留在 torch.float32 数据类型中的模块的列表。
  • 卸载_8bit_bnb (bool, 可选) — 是否在 cpu/磁盘上启用 8 位模块的卸载。
  • 严格bool可选,默认为 False) — 是否严格确保检查点状态字典中的键与模型状态字典中的键相匹配。

在模型内加载(可能已分片)的检查点,在加载过程中可能将权重发送到指定的设备。

在跨设备加载后,您仍然需要在您的模型上调用 dispatch_model() 以使其能够运行。要在一个单独的调用中合并检查点加载和分发,请使用 load_checkpoint_and_dispatch()

量化

这包括用于量化模型的实用工具。

accelerate.utils.load_and_quantize_model

< >

( model: 模块 bnb_quantization_config: BnbQuantizationConfig weights_location: 联合体 = None device_map: 可选型 = None no_split_module_classes: 可选型 = None max_memory: 可选型 = None offload_folder: 联合体 = None offload_state_dict: 布尔型 = False ) torch.nn.Module

参数

  • model (torch.nn.Module) — 输入模型。模型可以是已加载的或在元设备上
  • bnb_quantization_config(《BnbQuantizationConfig》)— bitsandbytes 量化参数
  • weights_location(《str 或 os.PathLike)— 加载的权重存储位置文件夹。它可以是指:
  • device_map(《Dict[str, Union[int, str, torch.device]], 可选)— 指定每个子模块应去往何处的映射。不需要对其每个参数/缓冲区名称进行细化,一旦给定的模块名称包含在内,其所有子模块都将被发送到相同的设备。
  • no_split_module_classes (, 可选) — 应避免在设备之间拆分的层类名列表(例如任何具有残差连接的层)。
  • max_memory (Dict, 可选) — 设备标识符到最大内存的字典。如果没有设置,则默认为可用的最大内存。
  • offload_folder (stros.PathLike, 可选) — 如果 device_map 包含任何值为 "disk" 的值,那么我们将卸载权重的文件夹。
  • offload_state_dict (bool, 可选,默认为False) — 如果True,将临时将CPU状态字典卸载到硬盘上,以避免CPU RAM不足的问题,当CPU状态字典的重量加上最大的分片不适合时。

返回值

torch.nn.Module

量化模型

此函数将使用传入的bnb_quantization_config中的相关配置对输入模型进行量化。如果模型在元设备中,我们将根据传入的device_map加载和分发权重。如果模型已经加载,我们将对模型进行量化并将模型放在GPU上。

< > 在GitHub上更新