Hugging Face 的 logo

加速文档

有状态类

Hugging Face's logo
加入 Hugging Face 社区

并获得增强型文档体验

开始使用

有状态类

以下是 单例类 的变体，从某种意义上说，所有实例共享相同的状态，该状态在第一次实例化时初始化。

这些类是不可变的，并存储有关某些配置或状态的信息。

PartialState

类 accelerate.PartialState

< >

( cpu: bool = False **kwargs )

参数

  • cpu (bool, 可选) — 是否强制脚本在 CPU 上执行。如果设置为 True，则会忽略任何可用的加速器，并强制在 CPU 上执行。
  • kwargs (其他关键字参数, 可选) — 传递给相关 init_process_group 函数的其他关键字参数。有效的 kwargs 可以在 utils.InitProcessGroupKwargs 中找到。有关详细用法，请参阅示例部分。

一个单例类，其中包含有关当前训练环境的信息以及用于帮助进行进程控制的函数。旨在仅在需要进程控制和设备执行状态时使用。不需要从 Accelerator 初始化。

可用属性

  • device (torch.device) — 要使用的设备。
  • distributed_type (DistributedType) — 当前使用的分布式环境的类型。
  • local_process_index (int) — 当前服务器上当前进程的索引。
  • mixed_precision (str) — 当前脚本是否使用混合精度，如果是，则执行混合精度的类型。（从“no”、“fp16”、“bf16”或“fp8”中选择）。
  • num_processes (int) — 当前并行启动的进程数。
  • process_index (int) — 当前进程的索引。
  • is_last_process (bool) — 当前进程是否是最后一个进程。
  • is_main_process (bool) — 当前进程是否是主进程。
  • is_local_main_process (bool) — 当前进程是否是本地节点上的主进程。
  • debug (bool) — 当前脚本是否在调试模式下运行。

示例

from accelerate.utils import InitProcessGroupKwargs

# To include `InitProcessGroupKwargs`, init then call `.to_kwargs()`
kwargs = InitProcessGroupKwargs(...).to_kwargs()
state = PartialState(**kwargs)

destroy_process_group

< >

( group = None )

销毁进程组。如果没有指定，则销毁默认进程组。

local_main_process_first

< >

( )

允许本地主进程进入 with 代码块。

其他进程将在主进程退出后进入 with 代码块。

示例

>>> from accelerate.state import PartialState

>>> state = PartialState()
>>> with state.local_main_process_first():
...     # This will be printed first by local process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {state.local_process_index}")

main_process_first

< >

( )

允许主进程首先进入 with 代码块。

其他进程将在主进程退出后进入 with 代码块。

示例

>>> from accelerate import Accelerator

>>> accelerator = Accelerator()
>>> with accelerator.main_process_first():
...     # This will be printed first by process 0 then in a seemingly
...     # random order by the other processes.
...     print(f"This will be printed by process {accelerator.process_index}")

on_last_process

< >

( 函数: Callable[..., Any] )

参数

  • 函数 (Callable) — 要装饰的函数。

仅在最后一个进程上运行装饰函数的装饰器。

示例

# Assume we have 4 processes.
from accelerate.state import PartialState

state = PartialState()


@state.on_last_process
def print_something():
    print(f"Printed on process {state.process_index}")


print_something()
"Printed on process 3"

on_local_main_process

< >

( 函数: Callable[..., Any] = None )

参数

  • 函数 (Callable) — 要装饰的函数。

仅在本地主进程上运行装饰函数的装饰器。

示例

# Assume we have 2 servers with 4 processes each.
from accelerate.state import PartialState

state = PartialState()


@state.on_local_main_process
def print_something():
    print("This will be printed by process 0 only on each server.")


print_something()
# On server 1:
"This will be printed by process 0 only"
# On server 2:
"This will be printed by process 0 only"

on_local_process

< >

( 函数: Callable[..., Any] = None 本地进程索引: int = None )

参数

  • 函数 (Callable, 可选) — 要装饰的函数。
  • 本地进程索引 (int, 可选) — 要在其上运行函数的本地进程的索引。

仅在当前节点上具有给定索引的进程上运行装饰函数的装饰器。

示例

# Assume we have 2 servers with 4 processes each.
from accelerate import Accelerator

accelerator = Accelerator()


@accelerator.on_local_process(local_process_index=2)
def print_something():
    print(f"Printed on process {accelerator.local_process_index}")


print_something()
# On server 1:
"Printed on process 2"
# On server 2:
"Printed on process 2"

on_main_process

< >

( 函数: Callable[..., Any] = None )

参数

  • 函数 (Callable) — 要装饰的函数。

仅在主进程上运行装饰函数的装饰器。

示例

>>> from accelerate.state import PartialState

>>> state = PartialState()


>>> @state.on_main_process
... def print_something():
...     print("This will be printed by process 0 only.")


>>> print_something()
"This will be printed by process 0 only"

on_process

< >

( 函数: Callable[..., Any] = None 进程索引: int = None )

参数

  • process_index (int, 可选) — 要在其中运行函数的进程索引。

仅在具有给定索引的进程上运行装饰函数的装饰器。

示例

# Assume we have 4 processes.
from accelerate.state import PartialState

state = PartialState()


@state.on_process(process_index=2)
def print_something():
    print(f"Printed on process {state.process_index}")


print_something()
"Printed on process 2"

set_device

< >

( )

将self.device中的设备设置为当前分布式环境。

split_between_processes

< >

( inputs: 列表 | 元组 | 字典 | torch.Tensor apply_padding: bool = False )

