Skip to content

P
pytorch-doc-zh

OpenDocCN / pytorch-doc-zh

通知 120
Star 3932
Fork 992
P
pytorch-doc-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 1efc722b 编写于 作者: 绝不原创的飞龙's avatar 绝不原创的飞龙
浏览文件
操作

2024-02-05 14:11:37

上级 10e4285b
展开全部 隐藏空白更改
内联 并排
Showing with 1347 addition and 1347 deletion
totrans/doc22_025.md
浏览文件 @ 1efc722b
......@@ -272,7 +272,7 @@ tensor([1.+1.j, 1.+1.j, 1.+1.j])
以下实用函数与序列化相关：
```py
torch.serialization.register_package(priority, tagger, deserializer)
torch.serialization.register_package(priority, tagger, deserializer)
```
为标记和反序列化存储对象注册可调用对象，并附带优先级。标记在保存时将设备与存储对象关联，而在加载时反序列化将存储对象移动到适当的设备上。`tagger`和`deserializer`按照它们的`priority`给出的顺序运行，直到一个标记器/反序列化器返回一个不是 None 的值。
......@@ -309,7 +309,7 @@ torch.serialization.register_package(priority, tagger, deserializer)¶
```
```py
torch.serialization.get_default_load_endianness()
torch.serialization.get_default_load_endianness()
```
获取用于加载文件的回退字节顺序
......@@ -325,7 +325,7 @@ Optional[LoadEndianness]
default_load_endian
```py
torch.serialization.set_default_load_endianness(endianness)
torch.serialization.set_default_load_endianness(endianness)
```
设置用于加载文件的回退字节顺序
......
totrans/doc22_031.md
浏览文件 @ 1efc722b
......@@ -128,7 +128,7 @@ torch 包含用于多维张量的数据结构，并定义了这些张量上的
| `set_rng_state` | 设置随机数生成器状态。 |
```py
torch.default_generator Returns the default CPU torch.Generator
torch.default_generator Returns the default CPU torch.Generator
```
| `bernoulli` | 从伯努利分布中抽取二进制随机数（0 或 1）。 |
......@@ -614,19 +614,19 @@ False
## 符号数字
```py
class torch.SymInt(node)
class torch.SymInt(node)
```
像一个整数（包括魔术方法），但重定向包装节点上的所有操作。这特别用于在符号形状工作流程中符号记录操作。
```py
class torch.SymFloat(node)
class torch.SymFloat(node)
```
像一个浮点数（包括魔术方法），但重定向包装节点上的所有操作。这特别用于在符号形状工作流程中符号记录操作。
```py
class torch.SymBool(node)
class torch.SymBool(node)
```
像一个布尔值（包括魔术方法），但重定向包装节点上的所有操作。这特别用于在符号形状工作流程中符号记录操作。
......@@ -668,7 +668,7 @@ class torch.SymBool(node)¶
## 操作符标签
```py
class torch.Tag
class torch.Tag
```
成员：
......@@ -694,5 +694,5 @@ pt2 兼容标签
视图复制
```py
property name
property name
```
totrans/doc22_034.md
浏览文件 @ 1efc722b
......@@ -138,7 +138,7 @@ tensor([[ 2.0000, -2.0000],
## 张量类参考
```py
class torch.Tensor
class torch.Tensor
```
有几种主要方法可以创建张量，取决于您的用例。
......@@ -152,7 +152,7 @@ class torch.Tensor¶
+ 要创建一个与另一个张量相似类型但不同大小的张量，请使用 `tensor.new_*` 创建操作。
```py
Tensor.T
Tensor.T
```
返回一个维度被颠倒的张量视图。
......@@ -164,7 +164,7 @@ Tensor.T¶
在维度不为 2 的张量上使用 `Tensor.T()` 来颠倒它们的形状已被弃用，并且在将来的版本中会引发错误。考虑使用 `mT` 来转置矩阵批次或者使用 x.permute(*torch.arange(x.ndim - 1, -1, -1)) 来颠倒张量的维度。
```py
Tensor.H
Tensor.H
```
返回一个共轭和转置的矩阵（2-D 张量）视图。
......@@ -176,7 +176,7 @@ Tensor.H¶
`mH`：也适用于矩阵批次的属性。
```py
Tensor.mT
Tensor.mT
```
返回一个最后两个维度被转置的张量视图。
......@@ -184,7 +184,7 @@ Tensor.mT¶
`x.mT` 等同于 `x.transpose(-2, -1)`。
```py
Tensor.mH
Tensor.mH
```
访问此属性等同于调用 `adjoint()`。
......
totrans/doc22_035.md
浏览文件 @ 1efc722b
......@@ -7,7 +7,7 @@
## torch.dtype
```py
class torch.dtype
class torch.dtype
```
`torch.dtype`是表示`torch.Tensor`的数据类型的对象。PyTorch 有 12 种不同的数据类型：
......@@ -119,7 +119,7 @@ torch.float32
``` ## torch.device
```py
class torch.device
class torch.device
```
`torch.device`是表示`torch.Tensor`分配或将要分配的设备的对象。
......@@ -209,7 +209,7 @@ device(type='cuda', index=1)
``` ## torch.layout
```py
class torch.layout
class torch.layout
```
警告
......@@ -236,7 +236,7 @@ class torch.layout¶
## torch.memory_format
```py
class torch.memory_format
class torch.memory_format
```
`torch.memory_format` 是一个表示 `torch.Tensor` 分配或将要分配的内存格式的对象。
......
totrans/doc22_037.md
浏览文件 @ 1efc722b
......@@ -43,7 +43,7 @@
## 自动转换
```py
class torch.autocast(device_type, dtype=None, enabled=True, cache_enabled=None)
class torch.autocast(device_type, dtype=None, enabled=True, cache_enabled=None)
```
`autocast` 的实例充当上下文管理器或装饰器，允许脚本的区域以混合精度运行。
......@@ -201,7 +201,7 @@ with torch.autocast(device_type="cuda"):
+ **cache_enabled**（*bool*，*可选*）- 是否启用自动转换内部的权重缓存。默认值：`True`
```py
class torch.cuda.amp.autocast(enabled=True, dtype=torch.float16, cache_enabled=True)
class torch.cuda.amp.autocast(enabled=True, dtype=torch.float16, cache_enabled=True)
```
请参阅`torch.autocast`。
......@@ -209,7 +209,7 @@ class torch.cuda.amp.autocast(enabled=True, dtype=torch.float16, cache_enabled=T
`torch.cuda.amp.autocast(args...)`等同于`torch.autocast("cuda", args...)`
```py
torch.cuda.amp.custom_fwd(fwd=None, *, cast_inputs=None)
torch.cuda.amp.custom_fwd(fwd=None, *, cast_inputs=None)
```
为自定义自动求导函数的`forward`方法创建一个辅助装饰器。
......@@ -225,7 +225,7 @@ torch.cuda.amp.custom_fwd(fwd=None, *, cast_inputs=None)¶
如果装饰的`forward`在自动转换启用的区域之外被调用，则`custom_fwd`是一个空操作，`cast_inputs`没有效果。
```py
torch.cuda.amp.custom_bwd(bwd)
torch.cuda.amp.custom_bwd(bwd)
```
为自定义自动求导函数的反向方法创建一个辅助装饰器。
......@@ -233,7 +233,7 @@ torch.cuda.amp.custom_bwd(bwd)¶
自动求导函数是`torch.autograd.Function`的子类。确保`backward`以与`forward`相同的自动转换状态执行。更多细节请参见示例页面。
```py
class torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloat16, cache_enabled=True)
class torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloat16, cache_enabled=True)
```
请参见`torch.autocast`。`torch.cpu.amp.autocast(args...)`等同于`torch.autocast("cpu", args...)` ## 梯度缩放[](#gradient-scaling "跳转到此标题")
......@@ -249,7 +249,7 @@ class torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloat16, cache_enabled=T
AMP/fp16 可能并不适用于每个模型！例如，大多数 bf16 预训练模型无法在最大 65504 的 fp16 数值范围内运行，会导致梯度溢出而不是下溢。在这种情况下，比例因子可能会减少到 1 以下，以尝试将梯度带到 fp16 动态范围内可表示的数字。虽然人们可能期望比例始终大于 1，但我们的 GradScaler 并不保证这一点以保持性能。如果在使用 AMP/fp16 时遇到损失或梯度中的 NaN，请验证您的模型是否兼容。
```py
class torch.cuda.amp.GradScaler(init_scale=65536.0, growth_factor=2.0, backoff_factor=0.5, growth_interval=2000, enabled=True)
class torch.cuda.amp.GradScaler(init_scale=65536.0, growth_factor=2.0, backoff_factor=0.5, growth_interval=2000, enabled=True)
```
`GradScaler`的一个实例`scaler`。
......@@ -309,7 +309,7 @@ for epoch in epochs:
+ **enabled** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*) – 如果为`False`，则禁用梯度缩放。`step()`只会调用底层的`optimizer.step()`，其他方法将变为无操作。默认值：`True`
```py
get_backoff_factor()
get_backoff_factor()
```
返回一个包含缩放退避因子的 Python 浮点数。
......@@ -319,7 +319,7 @@ get_backoff_factor()¶
[float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")
```py
get_growth_factor()
get_growth_factor()
```
返回一个包含增长因子的 Python 浮点数。
......@@ -329,7 +329,7 @@ get_growth_factor()¶
[float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")
```py
get_growth_interval()
get_growth_interval()
```
返回一个包含增长间隔的 Python 整数。
......@@ -339,7 +339,7 @@ get_growth_interval()¶
[int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")
```py
get_scale()
get_scale()
```
返回一个包含当前比例的 Python 浮点数，如果禁用了缩放，则返回 1.0。
......@@ -353,7 +353,7 @@ get_scale()¶
[float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")
```py
is_enabled()
is_enabled()
```
返回一个指示此实例是否已启用的布尔值。
......@@ -363,7 +363,7 @@ is_enabled()¶
[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")
```py
load_state_dict(state_dict)
load_state_dict(state_dict)
```
加载缩放器状态。
......@@ -375,7 +375,7 @@ load_state_dict(state_dict)¶
**state_dict** ([*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")) – 缩放器状态。应该是从调用`state_dict()`返回的对象。
```py
scale(outputs: Tensor) → Tensor
scale(outputs: Tensor) → Tensor
```
```py
......@@ -399,7 +399,7 @@ scale(outputs: Iterable[Tensor]) → Iterable[Tensor]
**outputs** (*Tensor* *或* *可迭代* *的* *Tensors*) – 要缩放的输出。
```py
set_backoff_factor(new_factor)
set_backoff_factor(new_factor)
```
设置一个新的退避因子。
......@@ -409,7 +409,7 @@ set_backoff_factor(new_factor)¶
**new_scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) – 用作新的缩放退避因子的值。
```py
set_growth_factor(new_factor)
set_growth_factor(new_factor)
```
设置一个新的增长因子。
......@@ -419,7 +419,7 @@ set_growth_factor(new_factor)¶
**new_scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) – 用作新的增长因子的值。
```py
set_growth_interval(new_interval)
set_growth_interval(new_interval)
```
设置一个新的增长间隔。
......@@ -429,7 +429,7 @@ set_growth_interval(new_interval)¶
**new_interval** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – 用作新增长间隔的值。
```py
state_dict()
state_dict()
```
返回一个[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")形式的缩放器状态。
......@@ -457,7 +457,7 @@ state_dict()¶
[*Dict*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")]
```py
step(optimizer, *args, **kwargs)
step(optimizer, *args, **kwargs)
```
如果梯度不是无穷大/NaN，则调用`unscale_(optimizer)`，然后进行参数更新。
......@@ -489,7 +489,7 @@ step(optimizer, *args, **kwargs)¶
目前不支持闭包使用。
```py
unscale_(optimizer)
unscale_(optimizer)
```
通过比例因子除（“取消缩放”）优化器的梯度张量。
......@@ -524,7 +524,7 @@ scaler.update()
`unscale_()`可能会在原地取消缩放稀疏梯度，替换`.grad`属性。
```py
update(new_scale=None)
update(new_scale=None)
```
更新比例因子。
......
totrans/doc22_038.md
浏览文件 @ 1efc722b
......@@ -113,7 +113,7 @@ Variable API 已被弃用：不再需要使用 Variables 来使用带有 `requir
## Function
```py
class torch.autograd.Function(*args, **kwargs)
class torch.autograd.Function(*args, **kwargs)
```
用于创建自定义自动求导函数的基类。
......@@ -170,7 +170,7 @@ class torch.autograd.Function(*args, **kwargs)¶
Autograd 包括一个性能分析器，让您可以检查模型内不同运算符的成本 - 包括在 CPU 和 GPU 上。目前实现了三种模式 - 仅 CPU 使用`profile`。基于 nvprof 的（同时注册 CPU 和 GPU 活动）使用`emit_nvtx`。基于 vtune 性能分析器的使用`emit_itt`。
```py
class torch.autograd.profiler.profile(enabled=True, *, use_cuda=False, use_device=None, record_shapes=False, with_flops=False, profile_memory=False, with_stack=False, with_modules=False, use_kineto=False, use_cpu=True, use_mtia=False, experimental_config=None)
class torch.autograd.profiler.profile(enabled=True, *, use_cuda=False, use_device=None, record_shapes=False, with_flops=False, profile_memory=False, with_stack=False, with_modules=False, use_kineto=False, use_cpu=True, use_mtia=False, experimental_config=None)
```
上下文管理器，管理自动求导分析器状态并保存结果摘要。
......@@ -227,7 +227,7 @@ torch::autograd::GraphRoot 691.816us 691.816us 100
| `profiler.profile.total_average` | 对所有事件进行平均。 |
```py
class torch.autograd.profiler.emit_nvtx(enabled=True, record_shapes=False)
class torch.autograd.profiler.emit_nvtx(enabled=True, record_shapes=False)
```
使每个自动求导操作发出一个 NVTX 范围的上下文管理器。
......@@ -268,7 +268,7 @@ nvprof --profile-from-start off -o trace_name.prof -- <regular command here>
另一方面，如果正在进行带有`create_graph=True`的反向传递（换句话说，如果您正在为双向传递做准备），则在反向期间执行的每个函数都会获得一个非零、有用的`seq=<N>`。这些函数本身可能会创建 Function 对象，以便稍后在双向传递期间执行，就像前向传递中的原始函数一样。反向和双向之间的关系在概念上与前向和反向之间的关系相同：函数仍然发出当前序列号标记的范围，它们创建的 Function 对象仍然存储这些序列号，并且在最终的双向传递期间，Function 对象的`apply()`范围仍然标记有`stashed seq`号，可以与反向传递中的 seq 号进行比较。
```py
class torch.autograd.profiler.emit_itt(enabled=True, record_shapes=False)
class torch.autograd.profiler.emit_itt(enabled=True, record_shapes=False)
```
上下文管理器，使每个自动求导操作都发出一个 ITT 范围。
......@@ -300,7 +300,7 @@ vtune <--vtune-flags> <regular command here>
## 异常检测
```py
class torch.autograd.detect_anomaly(check_nan=True)
class torch.autograd.detect_anomaly(check_nan=True)
```
上下文管理器，用于启用自动求导引擎的异常检测。
......@@ -367,7 +367,7 @@ class torch.autograd.detect_anomaly(check_nan=True)¶
```
```py
class torch.autograd.set_detect_anomaly(mode, check_nan=True)
class torch.autograd.set_detect_anomaly(mode, check_nan=True)
```
上下文管理器，用于设置自动求导引擎的异常检测开启或关闭。
......@@ -411,7 +411,7 @@ True
您还可以使用钩子定义这些保存的张量应如何打包/解包。一个常见的应用是通过将这些中间结果保存到磁盘或 CPU 来交换计算和内存，而不是将它们留在 GPU 上。如果您注意到您的模型在评估期间适合 GPU，但在训练期间不适合，则这是非常有用的。另请参阅保存张量的钩子。
```py
class torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook)
class torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook)
```
为保存的张量设置一对 pack / unpack 钩子的上下文管理器。
......@@ -463,7 +463,7 @@ Unpacking tensor([2., 2., 2., 2., 2.], grad_fn=<MulBackward0>)
一次只允许一个钩子对。当递归嵌套这个上下文管理器时，只有最内层的一对钩子将被应用。
```py
class torch.autograd.graph.save_on_cpu(pin_memory=False, device_type='cuda')
class torch.autograd.graph.save_on_cpu(pin_memory=False, device_type='cuda')
```
在前向传递期间保存的张量将存储在 CPU 上，然后在反向传递时检索。
......@@ -499,7 +499,7 @@ class torch.autograd.graph.save_on_cpu(pin_memory=False, device_type='cuda')¶
```
```py
class torch.autograd.graph.disable_saved_tensors_hooks(error_message)
class torch.autograd.graph.disable_saved_tensors_hooks(error_message)
```
禁用保存的张量默认钩子功能的上下文管理器。
......@@ -521,7 +521,7 @@ class torch.autograd.graph.disable_saved_tensors_hooks(error_message)¶
```
```py
class torch.autograd.graph.register_multi_grad_hook(tensors, fn)
class torch.autograd.graph.register_multi_grad_hook(tensors, fn)
```
注册一个多梯度反向钩子。
......@@ -561,7 +561,7 @@ class torch.autograd.graph.register_multi_grad_hook(tensors, fn)¶
```
```py
class torch.autograd.graph.allow_mutation_on_saved_tensors
class torch.autograd.graph.allow_mutation_on_saved_tensors
```
允许变异保存用于反向传播的张量的上下文管理器。
......@@ -592,13 +592,13 @@ tensor([[0.8415, 0.8415, 0.8415],
```
```py
class torch.autograd.graph.GradientEdge(node, output_nr)
class torch.autograd.graph.GradientEdge(node, output_nr)
```
表示 autograd 图中给定梯度边缘的对象。要获取将计算给定张量梯度的梯度边缘，可以执行`edge = autograd.graph.get_gradient_edge(tensor)`。
```py
torch.autograd.graph.get_gradient_edge(tensor)
torch.autograd.graph.get_gradient_edge(tensor)
```
获取给定张量的梯度的梯度边缘。
......
totrans/doc22_039.md
浏览文件 @ 1efc722b
......@@ -9,7 +9,7 @@ torch.library 是一组用于扩展 PyTorch 核心运算符库的 API。它包
使用`torch.library.define()`来定义新的自定义运算符。使用 impl 方法，例如`torch.library.impl()`和 func:torch.library.impl_abstract，为任何运算符添加实现（它们可以使用`torch.library.define()`创建，或通过 PyTorch 的 C++运算符注册 API 创建）。
```py
torch.library.define(qualname, schema, *, lib=None, tags=())
torch.library.define(qualname, schema, *, lib=None, tags=())
```
```py
......@@ -53,7 +53,7 @@ torch.library.define(lib, schema, alias_analysis='')
```
```py
torch.library.impl(qualname, types, func=None, *, lib=None)
torch.library.impl(qualname, types, func=None, *, lib=None)
```
```py
......@@ -94,7 +94,7 @@ torch.library.impl(lib, name, dispatch_key='')
```
```py
torch.library.impl_abstract(qualname, func=None, *, lib=None, _stacklevel=1)
torch.library.impl_abstract(qualname, func=None, *, lib=None, _stacklevel=1)
```
为此运算符注册一个抽象实现。
......@@ -153,7 +153,7 @@ torch.library.impl_abstract(qualname, func=None, *, lib=None, _stacklevel=1)¶
```
```py
torch.library.get_ctx()
torch.library.get_ctx()
```
get_ctx()返回当前的 AbstractImplCtx 对象。
......@@ -175,7 +175,7 @@ get_ctx()返回当前的 AbstractImplCtx 对象。
有关如何使用此 API 的一些示例的教程可在[Google Colab](https://colab.research.google.com/drive/1RRhSfk7So3Cn02itzLWE9K4Fam-8U011?usp=sharing)上找到。
```py
class torch.library.Library(ns, kind, dispatch_key='')
class torch.library.Library(ns, kind, dispatch_key='')
```
一个用于创建库的类，可以用于注册新操作符或从 Python 中覆盖现有库中的操作符。用户可以选择传递调度键名称，如果他们只想注册与特定调度键对应的内核。
......@@ -191,7 +191,7 @@ class torch.library.Library(ns, kind, dispatch_key='')¶
+ **dispatch_key** – PyTorch 调度键（默认：“”）
```py
define(schema, alias_analysis='', *, tags=())
define(schema, alias_analysis='', *, tags=())
```
在 ns 命名空间中定义一个新操作符及其语义。
......@@ -216,7 +216,7 @@ define(schema, alias_analysis='', *, tags=())¶
```
```py
impl(op_name, fn, dispatch_key='')
impl(op_name, fn, dispatch_key='')
```
为库中定义的操作符注册函数实现。
......@@ -239,7 +239,7 @@ impl(op_name, fn, dispatch_key='')¶
```
```py
torch.library.fallthrough_kernel()
torch.library.fallthrough_kernel()
```
一个虚拟函数，传递给`Library.impl`以注册一个默认情况。
totrans/doc22_042.md
浏览文件 @ 1efc722b
......@@ -40,7 +40,7 @@ torch.cuda.memory._dump_snapshot("my_snapshot.pickle")
# 快照 API 参考
```py
torch.cuda.memory._record_memory_history(enabled='all', context='all', stacks='all', max_entries=9223372036854775807, device=None)
torch.cuda.memory._record_memory_history(enabled='all', context='all', stacks='all', max_entries=9223372036854775807, device=None)
```
启用与内存分配相关的堆栈跟踪记录，这样您就可以知道`torch.cuda.memory._snapshot()`中分配了哪些内存片段。
......@@ -64,7 +64,7 @@ C++跟踪收集也很快（~50ns/帧），对于许多典型程序来说，每
+ **max_entries**（[*int*](https://docs.python.org/3/library/functions.html#int)，“可选”） - 在记录的历史记录中保留最多 max_entries 个分配/释放事件。
```py
torch.cuda.memory._snapshot(device=None)
torch.cuda.memory._snapshot(device=None)
```
在调用时保存 CUDA 内存状态的快照。
......@@ -142,7 +142,7 @@ class TraceEntry(TypedDict):
快照字典对象
```py
torch.cuda.memory._dump_snapshot(filename='dump_snapshot.pickle')
torch.cuda.memory._dump_snapshot(filename='dump_snapshot.pickle')
```
将 torch.memory._snapshot()字典的 pickled 版本保存到文件中。
......
totrans/doc22_044.md
浏览文件 @ 1efc722b
......@@ -27,7 +27,7 @@ torch.backends 控制 PyTorch 支持的各种后端的行为。
## torch.backends.cpu
```py
torch.backends.cpu.get_cpu_capability()
torch.backends.cpu.get_cpu_capability()
```
返回 CPU 能力作为字符串值。
......@@ -39,7 +39,7 @@ torch.backends.cpu.get_cpu_capability()¶
[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") ## torch.backends.cuda
```py
torch.backends.cuda.is_built()
torch.backends.cuda.is_built()
```
返回 PyTorch 是否构建有 CUDA 支持。
......@@ -47,49 +47,49 @@ torch.backends.cuda.is_built()¶
请注意，这并不一定意味着 CUDA 可用；只是如果在具有工作 CUDA 驱动程序和设备的机器上运行此 PyTorch 二进制文件，我们将能够使用它。
```py
torch.backends.cuda.matmul.allow_tf32
torch.backends.cuda.matmul.allow_tf32
```
一个控制在安培或更新的 GPU 上是否可以使用 TensorFloat-32 张量核心进行矩阵乘法的布尔值。请参阅 Ampere（以及更高版本）设备上的 TensorFloat-32（TF32）。
```py
torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction
torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction
```
一个控制是否允许使用减少精度的规约（例如，使用 fp16 累积类型）与 fp16 GEMM 一起使用的布尔值。
```py
torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction
torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction
```
一个控制是否允许使用 bf16 GEMM 的减少精度规约的布尔值。
```py
torch.backends.cuda.cufft_plan_cache
torch.backends.cuda.cufft_plan_cache
```
`cufft_plan_cache`包含每个 CUDA 设备的 cuFFT 计划缓存。通过 torch.backends.cuda.cufft_plan_cache[i]查询特定设备 i 的缓存。
```py
torch.backends.cuda.cufft_plan_cache.size
torch.backends.cuda.cufft_plan_cache.size
```
一个只读[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")，显示 cuFFT 计划缓存中当前计划的数量。
```py
torch.backends.cuda.cufft_plan_cache.max_size
torch.backends.cuda.cufft_plan_cache.max_size
```
一个[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")，控制 cuFFT 计划缓存的容量。
```py
torch.backends.cuda.cufft_plan_cache.clear()
torch.backends.cuda.cufft_plan_cache.clear()
```
清除 cuFFT 计划缓存。
```py
torch.backends.cuda.preferred_linalg_library(backend=None)
torch.backends.cuda.preferred_linalg_library(backend=None)
```
覆盖 PyTorch 用于在 CUDA 线性代数操作中选择 cuSOLVER 和 MAGMA 之间的启发式。
......@@ -147,19 +147,19 @@ torch.backends.cuda.preferred_linalg_library(backend=None)¶
*_LinalgBackend*
```py
torch.backends.cuda.SDPBackend
torch.backends.cuda.SDPBackend
```
别名为 `_SDPBackend`
```py
torch.backends.cuda.SDPAParams
torch.backends.cuda.SDPAParams
```
别名为 `_SDPAParams`
```py
torch.backends.cuda.flash_sdp_enabled()
torch.backends.cuda.flash_sdp_enabled()
```
警告
......@@ -169,7 +169,7 @@ torch.backends.cuda.flash_sdp_enabled()¶
返回 flash 缩放点积注意力是否已启用。
```py
torch.backends.cuda.enable_mem_efficient_sdp(enabled)
torch.backends.cuda.enable_mem_efficient_sdp(enabled)
```
警告
......@@ -179,7 +179,7 @@ torch.backends.cuda.enable_mem_efficient_sdp(enabled)¶
启用或禁用内存高效的缩放点积注意力。
```py
torch.backends.cuda.mem_efficient_sdp_enabled()
torch.backends.cuda.mem_efficient_sdp_enabled()
```
警告
......@@ -189,7 +189,7 @@ torch.backends.cuda.mem_efficient_sdp_enabled()¶
返回内存高效的缩放点积注意力是否已启用。
```py
torch.backends.cuda.enable_flash_sdp(enabled)
torch.backends.cuda.enable_flash_sdp(enabled)
```
警告
......@@ -199,7 +199,7 @@ torch.backends.cuda.enable_flash_sdp(enabled)¶
启用或禁用 flash 缩放点积注意力。
```py
torch.backends.cuda.math_sdp_enabled()
torch.backends.cuda.math_sdp_enabled()
```
警告
......@@ -209,7 +209,7 @@ torch.backends.cuda.math_sdp_enabled()¶
返回 math 缩放点积注意力是否已启用。
```py
torch.backends.cuda.enable_math_sdp(enabled)
torch.backends.cuda.enable_math_sdp(enabled)
```
警告
......@@ -219,7 +219,7 @@ torch.backends.cuda.enable_math_sdp(enabled)¶
启用或禁用 math 缩放点积注意力。
```py
torch.backends.cuda.can_use_flash_attention(params, debug=False)
torch.backends.cuda.can_use_flash_attention(params, debug=False)
```
检查是否可以在 scaled_dot_product_attention 中使用 FlashAttention。
......@@ -243,7 +243,7 @@ torch.backends.cuda.can_use_flash_attention(params, debug=False)¶
此函数依赖于 PyTorch 的 CUDA 版本。在非 CUDA 环境中将返回 False。
```py
torch.backends.cuda.can_use_efficient_attention(params, debug=False)
torch.backends.cuda.can_use_efficient_attention(params, debug=False)
```
检查是否可以在 scaled_dot_product_attention 中使用 efficient_attention。
......@@ -267,7 +267,7 @@ torch.backends.cuda.can_use_efficient_attention(params, debug=False)¶
此函数依赖于 PyTorch 的 CUDA 版本。在非 CUDA 环境中将返回 False。
```py
torch.backends.cuda.sdp_kernel(enable_flash=True, enable_math=True, enable_mem_efficient=True)
torch.backends.cuda.sdp_kernel(enable_flash=True, enable_math=True, enable_mem_efficient=True)
```
警告
......@@ -277,49 +277,49 @@ torch.backends.cuda.sdp_kernel(enable_flash=True, enable_math=True, enable_mem_e
此上下文管理器可用于临时启用或禁用缩放点积注意力的三个后端之一。退出上下文管理器时，将恢复标志的先前状态。## torch.backends.cudnn[](#module-torch.backends.cudnn "Permalink to this heading")
```py
torch.backends.cudnn.version()
torch.backends.cudnn.version()
```
返回 cuDNN 的版本。
```py
torch.backends.cudnn.is_available()
torch.backends.cudnn.is_available()
```
返回一个布尔值，指示当前是否可用 CUDNN。
```py
torch.backends.cudnn.enabled
torch.backends.cudnn.enabled
```
一个控制 cuDNN 是否启用的 [`bool`](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")。
```py
torch.backends.cudnn.allow_tf32
torch.backends.cudnn.allow_tf32
```
一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，控制在 Ampere 或更新的 GPU 上 cuDNN 卷积中是否可以使用 TensorFloat-32 张量核心。请参阅 Ampere（以及更高版本）设备上的 TensorFloat-32（TF32）。
```py
torch.backends.cudnn.deterministic
torch.backends.cudnn.deterministic
```
一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，如果为 True，则导致 cuDNN 仅使用确定性卷积算法。另请参阅`torch.are_deterministic_algorithms_enabled()`和`torch.use_deterministic_algorithms()`。
```py
torch.backends.cudnn.benchmark
torch.backends.cudnn.benchmark
```
一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，如果为 True，则导致 cuDNN 对多个卷积算法进行基准测试并选择最快的。
```py
torch.backends.cudnn.benchmark_limit
torch.backends.cudnn.benchmark_limit
```
一个[`int`](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")，指定 torch.backends.cudnn.benchmark 为 True 时尝试的 cuDNN 卷积算法的最大数量。将 benchmark_limit 设置为零以尝试每个可用算法。请注意，此设置仅影响通过 cuDNN v8 API 分派的卷积。 ## torch.backends.mps[](#module-torch.backends.mps "跳转到此标题的永久链接")
```py
torch.backends.mps.is_available()
torch.backends.mps.is_available()
```
返回一个指示当前是否可用 MPS 的布尔值。
......@@ -329,7 +329,7 @@ torch.backends.mps.is_available()¶
[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")
```py
torch.backends.mps.is_built()
torch.backends.mps.is_built()
```
返回 PyTorch 是否构建有 MPS 支持。
......@@ -341,13 +341,13 @@ torch.backends.mps.is_built()¶
[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ## torch.backends.mkl
```py
torch.backends.mkl.is_available()
torch.backends.mkl.is_available()
```
返回 PyTorch 是否构建有 MKL 支持。
```py
class torch.backends.mkl.verbose(enable)
class torch.backends.mkl.verbose(enable)
```
按需 oneMKL 详细功能。
......@@ -366,13 +366,13 @@ with torch.backends.mkl.verbose(torch.backends.mkl.VERBOSE_ON):
**level** – 详细级别 - `VERBOSE_OFF`：禁用详细 - `VERBOSE_ON`：启用详细 ## torch.backends.mkldnn[](#module-torch.backends.mkldnn "跳转到此标题的永久链接")
```py
torch.backends.mkldnn.is_available()
torch.backends.mkldnn.is_available()
```
返回 PyTorch 是否构建有 MKL-DNN 支持。
```py
class torch.backends.mkldnn.verbose(level)
class torch.backends.mkldnn.verbose(level)
```
按需 oneDNN（前 MKL-DNN）详细功能。
......@@ -391,13 +391,13 @@ with torch.backends.mkldnn.verbose(torch.backends.mkldnn.VERBOSE_ON):
**level** – 详细级别 - `VERBOSE_OFF`：禁用详细 - `VERBOSE_ON`：启用详细 - `VERBOSE_ON_CREATION`：启用详细，包括 oneDNN 内核创建 ## torch.backends.openmp[](#module-torch.backends.openmp "跳转到此标题的永久链接")
```py
torch.backends.openmp.is_available()
torch.backends.openmp.is_available()
```
返回 PyTorch 是否构建有 OpenMP 支持。 ## torch.backends.opt_einsum[](#module-torch.backends.opt_einsum "跳转到此标题")
```py
torch.backends.opt_einsum.is_available()
torch.backends.opt_einsum.is_available()
```
返回一个指示 opt_einsum 当前是否可用的 bool 值。
......@@ -407,7 +407,7 @@ torch.backends.opt_einsum.is_available()¶
[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")
```py
torch.backends.opt_einsum.get_opt_einsum()
torch.backends.opt_einsum.get_opt_einsum()
```
如果当前可用，则返回 opt_einsum 包，否则返回 None。
......@@ -417,7 +417,7 @@ torch.backends.opt_einsum.get_opt_einsum()¶
[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)")
```py
torch.backends.opt_einsum.enabled
torch.backends.opt_einsum.enabled
```
一个控制是否启用 opt_einsum 的`bool`（默认为`True`）。如果启用，torch.einsum 将使用 opt_einsum（[`optimized-einsum.readthedocs.io/en/stable/path_finding.html`](https://optimized-einsum.readthedocs.io/en/stable/path_finding.html)）来计算更快性能的最佳收缩路径。
......@@ -425,7 +425,7 @@ torch.backends.opt_einsum.enabled¶
如果 opt_einsum 不可用，torch.einsum 将退回到默认的从左到右的收缩路径。
```py
torch.backends.opt_einsum.strategy
torch.backends.opt_einsum.strategy
```
一个指定当`torch.backends.opt_einsum.enabled`为`True`时要尝试哪些策略的`str`。默认情况下，torch.einsum 将尝试“auto”策略，但也支持“greedy”和“optimal”策略。请注意，“optimal”策略在尝试所有可能路径时与输入数量的阶乘成正比。在 opt_einsum 的文档中查看更多细节（[`optimized-einsum.readthedocs.io/en/stable/path_finding.html`](https://optimized-einsum.readthedocs.io/en/stable/path_finding.html)）。 ## torch.backends.xeon
totrans/doc22_045.md
浏览文件 @ 1efc722b
......@@ -399,7 +399,7 @@ PyTorch 开发者深入了解
## API 参考
```py
torch.export.export(f, args, kwargs=None, *, constraints=None, dynamic_shapes=None, strict=True, preserve_module_call_signature=())
torch.export.export(f, args, kwargs=None, *, constraints=None, dynamic_shapes=None, strict=True, preserve_module_call_signature=())
```
`export()`接受任意的 Python 可调用对象（nn.Module、函数或方法）以及示例输入，并以 Ahead-of-Time（AOT）方式生成表示函数的张量计算的追踪图，随后可以使用不同的输入或序列化执行。追踪图（1）生成功能性 ATen 操作符集中的标准化操作符（以及任何用户指定的自定义操作符），（2）消除了所有 Python 控制流和数据结构（某些例外情况除外），（3）记录了为了证明这种标准化和控制流消除对未来输入是有效的所需的形状约束集。
......@@ -459,7 +459,7 @@ dim = Dim("dim0_x", max=5)
+ 包含所有上述类型的`dict`、`list`、`tuple`、`namedtuple`和`OrderedDict`组成的（嵌套）数据结构。
```py
torch.export.dynamic_dim(t, index)
torch.export.dynamic_dim(t, index)
```
警告
......@@ -537,7 +537,7 @@ torch.export.dynamic_dim(t, index)¶
+ 可以混合匹配上述所有类型，只要它们不表达冲突的要求
```py
torch.export.save(ep, f, *, extra_files=None, opset_version=None)
torch.export.save(ep, f, *, extra_files=None, opset_version=None)
```
警告
......@@ -581,7 +581,7 @@ torch.export.save(ep, 'exported_program.pt2', extra_files=extra_files)
```
```py
torch.export.load(f, *, extra_files=None, expected_opset_version=None)
torch.export.load(f, *, extra_files=None, expected_opset_version=None)
```
警告
......@@ -631,7 +631,7 @@ print(ep(torch.randn(5)))
```
```py
torch.export.register_dataclass(cls)
torch.export.register_dataclass(cls)
```
将数据类注册为`torch.export.export()`的有效输入/输出类型。
......@@ -663,7 +663,7 @@ print(ep)
```
```py
torch.export.Dim(name, *, min=None, max=None)
torch.export.Dim(name, *, min=None, max=None)
```
`Dim()`构造类似于具有范围的命名符号整数的类型。它可用于描述动态张量维度的多个可能值。请注意，同一张量的不同动态维度，或不同张量的动态维度，可以由相同类型描述。
......@@ -681,13 +681,13 @@ torch.export.Dim(name, *, min=None, max=None)¶
可以在张量的动态形状规范中使用的类型。
```py
torch.export.dims(*names, min=None, max=None)
torch.export.dims(*names, min=None, max=None)
```
用于创建多个`Dim()`类型的工具。
```py
class torch.export.Constraint(*args, **kwargs)
class torch.export.Constraint(*args, **kwargs)
```
警告
......@@ -697,7 +697,7 @@ class torch.export.Constraint(*args, **kwargs)¶
这代表了对输入张量维度的约束，例如，要求它们是完全多态的或在某个范围内。
```py
class torch.export.ExportedProgram(root, graph, graph_signature, state_dict, range_constraints, equality_constraints, module_call_graph, example_inputs=None, verifier=None, tensor_constants=None)
class torch.export.ExportedProgram(root, graph, graph_signature, state_dict, range_constraints, equality_constraints, module_call_graph, example_inputs=None, verifier=None, tensor_constants=None)
```
从`export()`导出的程序的包。它包含一个表示张量计算的 torch.fx.Graph，一个包含所有提升参数和缓冲区的张量值的 state_dict，以及各种元数据。
......@@ -707,7 +707,7 @@ class torch.export.ExportedProgram(root, graph, graph_signature, state_dict, ran
要对图进行转换，请使用`.module`属性来访问`torch.fx.GraphModule`。然后，您可以使用[FX 转换](https://pytorch.org/docs/stable/fx.html#writing-transformations)来重写图。之后，您可以简单地再次使用`export()`来构建一个正确的 ExportedProgram。
```py
module(*, flat=True)
module(*, flat=True)
```
返回一个包含所有参数/缓冲区的自包含 GraphModule。
......@@ -717,7 +717,7 @@ module(*, flat=True)¶
*模块*
```py
buffers()
buffers()
```
返回一个迭代器，遍历原始模块缓冲区。
......@@ -731,7 +731,7 @@ buffers()¶
[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在 Python v3.12 中)")[*张量*]
```py
named_buffers()
named_buffers()
```
返回一个迭代器，遍历原始模块缓冲区，同时产生缓冲区的名称和缓冲区本身。
......@@ -745,7 +745,7 @@ named_buffers()¶
[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在 Python v3.12 中)")[[*元组*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), *张量*]]
```py
parameters()
parameters()
```
返回一个迭代器，遍历原始模块的参数。
......@@ -759,7 +759,7 @@ parameters()¶
[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在 Python v3.12 中)")[*参数*]
```py
named_parameters()
named_parameters()
```
返回一个迭代器，遍历原始模块参数，同时产生参数的名称和参数本身。
......@@ -773,11 +773,11 @@ named_parameters()¶
[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在 Python v3.12 中)")[[*元组*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), *参数*]]
```py
class torch.export.ExportBackwardSignature(gradients_to_parameters: Dict[str, str], gradients_to_user_inputs: Dict[str, str], loss_output: str)
class torch.export.ExportBackwardSignature(gradients_to_parameters: Dict[str, str], gradients_to_user_inputs: Dict[str, str], loss_output: str)
```
```py
class torch.export.ExportGraphSignature(input_specs, output_specs)
class torch.export.ExportGraphSignature(input_specs, output_specs)
```
`ExportGraphSignature` 模型化导出图的输入/输出签名，这是一个具有更强不变性保证的 fx.Graph。
......@@ -851,35 +851,35 @@ ExportGraphSignature(
```
```py
class torch.export.ModuleCallSignature(inputs: List[Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument]], outputs: List[Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument]], in_spec: torch.utils._pytree.TreeSpec, out_spec: torch.utils._pytree.TreeSpec)
class torch.export.ModuleCallSignature(inputs: List[Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument]], outputs: List[Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument]], in_spec: torch.utils._pytree.TreeSpec, out_spec: torch.utils._pytree.TreeSpec)
```
```py
class torch.export.ModuleCallEntry(fqn: str, signature: Union[torch.export.exported_program.ModuleCallSignature, NoneType] = None)
class torch.export.ModuleCallEntry(fqn: str, signature: Union[torch.export.exported_program.ModuleCallSignature, NoneType] = None)
```
```py
class torch.export.graph_signature.InputKind(value)
class torch.export.graph_signature.InputKind(value)
```
一个枚举。
```py
class torch.export.graph_signature.InputSpec(kind: torch.export.graph_signature.InputKind, arg: Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument], target: Union[str, NoneType])
class torch.export.graph_signature.InputSpec(kind: torch.export.graph_signature.InputKind, arg: Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument], target: Union[str, NoneType])
```
```py
class torch.export.graph_signature.OutputKind(value)
class torch.export.graph_signature.OutputKind(value)
```
一个枚举。
```py
class torch.export.graph_signature.OutputSpec(kind: torch.export.graph_signature.OutputKind, arg: Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument], target: Union[str, NoneType])
class torch.export.graph_signature.OutputSpec(kind: torch.export.graph_signature.OutputKind, arg: Union[torch.export.graph_signature.TensorArgument, torch.export.graph_signature.SymIntArgument, torch.export.graph_signature.ConstantArgument], target: Union[str, NoneType])
```
```py
class torch.export.graph_signature.ExportGraphSignature(input_specs, output_specs)
class torch.export.graph_signature.ExportGraphSignature(input_specs, output_specs)
```
`ExportGraphSignature`模拟了导出图的输入/输出签名，这是一个具有更强不变性保证的 fx.Graph。
......@@ -953,7 +953,7 @@ ExportGraphSignature(
```
```py
replace_all_uses(old, new)
replace_all_uses(old, new)
```
在签名中用新名称替换所有旧名称的用法。
totrans/doc22_046.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_047.md
浏览文件 @ 1efc722b
......@@ -5,7 +5,7 @@
通用加入上下文管理器促进了不均匀输入的分布式训练。本页概述了相关类的 API：`Join`、`Joinable`和`JoinHook`。有关教程，请参阅[使用加入上下文管理器进行不均匀输入的分布式训练](https://pytorch.org/tutorials/advanced/generic_join.html)。
```py
class torch.distributed.algorithms.Join(joinables, enable=True, throw_on_early_termination=False, **kwargs)
class torch.distributed.algorithms.Join(joinables, enable=True, throw_on_early_termination=False, **kwargs)
```
此类定义了通用加入上下文管理器，允许在进程加入后调用自定义钩子。
......@@ -55,7 +55,7 @@ class torch.distributed.algorithms.Join(joinables, enable=True, throw_on_early_t
```
```py
static notify_join_context(joinable)
static notify_join_context(joinable)
```
通知加入上下文管理器，调用进程尚未加入。
......@@ -75,7 +75,7 @@ static notify_join_context(joinable)¶
一个用于全局归约的异步工作句柄，用于通知上下文管理器进程尚未加入，如果`joinable`是传递到上下文管理器的第一个；否则为`None`。
```py
class torch.distributed.algorithms.Joinable
class torch.distributed.algorithms.Joinable
```
这为可加入类定义了一个抽象基类。
......@@ -83,13 +83,13 @@ class torch.distributed.algorithms.Joinable¶
一个可加入的类（从`Joinable`继承）应该实现`join_hook()`，它返回一个`JoinHook`实例，另外还应该实现`join_device()`和`join_process_group()`来分别返回设备和进程组信息。
```py
abstract property join_device: device
abstract property join_device: device
```
返回执行加入上下文管理器所需的集体通信的设备。
```py
abstract join_hook(**kwargs)
abstract join_hook(**kwargs)
```
为给定的`Joinable`返回一个`JoinHook`实例。
......@@ -103,13 +103,13 @@ abstract join_hook(**kwargs)¶
*JoinHook*
```py
abstract property join_process_group: Any
abstract property join_process_group: Any
```
返回加入上下文管理器本身所需的集体通信的进程组。
```py
class torch.distributed.algorithms.JoinHook
class torch.distributed.algorithms.JoinHook
```
这定义了一个加入钩子，在加入上下文管理器中提供了两个入口点。
......@@ -119,7 +119,7 @@ class torch.distributed.algorithms.JoinHook¶
要为通用加入上下文管理器实现一个加入钩子，需要定义一个从`JoinHook`继承的类，并适当地重写`main_hook()`和`post_hook()`。
```py
main_hook()
main_hook()
```
在训练迭代中，当存在一个未加入的进程时调用此钩子以隐藏集体通信。
......@@ -127,7 +127,7 @@ main_hook()¶
训练迭代，即在一个前向传播、反向传播和优化器步骤中。
```py
post_hook(is_last_joiner)
post_hook(is_last_joiner)
```
在所有进程都已加入后调用钩子。
......
totrans/doc22_049.md
浏览文件 @ 1efc722b
......@@ -3,7 +3,7 @@
> 原文：[`pytorch.org/docs/stable/fsdp.html`](https://pytorch.org/docs/stable/fsdp.html)
```py
class torch.distributed.fsdp.FullyShardedDataParallel(module, process_group=None, sharding_strategy=None, cpu_offload=None, auto_wrap_policy=None, backward_prefetch=BackwardPrefetch.BACKWARD_PRE, mixed_precision=None, ignored_modules=None, param_init_fn=None, device_id=None, sync_module_states=False, forward_prefetch=False, limit_all_gathers=True, use_orig_params=False, ignored_states=None, device_mesh=None)
class torch.distributed.fsdp.FullyShardedDataParallel(module, process_group=None, sharding_strategy=None, cpu_offload=None, auto_wrap_policy=None, backward_prefetch=BackwardPrefetch.BACKWARD_PRE, mixed_precision=None, ignored_modules=None, param_init_fn=None, device_id=None, sync_module_states=False, forward_prefetch=False, limit_all_gathers=True, use_orig_params=False, ignored_states=None, device_mesh=None)
```
用于在数据并行工作者之间分片模块参数的包装器。
......@@ -147,7 +147,7 @@ FSDP 在前向和后向计算期间用`torch.Tensor`视图替换托管模块的
+ **ignored_states**（*可选**[**Iterable**[**torch.nn.Parameter**]**]**,* *可选****Iterable**[*[*torch.nn.Module**]**]*)- 不受此 FSDP 实例管理的被忽略的参数或模块，这意味着参数未分片，它们的梯度未在等级之间减少。此参数与现有的`ignored_modules`参数统一，我们可能很快会弃用`ignored_modules`。为了向后兼容，我们保留`ignored_states`和`ignored_modules`，但是 FSDP 只允许其中一个被指定为非`None`。
```py
apply(fn)
apply(fn)
```
递归地将`fn`应用于每个子模块（由`.children()`返回）以及自身。
......@@ -169,7 +169,7 @@ self
Module
```py
check_is_root()
check_is_root()
```
检查此实例是否为根 FSDP 模块。
......@@ -179,7 +179,7 @@ check_is_root()¶
[bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")
```py
clip_grad_norm_(max_norm, norm_type=2.0)
clip_grad_norm_(max_norm, norm_type=2.0)
```
裁剪所有参数的梯度规范。
......@@ -217,7 +217,7 @@ clip_grad_norm_(max_norm, norm_type=2.0)¶
由于使用集体通信，因此需要在所有秩上调用此函数。
```py
static flatten_sharded_optim_state_dict(sharded_optim_state_dict, model, optim)
static flatten_sharded_optim_state_dict(sharded_optim_state_dict, model, optim)
```
展平分片的优化器状态字典。
......@@ -241,7 +241,7 @@ API 类似于`shard_full_optim_state_dict()`。唯一的区别是输入的`shard
[*Dict*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")]
```py
forward(*args, **kwargs)
forward(*args, **kwargs)
```
运行包装模块的前向传递，插入 FSDP 特定的前向和后向分片逻辑。
......@@ -251,7 +251,7 @@ forward(*args, **kwargs)¶
[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")
```py
static fsdp_modules(module, root_only=False)
static fsdp_modules(module, root_only=False)
```
返回所有嵌套的 FSDP 实例。
......@@ -273,7 +273,7 @@ static fsdp_modules(module, root_only=False)¶
List[FullyShardedDataParallel]
```py
static full_optim_state_dict(model, optim, optim_input=None, rank0_only=True, group=None)
static full_optim_state_dict(model, optim, optim_input=None, rank0_only=True, group=None)
```
返回完整的优化器状态字典。
......@@ -313,7 +313,7 @@ static full_optim_state_dict(model, optim, optim_input=None, rank0_only=True, gr
Dict[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), Any]
```py
static get_state_dict_type(module)
static get_state_dict_type(module)
```
获取根据`module`根模块的 FSDP 模块的 state_dict_type 和相应的配置。
......@@ -335,13 +335,13 @@ static get_state_dict_type(module)¶
*StateDictSettings*
```py
property module: Module
property module: Module
```
返回包装的模块。
```py
named_buffers(*args, **kwargs)
named_buffers(*args, **kwargs)
```
返回一个模块缓冲区的迭代器，同时产生缓冲区的名称和缓冲区本身。
......@@ -353,7 +353,7 @@ named_buffers(*args, **kwargs)¶
[*Iterator*](https://docs.python.org/3/library/typing.html#typing.Iterator "(in Python v3.12)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), *Tensor*]]
```py
named_parameters(*args, **kwargs)
named_parameters(*args, **kwargs)
```
返回一个模块参数的迭代器，同时产生参数的名称和参数本身。
......@@ -365,7 +365,7 @@ named_parameters(*args, **kwargs)¶
[*Iterator*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在 Python v3.12 中)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), *Parameter*]]
```py
no_sync()
no_sync()
```
禁用 FSDP 实例之间的梯度同步。
......@@ -385,7 +385,7 @@ no_sync()¶
[*Generator*](https://docs.python.org/3/library/typing.html#typing.Generator "(在 Python v3.12 中)")
```py
static optim_state_dict(model, optim, optim_state_dict=None, group=None)
static optim_state_dict(model, optim, optim_state_dict=None, group=None)
```
转换与分片模型对应的优化器的状态字典。
......@@ -451,7 +451,7 @@ static optim_state_dict(model, optim, optim_state_dict=None, group=None)¶
Dict[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), Any]
```py
static optim_state_dict_to_load(model, optim, optim_state_dict, is_named_optimizer=False, load_directly=False, group=None)
static optim_state_dict_to_load(model, optim, optim_state_dict, is_named_optimizer=False, load_directly=False, group=None)
```
将优化器状态字典转换为可以加载到与 FSDP 模型关联的优化器中的格式。
......@@ -514,7 +514,7 @@ static optim_state_dict_to_load(model, optim, optim_state_dict, is_named_optimiz
[*Dict*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")]
```py
register_comm_hook(state, hook)
register_comm_hook(state, hook)
```
注册通信钩子。
......@@ -534,7 +534,7 @@ register_comm_hook(state, hook)¶
+ **hook** (*Callable*) – 可调用函数，具有以下签名之一：1) `hook: Callable[torch.Tensor] -> None`：此函数接受一个 Python 张量，表示与此 FSDP 单元包装的模型对应的所有变量的全面、扁平化、未分片梯度（未被其他 FSDP 子单元包装）。然后执行所有必要的处理并返回`None`；2) `hook: Callable[torch.Tensor, torch.Tensor] -> None`：此函数接受两个 Python 张量，第一个表示与此 FSDP 单元包装的模型对应的所有变量的全面、扁平化、未分片梯度（未被其他 FSDP 子单元包装）。后者表示一个预先大小的张量，用于存储分片梯度的一部分。在这两种情况下，可调用函数执行所有必要的处理并返回`None`。具有签名 1 的可调用函数应处理 NO_SHARD 情况的梯度通信。具有签名 2 的可调用函数应处理分片情况的梯度通信。
```py
static rekey_optim_state_dict(optim_state_dict, optim_state_key_type, model, optim_input=None, optim=None)
static rekey_optim_state_dict(optim_state_dict, optim_state_key_type, model, optim_input=None, optim=None)
```
重新调整优化器状态字典`optim_state_dict`以使用键类型`optim_state_key_type`。
......@@ -571,7 +571,7 @@ static rekey_optim_state_dict(optim_state_dict, optim_state_key_type, model, opt
字典[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), Any]
```py
static scatter_full_optim_state_dict(full_optim_state_dict, model, optim_input=None, optim=None, group=None)
static scatter_full_optim_state_dict(full_optim_state_dict, model, optim_input=None, optim=None, group=None)
```
将来自排名 0 的完整优化器状态字典分散到所有其他排名。
......@@ -615,7 +615,7 @@ static scatter_full_optim_state_dict(full_optim_state_dict, model, optim_input=N
Dict[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), Any]
```py
static set_state_dict_type(module, state_dict_type, state_dict_config=None, optim_state_dict_config=None)
static set_state_dict_type(module, state_dict_type, state_dict_config=None, optim_state_dict_config=None)
```
设置目标模块的所有后代 FSDP 模块的`state_dict_type`。
......@@ -663,7 +663,7 @@ static set_state_dict_type(module, state_dict_type, state_dict_config=None, opti
*StateDictSettings*
```py
static shard_full_optim_state_dict(full_optim_state_dict, model, optim_input=None, optim=None)
static shard_full_optim_state_dict(full_optim_state_dict, model, optim_input=None, optim=None)
```
分片完整的优化器状态字典。
......@@ -707,7 +707,7 @@ static shard_full_optim_state_dict(full_optim_state_dict, model, optim_input=Non
字典[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), Any]
```py
static sharded_optim_state_dict(model, optim, group=None)
static sharded_optim_state_dict(model, optim, group=None)
```
以其分片形式返回优化器状态字典。
......@@ -725,7 +725,7 @@ API 类似于`full_optim_state_dict()`，但此 API 将所有非零维状态分
[*字典*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")]
```py
static state_dict_type(module, state_dict_type, state_dict_config=None, optim_state_dict_config=None)
static state_dict_type(module, state_dict_type, state_dict_config=None, optim_state_dict_config=None)
```
设置目标模块的所有后代 FSDP 模块的`state_dict_type`。
......@@ -754,7 +754,7 @@ static state_dict_type(module, state_dict_type, state_dict_config=None, optim_st
[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在 Python v3.12 中)")
```py
static summon_full_params(module, recurse=True, writeback=True, rank0_only=False, offload_to_cpu=False, with_grads=False)
static summon_full_params(module, recurse=True, writeback=True, rank0_only=False, offload_to_cpu=False, with_grads=False)
```
使用此上下文管理器为 FSDP 实例公开完整参数。
......@@ -806,7 +806,7 @@ static summon_full_params(module, recurse=True, writeback=True, rank0_only=False
[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在 Python v3.12 版本)")
```py
class torch.distributed.fsdp.BackwardPrefetch(value)
class torch.distributed.fsdp.BackwardPrefetch(value)
```
这配置了显式的向后预取，通过在向后传递中启用通信和计算重叠来提高吞吐量，但会略微增加内存使用量。
......@@ -820,7 +820,7 @@ class torch.distributed.fsdp.BackwardPrefetch(value)¶
更多技术背景：对于使用 NCCL 后端的单个进程组，任何集合，即使从不同流发出，也会争夺相同的每个设备 NCCL 流，这意味着发出集合的相对顺序对于重叠很重要。两个向后预取值对应不同的发出顺序。
```py
class torch.distributed.fsdp.ShardingStrategy(value)
class torch.distributed.fsdp.ShardingStrategy(value)
```
这指定了由`FullyShardedDataParallel`用于分布式训练的分片策略。
......@@ -836,7 +836,7 @@ class torch.distributed.fsdp.ShardingStrategy(value)¶
+ `_HYBRID_SHARD_ZERO2`：在节点内应用`SHARD_GRAD_OP`，并在节点之间复制参数。这类似于`HYBRID_SHARD`，不同之处在于在前向传递后不释放未分片参数，从而节省了前向传递中的所有收集操作。
```py
class torch.distributed.fsdp.MixedPrecision(param_dtype=None, reduce_dtype=None, buffer_dtype=None, keep_low_precision_grads=False, cast_forward_inputs=False, cast_root_forward_inputs=True, _module_classes_to_ignore=(<class 'torch.nn.modules.batchnorm._BatchNorm'>, ))
class torch.distributed.fsdp.MixedPrecision(param_dtype=None, reduce_dtype=None, buffer_dtype=None, keep_low_precision_grads=False, cast_forward_inputs=False, cast_root_forward_inputs=True, _module_classes_to_ignore=(<class 'torch.nn.modules.batchnorm._BatchNorm'>, ))
```
这配置了 FSDP 本机混合精度训练。
......@@ -902,7 +902,7 @@ class torch.distributed.fsdp.MixedPrecision(param_dtype=None, reduce_dtype=None,
上面展示了一个工作示例。另一方面，如果 `model[1]` 被替换为 `model[0]`，意味着使用不同 `MixedPrecision` 的子模块先运行其前向传播，那么 `model[1]` 将错误地看到 `float16` 激活而不是 `bfloat16` 的激活。
```py
class torch.distributed.fsdp.CPUOffload(offload_params=False)
class torch.distributed.fsdp.CPUOffload(offload_params=False)
```
这配置了 CPU 卸载。
......@@ -912,7 +912,7 @@ class torch.distributed.fsdp.CPUOffload(offload_params=False)¶
**offload_params** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 这指定是否在计算中未涉及时将参数卸载到 CPU。如果为 `True`，则梯度也会被卸载到 CPU，这意味着优化器步骤在 CPU 上运行。
```py
class torch.distributed.fsdp.StateDictConfig(offload_to_cpu=False)
class torch.distributed.fsdp.StateDictConfig(offload_to_cpu=False)
```
`StateDictConfig` 是所有 `state_dict` 配置类的基类。用户应该实例化一个子类（例如 `FullStateDictConfig`）以配置由 FSDP 支持的相应 `state_dict` 类型的设置。
......@@ -922,7 +922,7 @@ class torch.distributed.fsdp.StateDictConfig(offload_to_cpu=False)¶
**offload_to_cpu** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为 `True`，则 FSDP 将状态字典值卸载到 CPU，如果为 `False`，则 FSDP 保留在 GPU 上。（默认值：`False`）
```py
class torch.distributed.fsdp.FullStateDictConfig(offload_to_cpu=False, rank0_only=False)
class torch.distributed.fsdp.FullStateDictConfig(offload_to_cpu=False, rank0_only=False)
```
`FullStateDictConfig` 是一个配置类，用于与 `StateDictType.FULL_STATE_DICT` 一起使用。我们建议在保存完整状态字典时分别启用 `offload_to_cpu=True` 和 `rank0_only=True`，以节省 GPU 内存和 CPU 内存。这个配置类应该通过 `state_dict_type()` 上下文管理器来使用，如下所示：
......@@ -951,7 +951,7 @@ class torch.distributed.fsdp.FullStateDictConfig(offload_to_cpu=False, rank0_onl
**rank0_only** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为 `True`，则只有排名为 0 的进程保存完整状态字典，非零排名的进程保存一个空字典。如果为 `False`，则所有排名都保存完整状态字典。（默认值：`False`）
```py
class torch.distributed.fsdp.ShardedStateDictConfig(offload_to_cpu=False, _use_dtensor=False)
class torch.distributed.fsdp.ShardedStateDictConfig(offload_to_cpu=False, _use_dtensor=False)
```
`ShardedStateDictConfig` 是一个配置类，用于与 `StateDictType.SHARDED_STATE_DICT` 一起使用。
......@@ -965,11 +965,11 @@ class torch.distributed.fsdp.ShardedStateDictConfig(offload_to_cpu=False, _use_d
`_use_dtensor`是`ShardedStateDictConfig`的私有字段，由 FSDP 用于确定状态字典值的类型。用户不应手动修改`_use_dtensor`。
```py
class torch.distributed.fsdp.LocalStateDictConfig(offload_to_cpu: bool = False)
class torch.distributed.fsdp.LocalStateDictConfig(offload_to_cpu: bool = False)
```
```py
class torch.distributed.fsdp.OptimStateDictConfig(offload_to_cpu=True)
class torch.distributed.fsdp.OptimStateDictConfig(offload_to_cpu=True)
```
`OptimStateDictConfig`是所有`optim_state_dict`配置类的基类。用户应该实例化一个子类（例如`FullOptimStateDictConfig`）以配置由 FSDP 支持的相应`optim_state_dict`类型的设置。
......@@ -979,7 +979,7 @@ class torch.distributed.fsdp.OptimStateDictConfig(offload_to_cpu=True)¶
**offload_to_cpu**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 如果为`True`，则 FSDP 将状态字典的张量值转移到 CPU，如果为`False`，则 FSDP 将其保留在原始设备上（即 GPU，除非启用了 CPU 卸载参数）。 （默认值：`True`）
```py
class torch.distributed.fsdp.FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=False)
class torch.distributed.fsdp.FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=False)
```
变量
......@@ -987,7 +987,7 @@ class torch.distributed.fsdp.FullOptimStateDictConfig(offload_to_cpu=True, rank0
**rank0_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 如果为`True`，则只有排名为 0 的进程保存完整的状态字典，非零排名的进程保存空字典。如果为`False`，则所有进程都保存完整的状态字典。（默认值：`False`）
```py
class torch.distributed.fsdp.ShardedOptimStateDictConfig(offload_to_cpu=True, _use_dtensor=False)
class torch.distributed.fsdp.ShardedOptimStateDictConfig(offload_to_cpu=True, _use_dtensor=False)
```
`ShardedOptimStateDictConfig`是一个配置类，用于与`StateDictType.SHARDED_STATE_DICT`一起使用。
......@@ -1001,9 +1001,9 @@ class torch.distributed.fsdp.ShardedOptimStateDictConfig(offload_to_cpu=True, _u
`_use_dtensor`是`ShardedOptimStateDictConfig`的私有字段，由 FSDP 用于确定状态字典值的类型。用户不应手动修改`_use_dtensor`。
```py
class torch.distributed.fsdp.LocalOptimStateDictConfig(offload_to_cpu: bool = False)
class torch.distributed.fsdp.LocalOptimStateDictConfig(offload_to_cpu: bool = False)
```
```py
class torch.distributed.fsdp.StateDictSettings(state_dict_type: torch.distributed.fsdp.api.StateDictType, state_dict_config: torch.distributed.fsdp.api.StateDictConfig, optim_state_dict_config: torch.distributed.fsdp.api.OptimStateDictConfig)
class torch.distributed.fsdp.StateDictSettings(state_dict_type: torch.distributed.fsdp.api.StateDictType, state_dict_config: torch.distributed.fsdp.api.StateDictConfig, optim_state_dict_config: torch.distributed.fsdp.api.OptimStateDictConfig)
```
totrans/doc22_050.md
浏览文件 @ 1efc722b
......@@ -9,7 +9,7 @@
`torch.distributed.optim` 暴露了 DistributedOptimizer，它接受一个远程参数（`RRef`）的列表，并在参数所在的工作节点上本地运行优化器。分布式优化器可以使用任何本地优化器基类来在每个工作节点上应用梯度。
```py
class torch.distributed.optim.DistributedOptimizer(optimizer_class, params_rref, *args, **kwargs)
class torch.distributed.optim.DistributedOptimizer(optimizer_class, params_rref, *args, **kwargs)
```
DistributedOptimizer 接受分布在工作节点上的参数的远程引用，并为每个参数本地应用给定的优化器。
......@@ -57,7 +57,7 @@ DistributedOptimizer 默认启用了启用了 TorchScript 的本地优化器，
```
```py
step(context_id)
step(context_id)
```
执行单个优化步骤。
......@@ -69,7 +69,7 @@ step(context_id)¶
**context_id** – 我们应该运行优化器步骤的自动求导上下文 id。
```py
class torch.distributed.optim.PostLocalSGDOptimizer(optim, averager)
class torch.distributed.optim.PostLocalSGDOptimizer(optim, averager)
```
包装任意`torch.optim.Optimizer`并运行[后局部 SGD](https://arxiv.org/abs/1808.07217)，此优化器在每一步都运行本地优化器。在热身阶段之后，它会定期平均参数，然后应用本地优化器。
......@@ -121,7 +121,7 @@ class torch.distributed.optim.PostLocalSGDOptimizer(optim, averager)¶
```
```py
load_state_dict(state_dict)
load_state_dict(state_dict)
```
这与`torch.optim.Optimizer` `load_state_dict()`相同，但还将模型平均器的步骤值恢复为提供的`state_dict`中保存的值。
......@@ -129,19 +129,19 @@ load_state_dict(state_dict)¶
如果`state_dict`中没有`"step"`条目，它将引发警告并将模型平均器的步骤初始化为 0。
```py
state_dict()
state_dict()
```
这与`torch.optim.Optimizer` `state_dict()`相同，但添加了一个额外的条目来记录模型平均器的步骤到检查点，以确保重新加载不会导致不必要的再次热身。
```py
step()
step()
```
执行单个优化步骤（参数更新）。
```py
class torch.distributed.optim.ZeroRedundancyOptimizer(params, optimizer_class, process_group=None, parameters_as_bucket_view=False, overlap_with_ddp=False, **defaults)
class torch.distributed.optim.ZeroRedundancyOptimizer(params, optimizer_class, process_group=None, parameters_as_bucket_view=False, overlap_with_ddp=False, **defaults)
```
将任意的`optim.Optimizer`包装起来，并将其状态在组中分片。
......@@ -198,7 +198,7 @@ class torch.distributed.optim.ZeroRedundancyOptimizer(params, optimizer_class, p
ZeroRedundancyOptimizer 是实验性的，可能会发生变化。
```py
add_param_group(param_group)
add_param_group(param_group)
```
向`Optimizer`的`param_groups`添加一个参数组。
......@@ -214,7 +214,7 @@ add_param_group(param_group)¶
此方法处理所有分区上的碎片更新，但需要在所有等级上调用。在部分等级上调用此方法将导致训练挂起，因为通信原语是根据受管理的参数调用的，并且期望所有等级参与相同的参数集。
```py
consolidate_state_dict(to=0)
consolidate_state_dict(to=0)
```
在目标等级上合并`state_dict`列表（每个等级一个）。
......@@ -232,13 +232,13 @@ consolidate_state_dict(to=0)¶
这需要在所有等级上调用。
```py
property join_device: device
property join_device: device
```
返回默认设备。
```py
join_hook(**kwargs)
join_hook(**kwargs)
```
返回 ZeRO 连接钩子。
......@@ -254,13 +254,13 @@ join_hook(**kwargs)¶
此钩子不支持任何关键字参数；即`kwargs`未使用。
```py
property join_process_group: Any
property join_process_group: Any
```
返回进程组。
```py
load_state_dict(state_dict)
load_state_dict(state_dict)
```
从输入`state_dict`中加载与给定等级相关的状态，根据需要更新本地优化器。
......@@ -274,7 +274,7 @@ load_state_dict(state_dict)¶
[**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError) - 如果`overlap_with_ddp=True`，并且在此`ZeroRedundancyOptimizer`实例完全初始化之前调用此方法，这会在`DistributedDataParallel`梯度桶被重建后发生。
```py
state_dict()
state_dict()
```
返回此等级已知的最后一个全局优化器状态。
......@@ -288,7 +288,7 @@ state_dict()¶
[*字典*](https://docs.python.org/3/library/typing.html#typing.Dict "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), [*任意*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)")]
```py
step(closure=None, **kwargs)
step(closure=None, **kwargs)
```
执行单个优化器步骤并同步所有排名的参数。
......
totrans/doc22_051.md
浏览文件 @ 1efc722b
......@@ -11,7 +11,7 @@
使用张量并行并行化您的`nn.Module`的入口点是：
```py
torch.distributed.tensor.parallel.parallelize_module(module, device_mesh, parallelize_plan, tp_mesh_dim=0)
torch.distributed.tensor.parallel.parallelize_module(module, device_mesh, parallelize_plan, tp_mesh_dim=0)
```
通过根据用户指定的计划并行化模块或子模块来应用 PyTorch 中的张量并行。
......@@ -60,7 +60,7 @@ torch.distributed.tensor.parallel.parallelize_module(module, device_mesh, parall
张量并行支持以下并行样式：
```py
class torch.distributed.tensor.parallel.ColwiseParallel(*, input_layouts=None, output_layouts=None, use_local_output=True)
class torch.distributed.tensor.parallel.ColwiseParallel(*, input_layouts=None, output_layouts=None, use_local_output=True)
```
以行方式对兼容的 nn.Module 进行分区。目前支持 nn.Linear 和 nn.Embedding。用户可以将其与 RowwiseParallel 组合在一起，以实现更复杂模块的分片（即 MLP、Attention）
......@@ -98,7 +98,7 @@ class torch.distributed.tensor.parallel.ColwiseParallel(*, input_layouts=None, o
默认情况下，如果未指定`output_layouts`，则`ColwiseParallel`输出在最后一个维度上进行分片，如果有需要特定张量形状的运算符（即在配对的`RowwiseParallel`之前），请记住，如果输出被分片，运算符可能需要调整为分片大小。
```py
class torch.distributed.tensor.parallel.RowwiseParallel(*, input_layouts=None, output_layouts=None, use_local_output=True)
class torch.distributed.tensor.parallel.RowwiseParallel(*, input_layouts=None, output_layouts=None, use_local_output=True)
```
将兼容的 nn.Module 按行划分。目前仅支持 nn.Linear。用户可以将其与 ColwiseParallel 组合，以实现更复杂模块的分片（即 MLP，Attention）
......@@ -134,7 +134,7 @@ class torch.distributed.tensor.parallel.RowwiseParallel(*, input_layouts=None, o
要简单配置 nn.Module 的输入和输出以及执行必要的布局重分配，而不将模块参数分发到 DTensors，可以在`parallelize_module`的`parallelize_plan`中使用以下类：
```py
class torch.distributed.tensor.parallel.PrepareModuleInput(*, input_layouts, desired_input_layouts, use_local_output=False)
class torch.distributed.tensor.parallel.PrepareModuleInput(*, input_layouts, desired_input_layouts, use_local_output=False)
```
根据`input_layouts`配置 nn.Module 的输入，根据`desired_input_layouts`执行布局重分配，将 nn.Module 的输入张量转换为 DTensors。
......@@ -171,7 +171,7 @@ class torch.distributed.tensor.parallel.PrepareModuleInput(*, input_layouts, des
```
```py
class torch.distributed.tensor.parallel.PrepareModuleOutput(*, output_layouts, desired_output_layouts, use_local_output=True)
class torch.distributed.tensor.parallel.PrepareModuleOutput(*, output_layouts, desired_output_layouts, use_local_output=True)
```
根据`output_layouts`配置 nn.Module 的输出，根据`desired_output_layouts`执行布局重分配，将 nn.Module 的输出张量转换为 DTensors。
......
totrans/doc22_052.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_053.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_057.md
浏览文件 @ 1efc722b
......@@ -5,7 +5,7 @@
此软件包提供了一个`Future`类型，封装了异步执行和一组实用函数，以简化对`Future`对象的操作。目前，`Future`类型主要由分布式 RPC 框架使用。
```py
class torch.futures.Future(*, devices=None)
class torch.futures.Future(*, devices=None)
```
封装了对可调用对象的异步执行的`torch._C.Future`的包装器，例如`rpc_async()`。它还公开了一组 API 来添加回调函数和设置结果。
......@@ -15,7 +15,7 @@ class torch.futures.Future(*, devices=None)¶
GPU 支持是一个测试功能，可能会发生变化。
```py
add_done_callback(callback)
add_done_callback(callback)
```
将给定的回调函数附加到此`Future`，当`Future`完成时将运行该回调。可以向同一个`Future`添加多个回调，但不能保证它们将以何种顺序执行。回调必须接受一个参数，即对此`Future`的引用。回调函数可以使用`value()`方法获取值。请注意，如果此`Future`已经完成，给定的回调将内联运行。
......@@ -46,7 +46,7 @@ This will run after the future has finished.
```
```py
done()
done()
```
如果此`Future`已完成，则返回`True`。如果`Future`有结果或异常，则已完成。
......@@ -58,7 +58,7 @@ done()¶
[bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")
```py
set_exception(result)
set_exception(result)
```
为此`Future`设置异常，这将标记此`Future`为已完成并触发所有附加的回调。请注意，当在此`Future`上调用 wait()/value()时，此处设置的异常将内联引发。
......@@ -79,7 +79,7 @@ ValueError: foo
```
```py
set_result(result)
set_result(result)
```
设置此`Future`的结果，这将标记此`Future`为已完成并触发所有附加的回调。请注意，`Future`不能被标记为已完成两次。
......@@ -110,7 +110,7 @@ tensor([3., 3.])
```
```py
then(callback)
then(callback)
```
将给定的回调函数附加到此`Future`，当`Future`完成时将运行该回调函数。可以向同一个`Future`添加多个回调，但不能保证它们将按照特定顺序执行（要强制执行特定顺序，请考虑链接：`fut.then(cb1).then(cb2)`）。回调函数必须接受一个参数，即对此`Future`的引用。回调函数可以使用`value()`方法获取值。请注意，如果此`Future`已经完成，给定的回调将立即内联运行。
......@@ -153,7 +153,7 @@ Chained cb done. None
```
```py
value()
value()
```
获取已完成 future 的值。
......@@ -171,7 +171,7 @@ value()¶
*T*
```py
wait()
wait()
```
阻塞，直到此`Future`的值准备就绪。
......@@ -187,7 +187,7 @@ wait()¶
*T*
```py
torch.futures.collect_all(futures)
torch.futures.collect_all(futures)
```
将提供的`Future`对象收集到一个单独的组合`Future`中，当所有子 Future 完成时，该组合 Future 完成。
......@@ -220,7 +220,7 @@ fut1 result = 1
```
```py
torch.futures.wait_all(futures)
torch.futures.wait_all(futures)
```
等待所有提供的 Futures 完成，并返回已完成值的列表。如果任何 Future 遇到错误，该方法将提前退出并报告错误，不等待其他 Futures 完成。
......
totrans/doc22_058.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_059.md
浏览文件 @ 1efc722b
......@@ -69,7 +69,7 @@ if pretrained:
Pytorch Hub 提供了方便的 API，通过`torch.hub.list()`来探索 hub 中所有可用的模型，通过`torch.hub.help()`显示文档字符串和示例，以及使用`torch.hub.load()`加载预训练模型。
```py
torch.hub.list(github, force_reload=False, skip_validation=False, trust_repo=None)
torch.hub.list(github, force_reload=False, skip_validation=False, trust_repo=None)
```
列出由`github`指定的存储库中可调用的所有入口点。
......@@ -111,7 +111,7 @@ torch.hub.list(github, force_reload=False, skip_validation=False, trust_repo=Non
```
```py
torch.hub.help(github, model, force_reload=False, skip_validation=False, trust_repo=None)
torch.hub.help(github, model, force_reload=False, skip_validation=False, trust_repo=None)
```
显示入口点`model`的文档字符串。
......@@ -147,7 +147,7 @@ torch.hub.help(github, model, force_reload=False, skip_validation=False, trust_r
```
```py
torch.hub.load(repo_or_dir, model, *args, source='github', trust_repo=None, force_reload=False, verbose=True, skip_validation=False, **kwargs)
torch.hub.load(repo_or_dir, model, *args, source='github', trust_repo=None, force_reload=False, verbose=True, skip_validation=False, **kwargs)
```
从 github 存储库或本地目录加载模型。
......@@ -206,7 +206,7 @@ torch.hub.load(repo_or_dir, model, *args, source='github', trust_repo=None, forc
```
```py
torch.hub.download_url_to_file(url, dst, hash_prefix=None, progress=True)
torch.hub.download_url_to_file(url, dst, hash_prefix=None, progress=True)
```
- 将给定 URL 处的对象下载到本地路径。
......@@ -228,7 +228,7 @@ torch.hub.download_url_to_file(url, dst, hash_prefix=None, progress=True)¶
```
```py
torch.hub.load_state_dict_from_url(url, model_dir=None, map_location=None, progress=True, check_hash=False, file_name=None, weights_only=False)
torch.hub.load_state_dict_from_url(url, model_dir=None, map_location=None, progress=True, check_hash=False, file_name=None, weights_only=False)
```
- 加载给定 URL 处的 Torch 序列化对象。
......@@ -286,7 +286,7 @@ torch.hub.load_state_dict_from_url(url, model_dir=None, map_location=None, progr
+ `~/.cache/torch/hub`
```py
torch.hub.get_dir()
torch.hub.get_dir()
```
获取用于存储下载模型和权重的 Torch Hub 缓存目录。
......@@ -294,7 +294,7 @@ torch.hub.get_dir()¶
如果未调用`set_dir()`，默认路径为`$TORCH_HOME/hub`，其中环境变量`$TORCH_HOME`默认为`$XDG_CACHE_HOME/torch`。`$XDG_CACHE_HOME`遵循 Linux 文件系统布局的 X Design Group 规范，如果未设置环境变量，则默认值为`~/.cache`。
```py
torch.hub.set_dir(d)
torch.hub.set_dir(d)
```
可选设置用于保存下载模型和权重的 Torch Hub 目录。
......
totrans/doc22_060.md
浏览文件 @ 1efc722b
......@@ -569,7 +569,7 @@ my_scripted_model = torch.jit.script(my_model)
当传递给`torch.jit.script`函数时，`torch.nn.Module`的数据会被复制到一个`ScriptModule`中，TorchScript 编译器会编译该模块。模块的`forward`默认被编译。从`forward`调用的方法会按照它们在`forward`中被使用的顺序进行延迟编译，以及任何`@torch.jit.export`方法。
```py
torch.jit.export(fn)
torch.jit.export(fn)
```
这个装饰器表示`nn.Module`上的一个方法被用作进入`ScriptModule`的入口点，并且应该被编译。
......
totrans/doc22_062.md
浏览文件 @ 1efc722b
......@@ -17,7 +17,7 @@
## API 参考
```py
class torch.monitor.Aggregation
class torch.monitor.Aggregation
```
> 这些是可用于累积统计数据的聚合类型。
......@@ -49,11 +49,11 @@ class torch.monitor.Aggregation¶
> MIN 返回添加值的最小值。
```py
property name
property name
```
```py
class torch.monitor.Stat
class torch.monitor.Stat
```
Stat 用于以高效的方式在固定间隔内计算摘要统计信息。Stat 每隔`window_size`持续时间记录一次统计信息作为事件。当窗口关闭时，统计信息将通过事件处理程序作为`torch.monitor.Stat`事件记录。
......@@ -65,43 +65,43 @@ Stat 用于以高效的方式在固定间隔内计算摘要统计信息。Stat
当 Stat 被销毁时，即使窗口尚未过去，也会记录任何剩余数据。
```py
__init__(self: torch._C._monitor.Stat, name: str, aggregations: List[torch._C._monitor.Aggregation], window_size: datetime.timedelta, max_samples: int = 9223372036854775807) → None
__init__(self: torch._C._monitor.Stat, name: str, aggregations: List[torch._C._monitor.Aggregation], window_size: datetime.timedelta, max_samples: int = 9223372036854775807) → None
```
构造`Stat`。
```py
add(self: torch._C._monitor.Stat, v: float) → None
add(self: torch._C._monitor.Stat, v: float) → None
```
将一个值添加到要根据配置的统计类型和聚合进行聚合的统计数据中。
```py
property count
property count
```
当前已收集的数据点数量。一旦事件已记录，将重置。
```py
get(self: torch._C._monitor.Stat) → Dict[torch._C._monitor.Aggregation, float]
get(self: torch._C._monitor.Stat) → Dict[torch._C._monitor.Aggregation, float]
```
返回统计数据的当前值，主要用于测试目的。如果统计数据已记录且未添加任何额外值，则该值将为零。
```py
property name
property name
```
在创建时设置的统计名称。
```py
class torch.monitor.data_value_t
class torch.monitor.data_value_t
```
data_value_t 是`str`、`float`、`int`、`bool`之一。
```py
class torch.monitor.Event
class torch.monitor.Event
```
Event 表示要记录的特定类型事件。这可以表示每个时代的损失或准确性等高级数据点，或者通过此库提供的统计数据进行更低级别的聚合。
......@@ -109,37 +109,37 @@ Event 表示要记录的特定类型事件。这可以表示每个时代的损
所有相同类型的事件应具有相同的名称，以便下游处理程序可以正确处理它们。
```py
__init__(self: torch._C._monitor.Event, name: str, timestamp: datetime.datetime, data: Dict[str, data_value_t]) → None
__init__(self: torch._C._monitor.Event, name: str, timestamp: datetime.datetime, data: Dict[str, data_value_t]) → None
```
构造`Event`。
```py
property data
property data
```
包含在`Event`中的结构化数据。
```py
property name
property name
```
`Event`的名称。
```py
property timestamp
property timestamp
```
事件发生时的时间戳。
```py
class torch.monitor.EventHandlerHandle
class torch.monitor.EventHandlerHandle
```
EventHandlerHandle 是由`register_event_handler`返回的包装类型，用于通过`unregister_event_handler`取消注册处理程序。不能直接初始化。
```py
torch.monitor.log_event(event: torch._C._monitor.Event) → None
torch.monitor.log_event(event: torch._C._monitor.Event) → None
```
log_event 将指定的事件记录到所有已注册的事件处理程序中。由事件处理程序负责将事件记录到相应的事件接收器。
......@@ -147,19 +147,19 @@ log_event 将指定的事件记录到所有已注册的事件处理程序中。
如果没有注册事件处理程序，则此方法不执行任何操作。
```py
torch.monitor.register_event_handler(callback: Callable[[torch._C._monitor.Event], None]) → torch._C._monitor.EventHandlerHandle
torch.monitor.register_event_handler(callback: Callable[[torch._C._monitor.Event], None]) → torch._C._monitor.EventHandlerHandle
```
register_event_handler 注册一个回调，每当通过`log_event`记录事件时都会调用该回调。这些处理程序应避免阻塞主线程，因为这可能会干扰训练，因为它们在`log_event`调用期间运行。
```py
torch.monitor.unregister_event_handler(handler: torch._C._monitor.EventHandlerHandle) → None
torch.monitor.unregister_event_handler(handler: torch._C._monitor.EventHandlerHandle) → None
```
unregister_event_handler 取消注册在调用`register_event_handler`后返回的`EventHandlerHandle`。完成后，事件处理程序将不再接收事件。
```py
class torch.monitor.TensorboardEventHandler(writer)
class torch.monitor.TensorboardEventHandler(writer)
```
TensorboardEventHandler 是一个事件处理程序，将已知事件写入提供的 SummaryWriter。
......@@ -176,7 +176,7 @@ TensorboardEventHandler 是一个事件处理程序，将已知事件写入提
```
```py
__init__(writer)
__init__(writer)
```
构造`TensorboardEventHandler`。
totrans/doc22_064.md
浏览文件 @ 1efc722b
......@@ -7,7 +7,7 @@ torch.special 模块，模仿 SciPy 的[special](https://docs.scipy.org/doc/scip
## 函数
```py
torch.special.airy_ai(input, *, out=None) → Tensor
torch.special.airy_ai(input, *, out=None) → Tensor
```
Airy 函数$\text{Ai}\left(\text{input}\right)$。
......@@ -21,7 +21,7 @@ Airy 函数$\text{Ai}\left(\text{input}\right)$。
- 输出张量（可选）- 输出张量。
```py
torch.special.bessel_j0(input, *, out=None) → Tensor
torch.special.bessel_j0(input, *, out=None) → Tensor
```
第一类贝塞尔函数的阶数为$0$。
......@@ -35,7 +35,7 @@ torch.special.bessel_j0(input, *, out=None) → Tensor¶
- 输出张量（可选）- 输出张量。
```py
torch.special.bessel_j1(input, *, out=None) → Tensor
torch.special.bessel_j1(input, *, out=None) → Tensor
```
第一类贝塞尔函数的阶数为$1$。
......@@ -49,7 +49,7 @@ torch.special.bessel_j1(input, *, out=None) → Tensor¶
- 输出张量（可选）- 输出张量。
```py
torch.special.digamma(input, *, out=None) → Tensor
torch.special.digamma(input, *, out=None) → Tensor
```
计算输入上的伽玛函数的对数导数。
......@@ -81,7 +81,7 @@ tensor([-0.5772, -1.9635])
```
```py
torch.special.entr(input, *, out=None) → Tensor
torch.special.entr(input, *, out=None) → Tensor
```
计算输入上的熵（如下所定义），逐元素。
......@@ -107,7 +107,7 @@ tensor([ -inf, 0.0000, 0.3466])
```
```py
torch.special.erf(input, *, out=None) → Tensor
torch.special.erf(input, *, out=None) → Tensor
```
计算输入的误差函数。误差函数定义如下：
......@@ -130,7 +130,7 @@ tensor([ 0.0000, -0.8427, 1.0000])
```
```py
torch.special.erfc(input, *, out=None) → Tensor
torch.special.erfc(input, *, out=None) → Tensor
```
计算输入的互补误差函数。互补误差函数定义如下：
......@@ -153,7 +153,7 @@ tensor([ 1.0000, 1.8427, 0.0000])
```
```py
torch.special.erfcx(input, *, out=None) → Tensor
torch.special.erfcx(input, *, out=None) → Tensor
```
计算输入的每个元素的缩放互补误差函数。缩放互补误差函数定义如下：
......@@ -176,7 +176,7 @@ tensor([ 1.0000, 5.0090, 0.0561])
```
```py
torch.special.erfinv(input, *, out=None) → Tensor
torch.special.erfinv(input, *, out=None) → Tensor
```
计算输入的逆误差函数。逆误差函数在范围$(-1, 1)$内定义如下：
......@@ -199,7 +199,7 @@ tensor([ 0.0000, 0.4769, -inf])
```
```py
torch.special.exp2(input, *, out=None) → Tensor
torch.special.exp2(input, *, out=None) → Tensor
```
计算输入的以 2 为底的指数函数。
......@@ -222,7 +222,7 @@ tensor([ 1., 2., 8., 16.])
```
```py
torch.special.expit(input, *, out=None) → Tensor
torch.special.expit(input, *, out=None) → Tensor
```
计算`input`元素的 expit（也称为逻辑 Sigmoid 函数）。
......@@ -248,7 +248,7 @@ tensor([ 0.7153, 0.7481, 0.2920, 0.1458])
```
```py
torch.special.expm1(input, *, out=None) → Tensor
torch.special.expm1(input, *, out=None) → Tensor
```
计算`input`元素减 1 的指数。
......@@ -275,7 +275,7 @@ tensor([ 0., 1.])
```
```py
torch.special.gammainc(input, other, *, out=None) → Tensor
torch.special.gammainc(input, other, *, out=None) → Tensor
```
计算正则化的下不完全伽玛函数：
......@@ -317,7 +317,7 @@ tensor([1., 1., 1.])
```
```py
torch.special.gammaincc(input, other, *, out=None) → Tensor
torch.special.gammaincc(input, other, *, out=None) → Tensor
```
计算正则化的上不完全伽玛函数：
......@@ -358,7 +358,7 @@ tensor([1., 1., 1.])
```
```py
torch.special.gammaln(input, *, out=None) → Tensor
torch.special.gammaln(input, *, out=None) → Tensor
```
计算`input`上伽玛函数绝对值的自然对数。
......@@ -382,7 +382,7 @@ tensor([ 0.5724, 0.0000, -0.1208])
```
```py
torch.special.i0(input, *, out=None) → Tensor
torch.special.i0(input, *, out=None) → Tensor
```
计算每个`input`元素的第零阶修正贝塞尔函数（如下所定义）。
......@@ -405,7 +405,7 @@ tensor([ 1.0000, 1.2661, 2.2796, 4.8808, 11.3019])
```
```py
torch.special.i0e(input, *, out=None) → Tensor
torch.special.i0e(input, *, out=None) → Tensor
```
计算每个`input`元素的指数缩放的第零阶修正贝塞尔函数（如下所定义）。
......@@ -428,7 +428,7 @@ tensor([1.0000, 0.4658, 0.3085, 0.2430, 0.2070])
```
```py
torch.special.i1(input, *, out=None) → Tensor
torch.special.i1(input, *, out=None) → Tensor
```
计算每个`input`元素的第一类修正贝塞尔函数（如下所定义）。
......@@ -451,7 +451,7 @@ tensor([0.0000, 0.5652, 1.5906, 3.9534, 9.7595])
```
```py
torch.special.i1e(input, *, out=None) → Tensor
torch.special.i1e(input, *, out=None) → Tensor
```
计算每个`input`元素的指数缩放的第一类修正贝塞尔函数（如下所定义）。
......@@ -474,13 +474,13 @@ tensor([0.0000, 0.2079, 0.2153, 0.1968, 0.1788])
```
```py
torch.special.log1p(input, *, out=None) → Tensor
torch.special.log1p(input, *, out=None) → Tensor
```
`torch.log1p()`的别名。
```py
torch.special.log_ndtr(input, *, out=None) → Tensor
torch.special.log_ndtr(input, *, out=None) → Tensor
```
计算标准高斯概率密度函数下面积的对数，从负无穷到`input`，逐元素。
......@@ -503,7 +503,7 @@ tensor([-6.6077 -3.7832 -1.841 -0.6931 -0.1728 -0.023 -0.0014])
```
```py
torch.special.log_softmax(input, dim, *, dtype=None) → Tensor
torch.special.log_softmax(input, dim, *, dtype=None) → Tensor
```
计算 softmax 后跟对数。
......@@ -530,7 +530,7 @@ tensor([[-0.6931, -0.6931],
```
```py
torch.special.logit(input, eps=None, *, out=None) → Tensor
torch.special.logit(input, eps=None, *, out=None) → Tensor
```
返回一个新张量，其中包含`input`元素的 logit。当 eps 不为 None 时，`input`被夹在[eps, 1 - eps]之间。当 eps 为 None 且`input` < 0 或`input` > 1 时，函数将产生 NaN。
......@@ -556,13 +556,13 @@ tensor([-0.9466, 2.6352, 0.6131, -1.7169, 0.6261])
```
```py
torch.special.logsumexp(input, dim, keepdim=False, *, out=None)
torch.special.logsumexp(input, dim, keepdim=False, *, out=None)
```
`torch.logsumexp()`的别名。
```py
torch.special.multigammaln(input, p, *, out=None) → Tensor
torch.special.multigammaln(input, p, *, out=None) → Tensor
```
计算多元对数伽玛函数，维度为$p$，逐元素给出
......@@ -594,7 +594,7 @@ tensor([[0.3928, 0.4007, 0.7586],
```
```py
torch.special.ndtr(input, *, out=None) → Tensor
torch.special.ndtr(input, *, out=None) → Tensor
```
计算标准高斯概率密度函数下的面积，从负无穷积分到`输入`，逐元素计算。
......@@ -613,7 +613,7 @@ tensor([0.0013, 0.0228, 0.1587, 0.5000, 0.8413, 0.9772, 0.9987])
```
```py
torch.special.ndtri(input, *, out=None) → Tensor
torch.special.ndtri(input, *, out=None) → Tensor
```
计算参数$x$，使得高斯概率密度函数下的面积（从负无穷积分到 x）等于`输入`，逐元素计算。
......@@ -636,7 +636,7 @@ tensor([ -inf, -0.6745, 0.0000, 0.6745, inf])
```
```py
torch.special.polygamma(n, input, *, out=None) → Tensor
torch.special.polygamma(n, input, *, out=None) → Tensor
```
计算`输入`上的第$n$阶 digamma 函数的导数。$n \geq 0$
......@@ -668,19 +668,19 @@ tensor([ -24.8863, -771.4742])
```
```py
torch.special.psi(input, *, out=None) → Tensor
torch.special.psi(input, *, out=None) → Tensor
```
`torch.special.digamma()`的别名。
```py
torch.special.round(input, *, out=None) → Tensor
torch.special.round(input, *, out=None) → Tensor
```
`torch.round()`的别名。
```py
torch.special.scaled_modified_bessel_k0(input, *, out=None) → Tensor
torch.special.scaled_modified_bessel_k0(input, *, out=None) → Tensor
```
第二类修正贝塞尔函数的缩放形式，阶数为$0$。
......@@ -690,7 +690,7 @@ torch.special.scaled_modified_bessel_k0(input, *, out=None) → Tensor¶
**输入**（*张量**,* *可选*）- 输出张量。
```py
torch.special.scaled_modified_bessel_k1(input, *, out=None) → Tensor
torch.special.scaled_modified_bessel_k1(input, *, out=None) → Tensor
```
第二类修正贝塞尔函数的缩放形式，阶数为$1$。
......@@ -700,7 +700,7 @@ torch.special.scaled_modified_bessel_k1(input, *, out=None) → Tensor¶
**输入**（*张量**,* *可选*） - 输出张量。
```py
torch.special.sinc(input, *, out=None) → Tensor
torch.special.sinc(input, *, out=None) → Tensor
```
计算`input`的归一化 sinc。
......@@ -726,7 +726,7 @@ tensor([ 0.9186, 0.8631, -0.0259, -0.1300])
```
```py
torch.special.softmax(input, dim, *, dtype=None) → Tensor
torch.special.softmax(input, dim, *, dtype=None) → Tensor
```
计算 softmax 函数。
......@@ -755,7 +755,7 @@ tensor([[0.5000, 0.5000],
```
```py
torch.special.spherical_bessel_j0(input, *, out=None) → Tensor
torch.special.spherical_bessel_j0(input, *, out=None) → Tensor
```
第一类零阶球贝塞尔函数。
......@@ -769,7 +769,7 @@ torch.special.spherical_bessel_j0(input, *, out=None) → Tensor¶
**out**（*Tensor**,* *可选*） - 输出张量。
```py
torch.special.xlog1py(input, other, *, out=None) → Tensor
torch.special.xlog1py(input, other, *, out=None) → Tensor
```
使用以下情况计算`input * log1p(other)`。
......@@ -810,7 +810,7 @@ tensor([2.7726, 2.1972, 1.3863])
```
```py
torch.special.xlogy(input, other, *, out=None) → Tensor
torch.special.xlogy(input, other, *, out=None) → Tensor
```
使用以下情况计算`input * log(other)`。
......@@ -851,7 +851,7 @@ tensor([2.1972, 1.3863, 0.0000])
```
```py
torch.special.zeta(input, other, *, out=None) → Tensor
torch.special.zeta(input, other, *, out=None) → Tensor
```
逐元素计算 Hurwitz zeta 函数。
......
totrans/doc22_065.md
浏览文件 @ 1efc722b
......@@ -7,7 +7,7 @@
## 函数
```py
torch.overrides.get_ignored_functions()
torch.overrides.get_ignored_functions()
```
返回不能通过`__torch_function__`覆盖的公共函数。
......@@ -30,7 +30,7 @@ False
```
```py
torch.overrides.get_overridable_functions()
torch.overrides.get_overridable_functions()
```
列出可以通过 __torch_function__ 覆盖的函数
......@@ -44,7 +44,7 @@ torch.overrides.get_overridable_functions()¶
Dict[Any, List[Callable]]
```py
torch.overrides.resolve_name(f)
torch.overrides.resolve_name(f)
```
获取传递给 __torch_function__ 的函数的人类可读字符串名称
......@@ -62,7 +62,7 @@ torch.overrides.resolve_name(f)¶
[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")
```py
torch.overrides.get_testing_overrides()
torch.overrides.get_testing_overrides()
```
返回一个包含所有可重写函数的虚拟覆盖的字典
......@@ -85,7 +85,7 @@ Dict[Callable, Callable]
```
```py
torch.overrides.handle_torch_function(public_api, relevant_args, *args, **kwargs)
torch.overrides.handle_torch_function(public_api, relevant_args, *args, **kwargs)
```
实现带有`__torch_function__`覆盖的函数。
......@@ -122,7 +122,7 @@ torch.overrides.handle_torch_function(public_api, relevant_args, *args, **kwargs
```
```py
torch.overrides.has_torch_function()
torch.overrides.has_torch_function()
```
检查可迭代对象中元素的 __torch_function__ 实现，或者是否启用了 __torch_function__ 模式。将确切的`Tensor`和`Parameter`视为不可分派。使用此功能来保护对`handle_torch_function()`的调用；不要用它来测试某物是否类似于 Tensor，而是使用`is_tensor_like()`。:param relevant_args: 要检查 __torch_function__ 方法的可迭代对象或参数。:type relevant_args: iterable
......@@ -142,7 +142,7 @@ torch.overrides.has_torch_function()¶
检查某物是否类似于 Tensor，包括确切的`Tensor`。
```py
torch.overrides.is_tensor_like(inp)
torch.overrides.is_tensor_like(inp)
```
如果传入的输入是类似于 Tensor 的，则返回`True`。
......@@ -183,7 +183,7 @@ True
```
```py
torch.overrides.is_tensor_method_or_property(func)
torch.overrides.is_tensor_method_or_property(func)
```
如果传入的函数是`torch.Tensor`的方法或属性的处理程序，则返回 True，如传入`__torch_function__`。
......@@ -212,7 +212,7 @@ False
[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")
```py
torch.overrides.wrap_torch_function(dispatcher)
torch.overrides.wrap_torch_function(dispatcher)
```
使用与`__torch_function__`相关的功能包装给定的函数。
......
totrans/doc22_066.md
浏览文件 @ 1efc722b
......@@ -697,19 +697,19 @@ print(imported_MyClass.__name__) # prints <torch_package_0>.foo.MyClass
## API 参考
```py
class torch.package.PackagingError(dependency_graph, debug=False)
class torch.package.PackagingError(dependency_graph, debug=False)
```
在导出包时出现问题时会引发此异常。`PackageExporter`将尝试收集所有错误并一次性呈现给您。
```py
class torch.package.EmptyMatchError
class torch.package.EmptyMatchError
```
当在打包过程中遇到将 mock 或 extern 标记为`allow_empty=False`，并且在打包期间未匹配到任何模块时，将引发此异常。
```py
class torch.package.PackageExporter(f, importer=<torch.package.importer._SysImporter object>, debug=False)
class torch.package.PackageExporter(f, importer=<torch.package.importer._SysImporter object>, debug=False)
```
导出器允许您将代码包、Python 数据、以及任意二进制和文本资源写入一个独立的包中。
......@@ -723,7 +723,7 @@ class torch.package.PackageExporter(f, importer=<torch.package.importer._SysImpo
当源代码添加到包中时，导出器可以选择扫描它以获取更多的代码依赖项（`dependencies=True`）。它查找导入语句，解析相对引用以获取限定模块名称，并执行用户指定的操作（参见：`extern()`，`mock()`和`intern()`).
```py
__init__(f, importer=<torch.package.importer._SysImporter object>, debug=False)
__init__(f, importer=<torch.package.importer._SysImporter object>, debug=False)
```
创建一个导出器。
......@@ -737,13 +737,13 @@ __init__(f, importer=<torch.package.importer._SysImporter object>, debug=False)
+ **debug** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果设置为 True，则将损坏模块的路径添加到 PackagingErrors 中。
```py
add_dependency(module_name, dependencies=True)
add_dependency(module_name, dependencies=True)
```
给定一个模块，根据用户指定的模式将其添加到依赖图中。
```py
all_paths(src, dst)
all_paths(src, dst)
```
返回子图的点表示
......@@ -759,7 +759,7 @@ all_paths(src, dst)¶
[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")
```py
close()
close()
```
将包写入文件系统。`close()`之后的任何调用现在都是无效的。最好使用资源保护语法：
......@@ -770,7 +770,7 @@ with PackageExporter("file.zip") as e:
```
```py
denied_modules()
denied_modules()
```
返回当前被拒绝的所有模块。
......@@ -784,7 +784,7 @@ denied_modules()¶
[*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]
```py
deny(include, *, exclude=())
deny(include, *, exclude=())
```
从包可以导入的模块列表中阻止与给定 glob 模式匹配的模块名称。如果找到任何匹配的包的依赖项，将引发`PackagingError`。
......@@ -796,7 +796,7 @@ deny(include, *, exclude=())¶
+ **exclude** (*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]*) – 一个可选模式，用于排除与包含字符串匹配的某些模式。
```py
dependency_graph_string()
dependency_graph_string()
```
返回包中依赖项的双字母字符串表示。
......@@ -810,7 +810,7 @@ dependency_graph_string()¶
[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")
```py
extern(include, *, exclude=(), allow_empty=True)
extern(include, *, exclude=(), allow_empty=True)
```
将`module`包含在包可以导入的外部模块列表中。这将阻止依赖项发现将其保存在包中。导入程序将直接从标准导入系统加载外部模块。外部模块的代码也必须存在于加载包的进程中。
......@@ -824,7 +824,7 @@ extern(include, *, exclude=(), allow_empty=True)¶
+ **allow_empty**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 一个可选标志，指定此调用`extern`方法指定的外部模块是否必须在打包过程中与某个模块匹配。如果添加了一个`allow_empty=False`的外部模块 glob 模式，并且在任何模块匹配该模式之前调用了`close()`（显式调用或通过`__exit__`），则会抛出异常。如果`allow_empty=True`，则不会抛出此类异常。
```py
externed_modules()
externed_modules()
```
返回当前所有已经 externed 的模块。
......@@ -838,7 +838,7 @@ externed_modules()¶
[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")]
```py
get_rdeps(module_name)
get_rdeps(module_name)
```
返回一个依赖于模块`module_name`的所有模块的列表。
......@@ -852,7 +852,7 @@ get_rdeps(module_name)¶
[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")]
```py
get_unique_id()
get_unique_id()
```
获取一个 id。此 id 保证仅在此包中分配一次。
......@@ -862,7 +862,7 @@ get_unique_id()¶
[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")
```py
intern(include, *, exclude=(), allow_empty=True)
intern(include, *, exclude=(), allow_empty=True)
```
指定应该打包的模块。模块必须匹配一些`intern`模式才能包含在包中，并且其依赖项会被递归处理。
......@@ -876,7 +876,7 @@ intern(include, *, exclude=(), allow_empty=True)¶
+ **allow_empty**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 一个可选标志，指定此调用`intern`方法指定的 intern 模块是否必须在打包过程中与某个模块匹配。如果添加了一个`allow_empty=False`的`intern`模块 glob 模式，并且在任何模块匹配该模式之前调用了`close()`（显式调用或通过`__exit__`），则会抛出异常。如果`allow_empty=True`，则不会抛出此类异常。
```py
interned_modules()
interned_modules()
```
返回当前所有已经 interned 的模块。
......@@ -890,7 +890,7 @@ interned_modules()¶
[*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]
```py
mock(include, *, exclude=(), allow_empty=True)
mock(include, *, exclude=(), allow_empty=True)
```
用模拟实现替换一些必需的模块。模拟的模块将为从中访问的任何属性返回一个虚假对象。因为我们是逐个文件复制的，所以依赖关系解析有时会找到由模型文件导入但其功能从未被使用的文件（例如自定义序列化代码或训练助手）。使用此函数可以模拟此功能，而无需修改原始代码。
......@@ -912,7 +912,7 @@ mock(include, *, exclude=(), allow_empty=True)¶
+ **allow_empty**（*bool*）- 一个可选标志，指定此调用`mock()`方法指定的模拟实现是否在打包期间必须与某个模块匹配。如果使用`allow_empty=False`添加了一个模拟，并且调用了`close()`（显式调用或通过`__exit__`），并且该模拟未与要导出的包使用的模块匹配，则会抛出异常。如果`allow_empty=True`，则不会抛出此类异常。
```py
mocked_modules()
mocked_modules()
```
返回当前模拟的所有模块。
......@@ -926,7 +926,7 @@ mocked_modules()¶
[*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]
```py
register_extern_hook(hook)
register_extern_hook(hook)
```
在导出器上注册一个 extern 钩子。
......@@ -948,7 +948,7 @@ hook(exporter: PackageExporter, module_name: str) -> None
`torch.utils.hooks.RemovableHandle`
```py
register_intern_hook(hook)
register_intern_hook(hook)
```
在导出器上注册一个 intern 钩子。
......@@ -970,7 +970,7 @@ hook(exporter: PackageExporter, module_name: str) -> None
`torch.utils.hooks.RemovableHandle`
```py
register_mock_hook(hook)
register_mock_hook(hook)
```
在导出器上注册一个模拟钩子。
......@@ -992,7 +992,7 @@ hook(exporter: PackageExporter, module_name: str) -> None
`torch.utils.hooks.RemovableHandle`
```py
save_binary(package, resource, binary)
save_binary(package, resource, binary)
```
将原始字节保存到包中。
......@@ -1006,7 +1006,7 @@ save_binary(package, resource, binary)¶
+ **二进制**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 要保存的数据。
```py
save_module(module_name, dependencies=True)
save_module(module_name, dependencies=True)
```
将`module`的代码保存到包中。使用`importers`路径解析模块对象的代码，然后使用其`__file__`属性查找源代码。
......@@ -1018,7 +1018,7 @@ save_module(module_name, dependencies=True)¶
+ **依赖项**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，可选） - 如果为`True`，我们会扫描源代码以查找依赖项。
```py
save_pickle(package, resource, obj, dependencies=True, pickle_protocol=3)
save_pickle(package, resource, obj, dependencies=True, pickle_protocol=3)
```
使用 pickle 将 Python 对象保存到存档中。相当于`torch.save()`，但保存到存档而不是独立文件。标准 pickle 不保存代码，只保存对象。如果`dependencies`为 true，则此方法还将扫描 pickled 对象以确定重建它们所需的模块，并保存相关代码。
......@@ -1036,7 +1036,7 @@ save_pickle(package, resource, obj, dependencies=True, pickle_protocol=3)¶
+ **依赖项**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，可选） - 如果为`True`，我们会扫描源代码以查找依赖项。
```py
save_source_file(module_name, file_or_directory, dependencies=True)
save_source_file(module_name, file_or_directory, dependencies=True)
```
将本地文件系统中的`file_or_directory`添加到源包中，以提供`module_name`的代码。
......@@ -1050,7 +1050,7 @@ save_source_file(module_name, file_or_directory, dependencies=True)¶
+ **依赖项**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，可选） - 如果为`True`，我们会扫描源代码以查找依赖项。
```py
save_source_string(module_name, src, is_package=False, dependencies=True)
save_source_string(module_name, src, is_package=False, dependencies=True)
```
在导出的包中将`src`作为`module_name`的源代码添加。
......@@ -1066,7 +1066,7 @@ save_source_string(module_name, src, is_package=False, dependencies=True)¶
+ **依赖**（*bool*，可选）- 如果为`True`，我们会扫描源代码以获取依赖项。
```py
save_text(package, resource, text)
save_text(package, resource, text)
```
将文本数据保存到包中。
......@@ -1080,7 +1080,7 @@ save_text(package, resource, text)¶
+ **text**（*str*）- 要保存的内容。
```py
class torch.package.PackageImporter(file_or_buffer, module_allowed=<function PackageImporter.<lambda>>)
class torch.package.PackageImporter(file_or_buffer, module_allowed=<function PackageImporter.<lambda>>)
```
导入器允许您加载由`PackageExporter`编写的包中的代码。代码以封闭方式加载，使用包中的文件而不是正常的 python 导入系统。这允许将 PyTorch 模型代码和数据打包，以便在服务器上运行或在将来用于迁移学习。
......@@ -1088,7 +1088,7 @@ class torch.package.PackageImporter(file_or_buffer, module_allowed=<function Pac
包的导入器确保模块中的代码只能从包内加载，除了在导出期间明确列出为外部模块的模块。zip 存档中的`extern_modules`文件列出了包在外部依赖的所有模块。这可以防止“隐式”依赖，其中包在本地运行，因为它正在导入一个本地安装的包，但是当包被复制到另一台机器时会失败。
```py
__init__(file_or_buffer, module_allowed=<function PackageImporter.<lambda>>)
__init__(file_or_buffer, module_allowed=<function PackageImporter.<lambda>>)
```
打开`file_or_buffer`以进行导入。这将检查导入的包是否仅需要`module_allowed`允许的模块。
......@@ -1104,7 +1104,7 @@ __init__(file_or_buffer, module_allowed=<function PackageImporter.<lambda>>)¶
[**ImportError**](https://docs.python.org/3/library/exceptions.html#ImportError "(in Python v3.12)")- 如果包将使用不允许的模块。
```py
file_structure(*, include='**', exclude=())
file_structure(*, include='**', exclude=())
```
返回包的 zip 文件结构表示。
......@@ -1124,7 +1124,7 @@ file_structure(*, include='**', exclude=())¶
*Directory*
```py
id()
id()
```
返回内部标识符，torch.package 用于区分 `PackageImporter` 实例。看起来像：
......@@ -1134,7 +1134,7 @@ id()¶
```
```py
import_module(name, package=None)
import_module(name, package=None)
```
如果尚未加载包中的模块，则加载该模块，然后返回模块。模块在导入程序本地加载，并将出现在 `self.modules` 而不是 `sys.modules` 中。
......@@ -1154,7 +1154,7 @@ import_module(name, package=None)¶
[types.ModuleType](https://docs.python.org/3/library/types.html#types.ModuleType "(in Python v3.12)")
```py
load_binary(package, resource)
load_binary(package, resource)
```
加载原始字节。
......@@ -1174,7 +1174,7 @@ load_binary(package, resource)¶
[bytes](https://docs.python.org/3/library/stdtypes.html#bytes "(in Python v3.12)")
```py
load_pickle(package, resource, map_location=None)
load_pickle(package, resource, map_location=None)
```
从包中反序列化资源，加载任何需要构造对象的模块，使用 `import_module()`。
......@@ -1196,7 +1196,7 @@ load_pickle(package, resource, map_location=None)¶
任何
```py
load_text(package, resource, encoding='utf-8', errors='strict')
load_text(package, resource, encoding='utf-8', errors='strict')
```
加载字符串。
......@@ -1220,7 +1220,7 @@ load_text(package, resource, encoding='utf-8', errors='strict')¶
[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")
```py
python_version()
python_version()
```
返回用于创建此包的 python 版本。
......@@ -1232,13 +1232,13 @@ python_version()¶
`Optional[str]` 一个 python 版本，例如 3.8.9，如果没有存储与此包相关的版本，则为 None
```py
class torch.package.Directory(name, is_dir)
class torch.package.Directory(name, is_dir)
```
文件结构表示。组织为具有其 Directory 子节点列表的 Directory 节点。通过调用 `PackageImporter.file_structure()` 来创建包的目录。
```py
has_file(filename)
has_file(filename)
```
检查文件是否存在于 `Directory` 中。
......
totrans/doc22_067.md
浏览文件 @ 1efc722b
......@@ -13,7 +13,7 @@ PyTorch Profiler 是一个工具，允许在训练和推断过程中收集性能
## API 参考
```py
class torch.profiler._KinetoProfile(*, activities=None, record_shapes=False, profile_memory=False, with_stack=False, with_flops=False, with_modules=False, experimental_config=None)
class torch.profiler._KinetoProfile(*, activities=None, record_shapes=False, profile_memory=False, with_stack=False, with_flops=False, with_modules=False, experimental_config=None)
```
低级别分析器包装自动梯度分析
......@@ -41,31 +41,31 @@ class torch.profiler._KinetoProfile(*, activities=None, record_shapes=False, pro
启用形状和堆栈跟踪会导致额外的开销。当指定 record_shapes=True 时，分析器将暂时保留对张量的引用；这可能进一步阻止依赖引用计数的某些优化，并引入额外的张量副本。
```py
add_metadata(key, value)
add_metadata(key, value)
```
向跟踪文件中添加具有字符串键和字符串值的用户定义的元数据
```py
add_metadata_json(key, value)
add_metadata_json(key, value)
```
向跟踪文件中添加具有字符串键和有效 json 值的用户定义的元数据
```py
events()
events()
```
返回未聚合的分析器事件列表，用于在跟踪回调中使用或在分析完成后使用
```py
export_chrome_trace(path)
export_chrome_trace(path)
```
以 Chrome JSON 格式导出收集的跟踪信息。
```py
export_memory_timeline(path, device=None)
export_memory_timeline(path, device=None)
```
从收集的树中导出分析器的内存事件信息，用于给定设备，并导出时间线图。使用`export_memory_timeline`有 3 个可导出的文件，每个文件由`path`的后缀控制。
......@@ -79,7 +79,7 @@ export_memory_timeline(path, device=None)¶
输出：内存时间线以 gzipped JSON、JSON 或 HTML 形式编写。
```py
export_stacks(path, metric='self_cpu_time_total')
export_stacks(path, metric='self_cpu_time_total')
```
将堆栈跟踪保存在适合可视化的文件中。
......@@ -101,7 +101,7 @@ export_stacks(path, metric='self_cpu_time_total')¶
+ ./flamegraph.pl –title “CPU time” –countname “us.” profiler.stacks > perf_viz.svg
```py
key_averages(group_by_input_shape=False, group_by_stack_n=0)
key_averages(group_by_input_shape=False, group_by_stack_n=0)
```
通过运算符名称和（可选）输入形状和堆栈对事件进行平均分组。
......@@ -111,7 +111,7 @@ key_averages(group_by_input_shape=False, group_by_stack_n=0)¶
要使用形状/堆栈功能，请确保在创建分析器上下文管理器时设置 record_shapes/with_stack。
```py
class torch.profiler.profile(*, activities=None, schedule=None, on_trace_ready=None, record_shapes=False, profile_memory=False, with_stack=False, with_flops=False, with_modules=False, experimental_config=None, use_cuda=None)
class torch.profiler.profile(*, activities=None, schedule=None, on_trace_ready=None, record_shapes=False, profile_memory=False, with_stack=False, with_flops=False, with_modules=False, experimental_config=None, use_cuda=None)
```
分析器上下文管理器。
......@@ -215,19 +215,19 @@ with torch.profiler.profile(
```
```py
step()
step()
```
信号分析器下一个分析步骤已经开始。
```py
class torch.profiler.ProfilerAction(value)
class torch.profiler.ProfilerAction(value)
```
在指定间隔可以执行的分析器操作
```py
class torch.profiler.ProfilerActivity
class torch.profiler.ProfilerActivity
```
成员：
......@@ -241,11 +241,11 @@ MTIA
CUDA
```py
property name
property name
```
```py
torch.profiler.schedule(*, wait, warmup, active, repeat=0, skip_first=0)
torch.profiler.schedule(*, wait, warmup, active, repeat=0, skip_first=0)
```
返回一个可用作分析器`schedule`参数的可调用对象。分析器将跳过前`skip_first`步，然后等待`wait`步，然后为接下来的`warmup`步进行预热，然后为接下来的`active`步进行活动记录，然后重复以`wait`步开始的循环。循环的可选次数由`repeat`参数指定，零值表示循环将持续直到分析完成。
......@@ -255,7 +255,7 @@ torch.profiler.schedule(*, wait, warmup, active, repeat=0, skip_first=0)¶
[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在 Python v3.12 中)")
```py
torch.profiler.tensorboard_trace_handler(dir_name, worker_name=None, use_gzip=False)
torch.profiler.tensorboard_trace_handler(dir_name, worker_name=None, use_gzip=False)
```
将跟踪文件输出到`dir_name`目录，然后该目录可以直接作为 logdir 传递给 tensorboard。在分布式场景中，`worker_name`应该对每个 worker 是唯一的，默认情况下将设置为‘[hostname]_[pid]’。
......@@ -263,13 +263,13 @@ torch.profiler.tensorboard_trace_handler(dir_name, worker_name=None, use_gzip=Fa
## 英特尔仪器和跟踪技术 APIs[](#intel-instrumentation-and-tracing-technology-apis "跳转到此标题")
```py
torch.profiler.itt.is_available()
torch.profiler.itt.is_available()
```
检查 ITT 功能是否可用
```py
torch.profiler.itt.mark(msg)
torch.profiler.itt.mark(msg)
```
描述在某个时间点发生的瞬时事件。
......@@ -279,7 +279,7 @@ torch.profiler.itt.mark(msg)¶
**msg** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 与事件关联的 ASCII 消息。
```py
torch.profiler.itt.range_push(msg)
torch.profiler.itt.range_push(msg)
```
将范围推送到嵌套范围堆栈上。返回开始的范围的从零开始的深度。
......@@ -289,7 +289,7 @@ torch.profiler.itt.range_push(msg)¶
**msg** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 与范围关联的 ASCII 消息
```py
torch.profiler.itt.range_pop()
torch.profiler.itt.range_pop()
```
从嵌套范围跨度堆栈中弹出一个范围。返回结束的范围的从零开始的深度。
totrans/doc22_068.md
浏览文件 @ 1efc722b
......@@ -7,7 +7,7 @@
该模块中的所有函数都旨在用于初始化神经网络参数，因此它们都在`torch.no_grad()`模式下运行，并且不会被 autograd 考虑。
```py
torch.nn.init.calculate_gain(nonlinearity, param=None)
torch.nn.init.calculate_gain(nonlinearity, param=None)
```
返回给定非线性函数的推荐增益值。
......@@ -41,7 +41,7 @@ torch.nn.init.calculate_gain(nonlinearity, param=None)¶
```
```py
torch.nn.init.uniform_(tensor, a=0.0, b=1.0, generator=None)
torch.nn.init.uniform_(tensor, a=0.0, b=1.0, generator=None)
```
用从均匀分布中抽取的值填充输入张量。
......@@ -70,7 +70,7 @@ $\mathcal{U}(a, b)$U(a,b).
```
```py
torch.nn.init.normal_(tensor, mean=0.0, std=1.0, generator=None)
torch.nn.init.normal_(tensor, mean=0.0, std=1.0, generator=None)
```
用从正态分布中抽取的值填充输入张量。
......@@ -99,7 +99,7 @@ $\mathcal{N}(\text{mean}, \text{std}²)$N(mean,std2).
```
```py
torch.nn.init.constant_(tensor, val)
torch.nn.init.constant_(tensor, val)
```
用值$\text{val}$填充输入张量。
......@@ -122,7 +122,7 @@ torch.nn.init.constant_(tensor, val)¶
```
```py
torch.nn.init.ones_(tensor)
torch.nn.init.ones_(tensor)
```
用标量值 1 填充输入张量。
......@@ -143,7 +143,7 @@ torch.nn.init.ones_(tensor)¶
```
```py
torch.nn.init.zeros_(tensor)
torch.nn.init.zeros_(tensor)
```
用标量值 0 填充输入张量。
......@@ -164,7 +164,7 @@ torch.nn.init.zeros_(tensor)¶
```
```py
torch.nn.init.eye_(tensor)
torch.nn.init.eye_(tensor)
```
用单位矩阵填充 2 维输入张量。
......@@ -183,7 +183,7 @@ torch.nn.init.eye_(tensor)¶
```
```py
torch.nn.init.dirac_(tensor, groups=1)
torch.nn.init.dirac_(tensor, groups=1)
```
使用 Dirac delta 函数填充{3, 4, 5}维度的输入张量。
......@@ -206,7 +206,7 @@ torch.nn.init.dirac_(tensor, groups=1)¶
```
```py
torch.nn.init.xavier_uniform_(tensor, gain=1.0, generator=None)
torch.nn.init.xavier_uniform_(tensor, gain=1.0, generator=None)
```
使用 Xavier 均匀分布填充输入张量的值。
......@@ -237,7 +237,7 @@ $a = \text{gain} \times \sqrt{\frac{6}{\text{fan\_in} + \text{fan\_out}}}$
```
```py
torch.nn.init.xavier_normal_(tensor, gain=1.0, generator=None)
torch.nn.init.xavier_normal_(tensor, gain=1.0, generator=None)
```
使用 Xavier 正态分布填充输入张量的值。
......@@ -268,7 +268,7 @@ $\text{std} = \text{gain} \times \sqrt{\frac{2}{\text{fan\_in} + \text{fan\_out}
```
```py
torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu', generator=None)
torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu', generator=None)
```
使用 Kaiming 均匀分布填充输入张量的值。
......@@ -299,7 +299,7 @@ $\text{bound} = \text{gain} \times \sqrt{\frac{3}{\text{fan\_mode}}}$
```
```py
torch.nn.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu', generator=None)
torch.nn.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu', generator=None)
```
用 Kaiming 正态分布填充输入张量的值。
......@@ -330,7 +330,7 @@ $\text{std} = \frac{\text{gain}}{\sqrt{\text{fan\_mode}}}$ std=fan_mode​gain
```
```py
torch.nn.init.trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0, generator=None)
torch.nn.init.trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0, generator=None)
```
用截断正态分布中抽取的值填充输入张量。
......@@ -363,7 +363,7 @@ torch.nn.init.trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0, generator=
```
```py
torch.nn.init.orthogonal_(tensor, gain=1, generator=None)
torch.nn.init.orthogonal_(tensor, gain=1, generator=None)
```
用（半）正交矩阵填充输入张量。
......@@ -386,7 +386,7 @@ torch.nn.init.orthogonal_(tensor, gain=1, generator=None)¶
```
```py
torch.nn.init.sparse_(tensor, sparsity, std=0.01, generator=None)
torch.nn.init.sparse_(tensor, sparsity, std=0.01, generator=None)
```
将 2D 输入张量填充为稀疏矩阵。
......
totrans/doc22_070.md
浏览文件 @ 1efc722b
......@@ -79,7 +79,7 @@ for input, target in dataset:
## 基类
```py
class torch.optim.Optimizer(params, defaults)
class torch.optim.Optimizer(params, defaults)
```
所有优化器的基类。
......
totrans/doc22_072.md
浏览文件 @ 1efc722b
......@@ -15,13 +15,13 @@ DDP 通信钩子是一个通用接口，通过覆盖[DistributedDataParallel](ht
通信钩子提供了一种灵活的方式来 allreduce 梯度。因此，它主要在每个副本上的梯度上操作，然后进行 allreduce，这些梯度被分桶以增加通信和计算之间的重叠。特别地，`torch.distributed.GradBucket`表示要进行 allreduce 的梯度张量的一个桶。
```py
class torch.distributed.GradBucket
class torch.distributed.GradBucket
```
这个类主要将一个扁平化的梯度张量（由`buffer()`返回）传递给 DDP 通信钩子。这个张量可以进一步分解为此桶中每个参数张量的列表（由`get_per_parameter_tensors()`返回），以应用逐层操作。
```py
torch.distributed.GradBucket.index(self: torch._C._distributed_c10d.GradBucket) → int
torch.distributed.GradBucket.index(self: torch._C._distributed_c10d.GradBucket) → int
```
警告
......@@ -33,7 +33,7 @@ torch.distributed.GradBucket.index(self: torch._C._distributed_c10d.GradBucket)
存储少数连续层梯度的桶的索引。所有梯度都被分桶。
```py
torch.distributed.GradBucket.buffer(self: torch._C._distributed_c10d.GradBucket) → torch.Tensor
torch.distributed.GradBucket.buffer(self: torch._C._distributed_c10d.GradBucket) → torch.Tensor
```
返回值
......@@ -41,7 +41,7 @@ torch.distributed.GradBucket.buffer(self: torch._C._distributed_c10d.GradBucket)
一个扁平化的 1D `torch.Tensor` 缓冲区，可以进一步分解为此桶中每个参数张量的列表。
```py
torch.distributed.GradBucket.gradients(self: torch._C._distributed_c10d.GradBucket) → List[torch.Tensor]
torch.distributed.GradBucket.gradients(self: torch._C._distributed_c10d.GradBucket) → List[torch.Tensor]
```
返回值
......@@ -49,7 +49,7 @@ torch.distributed.GradBucket.gradients(self: torch._C._distributed_c10d.GradBuck
一个`torch.Tensor`列表。列表中的每个张量对应一个梯度。
```py
torch.distributed.GradBucket.is_last(self: torch._C._distributed_c10d.GradBucket) → bool
torch.distributed.GradBucket.is_last(self: torch._C._distributed_c10d.GradBucket) → bool
```
返回值
......@@ -57,13 +57,13 @@ torch.distributed.GradBucket.is_last(self: torch._C._distributed_c10d.GradBucket
这个桶是否是迭代中最后一个要进行 allreduce 的桶。这也意味着这个桶对应于前向传播中的前几层。
```py
torch.distributed.GradBucket.set_buffer(self: torch._C._distributed_c10d.GradBucket, buffer: torch.Tensor) → None
torch.distributed.GradBucket.set_buffer(self: torch._C._distributed_c10d.GradBucket, buffer: torch.Tensor) → None
```
用输入张量缓冲区替换桶中的张量。
```py
torch.distributed.GradBucket.parameters(self: torch._C._distributed_c10d.GradBucket) → List[torch.Tensor]
torch.distributed.GradBucket.parameters(self: torch._C._distributed_c10d.GradBucket) → List[torch.Tensor]
```
返回值
......@@ -75,7 +75,7 @@ torch.distributed.GradBucket.parameters(self: torch._C._distributed_c10d.GradBuc
默认通信钩子是简单的**无状态**钩子，因此`register_comm_hook`中的输入状态要么是一个进程组，要么是`None`。输入`bucket`是一个`torch.distributed.GradBucket`对象。
```py
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.allreduce_hook(process_group, bucket)
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.allreduce_hook(process_group, bucket)
```
这个 DDP 通信钩子只是使用`GradBucket`张量调用`allreduce`。一旦梯度张量在所有工作进程中聚合，它的`then`回调会取平均值并返回结果。如果用户注册了这个钩子，DDP 的结果预计与未注册钩子的情况相同。因此，这不会改变 DDP 的行为，用户可以将其用作参考或修改此钩子以记录有用信息或其他目的，同时不影响 DDP 的行为。
......@@ -91,7 +91,7 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.allreduce_hook(process
*Future*[*Tensor*]
```py
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook(process_group, bucket)
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook(process_group, bucket)
```
这个 DDP 通信钩子实现了一种简单的梯度压缩方法，将`GradBucket`张量转换为半精度浮点格式（`torch.float16`），然后将其除以进程组大小。它对这些`float16`梯度张量进行全局归约。一旦压缩的梯度张量全部归约，链式回调`decompress`将其转换回输入数据类型（如`float32`）。
......@@ -107,7 +107,7 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook(pro
*Future*[*Tensor*]
```py
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook(process_group, bucket)
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook(process_group, bucket)
```
警告：此 API 是实验性的，需要 NCCL 版本高于 2.9.6。
......@@ -127,7 +127,7 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook(pro
此外，提供了一个通信钩子包装器，支持`fp16_compress_hook()`或`bf16_compress_hook()`作为一个包装器，可以与其他通信钩子组合使用。
```py
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_wrapper(hook)
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_wrapper(hook)
```
这个包装器将给定 DDP 通信钩子的输入梯度张量转换为半精度浮点格式（`torch.float16`），并将给定钩子的结果张量转换回输入数据类型，如`float32`。
......@@ -146,7 +146,7 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_wrapper(
[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(in Python v3.12)")[[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)"), *GradBucket*], *Future*[*Tensor*]]
```py
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_wrapper(hook)
torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_wrapper(hook)
```
警告：此 API 是实验性的，需要 NCCL 版本高于 2.9.6。
......@@ -173,7 +173,7 @@ PowerSGD（[Vogels 等人，NeurIPS 2019](https://arxiv.org/abs/1905.13727)）
### PowerSGD 状态
```py
class torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState(process_group, matrix_approximation_rank=1, start_powerSGD_iter=1000, min_compression_rate=2, use_error_feedback=True, warm_start=True, orthogonalization_epsilon=0, random_seed=0, compression_stats_logging_frequency=10000, batch_tensors_with_same_shape=False)
class torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState(process_group, matrix_approximation_rank=1, start_powerSGD_iter=1000, min_compression_rate=2, use_error_feedback=True, warm_start=True, orthogonalization_epsilon=0, random_seed=0, compression_stats_logging_frequency=10000, batch_tensors_with_same_shape=False)
```
在训练期间存储算法的超参数和所有梯度的内部状态。特别是，`matrix_approximation_rank` 和 `start_powerSGD_iter` 是用户应该调整的主要超参数。为了性能，建议保持二进制超参数 `use_error_feedback` 和 `warm_start` 打开。
......@@ -213,7 +213,7 @@ PowerSGD 通常需要额外的内存，大小与模型梯度相同，以启用
PowerSGD 钩子可能与[Apex 自动混合精度包](https://github.com/NVIDIA/apex)冲突。请改用 PyTorch 的[本机自动混合精度包](https://pytorch.org/docs/stable/amp.html)。
```py
torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook(state, bucket)
torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook(state, bucket)
```
这个 DDP 通信钩子实现了[论文](https://arxiv.org/abs/1905.13727)中描述的 PowerSGD 梯度压缩算法。一旦梯度张量在所有工作节点上聚合，此钩子将按以下方式应用压缩：
......@@ -271,7 +271,7 @@ torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook(state, b
```
```py
torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook(state, bucket)
torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook(state, bucket)
```
这个 DDP 通信钩子实现了一个简化的 PowerSGD 梯度压缩算法，描述在[论文](https://arxiv.org/abs/1905.13727)中。这个变体不是逐层压缩梯度，而是压缩批处理所有梯度的扁平输入张量。因此，它比`powerSGD_hook()`**更快**，但通常会导致**更低的准确性**，除非`matrix_approximation_rank`为 1。
......@@ -332,7 +332,7 @@ torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook(
调试通信挂钩不一定会输出正确的结果。
```py
torch.distributed.algorithms.ddp_comm_hooks.debugging_hooks.noop_hook(_, bucket)
torch.distributed.algorithms.ddp_comm_hooks.debugging_hooks.noop_hook(_, bucket)
```
此 DDP 通信挂钩返回一个包装输入的未来，因此它是一个不会产生任何通信开销的空操作。
......@@ -368,13 +368,13 @@ class torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState
```
```py
__getstate__()
__getstate__()
```
返回一个`Dict[str, Any]`，将被 pickle 化并保存。`process_group`不可序列化并从返回的状态中排除。
```py
__setstate__(state)
__setstate__(state)
```
接受一个提供的`state`并检索`PowerSGDState`。`process_group`设置为默认值。
......
totrans/doc22_073.md
浏览文件 @ 1efc722b
......@@ -27,7 +27,7 @@
## PyTorch 中的 Pipe API
```py
class torch.distributed.pipeline.sync.Pipe(module, chunks=1, checkpoint='except_last', deferred_batch_norm=False)
class torch.distributed.pipeline.sync.Pipe(module, chunks=1, checkpoint='except_last', deferred_batch_norm=False)
```
将任意`nn.Sequential`模块包装起来，以便使用同步管道并行训练。如果模块需要大量内存且无法放入单个 GPU 中，则管道并行是一种有用的训练技术。
......@@ -86,7 +86,7 @@ Pipe 将管道并行与检查点结合起来，以减少训练所需的峰值内
`Pipe`是实验性的，可能会发生变化。
```py
forward(*inputs)
forward(*inputs)
```
通过管道处理单个输入小批次并返回指向输出的`RRef`。`Pipe`是一个相当透明的模块包装器。它不修改底层模块的输入和输出签名。但有类型限制。输入和输出必须至少包含一个张量。此限制也适用于分区边界。
......@@ -122,7 +122,7 @@ forward(*inputs)¶
像[ResNeXt](https://pytorch.org/hub/pytorch_vision_resnext/)这样的某些模型并不完全是顺序的，它们在层之间有跳过连接。简单地作为管道并行的一部分实现会意味着我们需要通过多个 GPU 复制某些层的输出，直到最终到达包含跳过连接层的 GPU。为了避免这种复制开销，我们提供以下 API 来在模型的不同层中存储和弹出张量。
```py
torch.distributed.pipeline.sync.skip.skippable.skippable(stash=(), pop=())
torch.distributed.pipeline.sync.skip.skippable.skippable(stash=(), pop=())
```
定义一个装饰器来创建带有跳过连接的`nn.Module`。
......@@ -172,7 +172,7 @@ class StashStashPop(nn.Module):
[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在 Python v3.12 中)")[[[*Type*](https://docs.python.org/3/library/typing.html#typing.Type "(在 Python v3.12 中)")[*Module*]], [*Type*](https://docs.python.org/3/library/typing.html#typing.Type "(在 Python v3.12 中)")[*Skippable*]]
```py
class torch.distributed.pipeline.sync.skip.skippable.stash(name, tensor)
class torch.distributed.pipeline.sync.skip.skippable.stash(name, tensor)
```
存储跳过张量的命令。
......@@ -190,7 +190,7 @@ def forward(self, input):
+ **input** (*torch.Tensor* *或* *None*) – 传递给跳过连接的张量
```py
class torch.distributed.pipeline.sync.skip.skippable.pop(name)
class torch.distributed.pipeline.sync.skip.skippable.pop(name)
```
弹出跳过张量的命令。
......@@ -214,7 +214,7 @@ def forward(self, input):
无
```py
torch.distributed.pipeline.sync.skip.skippable.verify_skippables(module)
torch.distributed.pipeline.sync.skip.skippable.verify_skippables(module)
```
验证底层可跳过模块是否满足完整性。
......
totrans/doc22_075.md
浏览文件 @ 1efc722b
......@@ -33,7 +33,7 @@ CUDA 支持在 PyTorch 1.9 中引入，仍然是一个**beta**功能。RPC 包
在使用 RPC 和分布式自动微分原语之前，必须进行初始化。要初始化 RPC 框架，我们需要使用`init_rpc()`，这将初始化 RPC 框架、RRef 框架和分布式自动微分。
```py
torch.distributed.rpc.init_rpc(name, backend=None, rank=-1, world_size=None, rpc_backend_options=None)
torch.distributed.rpc.init_rpc(name, backend=None, rank=-1, world_size=None, rpc_backend_options=None)
```
初始化 RPC 原语，如本地 RPC 代理和分布式自动微分，这将立即使当前进程准备好发送和接收 RPC。
......@@ -57,7 +57,7 @@ torch.distributed.rpc.init_rpc(name, backend=None, rank=-1, world_size=None, rpc
RPC 中的 TorchScript 支持是一个原型功能，可能会发生变化。自 v1.5.0 以来，`torch.distributed.rpc`支持将 TorchScript 函数作为 RPC 目标函数调用，这将有助于提高被调用者端的并行性，因为执行 TorchScript 函数不需要 GIL。
```py
torch.distributed.rpc.rpc_sync(to, func, args=None, kwargs=None, timeout=-1.0)
torch.distributed.rpc.rpc_sync(to, func, args=None, kwargs=None, timeout=-1.0)
```
在工作节点`to`上运行函数`func`的阻塞 RPC 调用。RPC 消息在执行 Python 代码的同时并行发送和接收。此方法是线程安全的。
......@@ -127,7 +127,7 @@ export MASTER_ADDR=localhost export MASTER_PORT=5678
```
```py
torch.distributed.rpc.rpc_async(to, func, args=None, kwargs=None, timeout=-1.0)
torch.distributed.rpc.rpc_async(to, func, args=None, kwargs=None, timeout=-1.0)
```
在工作节点`to`上运行函数`func`的非阻塞 RPC 调用。RPC 消息在执行 Python 代码的同时并行发送和接收。此方法是线程安全的。此方法将立即返回一个可以等待的`Future`。
......@@ -208,7 +208,7 @@ torch.distributed.rpc.rpc_async(to, func, args=None, kwargs=None, timeout=-1.0)
```
```py
torch.distributed.rpc.remote(to, func, args=None, kwargs=None, timeout=-1.0)
torch.distributed.rpc.remote(to, func, args=None, kwargs=None, timeout=-1.0)
```
在工作节点 `to` 上运行 `func` 并立即返回结果值的 `RRef`。工作节点 `to` 将是返回的 `RRef` 的所有者，调用 `remote` 的工作节点是用户。所有者管理其 `RRef` 的全局引用计数，只有当全局没有对其的活动引用时，所有者的 `RRef` 才会被销毁。
......@@ -284,7 +284,7 @@ Below is an example of running a TorchScript function using RPC.
```
```py
torch.distributed.rpc.get_worker_info(worker_name=None)
torch.distributed.rpc.get_worker_info(worker_name=None)
```
获取给定工作进程名称的`WorkerInfo`。使用此`WorkerInfo`以避免在每次调用时传递昂贵的字符串。
......@@ -298,7 +298,7 @@ torch.distributed.rpc.get_worker_info(worker_name=None)¶
给定`worker_name`的`WorkerInfo`实例或当前工作进程的`WorkerInfo`如果`worker_name`为`None`。
```py
torch.distributed.rpc.shutdown(graceful=True, timeout=0)
torch.distributed.rpc.shutdown(graceful=True, timeout=0)
```
执行 RPC 代理的关闭，然后销毁 RPC 代理。这将停止本地代理接受未完成的请求，并通过终止所有 RPC 线程关闭 RPC 框架。如果`graceful=True`，这将阻塞，直到所有本地和远程 RPC 进程到达此方法并等待所有未完成的工作完成。否则，如果`graceful=False`，这是一个本地关闭，不会等待其他 RPC 进程到达此方法。
......@@ -339,19 +339,19 @@ export MASTER_ADDR=localhost export MASTER_PORT=5678
```
```py
class torch.distributed.rpc.WorkerInfo
class torch.distributed.rpc.WorkerInfo
```
封装系统中工作进程信息的结构。包含工作进程的名称和 ID。此类不应直接构造，而是可以通过`get_worker_info()`检索实例，并将结果传递给函数，如`rpc_sync()`、`rpc_async()`、`remote()`以避免在每次调用时复制字符串。
```py
property id
property id
```
用于标识工作进程的全局唯一 ID。
```py
property name
property name
```
工作进程的名称。
......@@ -359,7 +359,7 @@ property name¶
RPC 包还提供了装饰器，允许应用程序指定在被调用方如何处理给定函数。
```py
torch.distributed.rpc.functions.async_execution(fn)
torch.distributed.rpc.functions.async_execution(fn)
```
一个函数的装饰器，指示函数的返回值保证是一个`Future`对象，并且此函数可以在 RPC 被调用方异步运行。更具体地说，被调用方提取由包装函数返回的`Future`并将后续处理步骤安装为该`Future`的回调。安装的回调将在完成时从`Future`中读取值并将该值作为 RPC 响应发送回去。这也意味着返回的`Future`仅存在于被调用方，并且永远不会通过 RPC 发送。当包装函数的执行需要暂停和恢复时，例如包含`rpc_async()`或等待其他信号时，此装饰器非常有用。
......@@ -500,7 +500,7 @@ torch.distributed.rpc.functions.async_execution(fn)¶
RPC 模块可以利用不同的后端来执行节点之间的通信。要使用的后端可以在`init_rpc()`函数中指定，通过传递`BackendType`枚举的某个值。无论使用什么后端，RPC API 的其余部分都不会改变。每个后端还定义了自己的`RpcBackendOptions`类的子类，该类的实例也可以传递给`init_rpc()`以配置后端的行为。
```py
class torch.distributed.rpc.BackendType(value)
class torch.distributed.rpc.BackendType(value)
```
可用后端的枚举类。
......@@ -508,19 +508,19 @@ class torch.distributed.rpc.BackendType(value)¶
PyTorch 内置了`BackendType.TENSORPIPE`后端。可以使用`register_backend()`函数注册其他后端。
```py
class torch.distributed.rpc.RpcBackendOptions
class torch.distributed.rpc.RpcBackendOptions
```
封装传递给 RPC 后端的选项的抽象结构。可以将此类的实例传递给`init_rpc()`以使用特定配置初始化 RPC，例如 RPC 超时和要使用的`init_method`。
```py
property init_method
property init_method
```
指定如何初始化进程组的 URL。默认为`env://`。
```py
property rpc_timeout
property rpc_timeout
```
一个浮点数，表示用于所有 RPC 的超时时间。如果一个 RPC 在这个时间段内没有完成，它将以超时的异常完成。
......@@ -553,7 +553,7 @@ TensorPipe 后端已经在 PyTorch v1.6 中引入，并正在积极开发中。
```
```py
class torch.distributed.rpc.TensorPipeRpcBackendOptions(*, num_worker_threads=16, rpc_timeout=60.0, init_method='env://', device_maps=None, devices=None, _transports=None, _channels=None)
class torch.distributed.rpc.TensorPipeRpcBackendOptions(*, num_worker_threads=16, rpc_timeout=60.0, init_method='env://', device_maps=None, devices=None, _transports=None, _channels=None)
```
`TensorPipeAgent`的后端选项，派生自`RpcBackendOptions`。
......@@ -571,37 +571,37 @@ class torch.distributed.rpc.TensorPipeRpcBackendOptions(*, num_worker_threads=16
+ **devices**（List[int, str, or `torch.device`]，可选）– RPC 代理使用的所有本地 CUDA 设备。默认情况下，它将被初始化为来自其自身`device_maps`和对等方`device_maps`的所有本地设备。在处理 CUDA RPC 请求时，代理将为此`List`中的所有设备正确同步 CUDA 流。
```py
property device_maps
property device_maps
```
设备映射位置。
```py
property devices
property devices
```
本地代理使用的所有设备。
```py
property init_method
property init_method
```
指定如何初始化进程组的 URL。默认为`env://`
```py
property num_worker_threads
property num_worker_threads
```
`TensorPipeAgent`用于执行请求的线程池中的线程数。
```py
property rpc_timeout
property rpc_timeout
```
指示用于所有 RPC 的超时的浮点数。如果 RPC 在此时间段内未完成，它将以超时的异常完成。
```py
set_device_map(to, device_map)
set_device_map(to, device_map)
```
设置每个 RPC 调用者和被调用者对之间的设备映射。此函数可以多次调用以逐步添加设备放置配置。
......@@ -648,7 +648,7 @@ set_device_map(to, device_map)¶
```
```py
set_devices(devices)
set_devices(devices)
```
设置 TensorPipe RPC 代理使用的本地设备。在处理 CUDA RPC 请求时，TensorPipe RPC 代理将为此`List`中所有设备适当同步 CUDA 流。
......@@ -668,7 +668,7 @@ RPC 框架不会自动重试任何`rpc_sync()`、`rpc_async()`和`remote()`调
`RRef`（远程引用）是对远程工作器上某种类型`T`（例如`Tensor`）的值的引用。此句柄在所有者上保持引用的远程值保持活动状态，但并不意味着该值将来会传输到本地工作器。RRefs 可以通过持有对其他工作器上存在的[nn.Modules](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)的引用，在多机训练中使用，并调用适当的函数在训练期间检索或修改它们的参数。有关更多详细信息，请参见远程引用协议。
```py
class torch.distributed.rpc.PyRRef(RRef)
class torch.distributed.rpc.PyRRef(RRef)
```
封装对远程工作器上某种类型值的引用的类。此句柄将保持工作器上引用的远程值保持活动状态。当`UserRRef`被删除时，1）在应用程序代码和本地 RRef 上没有对它的引用，或 2）应用程序已调用了优雅关闭时，`UserRRef`将被删除。在已删除的 RRef 上调用方法会导致未定义的行为。RRef 实现仅提供尽力检测错误，应用程序不应在`rpc.shutdown()`之后使用`UserRRefs`。
......@@ -726,7 +726,7 @@ RRefs 只能由 RPC 模块序列化和反序列化。在没有 RPC 的情况下
```
```py
backward(self: torch._C._distributed_rpc.PyRRef, dist_autograd_ctx_id: int = -1, retain_graph: bool = False) → None
backward(self: torch._C._distributed_rpc.PyRRef, dist_autograd_ctx_id: int = -1, retain_graph: bool = False) → None
```
> 使用 RRef 作为反向传递的根运行反向传递。如果提供了`dist_autograd_ctx_id`，我们将使用提供的 ctx_id 从 RRef 的所有者开始执行分布式反向传递。在这种情况下，应使用`get_gradients()`来检索梯度。如果`dist_autograd_ctx_id`为`None`，则假定这是一个本地自动梯度图，我们只执行本地反向传递。在本地情况下，调用此 API 的节点必须是 RRef 的所有者。预期 RRef 的值是标量张量。
......@@ -746,37 +746,37 @@ backward(self: torch._C._distributed_rpc.PyRRef, dist_autograd_ctx_id: int = -1,
```
```py
confirmed_by_owner(self: torch._C._distributed_rpc.PyRRef) → bool
confirmed_by_owner(self: torch._C._distributed_rpc.PyRRef) → bool
```
返回此`RRef`是否已被所有者确认。`OwnerRRef`始终返回 true，而`UserRRef`仅在所有者知道此`UserRRef`时返回 true。
```py
is_owner(self: torch._C._distributed_rpc.PyRRef) → bool
is_owner(self: torch._C._distributed_rpc.PyRRef) → bool
```
返回当前节点是否是此`RRef`的所有者。
```py
local_value(self: torch._C._distributed_rpc.PyRRef) → object
local_value(self: torch._C._distributed_rpc.PyRRef) → object
```
如果当前节点是所有者，则返回对本地值的引用。否则，抛出异常。
```py
owner(self: torch._C._distributed_rpc.PyRRef) → torch._C._distributed_rpc.WorkerInfo
owner(self: torch._C._distributed_rpc.PyRRef) → torch._C._distributed_rpc.WorkerInfo
```
返回拥有此`RRef`的节点的工作人员信息。
```py
owner_name(self: torch._C._distributed_rpc.PyRRef) → str
owner_name(self: torch._C._distributed_rpc.PyRRef) → str
```
返回拥有此`RRef`的节点的工作人员名称。
```py
remote(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
remote(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
```
创建一个辅助代理，以便使用拥有 RRef 的所有者作为目标轻松启动`remote`，以在此 RRef 引用的对象上运行函数。更具体地说，`rref.remote().func_name(*args, **kwargs)`等同于以下内容：
......@@ -802,7 +802,7 @@ remote(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
```
```py
rpc_async(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
rpc_async(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
```
创建一个辅助代理，以便使用拥有 RRef 的所有者作为目标轻松启动`rpc_async`，以在此 RRef 引用的对象上运行函数。更具体地说，`rref.rpc_async().func_name(*args, **kwargs)`等同于以下内容：
......@@ -828,7 +828,7 @@ rpc_async(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → obj
```
```py
rpc_sync(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
rpc_sync(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
```
创建一个辅助代理，以便使用 RRef 的所有者轻松启动`rpc_sync`，以运行此 RRef 引用的对象上的函数。更具体地说，`rref.rpc_sync().func_name(*args, **kwargs)`等同于以下内容：
......@@ -854,7 +854,7 @@ rpc_sync(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → obje
```
```py
to_here(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
to_here(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object
```
阻塞调用，将 RRef 的值从所有者复制到本地节点并返回。如果当前节点是所有者，则返回对本地值的引用。
......@@ -894,7 +894,7 @@ to_here(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → objec
`RemoteModule`是在不同进程上轻松创建 nn.Module 的一种方式。实际模块驻留在远程主机上，但本地主机具有对此模块的句柄，并且可以像常规的 nn.Module 一样调用此模块。但是，调用会导致 RPC 调用到远程端，并且如果需要，可以通过 RemoteModule 支持的其他 API 以异步方式执行。
```py
class torch.distributed.nn.api.remote_module.RemoteModule(*args, **kwargs)
class torch.distributed.nn.api.remote_module.RemoteModule(*args, **kwargs)
```
> 只有在 RPC 初始化后才能创建 RemoteModule 实例。
......@@ -964,7 +964,7 @@ class torch.distributed.nn.api.remote_module.RemoteModule(*args, **kwargs)¶
此外，可以在[分布式数据并行](https://pytorch.org/docs/stable/nn.html#torch.nn.parallel.DistributedDataParallel)（DDP）中结合更实际的示例，详见此[教程](https://pytorch.org/tutorials/advanced/rpc_ddp_tutorial.html)。
```py
get_module_rref()
get_module_rref()
```
返回一个指向远程模块的 `RRef`（`RRef[nn.Module]`）。
......@@ -974,7 +974,7 @@ get_module_rref()¶
*RRef*[*Module*]
```py
remote_parameters(recurse=True)
remote_parameters(recurse=True)
```
返回一个指向远程模块参数的 `RRef` 列表。
......@@ -1002,7 +1002,7 @@ remote_parameters(recurse=True)¶
这个模块提供了一个基于 RPC 的分布式自动求导框架，可用于诸如模型并行训练等应用。简而言之，应用程序可以通过 RPC 发送和接收梯度记录张量。在前向传播中，当梯度记录张量通过 RPC 发送时，我们记录下来；在反向传播过程中，我们使用这些信息来使用 RPC 执行分布式反向传播。更多细节请参见分布式自动求导设计。
```py
torch.distributed.autograd.backward(context_id: int, roots: List[Tensor], retain_graph=False) → None
torch.distributed.autograd.backward(context_id: int, roots: List[Tensor], retain_graph=False) → None
```
使用提供的根启动分布式反向传播。目前实现了 FAST mode 算法，该算法假定在同一分布式自动求导上下文中的所有 RPC 消息在反向传播过程中都将成为自动求导图的一部分。
......@@ -1030,7 +1030,7 @@ torch.distributed.autograd.backward(context_id: int, roots: List[Tensor], retain
```
```py
class torch.distributed.autograd.context
class torch.distributed.autograd.context
```
在使用分布式自动求导时，用于包装前向和后向传递的上下文对象。在`with`语句中生成的`context_id`用于唯一标识所有工作进程上的分布式后向传递。每个工作进程存储与此`context_id`相关的元数据，这是正确执行分布式自动求导传递所必需的。
......@@ -1047,7 +1047,7 @@ class torch.distributed.autograd.context¶
```
```py
torch.distributed.autograd.get_gradients(context_id: int) → Dict[Tensor, Tensor]
torch.distributed.autograd.get_gradients(context_id: int) → Dict[Tensor, Tensor]
```
从张量到在分布式自动求导后向传递的提供的上下文中累积的该张量的适当梯度的映射中检索映射，对应于给定的`context_id`。
......
totrans/doc22_076.md
浏览文件 @ 1efc722b
......@@ -3,7 +3,7 @@
> 原文：[`pytorch.org/docs/stable/random.html`](https://pytorch.org/docs/stable/random.html)
```py
torch.random.fork_rng(devices=None, enabled=True, _caller='fork_rng', _devices_kw='devices', device_type='cuda')
torch.random.fork_rng(devices=None, enabled=True, _caller='fork_rng', _devices_kw='devices', device_type='cuda')
```
分叉 RNG，以便在返回时，RNG 被重置为先前的状态。
......@@ -21,7 +21,7 @@ torch.random.fork_rng(devices=None, enabled=True, _caller='fork_rng', _devices_k
[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在 Python v3.12 中)")
```py
torch.random.get_rng_state()
torch.random.get_rng_state()
```
将随机数生成器状态返回为 torch.ByteTensor。
......@@ -31,7 +31,7 @@ torch.random.get_rng_state()¶
*张量*
```py
torch.random.initial_seed()
torch.random.initial_seed()
```
返回生成随机数的初始种子作为 Python 长整型。
......@@ -41,7 +41,7 @@ torch.random.initial_seed()¶
[int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")
```py
torch.random.manual_seed(seed)
torch.random.manual_seed(seed)
```
设置生成随机数的种子。返回一个 torch.Generator 对象。
......@@ -55,7 +55,7 @@ torch.random.manual_seed(seed)¶
*生成器*
```py
torch.random.seed()
torch.random.seed()
```
将生成随机数的种子设置为非确定性随机数。返回用于种子 RNG 的 64 位数字。
......@@ -65,7 +65,7 @@ torch.random.seed()¶
[int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")
```py
torch.random.set_rng_state(new_state)
torch.random.set_rng_state(new_state)
```
设置随机数生成器状态。
......
totrans/doc22_078.md
浏览文件 @ 1efc722b
......@@ -159,7 +159,7 @@ nested_tensor([
以下函数与嵌套张量相关：
```py
torch.nested.nested_tensor(tensor_list, *, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False)
torch.nested.nested_tensor(tensor_list, *, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False)
```
从`tensor_list`（张量列表）构造一个没有自动求导历史（也称为“叶张量”，参见自动求导机制）的嵌套张量。
......@@ -197,7 +197,7 @@ True
```
```py
torch.nested.as_nested_tensor(tensor_list, dtype=None, device=None, layout=None)
torch.nested.as_nested_tensor(tensor_list, dtype=None, device=None, layout=None)
```
从`tensor_list`张量列表构造一个保留自动求导历史的嵌套张量。
......@@ -239,7 +239,7 @@ tensor([0., 0., 0., 0., 0.])
```
```py
torch.nested.to_padded_tensor(input, padding, output_size=None, out=None) → Tensor
torch.nested.to_padded_tensor(input, padding, output_size=None, out=None) → Tensor
```
通过填充`input`嵌套张量，返回一个新的（非嵌套）张量。前导条目将填充嵌套数据，而尾随条目将被填充。
......
totrans/doc22_080.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_081.md
浏览文件 @ 1efc722b
......@@ -3,7 +3,7 @@
> [`pytorch.org/docs/stable/testing.html`](https://pytorch.org/docs/stable/testing.html)
```py
torch.testing.assert_close(actual, expected, *, allow_subclasses=True, rtol=None, atol=None, equal_nan=False, check_device=True, check_dtype=True, check_layout=True, check_stride=False, msg=None)
torch.testing.assert_close(actual, expected, *, allow_subclasses=True, rtol=None, atol=None, equal_nan=False, check_device=True, check_dtype=True, check_layout=True, check_stride=False, msg=None)
```
断言`actual`和`expected`是接近的。
......@@ -240,7 +240,7 @@ Footer
```
```py
torch.testing.make_tensor(*shape, dtype, device, low=None, high=None, requires_grad=False, noncontiguous=False, exclude_zero=False, memory_format=None)
torch.testing.make_tensor(*shape, dtype, device, low=None, high=None, requires_grad=False, noncontiguous=False, exclude_zero=False, memory_format=None)
```
创建具有给定`shape`、`device`和`dtype`的张量，并用从`[low, high)`均匀抽取的值填充。
......@@ -309,7 +309,7 @@ tensor([[False, False],
```
```py
torch.testing.assert_allclose(actual, expected, rtol=None, atol=None, equal_nan=True, msg='')
torch.testing.assert_allclose(actual, expected, rtol=None, atol=None, equal_nan=True, msg='')
```
警告
......
totrans/doc22_083.md
浏览文件 @ 1efc722b
......@@ -3,7 +3,7 @@
> [`pytorch.org/docs/stable/benchmark_utils.html`](https://pytorch.org/docs/stable/benchmark_utils.html)
```py
class torch.utils.benchmark.Timer(stmt='pass', setup='pass', global_setup='', timer=<built-in function perf_counter>, globals=None, label=None, sub_label=None, description=None, env=None, num_threads=1, language=Language.PYTHON)
class torch.utils.benchmark.Timer(stmt='pass', setup='pass', global_setup='', timer=<built-in function perf_counter>, globals=None, label=None, sub_label=None, description=None, env=None, num_threads=1, language=Language.PYTHON)
```
用于测量 PyTorch 语句执行时间的辅助类。
......@@ -74,7 +74,7 @@ PyTorch 计时器特定的构造函数参数：
+ **num_threads**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12)")） - 在执行 stmt 时 PyTorch 线程池的大小。单线程性能很重要，既是关键的推理工作负载，也是内在算法效率的良好指标，因此默认设置为 1。这与默认的 PyTorch 线程池大小相反，后者尝试利用所有核心。
```py
adaptive_autorange(threshold=0.1, *, min_run_time=0.01, max_run_time=10.0, callback=None)
adaptive_autorange(threshold=0.1, *, min_run_time=0.01, max_run_time=10.0, callback=None)
```
类似于 blocked_autorange，但还检查测量中的变异性，并重复直到 iqr/median 小于阈值或达到 max_run_time。
......@@ -115,7 +115,7 @@ while times.sum < max_run_time
*Measurement*
```py
blocked_autorange(callback=None, min_run_time=0.2)
blocked_autorange(callback=None, min_run_time=0.2)
```
在保持计时器开销最低的情况下测量许多复制品。
......@@ -150,7 +150,7 @@ blocked_autorange 通过运行预热期来设置块大小，增加块大小直
*Measurement*
```py
collect_callgrind(number: int, *, repeats: None, collect_baseline: bool, retain_out_file: bool) → CallgrindStats
collect_callgrind(number: int, *, repeats: None, collect_baseline: bool, retain_out_file: bool) → CallgrindStats
```
```py
......@@ -172,7 +172,7 @@ collect_callgrind(number: int, *, repeats: int, collect_baseline: bool, retain_o
一个 CallgrindStats 对象，提供指令计数和一些基本设施用于分析和操作结果。
```py
timeit(number=1000000)
timeit(number=1000000)
```
反映了 timeit.Timer.timeit()的语义。
......@@ -184,7 +184,7 @@ timeit(number=1000000)¶
*Measurement*
```py
class torch.utils.benchmark.Measurement(number_per_run, raw_times, task_spec, metadata=None)
class torch.utils.benchmark.Measurement(number_per_run, raw_times, task_spec, metadata=None)
```
计时器测量的结果。
......@@ -192,7 +192,7 @@ class torch.utils.benchmark.Measurement(number_per_run, raw_times, task_spec, me
这个类存储给定语句的一个或多个测量。它是可序列化的，并为下游消费者提供几种便利方法（包括详细的 __repr__）。
```py
static merge(measurements)
static merge(measurements)
```
用于合并重复实验的便利方法。
......@@ -204,7 +204,7 @@ static merge(measurements)¶
[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*Measurement*]
```py
property significant_figures: int
property significant_figures: int
```
近似的显著数字估计。
......@@ -214,7 +214,7 @@ property significant_figures: int¶
与 trim_sigfig 方法一起使用的显著数字估计，以提供更易于人类理解的数据摘要。__repr__ 不使用此方法；它只显示原始值。显著数字估计用于 Compare。
```py
class torch.utils.benchmark.CallgrindStats(task_spec, number_per_run, built_with_debug_symbols, baseline_inclusive_stats, baseline_exclusive_stats, stmt_inclusive_stats, stmt_exclusive_stats, stmt_callgrind_out)
class torch.utils.benchmark.CallgrindStats(task_spec, number_per_run, built_with_debug_symbols, baseline_inclusive_stats, baseline_exclusive_stats, stmt_inclusive_stats, stmt_exclusive_stats, stmt_callgrind_out)
```
由计时器收集的 Callgrind 结果的顶层容器。
......@@ -222,7 +222,7 @@ class torch.utils.benchmark.CallgrindStats(task_spec, number_per_run, built_with
通常使用 FunctionCounts 类进行操作，该类通过调用 CallgrindStats.stats(…)获得。还提供了几种便利方法；最重要的是 CallgrindStats.as_standardized()。
```py
as_standardized()
as_standardized()
```
从函数字符串中删除库名称和一些前缀。
......@@ -246,7 +246,7 @@ as_standardized()¶
*CallgrindStats*
```py
counts(*, denoise=False)
counts(*, denoise=False)
```
返回执行的指令总数。
......@@ -258,7 +258,7 @@ counts(*, denoise=False)¶
[int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")
```py
delta(other, inclusive=False)
delta(other, inclusive=False)
```
比较两组计数。
......@@ -270,7 +270,7 @@ delta(other, inclusive=False)¶
*FunctionCounts*
```py
stats(inclusive=False)
stats(inclusive=False)
```
返回详细的函数计数。
......@@ -284,7 +284,7 @@ inclusive 匹配 callgrind 的语义。如果为 True，则计数包括子级执
*FunctionCounts*
```py
class torch.utils.benchmark.FunctionCounts(_data, inclusive, truncate_rows=True, _linewidth=None)
class torch.utils.benchmark.FunctionCounts(_data, inclusive, truncate_rows=True, _linewidth=None)
```
用于操作 Callgrind 结果的容器。
......@@ -300,7 +300,7 @@ class torch.utils.benchmark.FunctionCounts(_data, inclusive, truncate_rows=True,
1. 两个高阶方法（filter 和 transform）用于自定义操作。
```py
denoise()
denoise()
```
删除已知的嘈杂指令。
......@@ -312,7 +312,7 @@ CPython 解释器中的几条指令相当嘈杂。这些指令涉及 Python 用
*FunctionCounts*
```py
filter(filter_fn)
filter(filter_fn)
```
仅保留 filter_fn 应用于函数名称返回 True 的元素。
......@@ -322,7 +322,7 @@ filter(filter_fn)¶
*FunctionCounts*
```py
transform(map_fn)
transform(map_fn)
```
将 map_fn 应用于所有函数名称。
......
totrans/doc22_085.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_086.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_087.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_088.md
浏览文件 @ 1efc722b
......@@ -3,7 +3,7 @@
> [`pytorch.org/docs/stable/deterministic.html`](https://pytorch.org/docs/stable/deterministic.html)
```py
torch.utils.deterministic.fill_uninitialized_memory
torch.utils.deterministic.fill_uninitialized_memory
```
一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，如果为 True，则在将`torch.use_deterministic_algorithms()`设置为`True`时，未初始化的内存将被填充为已知值。浮点数和复数值设置为 NaN，整数值设置为最大值。
......
totrans/doc22_090.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_091.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_092.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_093.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_094.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_095.md
浏览文件 @ 1efc722b
此差异已折叠。
totrans/doc22_097.md
浏览文件 @ 1efc722b
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或