参数

  • inputs (列表, 元组, torch.Tensor, 字典的列表/元组/torch.Tensor，或datasets.Dataset) — 要在进程之间拆分的输入。
  • apply_padding (bool, 可选，默认为False) — 是否通过重复输入的最后一个元素来应用填充，以便所有进程具有相同数量的元素。在尝试对输出执行诸如gather()之类的操作或传递的输入少于进程数时很有用。如果是这样，只需记住之后丢弃填充的元素。

快速地在self.num_processes之间拆分input，然后可以在该进程上使用。在进行分布式推理时很有用，例如使用不同的提示。

请注意，在使用字典时，所有键都需要具有相同数量的元素。

示例

# Assume there are two processes
from accelerate import PartialState

state = PartialState()
with state.split_between_processes(["A", "B", "C"]) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C"]

with state.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C", "C"]

wait_for_everyone

< >

( )

将停止当前进程的执行，直到所有其他进程都到达该点（因此，当脚本仅在一个进程中运行时，此操作无效）。在保存模型之前执行此操作很有用。

示例

>>> # Assuming two GPU processes
>>> import time
>>> from accelerate.state import PartialState

>>> state = PartialState()
>>> if state.is_main_process:
...     time.sleep(2)
>>> else:
...     print("I'm waiting for the main process to finish its sleep...")
>>> state.wait_for_everyone()
>>> # Should print on every process at the same time
>>> print("Everyone is here")

AcceleratorState

类 accelerate.state.AcceleratorState

< >

( mixed_precision: str = None cpu: bool = False dynamo_plugin = None deepspeed_plugin = None fsdp_plugin = None megatron_lm_plugin = None _from_accelerator: bool = False **kwargs )

包含有关当前训练环境信息的单例类。

可用属性

  • device (torch.device) — 要使用的设备。
  • distributed_type (DistributedType) — 当前使用的分布式环境的类型。
  • initialized (bool) — AcceleratorState是否已从Accelerator初始化。
  • local_process_index (int) — 当前服务器上当前进程的索引。
  • mixed_precision (str) — 当前脚本是否使用混合精度，如果是，则执行混合精度的类型。（从“no”、“fp16”、“bf16”或“fp8”中选择）。
  • num_processes (int) — 当前并行启动的进程数。
  • process_index (int) — 当前进程的索引。
  • is_last_process (bool) — 当前进程是否是最后一个进程。
  • is_main_process (bool) — 当前进程是否是主进程。
  • is_local_main_process (bool) — 当前进程是否是本地节点上的主进程。
  • debug (bool) — 当前脚本是否在调试模式下运行。

destroy_process_group

< >

( group = None )

销毁进程组。如果没有指定，则销毁默认进程组。

如果self.fork_lauched为True且group为None，则不会发生任何事情。

get_deepspeed_plugin

< >

( name: str )

返回具有给定 plugin_key 的 DeepSpeedPlugin。

local_main_process_first

< >

( )

允许本地主进程进入 with 代码块。

其他进程将在主进程退出后进入 with 代码块。

main_process_first

< >

( )

允许主进程首先进入 with 代码块。

其他进程将在主进程退出后进入 with 代码块。

select_deepspeed_plugin

< >

( name: str = None )

激活具有给定 name 的 DeepSpeedPlugin，并将禁用所有其他插件。

split_between_processes

< >

( inputs: 列表 | 元组 | 字典 | torch.Tensor apply_padding: bool = False )

参数

  • inputs (list、tuple、torch.Tensor 或 dict 的 list/tuple/torch.Tensor) — 在进程之间拆分的输入。
  • apply_padding (bool，可选，默认为 False) — 是否通过重复输入的最后一个元素来应用填充，以便所有进程都具有相同数量的元素。在尝试对输出执行诸如 gather() 之类的操作或传入少于进程数量的输入时很有用。如果是这样，请记住之后丢弃填充的元素。

快速地在self.num_processes之间拆分input，然后可以在该进程上使用。在进行分布式推理时很有用，例如使用不同的提示。

请注意，在使用字典时，所有键都需要具有相同数量的元素。

示例

# Assume there are two processes
from accelerate.state import AcceleratorState

state = AcceleratorState()
with state.split_between_processes(["A", "B", "C"]) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C"]

with state.split_between_processes(["A", "B", "C"], apply_padding=True) as inputs:
    print(inputs)
# Process 0
["A", "B"]
# Process 1
["C", "C"]

GradientState

class accelerate.state.GradientState

< >

( gradient_accumulation_plugin: Optional[GradientAccumulationPlugin] = None )

单例类，包含与梯度累积的梯度同步相关的信息

可用属性

  • end_of_dataloader (bool) — 我们是否已到达当前数据加载器的末尾
  • remainder (int) — 从填充数据加载器中添加的额外样本数量
  • sync_gradients (bool) — 是否应在所有设备上同步梯度
  • active_dataloader (Optional[DataLoader]) — 当前正在迭代的数据加载器
  • dataloader_references (List[Optional[DataLoader]]) — 正在迭代的数据加载器的引用列表
  • num_steps (int) — 要累积的步数
  • adjust_scheduler (bool) — 调度程序是否应调整以考虑梯度累积
  • sync_with_dataloader (bool) — 是否应在数据加载器迭代结束时同步梯度并将总步数重置
  • is_xla_gradients_synced (bool) — XLA 梯度是否已同步。它初始化为 false。在优化器步骤之前减少梯度后，此标志将设置为 true。随后，在每个步骤之后，标志将重置为 false。FSDP 将始终同步梯度，因此 is_xla_gradients_synced 始终为 true。
< > 在 GitHub 上更新

←