From 10e4285b557f733e0e2f3b7fd546adf7198187b2 Mon Sep 17 00:00:00 2001 From: wizardforcel Date: Mon, 5 Feb 2024 14:08:18 +0800 Subject: [PATCH] 2024-02-05 14:08:18 --- totrans/doc22_000.md | 2 +- totrans/doc22_002.md | 12 +- totrans/doc22_003.md | 100 ++-- totrans/doc22_004.md | 38 +- totrans/doc22_005.md | 54 +- totrans/doc22_006.md | 10 +- totrans/doc22_008.md | 100 ++-- totrans/doc22_009.md | 150 +++--- totrans/doc22_010.md | 14 +- totrans/doc22_011.md | 18 +- totrans/doc22_012.md | 208 ++++---- totrans/doc22_013.md | 42 +- totrans/doc22_014.md | 186 +++---- totrans/doc22_015.md | 96 ++-- totrans/doc22_016.md | 26 +- totrans/doc22_017.md | 56 +-- totrans/doc22_018.md | 32 +- totrans/doc22_019.md | 40 +- totrans/doc22_020.md | 168 +++---- totrans/doc22_021.md | 8 +- totrans/doc22_022.md | 60 +-- totrans/doc22_023.md | 50 +- totrans/doc22_024.md | 48 +- totrans/doc22_025.md | 88 ++-- totrans/doc22_026.md | 6 +- totrans/doc22_028.md | 38 +- totrans/doc22_029.md | 4 +- totrans/doc22_031.md | 1000 ++++++++++++++++++------------------ totrans/doc22_032.md | 536 ++++++++++---------- totrans/doc22_033.md | 230 ++++----- totrans/doc22_034.md | 1142 +++++++++++++++++++++--------------------- totrans/doc22_035.md | 70 +-- totrans/doc22_036.md | 80 +-- totrans/doc22_037.md | 188 +++---- totrans/doc22_038.md | 144 +++--- totrans/doc22_039.md | 60 +-- totrans/doc22_040.md | 20 +- totrans/doc22_041.md | 174 +++---- totrans/doc22_042.md | 42 +- totrans/doc22_043.md | 30 +- totrans/doc22_044.md | 126 ++--- totrans/doc22_045.md | 224 ++++----- totrans/doc22_046.md | 514 ++++++++++--------- totrans/doc22_047.md | 28 +- totrans/doc22_048.md | 32 +- totrans/doc22_049.md | 300 ++++++----- totrans/doc22_050.md | 60 +-- totrans/doc22_051.md | 64 +-- totrans/doc22_052.md | 292 +++++------ totrans/doc22_053.md | 530 +++++++++----------- totrans/doc22_054.md | 42 +- totrans/doc22_055.md | 46 +- totrans/doc22_056.md | 50 +- totrans/doc22_057.md | 58 +-- totrans/doc22_058.md | 602 +++++++++++----------- totrans/doc22_059.md | 112 ++--- totrans/doc22_060.md | 234 ++++----- totrans/doc22_061.md | 86 ++-- totrans/doc22_062.md | 40 +- totrans/doc22_063.md | 26 +- totrans/doc22_064.md | 212 ++++---- totrans/doc22_065.md | 54 +- totrans/doc22_066.md | 302 +++++------ totrans/doc22_067.md | 78 +-- totrans/doc22_068.md | 138 ++--- totrans/doc22_069.md | 12 +- totrans/doc22_070.md | 152 +++--- totrans/doc22_071.md | 26 +- totrans/doc22_072.md | 130 ++--- totrans/doc22_073.md | 72 +-- totrans/doc22_074.md | 212 ++++---- totrans/doc22_075.md | 276 +++++----- totrans/doc22_076.md | 30 +- totrans/doc22_077.md | 322 ++++++------ totrans/doc22_078.md | 98 ++-- totrans/doc22_079.md | 384 +++++++------- totrans/doc22_080.md | 96 ++-- totrans/doc22_081.md | 50 +- totrans/doc22_082.md | 10 +- totrans/doc22_083.md | 120 ++--- totrans/doc22_084.md | 16 +- totrans/doc22_085.md | 24 +- totrans/doc22_086.md | 90 ++-- totrans/doc22_087.md | 216 ++++---- totrans/doc22_088.md | 12 +- totrans/doc22_089.md | 2 +- totrans/doc22_090.md | 18 +- totrans/doc22_091.md | 12 +- totrans/doc22_092.md | 20 +- totrans/doc22_093.md | 210 ++++---- totrans/doc22_094.md | 16 +- totrans/doc22_095.md | 108 ++-- totrans/doc22_096.md | 452 ++++++++--------- totrans/doc22_097.md | 4 +- totrans/doc22_098.md | 52 +- 95 files changed, 6384 insertions(+), 6478 deletions(-) diff --git a/totrans/doc22_000.md b/totrans/doc22_000.md index 233bbc5e..3716a17b 100644 --- a/totrans/doc22_000.md +++ b/totrans/doc22_000.md @@ -1,3 +1,3 @@ # PyTorch 2.2 文档 -来源：[https://pytorch.org/docs/stable/](https://pytorch.org/docs/stable/) +来源：[`pytorch.org/docs/stable/`](https://pytorch.org/docs/stable/) diff --git a/totrans/doc22_002.md b/totrans/doc22_002.md index a65d8783..e55ce596 100644 --- a/totrans/doc22_002.md +++ b/totrans/doc22_002.md @@ -1,21 +1,21 @@ -# PyTorch治理 | 构建 + CI +# PyTorch 治理 | 构建 + CI -> 原文：[https://pytorch.org/docs/stable/community/build_ci_governance.html](https://pytorch.org/docs/stable/community/build_ci_governance.html) +> 原文：[`pytorch.org/docs/stable/community/build_ci_governance.html`](https://pytorch.org/docs/stable/community/build_ci_governance.html) ## 如何添加新的维护者[](#how-to-add-a-new-maintainer "跳转到此标题") 要成为维护者，一个人需要： -+ 在PyTorch仓库的相关部分至少提交六次提交。 ++ 在 PyTorch 仓库的相关部分至少提交六次提交。 + 这些提交中至少有一个必须在过去的六个月内提交 -要将合格的人员添加到维护者列表中，请创建一个PR，将一个人添加到[感兴趣的人](https://pytorch.org/docs/main/community/persons_of_interest.html)页面和[merge_rules](https://github.com/pytorch/pytorch/blob/main/.github/merge_rules.yaml)文件中。当前维护者将投票支持。批准PR的决策标准： +要将合格的人员添加到维护者列表中，请创建一个 PR，将一个人添加到[感兴趣的人](https://pytorch.org/docs/main/community/persons_of_interest.html)页面和[merge_rules](https://github.com/pytorch/pytorch/blob/main/.github/merge_rules.yaml)文件中。当前维护者将投票支持。批准 PR 的决策标准： + 在合并之前至少过去了两个工作日（确保大多数贡献者已经看到） -+ PR具有正确的标签（module: ci） ++ PR 具有正确的标签（module: ci） + 当前维护者没有异议 -+ 当前维护者中至少有三个网站点赞（或者当模块的维护者少于3人时，所有维护者都投票赞成）。 ++ 当前维护者中至少有三个网站点赞（或者当模块的维护者少于 3 人时，所有维护者都投票赞成）。 diff --git a/totrans/doc22_003.md b/totrans/doc22_003.md index 88bfe0fd..683a755a 100644 --- a/totrans/doc22_003.md +++ b/totrans/doc22_003.md @@ -1,58 +1,58 @@ -# PyTorch贡献指南 +# PyTorch 贡献指南 -> 原文：[https://pytorch.org/docs/stable/community/contribution_guide.html](https://pytorch.org/docs/stable/community/contribution_guide.html) +> 原文：[`pytorch.org/docs/stable/community/contribution_guide.html`](https://pytorch.org/docs/stable/community/contribution_guide.html) 注意 -此页面已被弃用。请参考PyTorch Wiki上的[贡献指南](https://github.com/pytorch/pytorch/wiki/The-Ultimate-Guide-to-PyTorch-Contributions)。 +此页面已被弃用。请参考 PyTorch Wiki 上的[贡献指南](https://github.com/pytorch/pytorch/wiki/The-Ultimate-Guide-to-PyTorch-Contributions)。 -PyTorch是一个使用基于磁带的自动求导系统构建深度神经网络的GPU加速Python张量计算包。 +PyTorch 是一个使用基于磁带的自动求导系统构建深度神经网络的 GPU 加速 Python 张量计算包。 ## 贡献流程 -PyTorch组织受[PyTorch治理](governance.html)的管理，有关贡献的技术指南可以在[CONTRIBUTING.md](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md)中找到。 +PyTorch 组织受 PyTorch 治理的管理，有关贡献的技术指南可以在[CONTRIBUTING.md](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md)中找到。 -PyTorch开发过程涉及核心开发团队和社区之间的大量开放讨论。 +PyTorch 开发过程涉及核心开发团队和社区之间的大量开放讨论。 -PyTorch的运作方式与GitHub上的大多数开源项目类似。但是，如果您以前从未为开源项目做出过贡献，这是基本流程。 +PyTorch 的运作方式与 GitHub 上的大多数开源项目类似。但是，如果您以前从未为开源项目做出过贡献，这是基本流程。 + **确定您要做什么。**大多数开源贡献来自于人们解决自己的问题。但是，如果您不知道要做什么，或者只是想更熟悉项目，以下是一些寻找适当任务的提示： + 浏览[问题跟踪器](https://github.com/pytorch/pytorch/issues/)，看看是否有任何您知道如何解决的问题。其他贡献者确认的问题往往更好调查。我们还为可能适合新人的问题维护一些标签，例如**bootcamp**和**1hr**，尽管这些标签维护得不太好。 - + 加入我们在[dev discuss](https://dev-discuss.pytorch.org/)，让我们知道您有兴趣了解PyTorch。我们非常乐意帮助研究人员和合作伙伴快速掌握代码库。 + + 加入我们在[dev discuss](https://dev-discuss.pytorch.org/)，让我们知道您有兴趣了解 PyTorch。我们非常乐意帮助研究人员和合作伙伴快速掌握代码库。 -+ **确定您的更改范围，并在GitHub问题上寻求设计意见，如果更改较大。**大多数拉取请求都很小；在这种情况下，不需要告诉我们您想要做什么，只需开始。但是，如果更改将是大的，通常最好先通过[提交RFC](https://github.com/pytorch/rfcs/blob/master/README.md)获取一些设计意见。 ++ **确定您的更改范围，并在 GitHub 问题上寻求设计意见，如果更改较大。**大多数拉取请求都很小；在这种情况下，不需要告诉我们您想要做什么，只需开始。但是，如果更改将是大的，通常最好先通过[提交 RFC](https://github.com/pytorch/rfcs/blob/master/README.md)获取一些设计意见。 + 如果您不知道更改的大小，我们可以帮助您弄清楚！只需在[问题](https://github.com/pytorch/pytorch/issues/)或[dev discuss](https://dev-discuss.pytorch.org/)上发布关于此的帖子。 - + 一些功能添加是非常标准化的；例如，很多人向PyTorch添加新的运算符或优化器。在这些情况下的设计讨论主要归结为，“我们想要这个运算符/优化器吗？”提供其实用性的证据，例如在同行评审的论文中的使用，或在其他框架中的存在，有助于在这种情况下做出论证。 + + 一些功能添加是非常标准化的；例如，很多人向 PyTorch 添加新的运算符或优化器。在这些情况下的设计讨论主要归结为，“我们想要这个运算符/优化器吗？”提供其实用性的证据，例如在同行评审的论文中的使用，或在其他框架中的存在，有助于在这种情况下做出论证。 - + **从最近发布的研究中添加运算符/算法**通常不被接受，除非有压倒性证据表明这项新发布的工作具有突破性结果，并最终将成为该领域的标准。如果您不确定您的方法属于哪一类，请在实施PR之前先提出一个问题。 + + **从最近发布的研究中添加运算符/算法**通常不被接受，除非有压倒性证据表明这项新发布的工作具有突破性结果，并最终将成为该领域的标准。如果您不确定您的方法属于哪一类，请在实施 PR 之前先提出一个问题。 - + 核心更改和重构可能会很难协调，因为PyTorch主分支上的开发速度非常快。绝对要就基本或跨领域的更改进行沟通；我们通常可以指导如何将这些更改分阶段成更容易审查的部分。 + + 核心更改和重构可能会很难协调，因为 PyTorch 主分支上的开发速度非常快。绝对要就基本或跨领域的更改进行沟通；我们通常可以指导如何将这些更改分阶段成更容易审查的部分。 + **编写代码！** - + 查看[CONTRIBUTING.md](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md)文件，了解如何在技术形式上与PyTorch合作的建议。 + + 查看[CONTRIBUTING.md](https://github.com/pytorch/pytorch/blob/main/CONTRIBUTING.md)文件，了解如何在技术形式上与 PyTorch 合作的建议。 + **打开一个拉取请求。** - + 如果您还没有准备好进行审查拉取请求，请首先创建一个草稿拉取请求-您可以稍后通过按“准备审查”按钮将其转换为完整PR。您还可以在PR的标题前加上“[WIP]”（“正在进行中”）的前缀，而它仍处于草稿状态时。在进行审查时，我们将忽略草稿PR。如果您正在进行复杂的更改，最好从草稿开始，因为您需要花时间查看CI结果，以查看事情是否成功。 + + 如果您还没有准备好进行审查拉取请求，请首先创建一个草稿拉取请求-您可以稍后通过按“准备审查”按钮将其转换为完整 PR。您还可以在 PR 的标题前加上“[WIP]”（“正在进行中”）的前缀，而它仍处于草稿状态时。在进行审查时，我们将忽略草稿 PR。如果您正在进行复杂的更改，最好从草稿开始，因为您需要花时间查看 CI 结果，以查看事情是否成功。 - + 为您的更改找到一个合适的审阅者。我们有一些经常浏览PR队列并尝试审查所有内容的人，但如果您恰好知道受您补丁影响的给定子系统的维护者是谁，请随时在拉取请求中直接包含他们。您可以了解更多关于可能审查您代码的[感兴趣的人](https://pytorch.org/docs/main/community/persons_of_interest.html)。 + + 为您的更改找到一个合适的审阅者。我们有一些经常浏览 PR 队列并尝试审查所有内容的人，但如果您恰好知道受您补丁影响的给定子系统的维护者是谁，请随时在拉取请求中直接包含他们。您可以了解更多关于可能审查您代码的[感兴趣的人](https://pytorch.org/docs/main/community/persons_of_interest.html)。 + **在拉取请求被接受之前不断迭代！** - + 我们将尽力减少审查往返次数，并仅在存在重大问题时阻止PR。有关拉取请求中最常见的问题，请查看[常见错误](#common-mistakes-to-avoid)。 + + 我们将尽力减少审查往返次数，并仅在存在重大问题时阻止 PR。有关拉取请求中最常见的问题，请查看常见错误。 - + 一旦拉取请求被接受并且CI通过，您就不需要做任何其他事情；我们将为您合并PR。 + + 一旦拉取请求被接受并且 CI 通过，您就不需要做任何其他事情；我们将为您合并 PR。 ## 入门 ### 提出新功能 -最好在特定问题上讨论新功能想法。请尽可能提供尽可能多的信息，任何相关数据以及您的建议解决方案。PyTorch团队和社区经常审查他们认为可以帮助的新问题和评论。如果您对解决方案有信心，请继续实施。 +最好在特定问题上讨论新功能想法。请尽可能提供尽可能多的信息，任何相关数据以及您的建议解决方案。PyTorch 团队和社区经常审查他们认为可以帮助的新问题和评论。如果您对解决方案有信心，请继续实施。 ### 报告问题 @@ -60,23 +60,23 @@ PyTorch的运作方式与GitHub上的大多数开源项目类似。但是，如 ### 实施功能或修复错误 -如果您想修复特定问题，最好在个别问题上发表评论表明您的意图。但是，除非我们之前与开发人员合作过，在其他情况下我们不会锁定或分配问题。最好在问题上开始对话并讨论您提出的解决方案。PyTorch团队可以提供节省您时间的指导。 +如果您想修复特定问题，最好在个别问题上发表评论表明您的意图。但是，除非我们之前与开发人员合作过，在其他情况下我们不会锁定或分配问题。最好在问题上开始对话并讨论您提出的解决方案。PyTorch 团队可以提供节省您时间的指导。 -标记为first-new-issue、low或medium优先级的问题提供了最好的入口点，是开始的好地方。 +标记为 first-new-issue、low 或 medium 优先级的问题提供了最好的入口点，是开始的好地方。 ### 添加教程 -[pytorch.org](https://pytorch.org/)上的许多教程都来自社区本身，我们欢迎额外的贡献。要了解如何贡献新教程，您可以在这里了解更多：[GitHub上的PyTorch.org教程贡献指南](https://github.com/pytorch/tutorials/#contributing) +[pytorch.org](https://pytorch.org/)上的许多教程都来自社区本身，我们欢迎额外的贡献。要了解如何贡献新教程，您可以在这里了解更多：[GitHub 上的 PyTorch.org 教程贡献指南](https://github.com/pytorch/tutorials/#contributing) ### 改进文档和教程 我们的目标是制作高质量的文档和教程。在极少数情况下，内容可能包含拼写错误或错误。如果您发现可以修复的问题，请向我们发送拉取请求以供考虑。 -查看[文档](#on-documentation)部分以了解我们的系统如何运作。 +查看文档部分以了解我们的系统如何运作。 ### 参与在线讨论 -您可以在[PyTorch讨论论坛](https://discuss.pytorch.org/)上找到正在进行的活跃讨论，供用户使用，以及[PyTorch Dev讨论论坛](https://dev-discuss.pytorch.org/)供开发人员和维护者使用。 +您可以在[PyTorch 讨论论坛](https://discuss.pytorch.org/)上找到正在进行的活跃讨论，供用户使用，以及[PyTorch Dev 讨论论坛](https://dev-discuss.pytorch.org/)供开发人员和维护者使用。 ### 提交拉取请求以修复开放问题 @@ -88,19 +88,19 @@ PyTorch的运作方式与GitHub上的大多数开源项目类似。但是，如 ### 审查未解决的拉取请求[](#reviewing-open-pull-requests "跳转到此标题") -我们感谢您帮助审查和评论拉取请求。我们的团队努力保持可管理大小的未解决拉取请求数量，如果需要更多信息，我们会迅速回应，并合并我们认为有用的PR。然而，由于高度的兴趣，对拉取请求的额外关注总是受欢迎的。 +我们感谢您帮助审查和评论拉取请求。我们的团队努力保持可管理大小的未解决拉取请求数量，如果需要更多信息，我们会迅速回应，并合并我们认为有用的 PR。然而，由于高度的兴趣，对拉取请求的额外关注总是受欢迎的。 ### 提高代码可读性[](#improving-code-readability "跳转到此标题") -提高代码可读性有助于每个人。通常最好提交少量涉及少数文件的拉取请求，而不是涉及许多文件的大型拉取请求。在PyTorch论坛[这里](https://discuss.pytorch.org/)开始讨论或与您的改进相关的问题是开始的最佳方式。 +提高代码可读性有助于每个人。通常最好提交少量涉及少数文件的拉取请求，而不是涉及许多文件的大型拉取请求。在 PyTorch 论坛[这里](https://discuss.pytorch.org/)开始讨论或与您的改进相关的问题是开始的最佳方式。 ### 添加测试用例以使代码库更加健壮[](#adding-test-cases-to-make-the-codebase-more-robust "跳转到此标题") 额外的测试覆盖是受欢迎的。 -### 推广PyTorch +### 推广 PyTorch -您在项目、研究论文、写作、博客或互联网上的一般讨论中使用PyTorch有助于提高PyTorch和我们不断增长的社区的知名度。请联系[marketing@pytorch.org](mailto:marketing%40pytorch.org)获取营销支持。 +您在项目、研究论文、写作、博客或互联网上的一般讨论中使用 PyTorch 有助于提高 PyTorch 和我们不断增长的社区的知名度。请联系 marketing@pytorch.org 获取营销支持。 ### 分类问题 @@ -122,72 +122,72 @@ PyTorch的运作方式与GitHub上的大多数开源项目类似。但是，如 1. 帮助我们判断以后是否会破坏它 - 1. 帮助我们判断补丁是否正确（是的，我们已经审查过，但正如Knuth所说，“谨防以下代码，因为我没有运行它，只是证明它是正确的”） + 1. 帮助我们判断补丁是否正确（是的，我们已经审查过，但正如 Knuth 所说，“谨防以下代码，因为我没有运行它，只是证明它是正确的”） + 何时可以不添加测试？有时候一个更改无法方便地进行测试，或者更改是如此明显正确（并且不太可能出错），那么不测试也是可以的。相反，如果一个更改似乎可能（或已知可能）会被意外破坏，那么重要的是花时间制定测试策略。 -+ **您的PR太长了吗？** ++ **您的 PR 太长了吗？** - + 对我们来说，审查和合并小的PR更容易。审查PR的难度与其大小呈非线性关系。 + + 对我们来说，审查和合并小的 PR 更容易。审查 PR 的难度与其大小呈非线性关系。 - + 何时可以提交一个大的PR？如果在问题中有相应的设计讨论，并且得到了将要审查您的差异的人员的签署，那将会很有帮助。我们也可以帮助提供建议，如何将大的更改拆分成可以单独发布的部分。同样，如果PR的内容有完整的描述，那将会很有帮助：如果我们知道里面有什么，那么审查代码就会更容易！ + + 何时可以提交一个大的 PR？如果在问题中有相应的设计讨论，并且得到了将要审查您的差异的人员的签署，那将会很有帮助。我们也可以帮助提供建议，如何将大的更改拆分成可以单独发布的部分。同样，如果 PR 的内容有完整的描述，那将会很有帮助：如果我们知道里面有什么，那么审查代码就会更容易！ + **对微妙的事情有评论吗？** 在您的代码行为微妙的情况下，请包含额外的注释和文档，以便我们更好地理解您的代码的意图。 -+ **您添加了一个hack吗？** 有时，正确的答案是一个hack。但通常，我们将不得不讨论它。 ++ **您添加了一个 hack 吗？** 有时，正确的答案是一个 hack。但通常，我们将不得不讨论它。 + **您想要触及一个非常核心的组件吗？** 为了防止主要的退化，触及核心组件的拉取请求将接受额外的审查。确保在进行重大更改之前已经与团队讨论了您的更改。 + **想要添加一个新功能吗？** 如果您想添加新功能，请在相关问题上评论您的意图。我们的团队试图评论并向社区提供反馈。在构建新功能之前，最好与团队和其他社区进行公开讨论。这有助于我们了解您正在做什么，并增加它被合并的机会。 -+ **您是否触及了与PR无关的代码？** 为了帮助代码审查，请只在您的拉取请求中包含与您的更改直接相关的文件。 ++ **您是否触及了与 PR 无关的代码？** 为了帮助代码审查，请只在您的拉取请求中包含与您的更改直接相关的文件。 ## 常见问题[](#frequently-asked-questions "跳转到此标题") + **作为审阅者，我如何贡献？** 如果社区开发人员复制问题、尝试新功能或以其他方式帮助我们识别或解决问题，那将会有很大的价值。在任务或拉取请求上评论您的环境详细信息是有帮助和受欢迎的。 -+ **CI测试失败，这是什么意思？**也许您的PR基于一个破损的主分支？您可以尝试将您的更改重新基于最新的主分支。您还可以在[https://hud.pytorch.org/](https://hud.pytorch.org/)上查看主分支CI的当前状态。 ++ **CI 测试失败，这是什么意思？**也许您的 PR 基于一个破损的主分支？您可以尝试将您的更改重新基于最新的主分支。您还可以在[`hud.pytorch.org/`](https://hud.pytorch.org/)上查看主分支 CI 的当前状态。 + **哪些是最高风险的更改？** 任何涉及构建配置的更改都是一个风险区域。请避免在没有事先与团队讨论的情况下更改这些内容。 -+ **嘿，我的分支上出现了一个提交，怎么回事？** 有时，另一个社区成员会为您的拉取请求或分支提供补丁或修复。这通常是为了让CI测试通过。 ++ **嘿，我的分支上出现了一个提交，怎么回事？** 有时，另一个社区成员会为您的拉取请求或分支提供补丁或修复。这通常是为了让 CI 测试通过。 ## 关于文档 -### Python文档 +### Python 文档 -PyTorch文档是使用[Sphinx](https://www.sphinx-doc.org/en/master/)从Python源代码生成的。生成的HTML被复制到[pytorch.github.io](https://github.com/pytorch/pytorch.github.io/tree/master/docs)主分支的docs文件夹中，并通过GitHub页面提供服务。 +PyTorch 文档是使用[Sphinx](https://www.sphinx-doc.org/en/master/)从 Python 源代码生成的。生成的 HTML 被复制到[pytorch.github.io](https://github.com/pytorch/pytorch.github.io/tree/master/docs)主分支的 docs 文件夹中，并通过 GitHub 页面提供服务。 -+ 网站: [https://pytorch.org/docs](https://pytorch.org/docs) ++ 网站: [`pytorch.org/docs`](https://pytorch.org/docs) -+ GitHub: [https://github.com/pytorch/pytorch/tree/main/docs](https://github.com/pytorch/pytorch/tree/main/docs) ++ GitHub: [`github.com/pytorch/pytorch/tree/main/docs`](https://github.com/pytorch/pytorch/tree/main/docs) -+ 提供自：[https://github.com/pytorch/pytorch.github.io/tree/master/docs](https://github.com/pytorch/pytorch.github.io/tree/master/docs) ++ 提供自：[`github.com/pytorch/pytorch.github.io/tree/master/docs`](https://github.com/pytorch/pytorch.github.io/tree/master/docs) ### C++文档 -对于C++代码，我们使用Doxygen来生成内容文件。C++文档是在一个特殊的服务器上构建的，生成的文件被复制到[https://github.com/pytorch/cppdocs](https://github.com/pytorch/cppdocs)存储库，并通过GitHub页面提供服务。 +对于 C++代码，我们使用 Doxygen 来生成内容文件。C++文档是在一个特殊的服务器上构建的，生成的文件被复制到[`github.com/pytorch/cppdocs`](https://github.com/pytorch/cppdocs)存储库，并通过 GitHub 页面提供服务。 -+ 网站: [https://pytorch.org/cppdocs](https://pytorch.org/cppdocs) ++ 网站: [`pytorch.org/cppdocs`](https://pytorch.org/cppdocs) -+ GitHub: [https://github.com/pytorch/pytorch/tree/main/docs/cpp](https://github.com/pytorch/pytorch/tree/main/docs/cpp) ++ GitHub: [`github.com/pytorch/pytorch/tree/main/docs/cpp`](https://github.com/pytorch/pytorch/tree/main/docs/cpp) -+ 托管自：[https://github.com/pytorch/cppdocs](https://github.com/pytorch/cppdocs) ++ 托管自：[`github.com/pytorch/cppdocs`](https://github.com/pytorch/cppdocs) ## 教程 -PyTorch教程是用来帮助理解如何使用PyTorch来完成特定任务或理解更全面概念的文档。教程是使用[Sphinx-Gallery](https://sphinx-gallery.readthedocs.io/en/latest/index.html)从可执行的Python源文件或重构文本（rst）文件构建的。 +PyTorch 教程是用来帮助理解如何使用 PyTorch 来完成特定任务或理解更全面概念的文档。教程是使用[Sphinx-Gallery](https://sphinx-gallery.readthedocs.io/en/latest/index.html)从可执行的 Python 源文件或重构文本（rst）文件构建的。 -+ 站点：[https://pytorch.org/tutorials](https://pytorch.org/tutorials) ++ 站点：[`pytorch.org/tutorials`](https://pytorch.org/tutorials) -+ GitHub: [https://github.com/pytorch/tutorials](https://github.com/pytorch/tutorials) ++ GitHub: [`github.com/pytorch/tutorials`](https://github.com/pytorch/tutorials) ### 教程构建概述 -对于教程，[拉取请求](https://github.com/pytorch/tutorials/pulls)会触发使用CircleCI重新构建整个站点以测试更改的影响。此构建被分成9个工作构建，并总共需要大约40分钟。同时，我们使用*make html-noplot*进行Netlify构建，该构建在不将笔记本输出呈现为页面的情况下构建站点以便快速审阅。 +对于教程，[拉取请求](https://github.com/pytorch/tutorials/pulls)会触发使用 CircleCI 重新构建整个站点以测试更改的影响。此构建被分成 9 个工作构建，并总共需要大约 40 分钟。同时，我们使用*make html-noplot*进行 Netlify 构建，该构建在不将笔记本输出呈现为页面的情况下构建站点以便快速审阅。 -在PR被接受后，站点将使用GitHub Actions进行重新构建和部署。 +在 PR 被接受后，站点将使用 GitHub Actions 进行重新构建和部署。 ### 贡献新教程[](#contributing-a-new-tutorial "跳转到此标题的永久链接") -请参阅[PyTorch.org教程贡献指南](https://github.com/pytorch/tutorials/#contributing)。 +请参阅[PyTorch.org 教程贡献指南](https://github.com/pytorch/tutorials/#contributing)。 diff --git a/totrans/doc22_004.md b/totrans/doc22_004.md index ad1a86cf..d3753e5b 100644 --- a/totrans/doc22_004.md +++ b/totrans/doc22_004.md @@ -1,22 +1,22 @@ -# PyTorch设计哲学 +# PyTorch 设计哲学 -> 原文：[https://pytorch.org/docs/stable/community/design.html](https://pytorch.org/docs/stable/community/design.html) +> 原文：[`pytorch.org/docs/stable/community/design.html`](https://pytorch.org/docs/stable/community/design.html) -本文旨在帮助贡献者和模块维护者了解PyTorch中随着时间发展而形成的高层设计原则。这些并不是硬性规则，而是作为指导，帮助权衡不同的考虑因素，并解决在开发PyTorch过程中可能出现的分歧。有关更多贡献信息，模块维护和如何将分歧升级到核心维护者，请参阅[PyTorch Governance](https://pytorch.org/docs/main/community/governance.html)。 +本文旨在帮助贡献者和模块维护者了解 PyTorch 中随着时间发展而形成的高层设计原则。这些并不是硬性规则，而是作为指导，帮助权衡不同的考虑因素，并解决在开发 PyTorch 过程中可能出现的分歧。有关更多贡献信息，模块维护和如何将分歧升级到核心维护者，请参阅[PyTorch Governance](https://pytorch.org/docs/main/community/governance.html)。 ## 设计原则 -### 原则1：可用性优于性能 +### 原则 1：可用性优于性能 -这个原则可能会让人感到惊讶！正如一位Hacker News的作者写道：*PyTorch太棒了！[…]尽管我感到困惑。一个机器学习框架怎么可能不痴迷于速度/性能？*参见[Hacker News关于PyTorch的讨论](https://news.ycombinator.com/item?id=28066093)。 +这个原则可能会让人感到惊讶！正如一位 Hacker News 的作者写道：*PyTorch 太棒了！[…]尽管我感到困惑。一个机器学习框架怎么可能不痴迷于速度/性能？*参见[Hacker News 关于 PyTorch 的讨论](https://news.ycombinator.com/item?id=28066093)。 -Soumith在[Growing the PyTorch Community](https://soumith.ch/posts/2021/02/growing-opensource/?fbclid=IwAR1bvN_xZ8avGvu14ODJzS8Zp7jX1BOyfuGUf-zoRawpyL-s95Vjxf88W7s)的博客文章中深入探讨了这一点，但在高层次上： +Soumith 在[Growing the PyTorch Community](https://soumith.ch/posts/2021/02/growing-opensource/?fbclid=IwAR1bvN_xZ8avGvu14ODJzS8Zp7jX1BOyfuGUf-zoRawpyL-s95Vjxf88W7s)的博客文章中深入探讨了这一点，但在高层次上： -+ PyTorch的主要目标是可用性 ++ PyTorch 的主要目标是可用性 + 一个次要目标是具有*合理*的性能 -我们相信保持灵活性以支持在我们的抽象之上构建的研究人员的能力仍然至关重要。我们无法预见工作负载的未来会是什么样子，但我们知道我们希望它们首先建立在PyTorch上，这需要灵活性。 +我们相信保持灵活性以支持在我们的抽象之上构建的研究人员的能力仍然至关重要。我们无法预见工作负载的未来会是什么样子，但我们知道我们希望它们首先建立在 PyTorch 上，这需要灵活性。 更具体地说，我们以*可用性为先*的方式运作，并尝试避免在没有清晰看法的情况下跳到*限制为先*的制度（例如，静态形状，仅图模式）。通常会有一种诱惑，即在一开始就对用户施加严格的限制，因为这样可以简化实现，但这也带来了风险： @@ -24,39 +24,39 @@ Soumith在[Growing the PyTorch Community](https://soumith.ch/posts/2021/02/growi + 即使性能优势引人注目，限制也可能将生态系统分割成不同的限制集，这些限制集很快就会变得令用户难以理解。 -我们希望用户能够无缝地将他们的PyTorch代码移植到不同的硬件和软件平台，与不同的库和框架进行互操作，并体验PyTorch用户体验的全部丰富性，而不是最低公共分母子集。 +我们希望用户能够无缝地将他们的 PyTorch 代码移植到不同的硬件和软件平台，与不同的库和框架进行互操作，并体验 PyTorch 用户体验的全部丰富性，而不是最低公共分母子集。 -### 原则2：简单胜于容易 +### 原则 2：简单胜于容易 -在这里，我们借鉴了[Python之禅](https://peps.python.org/pep-0020/)： +在这里，我们借鉴了[Python 之禅](https://peps.python.org/pep-0020/)： + *显式胜于隐式* + *简单胜于复杂* -描述这两个目标的更简洁方式是[Simple Over Easy](https://www.infoq.com/presentations/Simple-Made-Easy/)。让我们从一个例子开始，因为*简单*和*容易*在日常英语中经常被互换使用。考虑如何在PyTorch中建模[设备](https://pytorch.org/docs/main/tensor_attributes.html#torch.device)： +描述这两个目标的更简洁方式是[Simple Over Easy](https://www.infoq.com/presentations/Simple-Made-Easy/)。让我们从一个例子开始，因为*简单*和*容易*在日常英语中经常被互换使用。考虑如何在 PyTorch 中建模[设备](https://pytorch.org/docs/main/tensor_attributes.html#torch.device)： + **简单/显式（易于理解，调试）：**每个张量都与一个设备相关联。用户明确指定张量设备移动。需要跨设备移动的操作会导致错误。 + **容易/隐式（使用）：**用户不必担心设备；系统会找出全局最佳设备放置。 -在这种特定情况下，以及作为一种一般的设计哲学，PyTorch更倾向于暴露简单和明确的构建块，而不是易于使用的API。简单版本对新的PyTorch用户来说是立即可理解和可调试的：如果在程序中调用需要跨设备移动的操作符，您会在操作符实际调用的地方得到清晰的错误。简单的解决方案可能让新用户最初移动得更快，但调试这样的系统可能会很复杂：系统是如何做出决定的？如何插入这样一个系统的API以及对象在其IR中是如何表示的？ +在这种特定情况下，以及作为一种一般的设计哲学，PyTorch 更倾向于暴露简单和明确的构建块，而不是易于使用的 API。简单版本对新的 PyTorch 用户来说是立即可理解和可调试的：如果在程序中调用需要跨设备移动的操作符，您会在操作符实际调用的地方得到清晰的错误。简单的解决方案可能让新用户最初移动得更快，但调试这样的系统可能会很复杂：系统是如何做出决定的？如何插入这样一个系统的 API 以及对象在其 IR 中是如何表示的？ 这种设计的一些经典论点来自于[A Note on Distributed Computation](https://dl.acm.org/doi/book/10.5555/974938)（TLDR：不要用非常不同性能特征的资源统一建模，细节会泄漏）和[End-to-End Principle](http://web.mit.edu/Saltzer/www/publications/endtoend/endtoend.pdf)（TLDR：在堆栈的较低层构建智能可以防止在堆栈的较高层构建高性能功能，并且通常也不起作用）。例如，我们可以构建操作级别或全局设备移动规则，但具体选择并不明显，构建一个可扩展的机制会带来不可避免的复杂性和延迟成本。 -这里的一个警告是，这并不意味着更高级的“易用”API没有价值；当然，例如，在堆栈的更高层支持在大型集群中跨异构计算进行有效的张量计算是有价值的。相反，我们的意思是专注于简单的低级构建块有助于指导易用API，同时在用户需要离开常规路径时仍保持良好的体验。这也为创新和更具观点的工具的增长提供了空间，这是我们在PyTorch核心库中无法支持的速度，但最终会受益于我们的[丰富生态系统](https://pytorch.org/ecosystem/)。换句话说，不在开始自动化可以让我们更快地达到良好自动化水平的可能性。 +这里的一个警告是，这并不意味着更高级的“易用”API 没有价值；当然，例如，在堆栈的更高层支持在大型集群中跨异构计算进行有效的张量计算是有价值的。相反，我们的意思是专注于简单的低级构建块有助于指导易用 API，同时在用户需要离开常规路径时仍保持良好的体验。这也为创新和更具观点的工具的增长提供了空间，这是我们在 PyTorch 核心库中无法支持的速度，但最终会受益于我们的[丰富生态系统](https://pytorch.org/ecosystem/)。换句话说，不在开始自动化可以让我们更快地达到良好自动化水平的可能性。 -### 原则3：Python First with Best In Class Language Interoperability（Python优先，具有最佳类语言互操作性） +### 原则 3：Python First with Best In Class Language Interoperability（Python 优先，具有最佳类语言互操作性） 这个原则始于**Python First**： -> PyTorch不是Python绑定到一个单片C++框架。它被构建为与Python深度集成。您可以像使用[NumPy](https://www.numpy.org/)、[SciPy](https://www.scipy.org/)、[scikit-learn]((https://scikit-learn.org/)或其他Python库一样自然地使用它。您可以在Python中编写您自己的新神经网络层，使用您喜欢的库，并使用诸如[Cython](https://cython.org/)和[Numba](http://numba.pydata.org/)等包。我们的目标是在适当的情况下不重新发明轮子。 +> PyTorch 不是 Python 绑定到一个单片 C++框架。它被构建为与 Python 深度集成。您可以像使用[NumPy](https://www.numpy.org/)、[SciPy](https://www.scipy.org/)、scikit-learn 或其他 Python 库一样自然地使用它。您可以在 Python 中编写您自己的新神经网络层，使用您喜欢的库，并使用诸如[Cython](https://cython.org/)和[Numba](http://numba.pydata.org/)等包。我们的目标是在适当的情况下不重新发明轮子。 -多年来PyTorch需要处理的一个问题是Python开销：我们首先用C++重写了自动求导引擎，然后是大部分操作符定义，然后开发了TorchScript和C++前端。 +多年来 PyTorch 需要处理的一个问题是 Python 开销：我们首先用 C++重写了自动求导引擎，然后是大部分操作符定义，然后开发了 TorchScript 和 C++前端。 -然而，在Python中工作为我们的用户提供了最好的体验：它灵活、熟悉，也许最重要的是，有一个巨大的科学计算库和扩展生态系统可供使用。这个事实激励了我们最近一些贡献，试图在接近Python可用性端的Pareto最优点上达到一个平衡点： +然而，在 Python 中工作为我们的用户提供了最好的体验：它灵活、熟悉，也许最重要的是，有一个巨大的科学计算库和扩展生态系统可供使用。这个事实激励了我们最近一些贡献，试图在接近 Python 可用性端的 Pareto 最优点上达到一个平衡点： -+ [TorchDynamo](https://dev-discuss.pytorch.org/t/torchdynamo-an-experiment-in-dynamic-python-bytecode-transformation/361)，这是一个Python帧评估工具，能够在最小程度用户干预的情况下加速现有的急切模式PyTorch程序。 ++ [TorchDynamo](https://dev-discuss.pytorch.org/t/torchdynamo-an-experiment-in-dynamic-python-bytecode-transformation/361)，这是一个 Python 帧评估工具，能够在最小程度用户干预的情况下加速现有的急切模式 PyTorch 程序。 + [torch_function](https://pytorch.org/docs/main/notes/extending.html#extending-torch) 和 [torch_dispatch](https://dev-discuss.pytorch.org/t/what-and-why-is-torch-dispatch/557) 扩展点，使得可以在 C++ 内部构建基于 Python 的功能，例如 [torch.fx tracer](https://pytorch.org/docs/stable/fx.html) 和 [functorch](https://github.com/pytorch/functorch)。 diff --git a/totrans/doc22_005.md b/totrans/doc22_005.md index 51db86be..a0e89c96 100644 --- a/totrans/doc22_005.md +++ b/totrans/doc22_005.md @@ -1,20 +1,20 @@ -# PyTorch治理 | 机制 +# PyTorch 治理 | 机制 -> 原文：[https://pytorch.org/docs/stable/community/governance.html](https://pytorch.org/docs/stable/community/governance.html) +> 原文：[`pytorch.org/docs/stable/community/governance.html`](https://pytorch.org/docs/stable/community/governance.html) ## 总结 -PyTorch采用了一个分层的技术治理结构。 +PyTorch 采用了一个分层的技术治理结构。 + 一个**贡献者**社区，提交问题，拉取请求，并为项目做出贡献。 -+ 一小部分**模块维护者**推动PyTorch项目的每个模块。 ++ 一小部分**模块维护者**推动 PyTorch 项目的每个模块。 + 他们由**核心维护者**监督，推动整个项目的方向。 + 核心维护者有一个**首席核心维护者**，他是最终决策者。 -所有维护者都应该对PyTorch的设计理念有强烈偏见。 +所有维护者都应该对 PyTorch 的设计理念有强烈偏见。 除了维护者，鼓励社区贡献、提交问题、提出建议、审查拉取请求并参与社区。根据贡献和愿意投入，任何人都可以被接受为维护者，并获得代码库部分的写入访问权限或所有权。 @@ -22,7 +22,7 @@ PyTorch采用了一个分层的技术治理结构。 ## 模块维护者 -模块被定义为PyTorch组织中的GitHub存储库，或者作为核心存储库[pytorch/pytorch](https://github.com/pytorch/pytorch)中的目录。每个模块都将有自己的维护者组。维护者组负责审查和批准提交，改进设计，以及更改模块的范围。每个维护者组可以采用自己的规则和程序来做决定（默认情况下是多数投票）。模块维护者有权对其他模块维护者做出的决定提出异议 - 尤其是如果这影响到他们。在发生争议时，模块维护者组应提供一个合理且公开的争议解释，相关论点以及解决方案。在极端情况下，如果模块维护者无法自行达成结论，他们将升级到核心维护者进行审查。升级由核心维护者根据其规则和程序解决。 +模块被定义为 PyTorch 组织中的 GitHub 存储库，或者作为核心存储库[pytorch/pytorch](https://github.com/pytorch/pytorch)中的目录。每个模块都将有自己的维护者组。维护者组负责审查和批准提交，改进设计，以及更改模块的范围。每个维护者组可以采用自己的规则和程序来做决定（默认情况下是多数投票）。模块维护者有权对其他模块维护者做出的决定提出异议 - 尤其是如果这影响到他们。在发生争议时，模块维护者组应提供一个合理且公开的争议解释，相关论点以及解决方案。在极端情况下，如果模块维护者无法自行达成结论，他们将升级到核心维护者进行审查。升级由核心维护者根据其规则和程序解决。 每个维护者组应该公开发布他们模块的可用通信（愿景、大致路线图、设计文档、任何争议和争议解决方案），以便贡献者和其他感兴趣的方了解项目的未来方向，并参与讨论。 @@ -38,21 +38,21 @@ PyTorch采用了一个分层的技术治理结构。 ## 核心维护者 -核心维护者应该对PyTorch代码库和设计理念有深入的了解。他们的责任包括： +核心维护者应该对 PyTorch 代码库和设计理念有深入的了解。他们的责任包括： + 阐明项目的长期愿景 + 协商和解决有争议的问题，以符合所有涉及方的要求 -+ 接收来自PyTorch利益相关者的广泛变更请求，并评估/接受它们（小模块级别的请求由模块维护者处理） ++ 接收来自 PyTorch 利益相关者的广泛变更请求，并评估/接受它们（小模块级别的请求由模块维护者处理） 核心维护者作为一个团体有权否决模块维护者层面做出的任何决定。核心维护者有权解决争议，如他们认为合适的那样。核心维护者应该公开阐明他们的决策，并对他们的决定、否决和争议解决给出清晰的理由。 -核心维护者是PyTorch GitHub组织的管理员，并列在[Maintainers](https://pytorch.org/docs/stable/community/persons_of_interest.html)中。 +核心维护者是 PyTorch GitHub 组织的管理员，并列在[Maintainers](https://pytorch.org/docs/stable/community/persons_of_interest.html)中。 ## 首席核心维护者（BDFL） -核心维护者可能无法达成共识的决定。为了做出这样的困难决定，核心维护者中有一个指定的并公开声明的首席核心维护者，也在开源治理模型中通常被称为BDFL。 +核心维护者可能无法达成共识的决定。为了做出这样的困难决定，核心维护者中有一个指定的并公开声明的首席核心维护者，也在开源治理模型中通常被称为 BDFL。 首席核心维护者应公开表明他们的决策，并对其决定给出清晰的理由。首席核心维护者还负责确认或删除核心维护者。 @@ -60,9 +60,9 @@ PyTorch采用了一个分层的技术治理结构。 ### 原则 -+ 模块维护者组的成员资格是基于个人的优点，经过贡献、审查和讨论展示出对组件的强大专业知识，并与组件如何符合整体PyTorch方向保持一致。 ++ 模块维护者组的成员资格是基于个人的优点，经过贡献、审查和讨论展示出对组件的强大专业知识，并与组件如何符合整体 PyTorch 方向保持一致。 -+ 成为维护者组成员的个人必须展示与整体PyTorch原则的强烈和持续的一致性。 ++ 成为维护者组成员的个人必须展示与整体 PyTorch 原则的强烈和持续的一致性。 + 模块维护者或核心维护者没有任期限制 @@ -112,7 +112,7 @@ PyTorch采用了一个分层的技术治理结构。 + 其他核心和模块维护者的支持信 - + PyTorch社区内利益相关者的一般支持信 + + PyTorch 社区内利益相关者的一般支持信 + 任何适合候选人的新相关信息 @@ -126,7 +126,7 @@ PyTorch采用了一个分层的技术治理结构。 ## 添加、删除和重新范围化模块和项目[](#add-remove-and-re-scope-modules-and-projects "跳转到此标题") -核心维护者共同负责决定在PyTorch组织中添加、删除和重新范围化新模块，无论是作为PyTorch GitHub组织中的新存储库，还是作为[pytorch/pytorch](https://github.com/pytorch/pytorch)存储库中的文件夹。 +核心维护者共同负责决定在 PyTorch 组织中添加、删除和重新范围化新模块，无论是作为 PyTorch GitHub 组织中的新存储库，还是作为[pytorch/pytorch](https://github.com/pytorch/pytorch)存储库中的文件夹。 他们邀请社区成员（包括自己）提出这些更改的提案。提案是开放式的，但应该有一些基本工作来提出一个令人信服的理由。以下是这个过程的一个示例方法： @@ -134,7 +134,7 @@ PyTorch采用了一个分层的技术治理结构。 1. 阅读论文，参加会议，根据经验构建示例流程； -1. 创建一个世界状态 - 确保这种更改是必要的，例如添加一个新项目或模块是否值得维护成本；或者删除一个项目或模块不会从PyTorch中删除太多价值； +1. 创建一个世界状态 - 确保这种更改是必要的，例如添加一个新项目或模块是否值得维护成本；或者删除一个项目或模块不会从 PyTorch 中删除太多价值； 1. 创建一个提案；提案涵盖了一旦提案获得批准后的维护、开发和社区计划。 @@ -144,17 +144,17 @@ PyTorch采用了一个分层的技术治理结构。 ### 无争议的更改 -主要工作通过GitHub上的问题和拉取请求进行。维护者应避免直接将更改推送到PyTorch存储库，而是依赖于拉取请求。核心或模块维护者批准拉取请求后，可以在不经过进一步流程的情况下合并。核心和模块维护者，如[维护者](https://pytorch.org/docs/stable/community/persons_of_interest.html)页面和[CODEOWNERS](https://github.com/pytorch/pytorch/blob/master/CODEOWNERS)中列出的那样，最终批准这些更改。 +主要工作通过 GitHub 上的问题和拉取请求进行。维护者应避免直接将更改推送到 PyTorch 存储库，而是依赖于拉取请求。核心或模块维护者批准拉取请求后，可以在不经过进一步流程的情况下合并。核心和模块维护者，如[维护者](https://pytorch.org/docs/stable/community/persons_of_interest.html)页面和[CODEOWNERS](https://github.com/pytorch/pytorch/blob/master/CODEOWNERS)中列出的那样，最终批准这些更改。 通知相关专家有关问题或拉取请求是重要的。强烈建议在给定兴趣领域的专家进行审查，特别是在拉取请求的批准上。如果未能这样做，可能会导致相关专家撤销更改。 ### 有争议的决策过程[](#controversial-decision-process "跳转到此标题") -在给定兴趣领域进行重大更改需要打开一个GitHub问题进行讨论。这包括： +在给定兴趣领域进行重大更改需要打开一个 GitHub 问题进行讨论。这包括： -+ 对PyTorch框架或库的任何语义或语法更改。 ++ 对 PyTorch 框架或库的任何语义或语法更改。 -+ 对Python或C++ API的不兼容更改。 ++ 对 Python 或 C++ API 的不兼容更改。 + 核心框架或库的添加，包括现有库中的重大新功能。 @@ -164,20 +164,20 @@ PyTorch采用了一个分层的技术治理结构。 ### 一般项目政策 -PyTorch已被建立为PyTorch系列的LF项目，LLC。适用于PyTorch和PyTorch参与者的政策，包括商标使用指南，位于[https://www.lfprojects.org/policies/](https://www.lfprojects.org/policies/)。 +PyTorch 已被建立为 PyTorch 系列的 LF 项目，LLC。适用于 PyTorch 和 PyTorch 参与者的政策，包括商标使用指南，位于[`www.lfprojects.org/policies/`](https://www.lfprojects.org/policies/)。 -PyTorch参与者承认，所有新贡献的版权将由版权持有者保留为独立的作品，并且没有贡献者或版权持有者需要将版权分配给项目。除非另有说明，所有对项目的代码贡献必须使用此处提供的3-Clause-BSD许可证进行：[https://opensource.org/licenses/BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)（“项目许可证”）。所有出站代码将根据项目许可证提供。维护者可以根据特殊情况批准使用替代的开放许可证或许可证进行入站或出站贡献。 +PyTorch 参与者承认，所有新贡献的版权将由版权持有者保留为独立的作品，并且没有贡献者或版权持有者需要将版权分配给项目。除非另有说明，所有对项目的代码贡献必须使用此处提供的 3-Clause-BSD 许可证进行：[`opensource.org/licenses/BSD-3-Clause`](https://opensource.org/licenses/BSD-3-Clause)（“项目许可证”）。所有出站代码将根据项目许可证提供。维护者可以根据特殊情况批准使用替代的开放许可证或许可证进行入站或出站贡献。 ## 常见问题 -**问：如果我想拥有（或部分拥有）项目的某个部分，比如功能区域或领域库，例如** [线性代数](https://github.com/pytorch/pytorch/tree/master/torch/linalg) **或** [Torch Vision](https://github.com/pytorch/vision) **？** 这是完全可能的。第一步是开始为现有项目领域做出贡献并支持其健康和成功。此外，您可以通过GitHub问题提出新功能或改进项目领域的建议。 +**问：如果我想拥有（或部分拥有）项目的某个部分，比如功能区域或领域库，例如** [线性代数](https://github.com/pytorch/pytorch/tree/master/torch/linalg) **或** [Torch Vision](https://github.com/pytorch/vision) **？** 这是完全可能的。第一步是开始为现有项目领域做出贡献并支持其健康和成功。此外，您可以通过 GitHub 问题提出新功能或改进项目领域的建议。 -**问：如果我是一家公司，希望在内部开发中使用PyTorch，可以获得或购买董事会席位来推动项目方向吗？** 不可以，PyTorch项目严格遵循维护者项目理念，明确区分技术治理和业务治理。但是，如果您想参与赞助和支持，可以通过PyTorch基金会（PTF）和赞助参与。您还可以让个人工程师成为维护者，但这并不是保证，而是基于成绩。 +**问：如果我是一家公司，希望在内部开发中使用 PyTorch，可以获得或购买董事会席位来推动项目方向吗？** 不可以，PyTorch 项目严格遵循维护者项目理念，明确区分技术治理和业务治理。但是，如果您想参与赞助和支持，可以通过 PyTorch 基金会（PTF）和赞助参与。您还可以让个人工程师成为维护者，但这并不是保证，而是基于成绩。 -**问：PyTorch项目是否支持资助或支持独立开发者使用或贡献项目的方式？** 目前不支持。但我们正在寻找更好地支持PyTorch周围独立开发者社区的方法。如果您有建议或意见，请在PyTorch论坛上联系讨论。 +**问：PyTorch 项目是否支持资助或支持独立开发者使用或贡献项目的方式？** 目前不支持。但我们正在寻找更好地支持 PyTorch 周围独立开发者社区的方法。如果您有建议或意见，请在 PyTorch 论坛上联系讨论。 -**问：我如何向项目贡献代码？** 如果更改相对较小，可以立即在GitHub上发起拉取请求，由项目提交者进行审查和合并。对于较大的更改，请先提出问题以进行讨论。请参阅[PyTorch贡献者Wiki](https://github.com/pytorch/pytorch/wiki/The-Ultimate-Guide-to-PyTorch-Contributions)以获取详细步骤。 +**问：我如何向项目贡献代码？** 如果更改相对较小，可以立即在 GitHub 上发起拉取请求，由项目提交者进行审查和合并。对于较大的更改，请先提出问题以进行讨论。请参阅[PyTorch 贡献者 Wiki](https://github.com/pytorch/pytorch/wiki/The-Ultimate-Guide-to-PyTorch-Contributions)以获取详细步骤。 -**问：我可以成为项目的提交者吗？** 不幸的是，目前向PyTorch提交的过程涉及与Facebook基础设施的交互，只能由Facebook员工触发。但是，我们正在寻找扩大提交者群体至Facebook以外个人的方式，并将在工具存在允许时提供更新。 +**问：我可以成为项目的提交者吗？** 不幸的是，目前向 PyTorch 提交的过程涉及与 Facebook 基础设施的交互，只能由 Facebook 员工触发。但是，我们正在寻找扩大提交者群体至 Facebook 以外个人的方式，并将在工具存在允许时提供更新。 -**问：如果我想在会议或其他场合提供PyTorch教程怎么办？我需要‘官方’成为提交者吗？** 不需要，我们鼓励社区成员在任何地方展示他们的工作。请联系[marketing@pytorch.org](mailto:marketing%40pytorch.org)以获取营销支持。 +**问：如果我想在会议或其他场合提供 PyTorch 教程怎么办？我需要‘官方’成为提交者吗？** 不需要，我们鼓励社区成员在任何地方展示他们的工作。请联系 marketing@pytorch.org 以获取营销支持。 diff --git a/totrans/doc22_006.md b/totrans/doc22_006.md index c520c875..ed0e5487 100644 --- a/totrans/doc22_006.md +++ b/totrans/doc22_006.md @@ -1,6 +1,6 @@ -# PyTorch治理 | 维护者 +# PyTorch 治理 | 维护者 -> 原文：[https://pytorch.org/docs/stable/community/persons_of_interest.html](https://pytorch.org/docs/stable/community/persons_of_interest.html) +> 原文：[`pytorch.org/docs/stable/community/persons_of_interest.html`](https://pytorch.org/docs/stable/community/persons_of_interest.html) ## 责任 @@ -182,7 +182,7 @@ + 彼得·贝尔（[peterbell10](https://github.com/peterbell10)） -### CPU性能（Torch Inductor / MKLDNN）[](#cpu-performance-torch-inductor-mkldnn "跳转到此标题的永久链接") +### CPU 性能（Torch Inductor / MKLDNN）[](#cpu-performance-torch-inductor-mkldnn "跳转到此标题的永久链接") + 马明飞（[mingfeima](https://github.com/mingfeima)） @@ -206,7 +206,7 @@ + （名誉退休）李建辉（[Jianhui-Li](https://github.com/Jianhui-Li)） -### GPU性能（Torch Inductor / Triton / CUDA）[](#gpu-performance-torch-inductor-triton-cuda "跳转到此标题的永久链接") +### GPU 性能（Torch Inductor / Triton / CUDA）[](#gpu-performance-torch-inductor-triton-cuda "跳转到此标题的永久链接") + 娜塔莉亚·吉梅尔谢因（[ngimel](https://github.com/ngimel)） @@ -300,7 +300,7 @@ + （名誉退休）Sebastian Messmer（[smessmer](https://github.com/smessmer)） -### ONNX导出器 +### ONNX 导出器 + Aaron Bockover（[abock](https://github.com/abock)） diff --git a/totrans/doc22_008.md b/totrans/doc22_008.md index 217fe386..50ba12b5 100644 --- a/totrans/doc22_008.md +++ b/totrans/doc22_008.md @@ -1,46 +1,46 @@ -# CUDA自动混合精度示例 +# CUDA 自动混合精度示例 -> [https://pytorch.org/docs/stable/notes/amp_examples.html](https://pytorch.org/docs/stable/notes/amp_examples.html) +> [`pytorch.org/docs/stable/notes/amp_examples.html`](https://pytorch.org/docs/stable/notes/amp_examples.html) -通常，“自动混合精度训练”意味着同时使用[`torch.autocast`](../amp.html#torch.autocast "torch.autocast")和[`torch.cuda.amp.GradScaler`](../amp.html#torch.cuda.amp.GradScaler "torch.cuda.amp.GradScaler")进行训练。 +通常，“自动混合精度训练”意味着同时使用`torch.autocast`和`torch.cuda.amp.GradScaler`进行训练。 -[`torch.autocast`](../amp.html#torch.autocast "torch.autocast")的实例使得可以为选择的区域进行自动转换。自动转换会自动选择GPU操作的精度，以提高性能同时保持准确性。 +`torch.autocast`的实例使得可以为选择的区域进行自动转换。自动转换会自动选择 GPU 操作的精度，以提高性能同时保持准确性。 -[`torch.cuda.amp.GradScaler`](../amp.html#torch.cuda.amp.GradScaler "torch.cuda.amp.GradScaler")的实例有助于方便地执行梯度缩放的步骤。梯度缩放通过最小化梯度下溢来提高具有`float16`梯度的网络的收敛性，如[此处](../amp.html#gradient-scaling)所解释。 +`torch.cuda.amp.GradScaler`的实例有助于方便地执行梯度缩放的步骤。梯度缩放通过最小化梯度下溢来提高具有`float16`梯度的网络的收敛性，如此处所解释。 -[`torch.autocast`](../amp.html#torch.autocast "torch.autocast")和[`torch.cuda.amp.GradScaler`](../amp.html#torch.cuda.amp.GradScaler "torch.cuda.amp.GradScaler")是模块化的。在下面的示例中，每个都按照其各自的文档建议使用。 +`torch.autocast`和`torch.cuda.amp.GradScaler`是模块化的。在下面的示例中，每个都按照其各自的文档建议使用。 （这里的示例仅供参考。请查看[自动混合精度教程](https://pytorch.org/tutorials/recipes/recipes/amp_recipe.html)以获得可运行的步骤。） -+ [典型的混合精度训练](#typical-mixed-precision-training) ++ 典型的混合精度训练 -+ [使用未缩放梯度](#working-with-unscaled-gradients) ++ 使用未缩放梯度 - + [梯度裁剪](#gradient-clipping) + + 梯度裁剪 -+ [使用缩放梯度](#working-with-scaled-gradients) ++ 使用缩放梯度 - + [梯度累积](#gradient-accumulation) + + 梯度累积 - + [梯度惩罚](#gradient-penalty) + + 梯度惩罚 -+ [使用多个模型、损失和优化器](#working-with-multiple-models-losses-and-optimizers) ++ 使用多个模型、损失和优化器 -+ [使用多个GPU](#working-with-multiple-gpus) ++ 使用多个 GPU - + [单进程中的DataParallel](#dataparallel-in-a-single-process) + + 单进程中的 DataParallel - + [DistributedDataParallel，每个进程一个GPU](#distributeddataparallel-one-gpu-per-process) + + DistributedDataParallel，每个进程一个 GPU - + [DistributedDataParallel，每个进程多个GPU](#distributeddataparallel-multiple-gpus-per-process) + + DistributedDataParallel，每个进程多个 GPU -+ [自动转换和自定义自动梯度函数](#autocast-and-custom-autograd-functions) ++ 自动转换和自定义自动梯度函数 - + [具有多个输入或可自动转换操作的函数](#functions-with-multiple-inputs-or-autocastable-ops) + + 具有多个输入或可自动转换操作的函数 - + [需要特定`dtype`的函数](#functions-that-need-a-particular-dtype) + + 需要特定`dtype`的函数 -## [典型的混合精度训练](#id2)[](#typical-mixed-precision-training "跳转到此标题") +## 典型的混合精度训练[](#typical-mixed-precision-training "跳转到此标题") ```py # Creates model and optimizer in default precision @@ -73,13 +73,13 @@ for epoch in epochs: scaler.update() ``` -## [使用未缩放梯度](#id3)[](#working-with-unscaled-gradients "跳转到此标题") +## 使用未缩放梯度[](#working-with-unscaled-gradients "跳转到此标题") -`scaler.scale(loss).backward()`产生的所有梯度都是经过缩放的。如果您希望在`backward()`和`scaler.step(optimizer)`之间修改或检查参数的`.grad`属性，您应该首先取消缩放它们。例如，梯度裁剪操作会操纵一组梯度，使它们的全局范数（参见[`torch.nn.utils.clip_grad_norm_()`](../generated/torch.nn.utils.clip_grad_norm_.html#torch.nn.utils.clip_grad_norm_ "torch.nn.utils.clip_grad_norm_")）或最大幅度（参见[`torch.nn.utils.clip_grad_value_()`](../generated/torch.nn.utils.clip_grad_value_.html#torch.nn.utils.clip_grad_value_ "torch.nn.utils.clip_grad_value_")）小于某个用户设定的阈值。如果您尝试在不取消缩放的情况下裁剪梯度，梯度的范数/最大幅度也会被缩放，因此您请求的阈值（本来是用于*未缩放*梯度的阈值）将无效。 +`scaler.scale(loss).backward()`产生的所有梯度都是经过缩放的。如果您希望在`backward()`和`scaler.step(optimizer)`之间修改或检查参数的`.grad`属性，您应该首先取消缩放它们。例如，梯度裁剪操作会操纵一组梯度，使它们的全局范数（参见`torch.nn.utils.clip_grad_norm_()`）或最大幅度（参见`torch.nn.utils.clip_grad_value_()`）小于某个用户设定的阈值。如果您尝试在不取消缩放的情况下裁剪梯度，梯度的范数/最大幅度也会被缩放，因此您请求的阈值（本来是用于*未缩放*梯度的阈值）将无效。 `scaler.unscale_(optimizer)`取消缩放`optimizer`的参数所持有的梯度。如果您的模型包含其他分配给另一个优化器（比如`optimizer2`）的参数，您可以单独调用`scaler.unscale_(optimizer2)`来取消缩放这些参数的梯度。 -### [梯度裁剪](#id4) +### 梯度裁剪 在裁剪之前调用`scaler.unscale_(optimizer)`使您可以像往常一样裁剪未缩放的梯度： @@ -112,15 +112,15 @@ for epoch in epochs: 警告 -[`unscale_`](../amp.html#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")应该每个优化器每次[`step`](../amp.html#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")调用只调用一次，并且只在为该优化器分配的参数的所有梯度都被累积之后才调用。在每个[`step`](../amp.html#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")之间为给定的优化器调用两次[`unscale_`](../amp.html#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")会触发一个运行时错误。 +`unscale_`应该每个优化器每次`step`调用只调用一次，并且只在为该优化器分配的参数的所有梯度都被累积之后才调用。在每个`step`之间为给定的优化器调用两次`unscale_`会触发一个运行时错误。 -## [使用缩放梯度](#id5)[](#working-with-scaled-gradients "跳转到此标题") +## 使用缩放梯度[](#working-with-scaled-gradients "跳转到此标题") -### [梯度累积](#id6)[](#gradient-accumulation "跳转到此标题") +### 梯度累积[](#gradient-accumulation "跳转到此标题") -梯度累积会在一个有效批次的大小上添加梯度，大小为`batch_per_iter * iters_to_accumulate`（如果是分布式的话还要乘以`num_procs`）。尺度应该校准到有效批次，这意味着在有效批次粒度上进行inf/NaN检查，如果发现inf/NaN梯度，则跳过步骤，同时尺度更新应该在有效批次粒度上发生。此外，梯度应该保持缩放，尺度因子应该保持恒定，而给定有效批次的梯度被累积。如果在累积完成之前梯度未被缩放（或尺度因子发生变化），下一个反向传播将会在将缩放的梯度添加到未缩放的梯度（或使用不同因子缩放的梯度）之后，无法恢复已累积的未缩放梯度，必须调用[`step`](../amp.html#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")。 +梯度累积会在一个有效批次的大小上添加梯度，大小为`batch_per_iter * iters_to_accumulate`（如果是分布式的话还要乘以`num_procs`）。尺度应该校准到有效批次，这意味着在有效批次粒度上进行 inf/NaN 检查，如果发现 inf/NaN 梯度，则跳过步骤，同时尺度更新应该在有效批次粒度上发生。此外，梯度应该保持缩放，尺度因子应该保持恒定，而给定有效批次的梯度被累积。如果在累积完成之前梯度未被缩放（或尺度因子发生变化），下一个反向传播将会在将缩放的梯度添加到未缩放的梯度（或使用不同因子缩放的梯度）之后，无法恢复已累积的未缩放梯度，必须调用`step`。 -因此，如果要对梯度进行[`unscale_`](../amp.html#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")（例如，允许裁剪未缩放的梯度），请在所有（缩放的）梯度为即将到来的[`step`](../amp.html#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")累积完成之后，在[`step`](../amp.html#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")之前调用[`unscale_`](../amp.html#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")。此外，只在调用了[`step`](../amp.html#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")进行完整有效批次的迭代结束时才调用[`update`](../amp.html#torch.cuda.amp.GradScaler.update "torch.cuda.amp.GradScaler.update")： +因此，如果要对梯度进行`unscale_`（例如，允许裁剪未缩放的梯度），请在所有（缩放的）梯度为即将到来的`step`累积完成之后，在`step`之前调用`unscale_`。此外，只在调用了`step`进行完整有效批次的迭代结束时才调用`update`： ```py scaler = GradScaler() @@ -143,11 +143,11 @@ for epoch in epochs: optimizer.zero_grad() ``` -### [梯度惩罚](#id7) +### 梯度惩罚 -梯度惩罚的实现通常使用[`torch.autograd.grad()`](../generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad")创建梯度，将它们组合以创建惩罚值，并将惩罚值添加到损失中。 +梯度惩罚的实现通常使用`torch.autograd.grad()`创建梯度，将它们组合以创建惩罚值，并将惩罚值添加到损失中。 -这是一个普通的L2惩罚的例子，没有梯度缩放或自动转换： +这是一个普通的 L2 惩罚的例子，没有梯度缩放或自动转换： ```py for epoch in epochs: @@ -175,11 +175,11 @@ for epoch in epochs: optimizer.step() ``` -要实现带有梯度缩放的梯度惩罚，传递给[`torch.autograd.grad()`](../generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad")的`outputs`张量应该被缩放。因此，得到的梯度将被缩放，应该在组合创建惩罚值之前取消缩放。 +要实现带有梯度缩放的梯度惩罚，传递给`torch.autograd.grad()`的`outputs`张量应该被缩放。因此，得到的梯度将被缩放，应该在组合创建惩罚值之前取消缩放。 -此外，惩罚项的计算是前向传播的一部分，因此应该在[`autocast`](../amp.html#torch.cuda.amp.autocast "torch.cuda.amp.autocast")上下文中。 +此外，惩罚项的计算是前向传播的一部分，因此应该在`autocast`上下文中。 -对于相同的L2惩罚，看起来是这样的： +对于相同的 L2 惩罚，看起来是这样的： ```py scaler = GradScaler() @@ -220,7 +220,7 @@ for epoch in epochs: scaler.update() ``` -## [使用多个模型、损失和优化器](#id8)[](#working-with-multiple-models-losses-and-optimizers "跳转到此标题") +## 使用多个模型、损失和优化器[](#working-with-multiple-models-losses-and-optimizers "跳转到此标题") 如果您的网络有多个损失，您必须分别对每个损失调用`scaler.scale`。如果您的网络有多个优化器，您可以分别对其中任何一个调用`scaler.unscale_`，并且您必须分别对每个调用`scaler.step`。 @@ -256,11 +256,11 @@ for epoch in epochs: 每个优化器都会检查其梯度是否包含无穷大/NaN，并独立决定是否跳过该步骤。这可能导致一个优化器跳过该步骤，而另一个不跳过。由于很少发生跳过步骤（每几百次迭代一次），这不应该影响收敛。如果您在将梯度缩放添加到多优化器模型后观察到收敛不佳，请报告错误。 -## [使用多个GPU](#id9) +## 使用多个 GPU 这里描述的问题只影响`autocast`。`GradScaler`的使用方式没有改变。 -### [单进程中的DataParallel](#id10) +### 单进程中的 DataParallel 即使`torch.nn.DataParallel`会生成线程来在每个设备上运行前向传播。自动转换状态在每个线程中传播，并且以下操作将起作用： @@ -276,21 +276,21 @@ with autocast(device_type='cuda', dtype=torch.float16): loss = loss_fn(output) ``` -### [分布式数据并行，每个进程一个GPU](#id11) +### 分布式数据并行，每个进程一个 GPU -`torch.nn.parallel.DistributedDataParallel`的文档建议每个进程一个GPU以获得最佳性能。在这种情况下，`DistributedDataParallel`不会在内部生成线程，因此对`autocast`和`GradScaler`的使用不受影响。 +`torch.nn.parallel.DistributedDataParallel`的文档建议每个进程一个 GPU 以获得最佳性能。在这种情况下，`DistributedDataParallel`不会在内部生成线程，因此对`autocast`和`GradScaler`的使用不受影响。 -### [分布式数据并行，每个进程多个GPU](#id12) +### 分布式数据并行，每个进程多个 GPU -在这里，`torch.nn.parallel.DistributedDataParallel`可能会生成一个辅助线程来在每个设备上运行前向传播，就像`torch.nn.DataParallel`一样。[修复方法相同](#amp-dataparallel)：在模型的`forward`方法中应用autocast，以确保在辅助线程中启用它。## [自动转换和自定义自动求导函数](#id13) +在这里，`torch.nn.parallel.DistributedDataParallel`可能会生成一个辅助线程来在每个设备上运行前向传播，就像`torch.nn.DataParallel`一样。修复方法相同：在模型的`forward`方法中应用 autocast，以确保在辅助线程中启用它。## 自动转换和自定义自动求导函数 -如果您的网络使用[自定义自动求导函数](extending.html#extending-autograd)（`torch.autograd.Function`的子类），则需要对自动转换兼容性进行更改，如果任何函数 +如果您的网络使用自定义自动求导函数（`torch.autograd.Function`的子类），则需要对自动转换兼容性进行更改，如果任何函数 + 接受多个浮点张量输入， -+ 包装任何可自动转换的操作（参见[自动转换操作参考](../amp.html#autocast-op-reference)，或者 ++ 包装任何可自动转换的操作（参见自动转换操作参考，或者 -+ 需要特定的`dtype`（例如，如果它包装了仅为`dtype`编译的[CUDA扩展](https://pytorch.org/tutorials/advanced/cpp_extension.html)）。 ++ 需要特定的`dtype`（例如，如果它包装了仅为`dtype`编译的[CUDA 扩展](https://pytorch.org/tutorials/advanced/cpp_extension.html)）。 在所有情况下，如果您正在导入该函数并且无法更改其定义，一个安全的备选方案是在出现错误的任何使用点禁用自动转换并强制执行为`float32`（或`dtype`）： @@ -301,11 +301,11 @@ with autocast(device_type='cuda', dtype=torch.float16): output = imported_function(input1.float(), input2.float()) ``` -如果您是函数的作者（或可以更改其定义），更好的解决方案是在下面相关案例中所示使用[`torch.cuda.amp.custom_fwd()`](../amp.html#torch.cuda.amp.custom_fwd)和[`torch.cuda.amp.custom_bwd()`](../amp.html#torch.cuda.amp.custom_bwd)装饰器。 +如果您是函数的作者（或可以更改其定义），更好的解决方案是在下面相关案例中所示使用`torch.cuda.amp.custom_fwd()`和`torch.cuda.amp.custom_bwd()`装饰器。 -### [具有多个输入或可自动转换操作的函数](#id14) +### 具有多个输入或可自动转换操作的函数 -将[`custom_fwd`](../amp.html#torch.cuda.amp.custom_fwd)和[`custom_bwd`](../amp.html#torch.cuda.amp.custom_bwd)（不带参数）分别应用于`forward`和`backward`。这些确保`forward`以当前自动转换状态执行，`backward`以与`forward`相同的自动转换状态执行（可以防止类型不匹配错误）： +将`custom_fwd`和`custom_bwd`（不带参数）分别应用于`forward`和`backward`。这些确保`forward`以当前自动转换状态执行，`backward`以与`forward`相同的自动转换状态执行（可以防止类型不匹配错误）： ```py class MyMM(torch.autograd.Function): @@ -330,9 +330,9 @@ with autocast(device_type='cuda', dtype=torch.float16): output = mymm(input1, input2) ``` -### [需要特定`dtype`的函数](#id15) +### 需要特定`dtype`的函数 -考虑一个需要`torch.float32`输入的自定义函数。将[`custom_fwd(cast_inputs=torch.float32)`](../amp.html#torch.cuda.amp.custom_fwd)应用于`forward`，将[`custom_bwd`](../amp.html#torch.cuda.amp.custom_bwd)（不带参数）应用于`backward`。如果`forward`在启用自动转换的区域运行，则装饰器将浮点CUDA张量输入转换为`float32`，并在`forward`和`backward`期间本地禁用自动转换： +考虑一个需要`torch.float32`输入的自定义函数。将`custom_fwd(cast_inputs=torch.float32)`应用于`forward`，将`custom_bwd`（不带参数）应用于`backward`。如果`forward`在启用自动转换的区域运行，则装饰器将浮点 CUDA 张量输入转换为`float32`，并在`forward`和`backward`期间本地禁用自动转换： ```py class MyFloat32Func(torch.autograd.Function): diff --git a/totrans/doc22_009.md b/totrans/doc22_009.md index 523f82de..16ddfa23 100644 --- a/totrans/doc22_009.md +++ b/totrans/doc22_009.md @@ -1,24 +1,24 @@ # 自动求导机制 -> 您可以使用[保存张量的钩子](#saved-tensors-hooks-doc)来控制PyTorch如何进行打包/解包。 +> 您可以使用保存张量的钩子来控制 PyTorch 如何进行打包/解包。 这个笔记将介绍自动求导的工作原理以及记录操作的概述。虽然不是严格必要理解所有这些，但我们建议熟悉它，因为这将帮助您编写更高效、更清洁的程序，并可以帮助您调试。 ## 自动求导如何编码历史[](#how-autograd-encodes-the-history "跳转到此标题") -自动求导是一个反向自动微分系统。概念上，autograd在执行操作时记录创建数据的所有操作的图，为您提供一个有向无环图，其叶子是输入张量，根是输出张量。通过从根到叶子跟踪这个图，您可以使用链式法则自动计算梯度。 +自动求导是一个反向自动微分系统。概念上，autograd 在执行操作时记录创建数据的所有操作的图，为您提供一个有向无环图，其叶子是输入张量，根是输出张量。通过从根到叶子跟踪这个图，您可以使用链式法则自动计算梯度。 -在内部，autograd将这个图表示为`Function`对象（实际上是表达式）的图，可以`apply()`来计算评估图的结果。在计算前向传播时，autograd同时执行请求的计算并构建一个表示计算梯度的函数的图（每个[`torch.Tensor`](../tensors.html#torch.Tensor "torch.Tensor")的`.grad_fn`属性是这个图的入口点）。完成前向传播后，我们在反向传播中评估这个图以计算梯度。 +在内部，autograd 将这个图表示为`Function`对象（实际上是表达式）的图，可以`apply()`来计算评估图的结果。在计算前向传播时，autograd 同时执行请求的计算并构建一个表示计算梯度的函数的图（每个`torch.Tensor`的`.grad_fn`属性是这个图的入口点）。完成前向传播后，我们在反向传播中评估这个图以计算梯度。 -需要注意的一点是，在每次迭代中，图形都是从头开始重新创建的，这正是允许使用任意Python控制流语句的原因，这些语句可以在每次迭代中改变图形的整体形状和大小。您不必在启动训练之前编码所有可能的路径 - 您运行的就是您要求导数的内容。 +需要注意的一点是，在每次迭代中，图形都是从头开始重新创建的，这正是允许使用任意 Python 控制流语句的原因，这些语句可以在每次迭代中改变图形的整体形状和大小。您不必在启动训练之前编码所有可能的路径 - 您运行的就是您要求导数的内容。 ### 已保存的张量 -一些操作需要在前向传播期间保存中间结果，以便执行反向传播。例如，函数$x\mapsto x^2$x↦x2 保存输入$x$x 来计算梯度。 +一些操作需要在前向传播期间保存中间结果，以便执行反向传播。例如，函数$x\mapsto x²$x↦x2 保存输入$x$x 来计算梯度。 -当定义自定义Python [`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")时，您可以使用`save_for_backward()`在前向传播期间保存张量，并使用`saved_tensors`在反向传播期间检索它们。有关更多信息，请参阅[扩展PyTorch](extending.html)。 +当定义自定义 Python `Function`时，您可以使用`save_for_backward()`在前向传播期间保存张量，并使用`saved_tensors`在反向传播期间检索它们。有关更多信息，请参阅扩展 PyTorch。 -对于PyTorch定义的操作（例如[`torch.pow()`](../generated/torch.pow.html#torch.pow "torch.pow")），张量会根据需要自动保存。您可以探索（用于教育或调试目的）通过查找以前缀`_saved`开头的属性来了解某个`grad_fn`保存了哪些张量。 +对于 PyTorch 定义的操作（例如`torch.pow()`），张量会根据需要自动保存。您可以探索（用于教育或调试目的）通过查找以前缀`_saved`开头的属性来了解某个`grad_fn`保存了哪些张量。 ```py x = torch.randn(5, requires_grad=True) @@ -27,7 +27,7 @@ print(x.equal(y.grad_fn._saved_self)) # True print(x is y.grad_fn._saved_self) # True ``` -在前面的代码中，`y.grad_fn._saved_self`指的是与x相同的张量对象。但这并不总是这样。例如： +在前面的代码中，`y.grad_fn._saved_self`指的是与 x 相同的张量对象。但这并不总是这样。例如： ```py x = torch.randn(5, requires_grad=True) @@ -36,7 +36,7 @@ print(y.equal(y.grad_fn._saved_result)) # True print(y is y.grad_fn._saved_result) # False ``` -在内部，为了防止引用循环，PyTorch在保存时*打包*张量，并在读取时*解包*为不同的张量。在这里，通过访问`y.grad_fn._saved_result`获得的张量对象与`y`是不同的张量对象（但它们仍然共享相同的存储）。 +在内部，为了防止引用循环，PyTorch 在保存时*打包*张量，并在读取时*解包*为不同的张量。在这里，通过访问`y.grad_fn._saved_result`获得的张量对象与`y`是不同的张量对象（但它们仍然共享相同的存储）。 张量是否会打包为不同的张量对象取决于它是否是其自己`grad_fn`的输出，这是一个实现细节，可能会发生变化，用户不应依赖于此。 @@ -56,7 +56,7 @@ print(y is y.grad_fn._saved_result) # False 1. 如果函数不是确定性映射（即不是[数学函数](https://en.wikipedia.org/wiki/Function_(mathematics))），它将被标记为不可微。如果在`no_grad`环境之外使用需要梯度的张量，则在反向传播中将出现错误。##局部禁用梯度计算[](#locally-disabling-gradient-computation "跳转到此标题的永久链接") -有几种机制可用于在Python中局部禁用梯度计算： +有几种机制可用于在 Python 中局部禁用梯度计算： 要在整个代码块中禁用梯度，有像无梯度模式和推断模式这样的上下文管理器。为了更细粒度地排除梯度计算中的子图，可以设置张量的`requires_grad`字段。 @@ -64,7 +64,7 @@ print(y is y.grad_fn._saved_result) # False ### 设置`requires_grad` -`requires_grad`是一个标志，默认为false，*除非包装在* `nn.Parameter`中，允许对梯度计算中的子图进行细粒度排除。它在前向和反向传播中都生效： +`requires_grad`是一个标志，默认为 false，*除非包装在* `nn.Parameter`中，允许对梯度计算中的子图进行细粒度排除。它在前向和反向传播中都生效： 在前向传播期间，只有在其输入张量中至少有一个需要梯度的情况下，操作才会记录在反向图中。在反向传播（`.backward()`）期间，只有`requires_grad=True`的叶子张量才会将梯度累积到其`.grad`字段中。 @@ -76,19 +76,19 @@ print(y is y.grad_fn._saved_result) # False 由于这是一个常见模式，`requires_grad`也可以在模块级别使用`nn.Module.requires_grad_()`进行设置。当应用于模块时，`.requires_grad_()`会对模块的所有参数（默认情况下具有`requires_grad=True`）生效。 -### Grad模式 +### Grad 模式 -除了设置`requires_grad`外，还有三种可以从Python中选择的grad模式，可以影响PyTorch中autograd内部处理计算的方式：默认模式（grad模式）、无梯度模式和推理模式，所有这些模式都可以通过上下文管理器和装饰器进行切换。 +除了设置`requires_grad`外，还有三种可以从 Python 中选择的 grad 模式，可以影响 PyTorch 中 autograd 内部处理计算的方式：默认模式（grad 模式）、无梯度模式和推理模式，所有这些模式都可以通过上下文管理器和装饰器进行切换。 -| 模式 | 排除在反向图中记录的操作 | 跳过额外的autograd跟踪开销 | 在启用模式时创建的张量可以在grad模式中使用 | 示例 | +| 模式 | 排除在反向图中记录的操作 | 跳过额外的 autograd 跟踪开销 | 在启用模式时创建的张量可以在 grad 模式中使用 | 示例 | | --- | --- | --- | --- | --- | | 默认 | | | ✓ | 前向传递 | | 无梯度 | ✓ | | ✓ | 优化器更新 | | 推理 | ✓ | ✓ | | 数据处理，模型评估 | -### 默认模式（grad模式） +### 默认模式（grad 模式） -“默认模式”是我们在没有启用其他模式（如无梯度模式和推理模式）时隐式处于的模式。与“无梯度模式”相对应，“默认模式”有时也被称为“grad模式”。 +“默认模式”是我们在没有启用其他模式（如无梯度模式和推理模式）时隐式处于的模式。与“无梯度模式”相对应，“默认模式”有时也被称为“grad 模式”。 关于默认模式最重要的一点是它是唯一一个`requires_grad`生效的模式。在另外两种模式中，`requires_grad`总是被覆盖为`False`。 @@ -96,19 +96,19 @@ print(y is y.grad_fn._saved_result) # False 在无梯度模式下的计算行为就好像没有任何输入需要梯度一样。换句话说，在无梯度模式下的计算永远不会被记录在反向图中，即使有`require_grad=True`的输入也是如此。 -当您需要执行不应被autograd记录的操作，但仍希望稍后在grad模式中使用这些计算的输出时，请启用无梯度模式。这个上下文管理器使得在不必临时将张量设置为`requires_grad=False`，然后再设置为`True`的情况下，方便地禁用一段代码或函数的梯度。 +当您需要执行不应被 autograd 记录的操作，但仍希望稍后在 grad 模式中使用这些计算的输出时，请启用无梯度模式。这个上下文管理器使得在不必临时将张量设置为`requires_grad=False`，然后再设置为`True`的情况下，方便地禁用一段代码或函数的梯度。 -例如，当编写优化器时，无梯度模式可能很有用：在执行训练更新时，您希望在不被autograd记录的情况下就地更新参数。您还打算在下一个前向传递中使用更新后的参数进行计算。 +例如，当编写优化器时，无梯度模式可能很有用：在执行训练更新时，您希望在不被 autograd 记录的情况下就地更新参数。您还打算在下一个前向传递中使用更新后的参数进行计算。 -在初始化参数时，[torch.nn.init](../nn.init.html#nn-init-doc)中的实现也依赖于无梯度模式，以避免在就地更新初始化参数时进行autograd跟踪。 +在初始化参数时，torch.nn.init 中的实现也依赖于无梯度模式，以避免在就地更新初始化参数时进行 autograd 跟踪。 ### 推理模式 -推理模式是无梯度模式的极端版本。就像在无梯度模式中一样，在推理模式中的计算不会被记录在反向图中，但启用推理模式将使PyTorch加速您的模型。这种更好的运行时性能伴随着一个缺点：在推理模式中创建的张量将无法在退出推理模式后用于由autograd记录的计算。 +推理模式是无梯度模式的极端版本。就像在无梯度模式中一样，在推理模式中的计算不会被记录在反向图中，但启用推理模式将使 PyTorch 加速您的模型。这种更好的运行时性能伴随着一个缺点：在推理模式中创建的张量将无法在退出推理模式后用于由 autograd 记录的计算。 -当您执行不需要在反向图中记录的计算，并且您不打算在稍后由autograd记录的任何计算中使用在推理模式中创建的张量时，请启用推理模式。 +当您执行不需要在反向图中记录的计算，并且您不打算在稍后由 autograd 记录的任何计算中使用在推理模式中创建的张量时，请启用推理模式。 -建议您在代码中不需要autograd跟踪的部分尝试推理模式（例如数据处理和模型评估）。如果它适用于您的用例，那么这是一个免费的性能提升。如果在启用推理模式后遇到错误，请检查您是否在退出推理模式后使用了在推理模式中创建的张量进行autograd记录的计算。如果您无法避免在您的情况下使用这种用法，您可以随时切换回无梯度模式。 +建议您在代码中不需要 autograd 跟踪的部分尝试推理模式（例如数据处理和模型评估）。如果它适用于您的用例，那么这是一个免费的性能提升。如果在启用推理模式后遇到错误，请检查您是否在退出推理模式后使用了在推理模式中创建的张量进行 autograd 记录的计算。如果您无法避免在您的情况下使用这种用法，您可以随时切换回无梯度模式。 有关推理模式的详细信息，请参见[推理模式](https://pytorch.org/cppdocs/notes/inference_mode.html)。 @@ -120,11 +120,11 @@ print(y is y.grad_fn._saved_result) # False 从功能上讲，`module.eval()`（或等效地`module.train(False)`）与无梯度模式和推断模式完全无关。`model.eval()`如何影响您的模型完全取决于您的模型中使用的特定模块以及它们是否定义了任何特定于训练模式的行为。 -如果您的模型依赖于诸如[`torch.nn.Dropout`](../generated/torch.nn.Dropout.html#torch.nn.Dropout "torch.nn.Dropout")和[`torch.nn.BatchNorm2d`](../generated/torch.nn.BatchNorm2d.html#torch.nn.BatchNorm2d "torch.nn.BatchNorm2d")等模块，这些模块可能会根据训练模式的不同而表现不同，例如，为了避免在验证数据上更新您的BatchNorm运行统计数据，您需要调用`model.eval()`和`model.train()`。 +如果您的模型依赖于诸如`torch.nn.Dropout`和`torch.nn.BatchNorm2d`等模块，这些模块可能会根据训练模式的不同而表现不同，例如，为了避免在验证数据上更新您的 BatchNorm 运行统计数据，您需要调用`model.eval()`和`model.train()`。 建议在训练时始终使用`model.train()`，在评估模型（验证/测试）时使用`model.eval()`，即使您不确定您的模型是否具有特定于训练模式的行为，因为您使用的模块可能会更新以在训练和评估模式下表现不同。 -## 使用autograd的原地操作 +## 使用 autograd 的原地操作 在自动求导中支持原地操作是一件困难的事情，我们不鼓励在大多数情况下使用它们。自动求导的积极缓冲区释放和重用使其非常高效，只有在极度内存压力下，原地操作才会显著降低内存使用量。除非您在极度内存压力下操作，否则您可能永远不需要使用它们。 @@ -132,17 +132,17 @@ print(y is y.grad_fn._saved_result) # False 1. 原地操作可能会覆盖计算梯度所需的值。 -1. 每个原地操作都需要实现重写计算图。非原地版本只是分配新对象并保留对旧图的引用，而原地操作需要将所有输入的创建者更改为代表此操作的`Function`。这可能会很棘手，特别是如果有许多Tensor引用相同的存储（例如通过索引或转置创建），并且如果修改后的输入的存储被任何其他`Tensor`引用，原地函数将引发错误。 +1. 每个原地操作都需要实现重写计算图。非原地版本只是分配新对象并保留对旧图的引用，而原地操作需要将所有输入的创建者更改为代表此操作的`Function`。这可能会很棘手，特别是如果有许多 Tensor 引用相同的存储（例如通过索引或转置创建），并且如果修改后的输入的存储被任何其他`Tensor`引用，原地函数将引发错误。 ### 原地正确性检查 -每个张量都保留一个版本计数器，每次在任何操作中标记为脏时都会递增。当一个Function保存任何张量用于反向传播时，它们包含的Tensor的版本计数器也会被保存。一旦访问`self.saved_tensors`，它就会被检查，如果大于保存的值，则会引发错误。这确保了如果您使用原地函数而没有看到任何错误，您可以确信计算的梯度是正确的。 +每个张量都保留一个版本计数器，每次在任何操作中标记为脏时都会递增。当一个 Function 保存任何张量用于反向传播时，它们包含的 Tensor 的版本计数器也会被保存。一旦访问`self.saved_tensors`，它就会被检查，如果大于保存的值，则会引发错误。这确保了如果您使用原地函数而没有看到任何错误，您可以确信计算的梯度是正确的。 ## 多线程自动求导 -自动求导引擎负责运行计算反向传播所需的所有反向操作。本节将描述所有细节，以帮助您在多线程环境中充分利用它。（这仅适用于PyTorch 1.6+，因为之前版本的行为不同。） +自动求导引擎负责运行计算反向传播所需的所有反向操作。本节将描述所有细节，以帮助您在多线程环境中充分利用它。（这仅适用于 PyTorch 1.6+，因为之前版本的行为不同。） -用户可以使用多线程代码训练他们的模型（例如，Hogwild训练），并且不会在并发反向计算上阻塞，示例代码可能是： +用户可以使用多线程代码训练他们的模型（例如，Hogwild 训练），并且不会在并发反向计算上阻塞，示例代码可能是： ```py # Define a train function to be used in different threads @@ -167,9 +167,9 @@ for p in threads: 请注意用户应该注意的一些行为： -### CPU上的并发 +### CPU 上的并发 -当您在CPU上通过Python或C++ API在多个线程上运行`backward()`或`grad()`时，您期望看到额外的并发，而不是在执行期间按特定顺序序列化所有的反向调用（PyTorch 1.6之前的行为）。 +当您在 CPU 上通过 Python 或 C++ API 在多个线程上运行`backward()`或`grad()`时，您期望看到额外的并发，而不是在执行期间按特定顺序序列化所有的反向调用（PyTorch 1.6 之前的行为）。 ### 非确定性 @@ -177,7 +177,7 @@ for p in threads: 开发具有共享参数的多线程模型的用户应该考虑线程模型，并应理解上述问题。 -可以使用函数式 API [`torch.autograd.grad()`](../generated/torch.autograd.grad.html#torch.autograd.grad) 来计算梯度，而不是使用 `backward()` 来避免非确定性。 +可以使用函数式 API `torch.autograd.grad()` 来计算梯度，而不是使用 `backward()` 来避免非确定性。 ### 保留图 @@ -203,7 +203,7 @@ Autograd 依赖用户编写线程安全的 C++ 钩子。如果要在多线程环 + 如果你有一个内部使用复杂运算的实到实函数，这里的约定并不重要：你总是会得到与仅使用实数运算实现时相同的结果。 -如果你对数学细节感兴趣，或者想知道如何在PyTorch中定义复杂导数，继续阅读。 +如果你对数学细节感兴趣，或者想知道如何在 PyTorch 中定义复杂导数，继续阅读。 ### 什么是复杂导数？ @@ -211,13 +211,13 @@ Autograd 依赖用户编写线程安全的 C++ 钩子。如果要在多线程环 > -其中u和v是两个变量的实值函数，j是虚数单位。 +其中u 和 v是两个变量的实值函数，j 是虚数单位。 使用导数定义，我们可以写成： > -为了使这个极限存在，不仅必须u和v是实可微的，而且f也必须满足柯西-黎曼方程。换句话说：为实部和虚部步长计算的极限（h）必须相等。这是一个更严格的条件。 +为了使这个极限存在，不仅必须u 和 v是实可微的，而且f 也必须满足柯西-黎曼方程。换句话说：为实部和虚部步长计算的极限（h）必须相等。这是一个更严格的条件。 复杂可微函数通常被称为全纯函数。它们表现良好，具有你从实可微函数中看到的所有好的性质，但在优化领域实际上没有什么用。在优化问题中，研究社区只使用实值目标函数，因为复数不属于任何有序域，因此具有复值损失并没有太多意义。 @@ -225,11 +225,11 @@ Im(z) = (z - z*) / 2j ### 同时，没有有趣的实值目标满足柯西-黎曼方程。因此，全纯函数的理论不能用于优化，大多数人因此使用威廉格微积分。威廉格微积分进入画面... -所以，我们有这个复可微和全纯函数的伟大理论，但我们根本无法使用它，因为许多常用函数都不是全纯的。一个可怜的数学家该怎么办呢？威廉格观察到，即使f(z)不是全纯的，也可以将其重写为一个两个变量的函数f(z, z*)，这个函数总是全纯的。这是因为z的实部和虚部可以用z和z*来表示： +所以，我们有这个复可微和全纯函数的伟大理论，但我们根本无法使用它，因为许多常用函数都不是全纯的。一个可怜的数学家该怎么办呢？威廉格观察到，即使 f(z)不是全纯的，也可以将其重写为一个两个变量的函数 f(z, z*)，这个函数总是全纯的。这是因为 z 的实部和虚部可以用 z 和 z*来表示： > Re(z) = (z + z*) / 2 -Wirtinger微积分建议研究f(z, z*)，如果f是实可微的，则保证是全纯的（另一种思考方式是将坐标系从f(x, y)变换为f(z, z*)）。这个函数有偏导数∂z∂和∂z*∂。我们可以使用链式法则建立这些偏导数与z的实部和虚部的偏导数之间的关系。 +Wirtinger 微积分建议研究 f(z, z*)，如果 f 是实可微的，则保证是全纯的（另一种思考方式是将坐标系从 f(x, y)变换为 f(z, z*)）。这个函数有偏导数∂z∂和∂z*∂。我们可以使用链式法则建立这些偏导数与 z 的实部和虚部的偏导数之间的关系。 > $\begin{aligned} \frac{\partial }{\partial x} &= \frac{\partial z}{\partial x} * \frac{\partial }{\partial z} + \frac{\partial z^*}{\partial x} * \frac{\partial }{\partial z^*} \\ &= \frac{\partial }{\partial z} + \frac{\partial }{\partial z^*} \\ \\ \frac{\partial }{\partial y} &= \frac{\partial z}{\partial y} * \frac{\partial }{\partial z} + \frac{\partial z^*}{\partial y} * \frac{\partial }{\partial z^*} \\ &= 1j * \left(\frac{\partial }{\partial z} - \frac{\partial }{\partial z^*}\right) \end{aligned}$ @@ -237,19 +237,19 @@ Wirtinger微积分建议研究f(z, z*)，如果f是实可微的，则保证是 > $\begin{aligned} \frac{\partial }{\partial z} &= 1/2 * \left(\frac{\partial }{\partial x} - 1j * \frac{\partial }{\partial y}\right) \\ \frac{\partial }{\partial z^*} &= 1/2 * \left(\frac{\partial }{\partial x} + 1j * \frac{\partial }{\partial y}\right) \end{aligned}$ ∂z∂​∂z∗∂​​=1/2∗(∂x∂​−1j∗∂y∂​)=1/2∗(∂x∂​+1j∗∂y∂​)​ -这是您在[Wikipedia](https://en.wikipedia.org/wiki/Wirtinger_derivatives)上找到的Wirtinger微积分的经典定义。 +这是您在[Wikipedia](https://en.wikipedia.org/wiki/Wirtinger_derivatives)上找到的 Wirtinger 微积分的经典定义。 这种变化有很多美好的结果。 -+ 首先，柯西-黎曼方程简单地表明$\frac{\partial f}{\partial z^*} = 0$∂z∗∂f​=0（也就是说，函数$f$f可以完全用$z$z来表示，而不涉及$z^*$z∗）。 ++ 首先，柯西-黎曼方程简单地表明$\frac{\partial f}{\partial z^*} = 0$∂z∗∂f​=0（也就是说，函数$f$f 可以完全用$z$z 来表示，而不涉及$z^*$z∗）。 + 另一个重要的（有些违反直觉的）结果是，当我们在实值损失上进行优化时，进行变量更新时应该采取的步骤由$\frac{\partial Loss}{\partial z^*}$∂z∗∂Loss​给出（而不是$\frac{\partial Loss}{\partial z}$∂z∂Loss​）。 -更多阅读，请查看：[https://arxiv.org/pdf/0906.4835.pdf](https://arxiv.org/pdf/0906.4835.pdf) +更多阅读，请查看：[`arxiv.org/pdf/0906.4835.pdf`](https://arxiv.org/pdf/0906.4835.pdf) -### Wirtinger微积分在优化中有什么用处？[](#how-is-wirtinger-calculus-useful-in-optimization "Permalink to this heading") +### Wirtinger 微积分在优化中有什么用处？[](#how-is-wirtinger-calculus-useful-in-optimization "Permalink to this heading") -研究人员在音频和其他领域更常见地使用梯度下降来优化具有复杂变量的实值损失函数。通常，这些人将实部和虚部视为可以更新的独立通道。对于步长 $\alpha/2$α/2 和损失 $L$L，我们可以在 $ℝ^2$R2 中写出以下方程： +研究人员在音频和其他领域更常见地使用梯度下降来优化具有复杂变量的实值损失函数。通常，这些人将实部和虚部视为可以更新的独立通道。对于步长 $\alpha/2$α/2 和损失 $L$L，我们可以在 $ℝ²$R2 中写出以下方程： > $\begin{aligned} x_{n+1} &= x_n - (\alpha/2) * \frac{\partial L}{\partial x} \\ y_{n+1} &= y_n - (\alpha/2) * \frac{\partial L}{\partial y} \end{aligned}$ xn+1​=xn​−(α/2)∗∂x∂L​yn+1​=yn​−(α/2)∗∂y∂L​​ @@ -257,23 +257,23 @@ Wirtinger微积分建议研究f(z, z*)，如果f是实可微的，则保证是 > $\begin{aligned} z_{n+1} &= x_n - (\alpha/2) * \frac{\partial L}{\partial x} + 1j * (y_n - (\alpha/2) * \frac{\partial L}{\partial y}) \\ &= z_n - \alpha * 1/2 * \left(\frac{\partial L}{\partial x} + j \frac{\partial L}{\partial y}\right) \\ &= z_n - \alpha * \frac{\partial L}{\partial z^*} \end{aligned}$ zn+1​​=xn​−(α/2)∗∂x∂L​+1j∗(yn​−(α/2)∗∂y∂L​)=zn​−α∗1/2∗(∂x∂L​+j∂y∂L​)=zn​−α∗∂z∗∂L​​ -发生了一件非常有趣的事情：Wirtinger微积分告诉我们，我们可以将上面的复变量更新公式简化为只涉及共轭Wirtinger导数$\frac{\partial L}{\partial z^*}$∂z∗∂L​，这样我们就得到了优化中所采取的确切步骤。 +发生了一件非常有趣的事情：Wirtinger 微积分告诉我们，我们可以将上面的复变量更新公式简化为只涉及共轭 Wirtinger 导数$\frac{\partial L}{\partial z^*}$∂z∗∂L​，这样我们就得到了优化中所采取的确切步骤。 -因为共轭Wirtinger导数给出了实值损失函数的正确步骤，所以当您对具有实值损失的函数进行微分时，PyTorch会给出这个导数。 +因为共轭 Wirtinger 导数给出了实值损失函数的正确步骤，所以当您对具有实值损失的函数进行微分时，PyTorch 会给出这个导数。 -### PyTorch如何计算共轭Wirtinger导数？[](#how-does-pytorch-compute-the-conjugate-wirtinger-derivative "Permalink to this heading") +### PyTorch 如何计算共轭 Wirtinger 导数？[](#how-does-pytorch-compute-the-conjugate-wirtinger-derivative "Permalink to this heading") -通常，我们的导数公式将grad_output作为输入，表示我们已经计算过的传入向量雅可比乘积，即，∂s∗∂L​，其中L是整个计算的损失（产生实际损失），s是我们函数的输出。这里的目标是计算∂z∗∂L​，其中z是函数的输入。事实证明，在实际损失的情况下，我们可以仅仅计算∂s∗∂L​，即使链式法则暗示我们也需要访问∂s∂L​。如果您想跳过这个推导，请查看本节中的最后一个方程，然后跳到下一节。 +通常，我们的导数公式将 grad_output 作为输入，表示我们已经计算过的传入向量雅可比乘积，即，∂s∗∂L​，其中 L 是整个计算的损失（产生实际损失），s 是我们函数的输出。这里的目标是计算∂z∗∂L​，其中 z 是函数的输入。事实证明，在实际损失的情况下，我们可以仅仅计算∂s∗∂L​，即使链式法则暗示我们也需要访问∂s∂L​。如果您想跳过这个推导，请查看本节中的最后一个方程，然后跳到下一节。 -让我们继续使用f:C→C定义为f(z)=f(x+yj)=u(x,y)+v(x,y)j。如上所述，autograd的梯度约定围绕着针对实值损失函数的优化，因此让我们假设f是更大的实值损失函数g的一部分。使用链式法则，我们可以写成： +让我们继续使用 f:C→C 定义为 f(z)=f(x+yj)=u(x,y)+v(x,y)j。如上所述，autograd 的梯度约定围绕着针对实值损失函数的优化，因此让我们假设 f 是更大的实值损失函数 g 的一部分。使用链式法则，我们可以写成： > ∂z∗∂L​=∂u∂L​∗∂z∗∂u​+∂v∂L​∗∂z∗∂v​ -现在使用Wirtinger导数定义，我们可以写成： +现在使用 Wirtinger 导数定义，我们可以写成： > （1） -这里需要注意，由于u和v是实函数，而L根据我们假设f是实值函数的一部分，我们有： +这里需要注意，由于 u 和 v 是实函数，而 L 根据我们假设 f 是实值函数的一部分，我们有： > (2)$\left( \frac{\partial L}{\partial s} \right)^* = \frac{\partial L}{\partial s^*}$ (∂s∂L​)∗=∂s∗∂L​ @@ -283,11 +283,11 @@ Wirtinger微积分建议研究f(z, z*)，如果f是实可微的，则保证是 > (3)$\begin{aligned} \frac{\partial L}{\partial u} = \frac{\partial L}{\partial s} + \frac{\partial L}{\partial s^*} \\ \frac{\partial L}{\partial v} = -1j * \left(\frac{\partial L}{\partial s} - \frac{\partial L}{\partial s^*}\right) \end{aligned}$ ∂u∂L​=∂s∂L​+∂s∗∂L​∂v∂L​=−1j∗(∂s∂L​−∂s∗∂L​)​ -将[(3)](#equation-3)代入[(1)](#equation-1)，我们得到： +将(3)代入(1)，我们得到： > ∂z∗∂L​​=(∂s∂L​+∂s∗∂L​)∗∂z∗∂u​−1j∗(∂s∂L​−∂s∗∂L​)∗∂z∗∂v​=∂s∂L​∗(∂z∗∂u​+∂z∗∂v​j)+∂s∗∂L​∗(∂z∗∂u​−∂z∗∂v​j)=∂s∗∂L​∗∂z∗∂(u+vj)​+∂s∂L​∗∂z∗∂(u+vj)∗​=∂s∂L​∗∂z∗∂s​+∂s∗∂L​∗∂z∗∂s∗​​ -使用[(2)](#equation-2)，我们得到： +使用(2)，我们得到： > ∂z∗∂L​​=(∂s∗∂L​)∗∗∂z∗∂s​+∂s∗∂L​∗(∂z∂s​)∗=(grad_output)∗∗∂z∗∂s​+grad_output∗(∂z∂s​)∗​​ @@ -297,29 +297,29 @@ Wirtinger微积分建议研究f(z, z*)，如果f是实可微的，则保证是 上面的方框方程式给出了复杂函数所有导数的一般公式。然而，我们仍然需要计算∂s∂z​和∂s∗∂z​。你可以通过两种方式来做到这一点： -> + 第一种方法是直接使用Wirtinger导数的定义，并通过使用∂x∂s和∂y∂s（可以以正常方式计算）来计算∂z∂s和∂z∗∂s。 +> + 第一种方法是直接使用 Wirtinger 导数的定义，并通过使用∂x∂s 和∂y∂s（可以以正常方式计算）来计算∂z∂s 和∂z∗∂s。 > + -> + 第二种方法是使用变量变换技巧，将f(z)重写为一个两个变量的函数f(z, z*)，并通过将z和z*视为独立变量来计算共轭Wirtinger导数。这通常更容易；例如，如果所讨论的函数是全纯的，只会使用z（而∂z∗∂s将为零）。 +> + 第二种方法是使用变量变换技巧，将 f(z)重写为一个两个变量的函数 f(z, z*)，并通过将 z 和 z*视为独立变量来计算共轭 Wirtinger 导数。这通常更容易；例如，如果所讨论的函数是全纯的，只会使用 z（而∂z∗∂s 将为零）。 -让我们以一个例子来考虑函数f(z=x+yj)=c*z=c*(x+yj)，其中c∈R。 +让我们以一个例子来考虑函数 f(z=x+yj)=c*z=c*(x+yj)，其中 c∈R。 -使用第一种方法计算Wirtinger导数，我们有。 +使用第一种方法计算 Wirtinger 导数，我们有。 ∂s∂z∗​=1/2∗(∂s∂x​+∂s∂y​j)=1/2∗(c+(c∗1j)∗1j)=0 -使用第二种计算Wirtinger导数的方法，我们直接得到： +使用第二种计算 Wirtinger 导数的方法，我们直接得到： -> 使用[(4)](#equation-4)，并且grad_output = 1.0（这是在PyTorch中对标量输出调用`backward()`时使用的默认梯度输出值），我们得到： +> 使用(4)，并且 grad_output = 1.0（这是在 PyTorch 中对标量输出调用`backward()`时使用的默认梯度输出值），我们得到： ∂s∂z​=1/2∗(∂s∂x​−∂s∂y​j)=1/2∗(c−(c∗1j)∗1j)=c > $\begin{aligned} \frac{\partial s}{\partial z} &= \frac{\partial (c*z)}{\partial z} \\ &= c \\ \frac{\partial s}{\partial z^*} &= \frac{\partial (c*z)}{\partial z^*} \\ &= 0 \end{aligned}$∂z∂s​∂z∗∂s​​=∂z∂(c∗z)​=c=∂z∗∂(c∗z)​=0​ -再次使用[(4)](#equation-4)，我们得到$\frac{\partial L}{\partial z^*} = c$∂z∗∂L​=c。如您所见，第二种方法涉及更少的计算，并且更适用于更快的计算。 +再次使用(4)，我们得到$\frac{\partial L}{\partial z^*} = c$∂z∗∂L​=c。如您所见，第二种方法涉及更少的计算，并且更适用于更快的计算。 ### 跨域函数呢？[](#what-about-cross-domain-functions "Permalink to this heading") -一些函数从复杂输入映射到实数输出，或者反之亦然。这些函数形成了[(4)](#equation-4)的一个特殊情况，我们可以使用链式法则推导出来： +一些函数从复杂输入映射到实数输出，或者反之亦然。这些函数形成了(4)的一个特殊情况，我们可以使用链式法则推导出来： > + 对于$f: ℂ → ℝ$f:C→R，我们得到： > + @@ -329,7 +329,7 @@ Wirtinger微积分建议研究f(z, z*)，如果f是实可微的，则保证是 > + > > $\frac{\partial L}{\partial z^*} = 2 * \mathrm{Re}(grad\_output^* * \frac{\partial s}{\partial z^{*}})$ ∂z∗∂L​=2∗Re(grad_output∗∗∂z∗∂s​) ## 保存的张量的钩子 -通过定义一对`pack_hook` / `unpack_hook`钩子，您可以控制[保存的张量如何打包/解包](#saved-tensors-doc)。`pack_hook`函数应该以一个张量作为其单个参数，但可以返回任何Python对象（例如另一个张量，一个元组，甚至包含文件名的字符串）。`unpack_hook`函数以`pack_hook`的输出作为其单个参数，并应返回一个张量，用于在反向传播中使用。`unpack_hook`返回的张量只需要与传递给`pack_hook`的输入张量具有相同的内容。特别地，任何与自动求导相关的元数据都可以忽略，因为它们在解包过程中将被覆盖。 +通过定义一对`pack_hook` / `unpack_hook`钩子，您可以控制保存的张量如何打包/解包。`pack_hook`函数应该以一个张量作为其单个参数，但可以返回任何 Python 对象（例如另一个张量，一个元组，甚至包含文件名的字符串）。`unpack_hook`函数以`pack_hook`的输出作为其单个参数，并应返回一个张量，用于在反向传播中使用。`unpack_hook`返回的张量只需要与传递给`pack_hook`的输入张量具有相同的内容。特别地，任何与自动求导相关的元数据都可以忽略，因为它们在解包过程中将被覆盖。 一个这样的示例是： @@ -350,7 +350,7 @@ def unpack_hook(temp_file): return torch.load(temp_file.name) ``` -请注意，`unpack_hook`不应删除临时文件，因为它可能会被多次调用：临时文件应该在返回的SelfDeletingTempFile对象存在期间保持活动状态。在上面的示例中，我们通过在不再需要时关闭临时文件（在删除SelfDeletingTempFile对象时）来防止泄漏临时文件。 +请注意，`unpack_hook`不应删除临时文件，因为它可能会被多次调用：临时文件应该在返回的 SelfDeletingTempFile 对象存在期间保持活动状态。在上面的示例中，我们通过在不再需要时关闭临时文件（在删除 SelfDeletingTempFile 对象时）来防止泄漏临时文件。 注意 @@ -358,7 +358,7 @@ def unpack_hook(temp_file): 警告 -对任何函数的输入执行原地操作是禁止的，因为这可能会导致意外的副作用。如果对pack hook的输入进行了原地修改，PyTorch会抛出错误，但不会捕获对unpack hook的输入进行原地修改的情况。 +对任何函数的输入执行原地操作是禁止的，因为这可能会导致意外的副作用。如果对 pack hook 的输入进行了原地修改，PyTorch 会抛出错误，但不会捕获对 unpack hook 的输入进行原地修改的情况。 ### 注册保存的张量的钩子[](#registering-hooks-for-a-saved-tensor "跳转到此标题的永久链接") @@ -374,11 +374,11 @@ y.grad_fn._raw_saved_self.register_hooks(pack_hook, unpack_hook) 警告 -如果在保存的张量被释放后（即在调用反向传播后）仍保留对`SavedTensor`的引用，则禁止调用其`register_hooks()`。PyTorch大多数情况下会抛出错误，但在某些情况下可能无法这样做，可能会出现未定义的行为。 +如果在保存的张量被释放后（即在调用反向传播后）仍保留对`SavedTensor`的引用，则禁止调用其`register_hooks()`。PyTorch 大多数情况下会抛出错误，但在某些情况下可能无法这样做，可能会出现未定义的行为。 ### 注册保存的张量的默认钩子[](#registering-default-hooks-for-saved-tensors "跳转到此标题的永久链接") -另外，您可以使用上下文管理器[`saved_tensors_hooks`](../autograd.html#torch.autograd.graph.saved_tensors_hooks "torch.autograd.graph.saved_tensors_hooks")来注册一对钩子，这些钩子将应用于在该上下文中创建的*所有*保存的张量。 +另外，您可以使用上下文管理器`saved_tensors_hooks`来注册一对钩子，这些钩子将应用于在该上下文中创建的*所有*保存的张量。 示例： @@ -409,7 +409,7 @@ model = Model() net = nn.DataParallel(model) ``` -使用此上下文管理器定义的钩子是线程局部的。因此，以下代码不会产生期望的效果，因为这些钩子不会通过DataParallel。 +使用此上下文管理器定义的钩子是线程局部的。因此，以下代码不会产生期望的效果，因为这些钩子不会通过 DataParallel。 ```py # Example what NOT to do @@ -427,23 +427,23 @@ with torch.autograd.graph.saved_tensors_hooks(lambda x: x, lambda x: x): y = x * x ``` -没有钩子，`x`，`y.grad_fn._saved_self`和`y.grad_fn._saved_other`都指向同一个张量对象。有了钩子，PyTorch将x打包并解包为两个新的张量对象，这两个对象与原始x共享相同的存储（不执行复制）。## 后向钩子执行[](#backward-hooks-execution "Permalink to this heading") +没有钩子，`x`，`y.grad_fn._saved_self`和`y.grad_fn._saved_other`都指向同一个张量对象。有了钩子，PyTorch 将 x 打包并解包为两个新的张量对象，这两个对象与原始 x 共享相同的存储（不执行复制）。## 后向钩子执行[](#backward-hooks-execution "Permalink to this heading") -本节将讨论不同的钩子何时触发或不触发。然后将讨论它们触发的顺序。将涵盖的钩子包括：通过[`torch.Tensor.register_hook()`](../generated/torch.Tensor.register_hook.html#torch.Tensor.register_hook "torch.Tensor.register_hook")注册到张量的后向钩子，通过[`torch.Tensor.register_post_accumulate_grad_hook()`](../generated/torch.Tensor.register_post_accumulate_grad_hook.html#torch.Tensor.register_post_accumulate_grad_hook "torch.Tensor.register_post_accumulate_grad_hook")注册到张量的后累积梯度钩子，通过[`torch.autograd.graph.Node.register_hook()`](../generated/torch.autograd.graph.Node.register_hook.html#torch.autograd.graph.Node.register_hook "torch.autograd.graph.Node.register_hook")注册到节点的后钩子，以及通过[`torch.autograd.graph.Node.register_prehook()`](../generated/torch.autograd.graph.Node.register_prehook.html#torch.autograd.graph.Node.register_prehook "torch.autograd.graph.Node.register_prehook")注册到节点的前钩子。 +本节将讨论不同的钩子何时触发或不触发。然后将讨论它们触发的顺序。将涵盖的钩子包括：通过`torch.Tensor.register_hook()`注册到张量的后向钩子，通过`torch.Tensor.register_post_accumulate_grad_hook()`注册到张量的后累积梯度钩子，通过`torch.autograd.graph.Node.register_hook()`注册到节点的后钩子，以及通过`torch.autograd.graph.Node.register_prehook()`注册到节点的前钩子。 ### 特定钩子是否会被触发[](#whether-a-particular-hook-will-be-fired "Permalink to this heading") -通过[`torch.Tensor.register_hook()`](../generated/torch.Tensor.register_hook.html#torch.Tensor.register_hook "torch.Tensor.register_hook")注册到张量的钩子在计算该张量的梯度时执行。（请注意，这不需要执行张量的grad_fn。例如，如果张量作为`inputs`参数的一部分传递给[`torch.autograd.grad()`](../generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad")，则可能不会执行张量的grad_fn，但是注册到该张量的钩子将始终被执行。） +通过`torch.Tensor.register_hook()`注册到张量的钩子在计算该张量的梯度时执行。（请注意，这不需要执行张量的 grad_fn。例如，如果张量作为`inputs`参数的一部分传递给`torch.autograd.grad()`，则可能不会执行张量的 grad_fn，但是注册到该张量的钩子将始终被执行。） -通过[`torch.Tensor.register_post_accumulate_grad_hook()`](../generated/torch.Tensor.register_post_accumulate_grad_hook.html#torch.Tensor.register_post_accumulate_grad_hook "torch.Tensor.register_post_accumulate_grad_hook")注册到张量的钩子在该张量的梯度累积后执行，这意味着张量的grad字段已经设置。而通过[`torch.Tensor.register_hook()`](../generated/torch.Tensor.register_hook.html#torch.Tensor.register_hook "torch.Tensor.register_hook")注册的钩子在计算梯度时运行，通过[`torch.Tensor.register_post_accumulate_grad_hook()`](../generated/torch.Tensor.register_post_accumulate_grad_hook.html#torch.Tensor.register_post_accumulate_grad_hook "torch.Tensor.register_post_accumulate_grad_hook")注册的钩子只有在autograd在反向传播结束时更新张量的grad字段时才会触发。因此，后累积梯度钩子只能注册给叶子张量。在非叶子张量上通过[`torch.Tensor.register_post_accumulate_grad_hook()`](../generated/torch.Tensor.register_post_accumulate_grad_hook.html#torch.Tensor.register_post_accumulate_grad_hook "torch.Tensor.register_post_accumulate_grad_hook")注册钩子会出错，即使您调用backward(retain_graph=True)。 +通过`torch.Tensor.register_post_accumulate_grad_hook()`注册到张量的钩子在该张量的梯度累积后执行，这意味着张量的 grad 字段已经设置。而通过`torch.Tensor.register_hook()`注册的钩子在计算梯度时运行，通过`torch.Tensor.register_post_accumulate_grad_hook()`注册的钩子只有在 autograd 在反向传播结束时更新张量的 grad 字段时才会触发。因此，后累积梯度钩子只能注册给叶子张量。在非叶子张量上通过`torch.Tensor.register_post_accumulate_grad_hook()`注册钩子会出错，即使您调用 backward(retain_graph=True)。 -使用[`torch.autograd.graph.Node.register_hook()`](../generated/torch.autograd.graph.Node.register_hook.html#torch.autograd.graph.Node.register_hook)或[`torch.autograd.graph.Node.register_prehook()`](../generated/torch.autograd.graph.Node.register_prehook.html#torch.autograd.graph.Node.register_prehook)注册到`torch.autograd.graph.Node`的钩子仅在注册的节点被执行时触发。 +使用`torch.autograd.graph.Node.register_hook()`或`torch.autograd.graph.Node.register_prehook()`注册到`torch.autograd.graph.Node`的钩子仅在注册的节点被执行时触发。 -特定节点是否执行可能取决于反向传播是使用[`torch.autograd.grad()`](../generated/torch.autograd.grad.html#torch.autograd.grad)还是[`torch.autograd.backward()`](../generated/torch.autograd.backward.html#torch.autograd.backward)调用的。具体来说，当您在注册到与作为`inputs`参数的一部分传递给[`torch.autograd.grad()`](../generated/torch.autograd.grad.html#torch.autograd.grad)或[`torch.autograd.backward()`](../generated/torch.autograd.backward.html#torch.autograd.backward)的张量对应的节点上注册钩子时，您应该注意这些差异。 +特定节点是否执行可能取决于反向传播是使用`torch.autograd.grad()`还是`torch.autograd.backward()`调用的。具体来说，当您在注册到与作为`inputs`参数的一部分传递给`torch.autograd.grad()`或`torch.autograd.backward()`的张量对应的节点上注册钩子时，您应该注意这些差异。 -如果您使用[`torch.autograd.backward()`](../generated/torch.autograd.backward.html#torch.autograd.backward)，上述提到的所有钩子都将被执行，无论您是否指定了`inputs`参数。这是因为.backward()执行所有节点，即使它们对应于作为输入指定的张量。（请注意，执行作为`inputs`传递的张量对应的此额外节点通常是不必要的，但仍然会执行。此行为可能会更改；您不应该依赖它。） +如果您使用`torch.autograd.backward()`，上述提到的所有钩子都将被执行，无论您是否指定了`inputs`参数。这是因为.backward()执行所有节点，即使它们对应于作为输入指定的张量。（请注意，执行作为`inputs`传递的张量对应的此额外节点通常是不必要的，但仍然会执行。此行为可能会更改；您不应该依赖它。） -另一方面，如果您使用[`torch.autograd.grad()`](../generated/torch.autograd.grad.html#torch.autograd.grad)，则注册到与传递给`input`的张量对应的节点的反向钩子可能不会被执行，因为除非有另一个依赖于此节点梯度结果的输入，否则不会执行这些节点。 +另一方面，如果您使用`torch.autograd.grad()`，则注册到与传递给`input`的张量对应的节点的反向钩子可能不会被执行，因为除非有另一个依赖于此节点梯度结果的输入，否则不会执行这些节点。 ### 不同钩子被触发的顺序[](#the-order-in-which-the-different-hooks-are-fired) @@ -465,9 +465,9 @@ with torch.autograd.graph.saved_tensors_hooks(lambda x: x, lambda x: x): ### 特殊钩子 -[`torch.autograd.graph.register_multi_grad_hook()`](../autograd.html#torch.autograd.graph.register_multi_grad_hook)是使用注册到张量的钩子实现的。每个单独的张量钩子按照上面定义的张量钩子顺序触发，并且当计算最后一个张量梯度时调用注册的多梯度钩子。 +`torch.autograd.graph.register_multi_grad_hook()`是使用注册到张量的钩子实现的。每个单独的张量钩子按照上面定义的张量钩子顺序触发，并且当计算最后一个张量梯度时调用注册的多梯度钩子。 -[`torch.nn.modules.module.register_module_full_backward_hook()`](../generated/torch.nn.modules.module.register_module_full_backward_hook.html#torch.nn.modules.module.register_module_full_backward_hook "torch.nn.modules.module.register_module_full_backward_hook") 是使用注册到节点的钩子来实现的。在计算前向传播时，钩子被注册到与模块的输入和输出对应的grad_fn上。因为一个模块可能接受多个输入并返回多个输出，所以在前向传播之前，首先对模块的输入应用一个虚拟的自定义自动求导函数，然后将前向传播的输出返回到确保这些张量共享一个单一的grad_fn，然后我们可以将我们的钩子附加到上面。 +`torch.nn.modules.module.register_module_full_backward_hook()` 是使用注册到节点的钩子来实现的。在计算前向传播时，钩子被注册到与模块的输入和输出对应的 grad_fn 上。因为一个模块可能接受多个输入并返回多个输出，所以在前向传播之前，首先对模块的输入应用一个虚拟的自定义自动求导函数，然后将前向传播的输出返回到确保这些张量共享一个单一的 grad_fn，然后我们可以将我们的钩子附加到上面。 ### 张量在原地修改时的钩子行为[](#behavior-of-tensor-hooks-when-tensor-is-modified-in-place "Permalink to this heading") @@ -484,4 +484,4 @@ t.register_hook(fn) t.backward() ``` -此外，值得知道的是，在幕后，当钩子注册到张量时，它们实际上会永久绑定到该张量的grad_fn上，因此如果该张量随后被原地修改，即使该张量现在有一个新的grad_fn，之前在原地修改之前注册的钩子仍将继续与旧的grad_fn相关联，例如，当自动求导引擎在图中到达该张量的旧grad_fn时，它们将触发。 +此外，值得知道的是，在幕后，当钩子注册到张量时，它们实际上会永久绑定到该张量的 grad_fn 上，因此如果该张量随后被原地修改，即使该张量现在有一个新的 grad_fn，之前在原地修改之前注册的钩子仍将继续与旧的 grad_fn 相关联，例如，当自动求导引擎在图中到达该张量的旧 grad_fn 时，它们将触发。 diff --git a/totrans/doc22_010.md b/totrans/doc22_010.md index 5a151743..00c00d7f 100644 --- a/totrans/doc22_010.md +++ b/totrans/doc22_010.md @@ -1,10 +1,10 @@ # 广播语义 -> 原文：[https://pytorch.org/docs/stable/notes/broadcasting.html](https://pytorch.org/docs/stable/notes/broadcasting.html) +> 原文：[`pytorch.org/docs/stable/notes/broadcasting.html`](https://pytorch.org/docs/stable/notes/broadcasting.html) -许多PyTorch操作支持NumPy的广播语义。有关详细信息，请参阅[https://numpy.org/doc/stable/user/basics.broadcasting.html](https://numpy.org/doc/stable/user/basics.broadcasting.html)。 +许多 PyTorch 操作支持 NumPy 的广播语义。有关详细信息，请参阅[`numpy.org/doc/stable/user/basics.broadcasting.html`](https://numpy.org/doc/stable/user/basics.broadcasting.html)。 -简而言之，如果PyTorch操作支持广播，则其张量参数可以自动扩展为相等大小（而不会复制数据）。 +简而言之，如果 PyTorch 操作支持广播，则其张量参数可以自动扩展为相等大小（而不会复制数据）。 ## 一般语义 @@ -12,7 +12,7 @@ + 每个张量至少有一个维度。 -+ 在迭代维度大小时，从尾部维度开始，维度大小必须要么相等，要么其中一个为1，要么其中一个不存在。 ++ 在迭代维度大小时，从尾部维度开始，维度大小必须要么相等，要么其中一个为 1，要么其中一个不存在。 例如： @@ -42,7 +42,7 @@ 如果两个张量`x`，`y`是“可广播的”，则结果张量大小计算如下： -+ 如果`x`和`y`的维度数不相等，则在较少维度的张量的维度前添加1，使它们长度相等。 ++ 如果`x`和`y`的维度数不相等，则在较少维度的张量的维度前添加 1，使它们长度相等。 + 然后，对于每个维度大小，结果维度大小是沿该维度的`x`和`y`的大小的最大值。 @@ -88,7 +88,7 @@ RuntimeError: The expanded size of the tensor (1) must match the existing size ( ## 向后兼容性 -PyTorch的先前版本允许某些逐点函数在具有不同形状的张量上执行，只要每个张量中的元素数量相等即可。然后，逐点操作将通过将每个张量视为1维来执行。PyTorch现在支持广播，而“1维”逐点行为被视为已弃用，并且在张量不可广播但具有相同数量的元素的情况下会生成Python警告。 +PyTorch 的先前版本允许某些逐点函数在具有不同形状的张量上执行，只要每个张量中的元素数量相等即可。然后，逐点操作将通过将每个张量视为 1 维来执行。PyTorch 现在支持广播，而“1 维”逐点行为被视为已弃用，并且在张量不可广播但具有相同数量的元素的情况下会生成 Python 警告。 请注意，广播的引入可能会导致向后不兼容的更改，即两个张量的形状不相同，但可以广播并且具有相同数量的元素的情况。例如： @@ -96,7 +96,7 @@ PyTorch的先前版本允许某些逐点函数在具有不同形状的张量上 >>> torch.add(torch.ones(4,1), torch.randn(4)) ``` -以前会产生一个大小为torch.Size([4,1])的张量，但现在会产生一个大小为torch.Size([4,4])的张量。为了帮助识别代码中可能存在的由广播引入的向后不兼容性，您可以将torch.utils.backcompat.broadcast_warning.enabled设置为True，在这种情况下会生成一个Python警告。 +以前会产生一个大小为 torch.Size([4,1])的张量，但现在会产生一个大小为 torch.Size([4,4])的张量。为了帮助识别代码中可能存在的由广播引入的向后不兼容性，您可以将 torch.utils.backcompat.broadcast_warning.enabled 设置为 True，在这种情况下会生成一个 Python 警告。 例如： diff --git a/totrans/doc22_011.md b/totrans/doc22_011.md index 7cba8779..58c91042 100644 --- a/totrans/doc22_011.md +++ b/totrans/doc22_011.md @@ -1,10 +1,10 @@ # CPU 线程和 TorchScript 推理 -> [https://pytorch.org/docs/stable/notes/cpu_threading_torchscript_inference.html](https://pytorch.org/docs/stable/notes/cpu_threading_torchscript_inference.html) +> [`pytorch.org/docs/stable/notes/cpu_threading_torchscript_inference.html`](https://pytorch.org/docs/stable/notes/cpu_threading_torchscript_inference.html) PyTorch 允许在 TorchScript 模型推理期间使用多个 CPU 线程。以下图显示了在典型应用程序中可能找到的不同级别的并行性： -[![../_images/cpu_threading_torchscript_inference.svg](../Images/8df78fa0159321538b2e2a438f6cae52.png)](../_images/cpu_threading_torchscript_inference.svg) +![../_images/cpu_threading_torchscript_inference.svg](img/cpu_threading_torchscript_inference.svg) 一个或多个推理线程在给定输入上执行模型的前向传递。每个推理线程调用 JIT 解释器，逐个执行模型的操作。模型可以利用 `fork` TorchScript 原语启动一个异步任务。一次分叉多个操作会导致并行执行的任务。`fork` 操作符返回一个 `Future` 对象，可以稍后用于同步，例如： @@ -62,8 +62,8 @@ PyTorch 允许在构建时选择 ATen 和其他库使用的并行化后端，具 | 并行性类型 | 设置 | 备注 | | --- | --- | --- | -| 操作间的并行性 | `at::set_num_interop_threads`，`at::get_num_interop_threads`（C++）`set_num_interop_threads`，`get_num_interop_threads`（Python，[`torch`](../torch.html#module-torch "torch") 模块） | 默认线程数：CPU 核心数。 | -| 手术过程中的并行性 | `at::set_num_threads`，`at::get_num_threads`（C++）`set_num_threads`，`get_num_threads`（Python，[`torch`](../torch.html#module-torch "torch") 模块）环境变量：`OMP_NUM_THREADS` 和 `MKL_NUM_THREADS` | +| 操作间的并行性 | `at::set_num_interop_threads`，`at::get_num_interop_threads`（C++）`set_num_interop_threads`，`get_num_interop_threads`（Python，`torch` 模块） | 默认线程数：CPU 核心数。 | +| 手术过程中的并行性 | `at::set_num_threads`，`at::get_num_threads`（C++）`set_num_threads`，`get_num_threads`（Python，`torch` 模块）环境变量：`OMP_NUM_THREADS` 和 `MKL_NUM_THREADS` | 对于内部操作并行设置，`at::set_num_threads`，`torch.set_num_threads`始终优先于环境变量，`MKL_NUM_THREADS`变量优先于`OMP_NUM_THREADS`。 @@ -82,9 +82,9 @@ for t in threads: # ... plotting (threads, runtimes) ... ``` -在具有24个物理CPU核心的系统（基于Xeon E5-2680、MKL和OpenMP构建）上运行脚本会产生以下运行时间： +在具有 24 个物理 CPU 核心的系统（基于 Xeon E5-2680、MKL 和 OpenMP 构建）上运行脚本会产生以下运行时间： -[![../_images/cpu_threading_runtimes.svg](../Images/50cb089741be0ac4482f410e4d719b4b.png)](../_images/cpu_threading_runtimes.svg) +![../_images/cpu_threading_runtimes.svg](img/cpu_threading_runtimes.svg) 调整内部和外部操作线程数量时应考虑以下因素： @@ -94,12 +94,12 @@ for t in threads: 警告 -OpenMP不能保证应用程序将使用单个进程内部操作线程池。相反，两个不同的应用程序或内部操作线程可能会使用不同的OpenMP线程池进行内部操作工作。这可能导致应用程序使用大量线程。在OpenMP情况下，需要特别注意调整线程数量，以避免多线程应用程序中的过度订阅。 +OpenMP 不能保证应用程序将使用单个进程内部操作线程池。相反，两个不同的应用程序或内部操作线程可能会使用不同的 OpenMP 线程池进行内部操作工作。这可能导致应用程序使用大量线程。在 OpenMP 情况下，需要特别注意调整线程数量，以避免多线程应用程序中的过度订阅。 注意 -预编译的PyTorch版本已编译为支持OpenMP。 +预编译的 PyTorch 版本已编译为支持 OpenMP。 注意 -`parallel_info`实用程序打印有关线程设置的信息，可用于调试。在Python中也可以通过`torch.__config__.parallel_info()`调用获得类似的输出。 +`parallel_info`实用程序打印有关线程设置的信息，可用于调试。在 Python 中也可以通过`torch.__config__.parallel_info()`调用获得类似的输出。 diff --git a/totrans/doc22_012.md b/totrans/doc22_012.md index 00feb6fc..d4ca70c7 100644 --- a/totrans/doc22_012.md +++ b/totrans/doc22_012.md @@ -1,12 +1,12 @@ -# CUDA语义 +# CUDA 语义 -> 原文：[https://pytorch.org/docs/stable/notes/cuda.html](https://pytorch.org/docs/stable/notes/cuda.html) +> 原文：[`pytorch.org/docs/stable/notes/cuda.html`](https://pytorch.org/docs/stable/notes/cuda.html) -[`torch.cuda`](../cuda.html#module-torch.cuda "torch.cuda")用于设置和运行CUDA操作。它跟踪当前选择的GPU，您分配的所有CUDA张量默认将在该设备上创建。所选设备可以通过[`torch.cuda.device`](../generated/torch.cuda.device.html#torch.cuda.device "torch.cuda.device")上下文管理器更改。 +`torch.cuda`用于设置和运行 CUDA 操作。它跟踪当前选择的 GPU，您分配的所有 CUDA 张量默认将在该设备上创建。所选设备可以通过`torch.cuda.device`上下文管理器更改。 然而，一旦分配了张量，您可以对其进行操作，而不管所选设备如何，结果将始终放置在与张量相同的设备上。 -默认情况下不允许跨GPU操作，除了[`copy_()`](../generated/torch.Tensor.copy_.html#torch.Tensor.copy_ "torch.Tensor.copy_")和其他具有类似复制功能的方法，如[`to()`](../generated/torch.Tensor.to.html#torch.Tensor.to "torch.Tensor.to")和[`cuda()`](../generated/torch.Tensor.cuda.html#torch.Tensor.cuda "torch.Tensor.cuda")。除非启用对等内存访问，否则任何尝试在不同设备上分布的张量上启动操作的尝试都将引发错误。 +默认情况下不允许跨 GPU 操作，除了`copy_()`和其他具有类似复制功能的方法，如`to()`和`cuda()`。除非启用对等内存访问，否则任何尝试在不同设备上分布的张量上启动操作的尝试都将引发错误。 以下是一个展示示例： @@ -46,13 +46,13 @@ with torch.cuda.device(1): # d.device, e.device, and f.device are all device(type='cuda', index=2) ``` -## Ampere（以及更高版本）设备上的TensorFloat-32（TF32）[](#tensorfloat-32-tf32-on-ampere-and-later-devices "跳转到此标题的永久链接") +## Ampere（以及更高版本）设备上的 TensorFloat-32（TF32）[](#tensorfloat-32-tf32-on-ampere-and-later-devices "跳转到此标题的永久链接") -从PyTorch 1.7开始，有一个名为allow_tf32的新标志。在PyTorch 1.7到PyTorch 1.11中，默认为True，在PyTorch 1.12及以后为False。该标志控制PyTorch是否允许在NVIDIA GPU上使用TensorFloat32（TF32）张量核心来计算matmul（矩阵乘法和批量矩阵乘法）和卷积。 +从 PyTorch 1.7 开始，有一个名为 allow_tf32 的新标志。在 PyTorch 1.7 到 PyTorch 1.11 中，默认为 True，在 PyTorch 1.12 及以后为 False。该标志控制 PyTorch 是否允许在 NVIDIA GPU 上使用 TensorFloat32（TF32）张量核心来计算 matmul（矩阵乘法和批量矩阵乘法）和卷积。 -TF32张量核心旨在通过将输入数据四舍五入为10位尾数，并使用FP32精度累积结果，保持FP32动态范围，从而在torch.float32张量上实现更好的matmul和卷积性能。 +TF32 张量核心旨在通过将输入数据四舍五入为 10 位尾数，并使用 FP32 精度累积结果，保持 FP32 动态范围，从而在 torch.float32 张量上实现更好的 matmul 和卷积性能。 -matmuls和卷积是分别控制的，它们对应的标志可以在以下位置访问： +matmuls 和卷积是分别控制的，它们对应的标志可以在以下位置访问： ```py # The flag below controls whether to allow TF32 on matmul. This flag defaults to False @@ -63,9 +63,9 @@ torch.backends.cuda.matmul.allow_tf32 = True torch.backends.cudnn.allow_tf32 = True ``` -matmuls的精度也可以更广泛地设置（不仅限于CUDA），通过`set_float_32_matmul_precision()`。请注意，除了matmuls和卷积本身，内部使用matmuls或卷积的函数和nn模块也会受到影响。这些包括nn.Linear、nn.Conv*、cdist、tensordot、affine grid和grid sample、adaptive log softmax、GRU和LSTM。 +matmuls 的精度也可以更广泛地设置（不仅限于 CUDA），通过`set_float_32_matmul_precision()`。请注意，除了 matmuls 和卷积本身，内部使用 matmuls 或卷积的函数和 nn 模块也会受到影响。这些包括 nn.Linear、nn.Conv*、cdist、tensordot、affine grid 和 grid sample、adaptive log softmax、GRU 和 LSTM。 -要了解精度和速度的概念，请参见下面的示例代码和基准数据（在A100上）： +要了解精度和速度的概念，请参见下面的示例代码和基准数据（在 A100 上）： ```py a_full = torch.randn(10240, 10240, dtype=torch.double, device='cuda') @@ -89,31 +89,31 @@ error = (ab_fp32 - ab_full).abs().max() # 0.0031 relative_error = error / mean # 0.000039 ``` -从上面的例子可以看出，启用TF32后，在A100上速度快约7倍，与双精度相比的相对误差大约大2个数量级。请注意，TF32与单精度速度的确切比率取决于硬件生成，例如内存带宽与计算的比率以及TF32与FP32 matmul吞吐量的比率可能会因世代或模型而异。如果需要完整的FP32精度，用户可以通过禁用TF32来实现： +从上面的例子可以看出，启用 TF32 后，在 A100 上速度快约 7 倍，与双精度相比的相对误差大约大 2 个数量级。请注意，TF32 与单精度速度的确切比率取决于硬件生成，例如内存带宽与计算的比率以及 TF32 与 FP32 matmul 吞吐量的比率可能会因世代或模型而异。如果需要完整的 FP32 精度，用户可以通过禁用 TF32 来实现： ```py torch.backends.cuda.matmul.allow_tf32 = False torch.backends.cudnn.allow_tf32 = False ``` -要在C++中关闭TF32标志，可以执行以下操作： +要在 C++中关闭 TF32 标志，可以执行以下操作： ```py at::globalContext().setAllowTF32CuBLAS(false); at::globalContext().setAllowTF32CuDNN(false); ``` -有关TF32的更多信息，请参见： +有关 TF32 的更多信息，请参见： + [TensorFloat-32](https://blogs.nvidia.com/blog/2020/05/14/tensorfloat-32-precision-format/) + [CUDA 11](https://devblogs.nvidia.com/cuda-11-features-revealed/) -+ [Ampere架构](https://devblogs.nvidia.com/nvidia-ampere-architecture-in-depth/) ## FP16 GEMMs中的降低精度缩减[](#reduced-precision-reduction-in-fp16-gemms "跳转到此标题的永久链接") ++ [Ampere 架构](https://devblogs.nvidia.com/nvidia-ampere-architecture-in-depth/) ## FP16 GEMMs 中的降低精度缩减[](#reduced-precision-reduction-in-fp16-gemms "跳转到此标题的永久链接") -fp16 GEMMs可能使用一些中间降低精度的缩减（例如在fp16而不是fp32中）。这些选择性的精度降低可以在某些工作负载（特别是具有大k维度的工作负载）和GPU架构上实现更高的性能，但会牺牲数值精度和可能会发生溢出。 +fp16 GEMMs 可能使用一些中间降低精度的缩减（例如在 fp16 而不是 fp32 中）。这些选择性的精度降低可以在某些工作负载（特别是具有大 k 维度的工作负载）和 GPU 架构上实现更高的性能，但会牺牲数值精度和可能会发生溢出。 -V100上的一些示例基准数据： +V100 上的一些示例基准数据： ```py [--------------------------- bench_gemm_transformer --------------------------] @@ -169,7 +169,7 @@ at::globalContext().setAllowBF16ReductionCuBLAS(true); 可以通过设置环境变量`CUDA_LAUNCH_BLOCKING=1`来强制同步计算。当 GPU 上发生错误时，这可能会很方便。（使用异步执行时，直到操作实际执行后才报告此类错误，因此堆栈跟踪不显示请求位置。） -异步计算的一个后果是，没有同步的时间测量不准确。为了获得精确的测量结果，应在测量之前调用 [`torch.cuda.synchronize()`](../generated/torch.cuda.synchronize.html#torch.cuda.synchronize "torch.cuda.synchronize")，或者使用 [`torch.cuda.Event`](../generated/torch.cuda.Event.html#torch.cuda.Event "torch.cuda.Event") 记录时间如下： +异步计算的一个后果是，没有同步的时间测量不准确。为了获得精确的测量结果，应在测量之前调用 `torch.cuda.synchronize()`，或者使用 `torch.cuda.Event` 记录时间如下： ```py start_event = torch.cuda.Event(enable_timing=True) @@ -183,13 +183,13 @@ torch.cuda.synchronize() # Wait for the events to be recorded! elapsed_time_ms = start_event.elapsed_time(end_event) ``` -作为例外，一些函数（如[`to()`](../generated/torch.Tensor.to.html#torch.Tensor.to "torch.Tensor.to") 和 [`copy_()`](../generated/torch.Tensor.copy_.html#torch.Tensor.copy_ "torch.Tensor.copy_")）允许显式的 `non_blocking` 参数，让调用者在不必要时绕过同步。另一个例外是 CUDA 流，下面会解释。 +作为例外，一些函数（如`to()` 和 `copy_()`）允许显式的 `non_blocking` 参数，让调用者在不必要时绕过同步。另一个例外是 CUDA 流，下面会解释。 ### CUDA 流 [CUDA 流](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#streams) 是属于特定设备的线性执行序列。通常情况下，您不需要显式创建一个：默认情况下，每个设备使用自己的“默认”流。 -每个流内部的操作按创建顺序串行化，但来自不同流的操作可以以任何相对顺序并发执行，除非使用显式同步函数（如[`synchronize()`](../generated/torch.cuda.synchronize.html#torch.cuda.synchronize "torch.cuda.synchronize") 或 [`wait_stream()`](../generated/torch.cuda.Stream.html#torch.cuda.Stream.wait_stream "torch.cuda.Stream.wait_stream")）。例如，以下代码是不正确的： +每个流内部的操作按创建顺序串行化，但来自不同流的操作可以以任何相对顺序并发执行，除非使用显式同步函数（如`synchronize()` 或 `wait_stream()`）。例如，以下代码是不正确的： ```py cuda = torch.device('cuda') @@ -212,7 +212,7 @@ with torch.cuda.stream(s): A.record_stream(s) # NEW! ``` -有两个新的添加。[`torch.cuda.Stream.wait_stream()`](../generated/torch.cuda.Stream.html#torch.cuda.Stream.wait_stream "torch.cuda.Stream.wait_stream")调用确保`normal_()`执行完成后，我们开始在侧流上运行`sum(A)`。[`torch.Tensor.record_stream()`](../generated/torch.Tensor.record_stream.html#torch.Tensor.record_stream "torch.Tensor.record_stream")（有关更多详细信息，请参见）确保在`sum(A)`完成之前我们不会释放A。您还可以在以后的某个时间点手动等待流`torch.cuda.default_stream(cuda).wait_stream(s)`（请注意，立即等待是没有意义的，因为这将阻止流执行与默认流上的其他工作并行运行）。有关何时使用其中一个的更多详细信息，请参阅[`torch.Tensor.record_stream()`](../generated/torch.Tensor.record_stream.html#torch.Tensor.record_stream "torch.Tensor.record_stream")的文档。 +有两个新的添加。`torch.cuda.Stream.wait_stream()`调用确保`normal_()`执行完成后，我们开始在侧流上运行`sum(A)`。`torch.Tensor.record_stream()`（有关更多详细信息，请参见）确保在`sum(A)`完成之前我们不会释放 A。您还可以在以后的某个时间点手动等待流`torch.cuda.default_stream(cuda).wait_stream(s)`（请注意，立即等待是没有意义的，因为这将阻止流执行与默认流上的其他工作并行运行）。有关何时使用其中一个的更多详细信息，请参阅`torch.Tensor.record_stream()`的文档。 请注意，即使没有读取依赖关系，例如在这个例子中看到的情况下，这种同步也是必要的： @@ -226,13 +226,13 @@ with torch.cuda.stream(s): A.record_stream(s) ``` -尽管`s`上的计算不读取`A`的内容，也没有其他对`A`的使用，但仍然需要同步，因为`A`可能对应于由CUDA缓存分配器重新分配的内存，其中包含来自旧（已释放）内存的挂起操作。 +尽管`s`上的计算不读取`A`的内容，也没有其他对`A`的使用，但仍然需要同步，因为`A`可能对应于由 CUDA 缓存分配器重新分配的内存，其中包含来自旧（已释放）内存的挂起操作。 ### 反向传递的流语义[](#stream-semantics-of-backward-passes "跳转到此标题") -每个反向CUDA操作都在用于其对应的前向操作的相同流上运行。如果您的前向传递在不同流上并行运行独立操作，这有助于反向传递利用相同的并行性。 +每个反向 CUDA 操作都在用于其对应的前向操作的相同流上运行。如果您的前向传递在不同流上并行运行独立操作，这有助于反向传递利用相同的并行性。 -关于周围操作的反向调用的流语义与任何其他调用的流语义相同。在反向传递中，即使反向操作在多个流上运行，也会插入内部同步，以确保这一点，如前一段所述。更具体地说，当调用[`autograd.backward`](../generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward"), [`autograd.grad`](../generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad"), 或 [`tensor.backward`](../generated/torch.Tensor.backward.html#torch.Tensor.backward "torch.Tensor.backward")，并可选择将CUDA张量作为初始梯度（例如，[`autograd.backward(..., grad_tensors=initial_grads)`](../generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward"), [`autograd.grad(..., grad_outputs=initial_grads)`](../generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad"), 或 [`tensor.backward(..., gradient=initial_grad)`](../generated/torch.Tensor.backward.html#torch.Tensor.backward "torch.Tensor.backward"))时， +关于周围操作的反向调用的流语义与任何其他调用的流语义相同。在反向传递中，即使反向操作在多个流上运行，也会插入内部同步，以确保这一点，如前一段所述。更具体地说，当调用`autograd.backward`, `autograd.grad`, 或 `tensor.backward`，并可选择将 CUDA 张量作为初始梯度（例如，`autograd.backward(..., grad_tensors=initial_grads)`, `autograd.grad(..., grad_outputs=initial_grads)`, 或 `tensor.backward(..., gradient=initial_grad)`)时， 1. 可选择填充初始梯度， @@ -279,9 +279,9 @@ with torch.cuda.stream(s): loss.backward(gradient=initial_grad) ``` -#### BC注意：在默认流上使用梯度[](#bc-note-using-grads-on-the-default-stream "跳转到此标题") +#### BC 注意：在默认流上使用梯度[](#bc-note-using-grads-on-the-default-stream "跳转到此标题") -在PyTorch的早期版本（1.9及更早版本）中，自动求导引擎总是将默认流与所有反向操作同步，因此以下模式： +在 PyTorch 的早期版本（1.9 及更早版本）中，自动求导引擎总是将默认流与所有反向操作同步，因此以下模式： ```py with torch.cuda.stream(s): @@ -289,7 +289,7 @@ with torch.cuda.stream(s): use grads ``` -只要`使用梯度`发生在默认流上，就是安全的。在当前的PyTorch中，该模式不再安全。如果`backward()`和`使用梯度`在不同的流上下文中，您必须同步这些流： +只要`使用梯度`发生在默认流上，就是安全的。在当前的 PyTorch 中，该模式不再安全。如果`backward()`和`使用梯度`在不同的流上下文中，您必须同步这些流： ```py with torch.cuda.stream(s): @@ -300,11 +300,11 @@ use grads 即使`使用梯度`在默认流上。## 内存管理[](#memory-management "跳转到此标题") -PyTorch 使用缓存内存分配器加速内存分配。这允许快速内存释放而无需设备同步。但是，分配器管理的未使用内存仍会显示为在 `nvidia-smi` 中使用。您可以使用 [`memory_allocated()`](../generated/torch.cuda.memory_allocated.html#torch.cuda.memory_allocated "torch.cuda.memory_allocated") 和 [`max_memory_allocated()`](../generated/torch.cuda.max_memory_allocated.html#torch.cuda.max_memory_allocated "torch.cuda.max_memory_allocated") 监视张量占用的内存，并使用 [`memory_reserved()`](../generated/torch.cuda.memory_reserved.html#torch.cuda.memory_reserved "torch.cuda.memory_reserved") 和 [`max_memory_reserved()`](../generated/torch.cuda.max_memory_reserved.html#torch.cuda.max_memory_reserved "torch.cuda.max_memory_reserved") 监视缓存分配器管理的总内存量。调用 [`empty_cache()`](../generated/torch.cuda.empty_cache.html#torch.cuda.empty_cache "torch.cuda.empty_cache") 释放 PyTorch 中所有**未使用**的缓存内存，以便其他 GPU 应用程序可以使用。但是，张量占用的 GPU 内存不会被释放，因此不能增加供 PyTorch 使用的 GPU 内存量。 +PyTorch 使用缓存内存分配器加速内存分配。这允许快速内存释放而无需设备同步。但是，分配器管理的未使用内存仍会显示为在 `nvidia-smi` 中使用。您可以使用 `memory_allocated()` 和 `max_memory_allocated()` 监视张量占用的内存，并使用 `memory_reserved()` 和 `max_memory_reserved()` 监视缓存分配器管理的总内存量。调用 `empty_cache()` 释放 PyTorch 中所有**未使用**的缓存内存，以便其他 GPU 应用程序可以使用。但是，张量占用的 GPU 内存不会被释放，因此不能增加供 PyTorch 使用的 GPU 内存量。 -为了更好地了解 CUDA 内存如何随时间变化，[了解 CUDA 内存使用情况](../torch_cuda_memory.html#torch-cuda-memory) 描述了捕获和可视化内存使用痕迹的工具。 +为了更好地了解 CUDA 内存如何随时间变化，了解 CUDA 内存使用情况 描述了捕获和可视化内存使用痕迹的工具。 -对于更高级的用户，我们通过 [`memory_stats()`](../generated/torch.cuda.memory_stats.html#torch.cuda.memory_stats "torch.cuda.memory_stats") 提供更全面的内存基准测试。我们还提供通过 [`memory_snapshot()`](../generated/torch.cuda.memory_snapshot.html#torch.cuda.memory_snapshot "torch.cuda.memory_snapshot") 捕获内存分配器状态的完整快照的功能，这可以帮助您了解代码产生的底层分配模式。 +对于更高级的用户，我们通过 `memory_stats()` 提供更全面的内存基准测试。我们还提供通过 `memory_snapshot()` 捕获内存分配器状态的完整快照的功能，这可以帮助您了解代码产生的底层分配模式。 ### 环境变量 @@ -314,25 +314,25 @@ PyTorch 使用缓存内存分配器加速内存分配。这允许快速内存释 + `backend` 允许选择底层分配器的实现。目前，有效选项有 `native`，使用 PyTorch 的原生实现，以及 `cudaMallocAsync`，使用 [CUDA 内置的异步分配器](https://developer.nvidia.com/blog/using-cuda-stream-ordered-memory-allocator-part-1/)。`cudaMallocAsync` 需要 CUDA 11.4 或更新版本。默认值是 `native`。`backend` 适用于进程使用的所有设备，不能针对每个设备指定。 -+ `max_split_size_mb` 防止原生分配器分割大于此大小（以 MB 为单位）的块。这可以减少碎片化，并可能使一些边缘工作负载在不耗尽内存的情况下完成。性能成本可能从‘零’到‘可观’不等，取决于分配模式。默认值为无限制，即所有块都可以分割。[`memory_stats()`](../generated/torch.cuda.memory_stats.html#torch.cuda.memory_stats "torch.cuda.memory_stats") 和 [`memory_summary()`](../generated/torch.cuda.memory_summary.html#torch.cuda.memory_summary "torch.cuda.memory_summary") 方法对调整很有用。此选项应作为最后的手段用于因‘内存不足’而中止的工作负载，并显示大量非活动分割块。`max_split_size_mb` 仅在 `backend:native` 时有意义。对于 `backend:cudaMallocAsync`，`max_split_size_mb` 将被忽略。 ++ `max_split_size_mb` 防止原生分配器分割大于此大小（以 MB 为单位）的块。这可以减少碎片化，并可能使一些边缘工作负载在不耗尽内存的情况下完成。性能成本可能从‘零’到‘可观’不等，取决于分配模式。默认值为无限制，即所有块都可以分割。`memory_stats()` 和 `memory_summary()` 方法对调整很有用。此选项应作为最后的手段用于因‘内存不足’而中止的工作负载，并显示大量非活动分割块。`max_split_size_mb` 仅在 `backend:native` 时有意义。对于 `backend:cudaMallocAsync`，`max_split_size_mb` 将被忽略。 -+ `roundup_power2_divisions`有助于将请求的分配大小四舍五入到最接近的2的幂次方，并更好地利用块。在原生CUDACachingAllocator中，大小会被四舍五入到512的倍数块大小，因此对于较小的大小效果很好。然而，对于大型相邻分配来说，这可能效率低下，因为每个分配都会进入不同大小的块，并且这些块的重复使用被最小化。这可能会产生大量未使用的块，并浪费GPU内存容量。此选项使分配大小四舍五入到最接近的2的幂次方。例如，如果我们需要将大小为1200四舍五入，如果分割数为4，那么大小1200位于1024和2048之间，如果在它们之间进行4次分割，值为1024、1280、1536和1792。因此，大小为1200的分配将被四舍五入为1280，作为最接近2的幂次方的上限。指定一个值应用于所有分配大小，或指定一个键值对数组，为每个2的幂次方间隔单独设置2的幂次方分割。例如，为所有小于256MB的分配设置1个分割，为256MB至512MB之间的分配设置2个分割，为512MB至1GB之间的分配设置4个分割，为任何更大的分配设置8个分割，将旋钮值设置为：[256:1,512:2,1024:4,>:8]。`roundup_power2_divisions`仅在`backend:native`时有意义。在`backend:cudaMallocAsync`中，`roundup_power2_divisions`会被忽略。 ++ `roundup_power2_divisions`有助于将请求的分配大小四舍五入到最接近的 2 的幂次方，并更好地利用块。在原生 CUDACachingAllocator 中，大小会被四舍五入到 512 的倍数块大小，因此对于较小的大小效果很好。然而，对于大型相邻分配来说，这可能效率低下，因为每个分配都会进入不同大小的块，并且这些块的重复使用被最小化。这可能会产生大量未使用的块，并浪费 GPU 内存容量。此选项使分配大小四舍五入到最接近的 2 的幂次方。例如，如果我们需要将大小为 1200 四舍五入，如果分割数为 4，那么大小 1200 位于 1024 和 2048 之间，如果在它们之间进行 4 次分割，值为 1024、1280、1536 和 1792。因此，大小为 1200 的分配将被四舍五入为 1280，作为最接近 2 的幂次方的上限。指定一个值应用于所有分配大小，或指定一个键值对数组，为每个 2 的幂次方间隔单独设置 2 的幂次方分割。例如，为所有小于 256MB 的分配设置 1 个分割，为 256MB 至 512MB 之间的分配设置 2 个分割，为 512MB 至 1GB 之间的分配设置 4 个分割，为任何更大的分配设置 8 个分割，将旋钮值设置为：[256:1,512:2,1024:4,>:8]。`roundup_power2_divisions`仅在`backend:native`时有意义。在`backend:cudaMallocAsync`中，`roundup_power2_divisions`会被忽略。 -+ `garbage_collection_threshold`有助于主动回收未使用的GPU内存，以避免触发昂贵的同步和回收所有操作（release_cached_blocks），这可能对延迟关键的GPU应用（例如服务器）不利。设置此阈值（例如0.8）后，如果GPU内存容量使用超过阈值（即分配给GPU应用程序的总内存的80%），分配器将开始回收GPU内存块。该算法更倾向于首先释放旧的和未使用的块，以避免释放正在被活跃重复使用的块。阈值应该在大于0.0且小于1.0之间。`garbage_collection_threshold`仅在`backend:native`时有意义。在`backend:cudaMallocAsync`中，`garbage_collection_threshold`会被忽略。 ++ `garbage_collection_threshold`有助于主动回收未使用的 GPU 内存，以避免触发昂贵的同步和回收所有操作（release_cached_blocks），这可能对延迟关键的 GPU 应用（例如服务器）不利。设置此阈值（例如 0.8）后，如果 GPU 内存容量使用超过阈值（即分配给 GPU 应用程序的总内存的 80%），分配器将开始回收 GPU 内存块。该算法更倾向于首先释放旧的和未使用的块，以避免释放正在被活跃重复使用的块。阈值应该在大于 0.0 且小于 1.0 之间。`garbage_collection_threshold`仅在`backend:native`时有意义。在`backend:cudaMallocAsync`中，`garbage_collection_threshold`会被忽略。 -+ `expandable_segments`（实验性，默认值：False）如果设置为True，则此设置指示分配器创建可以稍后扩展的CUDA分配，以更好地处理频繁更改分配大小的情况，例如具有不断更改批量大小的作业。通常对于大型（>2MB）分配，分配器调用cudaMalloc以获取与用户请求的大小相同的分配。将来，如果这些分配的部分是空闲的，它们可以被重用于其他请求。当程序多次请求完全相同大小的请求或者是该大小的倍数时，这种方法效果很好。许多深度学习模型遵循这种行为。然而，一个常见的例外是当批量大小从一次迭代到下一次略微变化时，例如在批量推理中。当程序最初以批量大小N运行时，它将进行适合该大小的分配。如果将来以大小N - 1运行，则现有的分配仍然足够大。但是，如果以大小N + 1运行，则将不得不进行稍微更大的新分配。并非所有张量的大小都相同。有些可能是(N + 1)*A，而其他可能是(N + 1)*A*B，其中A和B是模型中的一些非批量维度。因为分配器在足够大时重用现有的分配，一些(N + 1)*A的分配实际上将适合已经存在的N*B*A段中，尽管不完全。随着模型的运行，它将部分填充所有这些段，留下这些段末尾的无法使用的空闲内存片段。在某个时刻，分配器将需要cudaMalloc一个新的(N + 1)*A*B段。如果没有足够的内存，现在没有办法恢复现有段末尾的空闲内存片段。对于50层以上的模型，这种模式可能重复50多次，创建许多碎片。 ++ `expandable_segments`（实验性，默认值：False）如果设置为 True，则此设置指示分配器创建可以稍后扩展的 CUDA 分配，以更好地处理频繁更改分配大小的情况，例如具有不断更改批量大小的作业。通常对于大型（>2MB）分配，分配器调用 cudaMalloc 以获取与用户请求的大小相同的分配。将来，如果这些分配的部分是空闲的，它们可以被重用于其他请求。当程序多次请求完全相同大小的请求或者是该大小的倍数时，这种方法效果很好。许多深度学习模型遵循这种行为。然而，一个常见的例外是当批量大小从一次迭代到下一次略微变化时，例如在批量推理中。当程序最初以批量大小 N 运行时，它将进行适合该大小的分配。如果将来以大小 N - 1 运行，则现有的分配仍然足够大。但是，如果以大小 N + 1 运行，则将不得不进行稍微更大的新分配。并非所有张量的大小都相同。有些可能是(N + 1)*A，而其他可能是(N + 1)*A*B，其中 A 和 B 是模型中的一些非批量维度。因为分配器在足够大时重用现有的分配，一些(N + 1)*A 的分配实际上将适合已经存在的 N*B*A 段中，尽管不完全。随着模型的运行，它将部分填充所有这些段，留下这些段末尾的无法使用的空闲内存片段。在某个时刻，分配器将需要 cudaMalloc 一个新的(N + 1)*A*B 段。如果没有足够的内存，现在没有办法恢复现有段末尾的空闲内存片段。对于 50 层以上的模型，这种模式可能重复 50 多次，创建许多碎片。 - expandable_segments允许分配器最初创建一个段，然后在需要更多内存时扩展其大小。它尝试创建一个（每个流）随需增长的段，而不是每次分配一个段。现在当N + 1的情况发生时，分配将很好地平铺到一个大段中，直到填满。然后请求更多内存并附加到段的末尾。这个过程不会创建太多无法使用的内存碎片，因此更有可能成功找到这些内存。 + expandable_segments 允许分配器最初创建一个段，然后在需要更多内存时扩展其大小。它尝试创建一个（每个流）随需增长的段，而不是每次分配一个段。现在当 N + 1 的情况发生时，分配将很好地平铺到一个大段中，直到填满。然后请求更多内存并附加到段的末尾。这个过程不会创建太多无法使用的内存碎片，因此更有可能成功找到这些内存。 - pinned_use_cuda_host_register选项是一个布尔标志，用于确定是否使用CUDA API的cudaHostRegister函数来分配固定内存，而不是默认的cudaHostAlloc。当设置为True时，内存是使用常规malloc分配的，然后在调用cudaHostRegister之前将页面映射到内存。这种页面的预映射有助于减少执行cudaHostRegister期间的锁定时间。 + pinned_use_cuda_host_register 选项是一个布尔标志，用于确定是否使用 CUDA API 的 cudaHostRegister 函数来分配固定内存，而不是默认的 cudaHostAlloc。当设置为 True 时，内存是使用常规 malloc 分配的，然后在调用 cudaHostRegister 之前将页面映射到内存。这种页面的预映射有助于减少执行 cudaHostRegister 期间的锁定时间。 - 当pinned_use_cuda_host_register设置为True时，pinned_num_register_threads选项才有效。默认情况下，使用一个线程来映射页面。此选项允许使用更多线程并行化页面映射操作，以减少固定内存的总分配时间。根据基准测试结果，此选项的一个良好值为8。 + 当 pinned_use_cuda_host_register 设置为 True 时，pinned_num_register_threads 选项才有效。默认情况下，使用一个线程来映射页面。此选项允许使用更多线程并行化页面映射操作，以减少固定内存的总分配时间。根据基准测试结果，此选项的一个良好值为 8。 注意 -一些由[CUDA内存管理API](../cuda.html#cuda-memory-management-api)报告的统计数据是特定于`backend:native`的，并且在`backend:cudaMallocAsync`中没有意义。有关详细信息，请参阅每个函数的文档字符串。## 为CUDA使用自定义内存分配器 +一些由 CUDA 内存管理 API 报告的统计数据是特定于`backend:native`的，并且在`backend:cudaMallocAsync`中没有意义。有关详细信息，请参阅每个函数的文档字符串。## 为 CUDA 使用自定义内存分配器 -可以将分配器定义为C/C++中的简单函数，并将它们编译为共享库，下面的代码展示了一个基本的分配器，只是跟踪所有内存操作。 +可以将分配器定义为 C/C++中的简单函数，并将它们编译为共享库，下面的代码展示了一个基本的分配器，只是跟踪所有内存操作。 ```py #include @@ -354,7 +354,7 @@ void my_free(void* ptr, ssize_t size, int device, cudaStream_t stream) } ``` -这可以通过[`torch.cuda.memory.CUDAPluggableAllocator`](../generated/torch.cuda.CUDAPluggableAllocator.html#torch.cuda.CUDAPluggableAllocator "torch.cuda.memory.CUDAPluggableAllocator")在Python中使用。用户负责提供与上述签名匹配的.so文件路径和alloc/free函数的名称。 +这可以通过`torch.cuda.memory.CUDAPluggableAllocator`在 Python 中使用。用户负责提供与上述签名匹配的.so 文件路径和 alloc/free 函数的名称。 ```py import torch @@ -380,35 +380,35 @@ new_alloc = torch.cuda.memory.CUDAPluggableAllocator( torch.cuda.memory.change_current_allocator(new_alloc) ``` -## cuBLAS工作空间 +## cuBLAS 工作空间 -对于每个cuBLAS句柄和CUDA流的组合，如果该句柄和流组合执行需要工作空间的cuBLAS内核，则将分配一个cuBLAS工作空间。为了避免重复分配工作空间，除非调用`torch._C._cuda_clearCublasWorkspaces()`，否则这些工作空间不会被释放。每次分配的工作空间大小可以通过环境变量`CUBLAS_WORKSPACE_CONFIG`指定，格式为`:[SIZE]:[COUNT]`。例如，默认每次分配的工作空间大小为`CUBLAS_WORKSPACE_CONFIG=:4096:2:16:8`，指定总大小为`2 * 4096 + 8 * 16 KiB`。要强制cuBLAS避免使用工作空间，请设置`CUBLAS_WORKSPACE_CONFIG=:0:0`。 +对于每个 cuBLAS 句柄和 CUDA 流的组合，如果该句柄和流组合执行需要工作空间的 cuBLAS 内核，则将分配一个 cuBLAS 工作空间。为了避免重复分配工作空间，除非调用`torch._C._cuda_clearCublasWorkspaces()`，否则这些工作空间不会被释放。每次分配的工作空间大小可以通过环境变量`CUBLAS_WORKSPACE_CONFIG`指定，格式为`:[SIZE]:[COUNT]`。例如，默认每次分配的工作空间大小为`CUBLAS_WORKSPACE_CONFIG=:4096:2:16:8`，指定总大小为`2 * 4096 + 8 * 16 KiB`。要强制 cuBLAS 避免使用工作空间，请设置`CUBLAS_WORKSPACE_CONFIG=:0:0`。 -## cuFFT计划缓存 +## cuFFT 计划缓存 -对于每个CUDA设备，使用cuFFT计划的LRU缓存来加速重复运行FFT方法（例如[`torch.fft.fft()`](../generated/torch.fft.fft.html#torch.fft.fft "torch.fft.fft")）在具有相同几何形状和相同配置的CUDA张量上。因为一些cuFFT计划可能分配GPU内存，这些缓存具有最大容量。 +对于每个 CUDA 设备，使用 cuFFT 计划的 LRU 缓存来加速重复运行 FFT 方法（例如`torch.fft.fft()`）在具有相同几何形状和相同配置的 CUDA 张量上。因为一些 cuFFT 计划可能分配 GPU 内存，这些缓存具有最大容量。 -您可以使用以下API来控制和查询当前设备缓存的属性： +您可以使用以下 API 来控制和查询当前设备缓存的属性： -+ `torch.backends.cuda.cufft_plan_cache.max_size`给出缓存的容量（在CUDA 10及更新版本上默认为4096，在旧版本的CUDA上为1023）。直接设置此值会修改容量。 ++ `torch.backends.cuda.cufft_plan_cache.max_size`给出缓存的容量（在 CUDA 10 及更新版本上默认为 4096，在旧版本的 CUDA 上为 1023）。直接设置此值会修改容量。 + `torch.backends.cuda.cufft_plan_cache.size`给出当前驻留在缓存中的计划数量。 + `torch.backends.cuda.cufft_plan_cache.clear()`清除缓存。 -要控制和查询非默认设备的计划缓存，可以使用`torch.backends.cuda.cufft_plan_cache`对象与[`torch.device`](../tensor_attributes.html#torch.device "torch.device")对象或设备索引进行索引，并访问上述属性之一。例如，要设置设备`1`的缓存容量，可以编写`torch.backends.cuda.cufft_plan_cache[1].max_size = 10`。## 即时编译 +要控制和查询非默认设备的计划缓存，可以使用`torch.backends.cuda.cufft_plan_cache`对象与`torch.device`对象或设备索引进行索引，并访问上述属性之一。例如，要设置设备`1`的缓存容量，可以编写`torch.backends.cuda.cufft_plan_cache[1].max_size = 10`。## 即时编译 -PyTorch会在CUDA张量上执行一些操作时，如torch.special.zeta，进行即时编译。这种编译可能会耗时（取决于您的硬件和软件，最多几秒钟），并且对于单个运算符可能会多次发生，因为许多PyTorch运算符实际上会从各种内核中选择，每个内核必须根据其输入编译一次。这种编译每个进程只发生一次，或者如果使用内核缓存，则只发生一次。 +PyTorch 会在 CUDA 张量上执行一些操作时，如 torch.special.zeta，进行即时编译。这种编译可能会耗时（取决于您的硬件和软件，最多几秒钟），并且对于单个运算符可能会多次发生，因为许多 PyTorch 运算符实际上会从各种内核中选择，每个内核必须根据其输入编译一次。这种编译每个进程只发生一次，或者如果使用内核缓存，则只发生一次。 -默认情况下，如果定义了XDG_CACHE_HOME，则PyTorch会在$XDG_CACHE_HOME/torch/kernels中创建一个内核缓存，如果没有定义则在$HOME/.cache/torch/kernels中创建（在Windows上，内核缓存尚不受支持）。缓存行为可以直接通过两个环境变量进行控制。如果将USE_PYTORCH_KERNEL_CACHE设置为0，则不会使用任何缓存，如果设置了PYTORCH_KERNEL_CACHE_PATH，则该路径将用作内核缓存的位置，而不是默认位置。 +默认情况下，如果定义了 XDG_CACHE_HOME，则 PyTorch 会在$XDG_CACHE_HOME/torch/kernels 中创建一个内核缓存，如果没有定义则在$HOME/.cache/torch/kernels 中创建（在 Windows 上，内核缓存尚不受支持）。缓存行为可以直接通过两个环境变量进行控制。如果将 USE_PYTORCH_KERNEL_CACHE 设置为 0，则不会使用任何缓存，如果设置了 PYTORCH_KERNEL_CACHE_PATH，则该路径将用作内核缓存的位置，而不是默认位置。 ## 最佳实践 ### 与设备无关的代码 -由于PyTorch的结构，您可能需要明确编写与设备无关（CPU或GPU）的代码；一个示例可能是创建一个新张量作为循环神经网络的初始隐藏状态。 +由于 PyTorch 的结构，您可能需要明确编写与设备无关（CPU 或 GPU）的代码；一个示例可能是创建一个新张量作为循环神经网络的初始隐藏状态。 -第一步是确定是否应该使用GPU。一个常见的模式是使用Python的`argparse`模块读取用户参数，并有一个可以用来禁用CUDA的标志，结合[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")。在下面的示例中，`args.device`会产生一个[`torch.device`](../tensor_attributes.html#torch.device "torch.device")对象，可以用来将张量移动到CPU或CUDA。 +第一步是确定是否应该使用 GPU。一个常见的模式是使用 Python 的`argparse`模块读取用户参数，并有一个可以用来禁用 CUDA 的标志，结合`is_available()`。在下面的示例中，`args.device`会产生一个`torch.device`对象，可以用来将张量移动到 CPU 或 CUDA。 ```py import argparse @@ -427,13 +427,13 @@ else: 注意 -在给定环境中评估CUDA的可用性时（[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")），PyTorch的默认行为是调用CUDA Runtime API方法[cudaGetDeviceCount](https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__DEVICE.html#group__CUDART__DEVICE_1g18808e54893cfcaafefeab31a73cc55f)。因为这个调用反过来会初始化CUDA Driver API（通过[cuInit](https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__INITIALIZE.html#group__CUDA__INITIALIZE_1g0a2f1517e1bd8502c7194c3a8c134bc3)），如果尚未初始化，那么运行[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")的进程的后续分叉将因CUDA初始化错误而失败。 +在给定环境中评估 CUDA 的可用性时（`is_available()`），PyTorch 的默认行为是调用 CUDA Runtime API 方法[cudaGetDeviceCount](https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__DEVICE.html#group__CUDART__DEVICE_1g18808e54893cfcaafefeab31a73cc55f)。因为这个调用反过来会初始化 CUDA Driver API（通过[cuInit](https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__INITIALIZE.html#group__CUDA__INITIALIZE_1g0a2f1517e1bd8502c7194c3a8c134bc3)），如果尚未初始化，那么运行`is_available()`的进程的后续分叉将因 CUDA 初始化错误而失败。 -可以在导入执行[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")的PyTorch模块之前（或直接执行之前）在环境中设置`PYTORCH_NVML_BASED_CUDA_CHECK=1`，以便指导[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")尝试基于NVML的评估（[nvmlDeviceGetCount_v2](https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1ga93623b195bff04bbe3490ca33c8a42d)）。如果基于NVML的评估成功（即NVML发现/初始化不失败），[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")调用将不会影响后续的分叉。 +可以在导入执行`is_available()`的 PyTorch 模块之前（或直接执行之前）在环境中设置`PYTORCH_NVML_BASED_CUDA_CHECK=1`，以便指导`is_available()`尝试基于 NVML 的评估（[nvmlDeviceGetCount_v2](https://docs.nvidia.com/deploy/nvml-api/group__nvmlDeviceQueries.html#group__nvmlDeviceQueries_1ga93623b195bff04bbe3490ca33c8a42d)）。如果基于 NVML 的评估成功（即 NVML 发现/初始化不失败），`is_available()`调用将不会影响后续的分叉。 -如果NVML发现/初始化失败，[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")将回退到标准的CUDA Runtime API评估，并且前面提到的分叉约束将适用。 +如果 NVML 发现/初始化失败，`is_available()`将回退到标准的 CUDA Runtime API 评估，并且前面提到的分叉约束将适用。 -请注意，上述基于NVML的CUDA可用性评估提供的保证比默认的CUDA Runtime API方法更弱（需要CUDA初始化成功）。在某些情况下，基于NVML的检查可能成功，而后续的CUDA初始化失败。 +请注意，上述基于 NVML 的 CUDA 可用性评估提供的保证比默认的 CUDA Runtime API 方法更弱（需要 CUDA 初始化成功）。在某些情况下，基于 NVML 的检查可能成功，而后续的 CUDA 初始化失败。 现在我们有了`args.device`，我们可以使用它在所需的设备上创建一个张量。 @@ -450,7 +450,7 @@ for i, x in enumerate(train_loader): x = x.to(cuda0) ``` -在系统上使用多个GPU时，可以使用`CUDA_VISIBLE_DEVICES`环境标志来管理PyTorch可用的GPU。如上所述，要手动控制在哪个GPU上创建张量的最佳实践是使用[`torch.cuda.device`](../generated/torch.cuda.device.html#torch.cuda.device "torch.cuda.device")上下文管理器。 +在系统上使用多个 GPU 时，可以使用`CUDA_VISIBLE_DEVICES`环境标志来管理 PyTorch 可用的 GPU。如上所述，要手动控制在哪个 GPU 上创建张量的最佳实践是使用`torch.cuda.device`上下文管理器。 ```py print("Outside device is 0") # On device 0 (default in most scenarios) @@ -459,7 +459,7 @@ with torch.cuda.device(1): print("Outside device is still 0") # On device 0 ``` -如果您有一个张量，并希望在同一设备上创建相同类型的新张量，则可以使用`torch.Tensor.new_*`方法（参见[`torch.Tensor`](../tensors.html#torch.Tensor "torch.Tensor")）。虽然先前提到的`torch.*`工厂函数（[Creation Ops](../torch.html#tensor-creation-ops)）依赖于当前GPU上下文和您传递的属性参数，`torch.Tensor.new_*`方法会保留张量的设备和其他属性。 +如果您有一个张量，并希望在同一设备上创建相同类型的新张量，则可以使用`torch.Tensor.new_*`方法（参见`torch.Tensor`）。虽然先前提到的`torch.*`工厂函数（Creation Ops）依赖于当前 GPU 上下文和您传递的属性参数，`torch.Tensor.new_*`方法会保留张量的设备和其他属性。 这是在创建模块时的推荐做法，其中在前向传递期间需要在内部创建新张量。 @@ -489,7 +489,7 @@ print(y_cpu_long) tensor([[ 1, 2, 3]]) ``` -如果您想创建一个与另一个张量相同类型和大小的张量，并用1或0填充它，[`ones_like()`](../generated/torch.ones_like.html#torch.ones_like "torch.ones_like")或[`zeros_like()`](../generated/torch.zeros_like.html#torch.zeros_like "torch.zeros_like")提供了方便的辅助函数（还保留了张量的[`torch.device`](../tensor_attributes.html#torch.device "torch.device")和[`torch.dtype`](../tensor_attributes.html#torch.dtype "torch.dtype")）。 +如果您想创建一个与另一个张量相同类型和大小的张量，并用 1 或 0 填充它，`ones_like()`或`zeros_like()`提供了方便的辅助函数（还保留了张量的`torch.device`和`torch.dtype`）。 ```py x_cpu = torch.empty(2, 3) @@ -505,43 +505,43 @@ y_gpu = torch.zeros_like(x_gpu) 这是一个高级提示。如果过度使用固定内存，当内存不足时可能会导致严重问题，您应该意识到固定通常是一个昂贵的操作。 -主机到GPU的拷贝速度在源自固定（锁页）内存时要快得多。CPU张量和存储提供了一个[`pin_memory()`](../generated/torch.Tensor.pin_memory.html#torch.Tensor.pin_memory "torch.Tensor.pin_memory")方法，返回一个数据放在固定区域的对象副本。 +主机到 GPU 的拷贝速度在源自固定（锁页）内存时要快得多。CPU 张量和存储提供了一个`pin_memory()`方法，返回一个数据放在固定区域的对象副本。 -此外，一旦您固定了一个张量或存储，您可以使用异步GPU拷贝。只需在[`to()`](../generated/torch.Tensor.to.html#torch.Tensor.to "torch.Tensor.to")或[`cuda()`](../generated/torch.Tensor.cuda.html#torch.Tensor.cuda "torch.Tensor.cuda")调用中传递一个额外的`non_blocking=True`参数。这可以用来重叠数据传输和计算。 +此外，一旦您固定了一个张量或存储，您可以使用异步 GPU 拷贝。只需在`to()`或`cuda()`调用中传递一个额外的`non_blocking=True`参数。这可以用来重叠数据传输和计算。 -您可以通过在其构造函数中传递`pin_memory=True`来使[`DataLoader`](../data.html#torch.utils.data.DataLoader "torch.utils.data.DataLoader")返回放置在固定内存中的批次。### 使用nn.parallel.DistributedDataParallel而不是多进程或nn.DataParallel[](#use-nn-parallel-distributeddataparallel-instead-of-multiprocessing-or-nn-dataparallel "Permalink to this heading") +您可以通过在其构造函数中传递`pin_memory=True`来使`DataLoader`返回放置在固定内存中的批次。### 使用 nn.parallel.DistributedDataParallel 而不是多进程或 nn.DataParallel[](#use-nn-parallel-distributeddataparallel-instead-of-multiprocessing-or-nn-dataparallel "Permalink to this heading") -大多数涉及批量输入和多个GPU的用例应默认使用[`DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")来利用多个GPU。 +大多数涉及批量输入和多个 GPU 的用例应默认使用`DistributedDataParallel`来利用多个 GPU。 -使用CUDA模型与[`multiprocessing`](../multiprocessing.html#module-torch.multiprocessing "torch.multiprocessing")存在重要注意事项；除非确切满足数据处理要求，否则您的程序可能会出现不正确或未定义的行为。 +使用 CUDA 模型与`multiprocessing`存在重要注意事项；除非确切满足数据处理要求，否则您的程序可能会出现不正确或未定义的行为。 -建议使用[`DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")来进行多GPU训练，而不是[`DataParallel`](../generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel")，即使只有一个节点。 +建议使用`DistributedDataParallel`来进行多 GPU 训练，而不是`DataParallel`，即使只有一个节点。 -[`DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")和[`DataParallel`](../generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel")之间的区别是：[`DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")使用多进程，其中为每个GPU创建一个进程，而[`DataParallel`](../generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel")使用多线程。通过使用多进程，每个GPU都有其专用进程，这避免了Python解释器的GIL引起的性能开销。 +`DistributedDataParallel`和`DataParallel`之间的区别是：`DistributedDataParallel`使用多进程，其中为每个 GPU 创建一个进程，而`DataParallel`使用多线程。通过使用多进程，每个 GPU 都有其专用进程，这避免了 Python 解释器的 GIL 引起的性能开销。 -如果您使用[`DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")，您可以使用torch.distributed.launch实用程序来启动您的程序，请参阅[第三方后端](../distributed.html#distributed-launch)。## CUDA图 +如果您使用`DistributedDataParallel`，您可以使用 torch.distributed.launch 实用程序来启动您的程序，请参阅第三方后端。## CUDA 图 -CUDA图是CUDA流及其依赖流执行的工作记录（主要是内核及其参数）。有关基础CUDA API的一般原则和详细信息，请参阅[使用CUDA图入门](https://developer.nvidia.com/blog/cuda-graphs/)和CUDA C编程指南的[图形部分](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cuda-graphs)。 +CUDA 图是 CUDA 流及其依赖流执行的工作记录（主要是内核及其参数）。有关基础 CUDA API 的一般原则和详细信息，请参阅[使用 CUDA 图入门](https://developer.nvidia.com/blog/cuda-graphs/)和 CUDA C 编程指南的[图形部分](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cuda-graphs)。 -PyTorch支持使用[流捕获](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#creating-a-graph-using-stream-capture)构建CUDA图，这将使CUDA流处于*捕获模式*。发送到捕获流的CUDA工作实际上不会在GPU上运行。相反，工作将记录在图中。 +PyTorch 支持使用[流捕获](https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#creating-a-graph-using-stream-capture)构建 CUDA 图，这将使 CUDA 流处于*捕获模式*。发送到捕获流的 CUDA 工作实际上不会在 GPU 上运行。相反，工作将记录在图中。 -捕获后，可以*启动*图以多次运行GPU工作。每次重播都会使用相同的内核和相同的参数运行相同的内核。对于指针参数，这意味着使用相同的内存地址。通过在每次重播之前用新数据（例如来自新批次）填充输入内存，可以在新数据上重新运行相同的工作。 +捕获后，可以*启动*图以多次运行 GPU 工作。每次重播都会使用相同的内核和相同的参数运行相同的内核。对于指针参数，这意味着使用相同的内存地址。通过在每次重播之前用新数据（例如来自新批次）填充输入内存，可以在新数据上重新运行相同的工作。 -### 为什么使用CUDA图？ +### 为什么使用 CUDA 图？ -重播图牺牲了典型急切执行的动态灵活性，以换取**大大减少的CPU开销**。图的参数和内核是固定的，因此图的重播跳过了所有层的参数设置和内核调度，包括Python、C++和CUDA驱动程序开销。在幕后，重播通过单个调用[cudaGraphLaunch](https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__GRAPH.html#group__CUDART__GRAPH_1g1accfe1da0c605a577c22d9751a09597)将整个图的工作提交给GPU。重播中的内核在GPU上执行速度稍快，但省略CPU开销是主要好处。 +重播图牺牲了典型急切执行的动态灵活性，以换取**大大减少的 CPU 开销**。图的参数和内核是固定的，因此图的重播跳过了所有层的参数设置和内核调度，包括 Python、C++和 CUDA 驱动程序开销。在幕后，重播通过单个调用[cudaGraphLaunch](https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__GRAPH.html#group__CUDART__GRAPH_1g1accfe1da0c605a577c22d9751a09597)将整个图的工作提交给 GPU。重播中的内核在 GPU 上执行速度稍快，但省略 CPU 开销是主要好处。 -如果您的网络的全部或部分是图形安全的（通常意味着静态形状和静态控制流，但请参阅其他[约束](#capture-constraints)），并且您怀疑其运行时至少在某种程度上受到CPU限制，则应尝试CUDA图。 +如果您的网络的全部或部分是图形安全的（通常意味着静态形状和静态控制流，但请参阅其他约束），并且您怀疑其运行时至少在某种程度上受到 CPU 限制，则应尝试 CUDA 图。 ### PyTorch API 警告 -此API处于beta阶段，可能会在未来版本中更改。 +此 API 处于 beta 阶段，可能会在未来版本中更改。 -PyTorch通过原始[`torch.cuda.CUDAGraph`](../generated/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph "torch.cuda.CUDAGraph")类和两个方便的包装器[`torch.cuda.graph`](../generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph")和[`torch.cuda.make_graphed_callables`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")公开图形。 +PyTorch 通过原始`torch.cuda.CUDAGraph`类和两个方便的包装器`torch.cuda.graph`和`torch.cuda.make_graphed_callables`公开图形。 -[`torch.cuda.graph`](../generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph")是一个简单、多功能的上下文管理器，可以在其上下文中捕获CUDA工作。在捕获之前，通过运行几个急切迭代来预热要捕获的工作负载。预热必须在侧流上进行。由于图在每次重播时都从相同的内存地址读取和写入，因此在捕获期间必须保持对保存输入和输出数据的张量的长期引用。要在新输入数据上运行图，请将新数据复制到捕获的输入张量中，重播图，然后从捕获的输出张量中读取新输出。示例： +`torch.cuda.graph`是一个简单、多功能的上下文管理器，可以在其上下文中捕获 CUDA 工作。在捕获之前，通过运行几个急切迭代来预热要捕获的工作负载。预热必须在侧流上进行。由于图在每次重播时都从相同的内存地址读取和写入，因此在捕获期间必须保持对保存输入和输出数据的张量的长期引用。要在新输入数据上运行图，请将新数据复制到捕获的输入张量中，重播图，然后从捕获的输出张量中读取新输出。示例： ```py g = torch.cuda.CUDAGraph() @@ -574,39 +574,39 @@ g.replay() print(static_output) # full of 4 * 2 = 8 ``` -查看[整个网络捕获](#whole-network-capture)，[与torch.cuda.amp一起使用](#graphs-with-amp)，以及[使用多个流](#multistream-capture)以获取现实和高级模式。 +查看整个网络捕获，与 torch.cuda.amp 一起使用，以及使用多个流以获取现实和高级模式。 -[`make_graphed_callables`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")更为复杂。[`make_graphed_callables`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")接受Python函数和[`torch.nn.Module`](../generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")。对于每个传递的函数或模块，它会创建前向传递和反向传递工作的单独图。请参阅[部分网络捕获](#partial-network-capture)。 +`make_graphed_callables`更为复杂。`make_graphed_callables`接受 Python 函数和`torch.nn.Module`。对于每个传递的函数或模块，它会创建前向传递和反向传递工作的单独图。请参阅部分网络捕获。 #### 约束 如果一组操作是*可捕获*的，则不会违反以下任何约束。 -约束条件适用于[`torch.cuda.graph`](../generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph")上下文中的所有工作，以及您传递给[`torch.cuda.make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")的任何可调用对象的前向和后向传递中的所有工作。 +约束条件适用于`torch.cuda.graph`上下文中的所有工作，以及您传递给`torch.cuda.make_graphed_callables()`的任何可调用对象的前向和后向传递中的所有工作。 违反任何这些规则可能会导致运行时错误： -+ 捕获必须发生在非默认流上。（只有在使用原始[`CUDAGraph.capture_begin`](../generated/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph.capture_begin "torch.cuda.CUDAGraph.capture_begin")和[`CUDAGraph.capture_end`](../generated/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph.capture_end "torch.cuda.CUDAGraph.capture_end")调用时才需要关注。[`graph`](../generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph")和[`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")会为您设置一个侧边流。） ++ 捕获必须发生在非默认流上。（只有在使用原始`CUDAGraph.capture_begin`和`CUDAGraph.capture_end`调用时才需要关注。`graph`和`make_graphed_callables()`会为您设置一个侧边流。） -+ 禁止与GPU同步的操作（例如`.item()`调用）。 ++ 禁止与 GPU 同步的操作（例如`.item()`调用）。 -+ 允许CUDA RNG操作，但必须使用默认生成器。例如，明确构造一个新的[`torch.Generator`](../generated/torch.Generator.html#torch.Generator "torch.Generator")实例，并将其作为`generator`参数传递给RNG函数是被禁止的。 ++ 允许 CUDA RNG 操作，但必须使用默认生成器。例如，明确构造一个新的`torch.Generator`实例，并将其作为`generator`参数传递给 RNG 函数是被禁止的。 违反任何这些规则可能会导致潜在的数值错误或未定义行为： + 在一个进程中，一次只能进行一次捕获。 -+ 在进行捕获时，此进程中不得运行任何未捕获的CUDA工作（在任何线程上）。 ++ 在进行捕获时，此进程中不得运行任何未捕获的 CUDA 工作（在任何线程上）。 -+ 不会捕获CPU工作。如果捕获的操作包括CPU工作，则在重放过程中将省略该工作。 ++ 不会捕获 CPU 工作。如果捕获的操作包括 CPU 工作，则在重放过程中将省略该工作。 + 每次重放都从同一（虚拟）内存地址读取和写入。 -+ 禁止动态控制流（基于CPU或GPU数据）。 ++ 禁止动态控制流（基于 CPU 或 GPU 数据）。 + 禁止动态形状。图假定捕获的操作序列中的每个张量在每次重放中都具有相同的大小和布局。 -+ 允许在捕获中使用多个流，但有[限制](#multistream-capture)。 ++ 允许在捕获中使用多个流，但有限制。 #### 非约束条件 @@ -670,13 +670,13 @@ for data, target in zip(real_inputs, real_targets): # attributes hold values from computing on this iteration's data. ``` ### 部分网络捕获[](#partial-network-capture "Permalink to this heading") -如果您的网络中有一部分不安全可捕获（例如，由于动态控制流、动态形状、CPU同步或基本的CPU端逻辑），您可以急切地运行不安全的部分，并使用[`torch.cuda.make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")仅对可捕获的部分进行图形化处理。 +如果您的网络中有一部分不安全可捕获（例如，由于动态控制流、动态形状、CPU 同步或基本的 CPU 端逻辑），您可以急切地运行不安全的部分，并使用`torch.cuda.make_graphed_callables()`仅对可捕获的部分进行图形化处理。 -默认情况下，由[`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")返回的可调用对象是自动求导感知的，并且可以在训练循环中直接替换您传递的函数或[`nn.Module`](../generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")。 +默认情况下，由`make_graphed_callables()`返回的可调用对象是自动求导感知的，并且可以在训练循环中直接替换您传递的函数或`nn.Module`。 -[`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")在内部创建[`CUDAGraph`](../generated/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph "torch.cuda.CUDAGraph")对象，运行预热迭代，并根据需要维护静态输入和输出。因此（与[`torch.cuda.graph`](../generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph")不同），您无需手动处理这些。 +`make_graphed_callables()`在内部创建`CUDAGraph`对象，运行预热迭代，并根据需要维护静态输入和输出。因此（与`torch.cuda.graph`不同），您无需手动处理这些。 -在以下示例中，数据相关的动态控制流意味着网络不能端到端捕获，但[`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")让我们能够捕获和运行图安全的部分作为图形: +在以下示例中，数据相关的动态控制流意味着网络不能端到端捕获，但`make_graphed_callables()`让我们能够捕获和运行图安全的部分作为图形: ```py N, D_in, H, D_out = 640, 4096, 2048, 1024 @@ -719,9 +719,9 @@ for data, target in zip(real_inputs, real_targets): # as well as module1's backward ops, run as graphs loss.backward() optimizer.step() -``` ### 与torch.cuda.amp一起使用[](#usage-with-torch-cuda-amp "跳转到此标题") +``` ### 与 torch.cuda.amp 一起使用[](#usage-with-torch-cuda-amp "跳转到此标题") -对于典型的优化器，[`GradScaler.step`](../amp.html#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")会将CPU与GPU同步，这在捕获过程中是被禁止的。为了避免错误，要么使用[部分网络捕获](#partial-network-capture)，要么（如果前向、损失和反向是捕获安全的）捕获前向、损失和反向，但不捕获优化器步骤: +对于典型的优化器，`GradScaler.step`会将 CPU 与 GPU 同步，这在捕获过程中是被禁止的。为了避免错误，要么使用部分网络捕获，要么（如果前向、损失和反向是捕获安全的）捕获前向、损失和反向，但不捕获优化器步骤: ```py # warmup @@ -761,7 +761,7 @@ for data, target in zip(real_inputs, real_targets): scaler.update() ``` ### 与多个流一起使用[](#usage-with-multiple-streams "跳转到此标题") -捕获模式会自动传播到与捕获流同步的任何流。在捕获过程中，您可以通过向不同流发出调用来暴露并行性，但整体流依赖DAG必须从初始捕获流开始分支，并在捕获开始后重新加入初始流，然后在捕获结束前重新加入初始流: +捕获模式会自动传播到与捕获流同步的任何流。在捕获过程中，您可以通过向不同流发出调用来暴露并行性，但整体流依赖 DAG 必须从初始捕获流开始分支，并在捕获开始后重新加入初始流，然后在捕获结束前重新加入初始流: ```py with torch.cuda.graph(g): @@ -783,47 +783,47 @@ with torch.cuda.graph(g): 注意 -为了避免对在nsight系统或nvprof中查看重播的高级用户造成困惑: 与急切执行不同，图形在捕获中将非平凡的流DAG解释为提示，而不是命令。在重播过程中，图形可能会将独立操作重新组织到不同的流中，或以不同的顺序排队（同时尊重您原始DAG的整体依赖关系）。 +为了避免对在 nsight 系统或 nvprof 中查看重播的高级用户造成困惑: 与急切执行不同，图形在捕获中将非平凡的流 DAG 解释为提示，而不是命令。在重播过程中，图形可能会将独立操作重新组织到不同的流中，或以不同的顺序排队（同时尊重您原始 DAG 的整体依赖关系）。 -### 使用DistributedDataParallel[](#usage-with-distributeddataparallel "跳转到此标题") +### 使用 DistributedDataParallel[](#usage-with-distributeddataparallel "跳转到此标题") #### NCCL < 2.9.6 -早于2.9.6的NCCL版本不允许捕获集合。您必须使用[部分网络捕获](#partial-network-capture)，将所有reduce推迟到反向的图形化部分之外。 +早于 2.9.6 的 NCCL 版本不允许捕获集合。您必须使用部分网络捕获，将所有 reduce 推迟到反向的图形化部分之外。 -在使用DDP包装网络之前，在可图形化的网络部分上调用[`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")。 +在使用 DDP 包装网络之前，在可图形化的网络部分上调用`make_graphed_callables()`。 #### NCCL >= 2.9.6 -NCCL版本2.9.6或更高版本允许图中的集合。捕获整个反向传播的方法是一个可行的选择，但需要三个设置步骤。 +NCCL 版本 2.9.6 或更高版本允许图中的集合。捕获整个反向传播的方法是一个可行的选择，但需要三个设置步骤。 -1. 禁用DDP的内部异步错误处理: +1. 禁用 DDP 的内部异步错误处理: ```py os.environ["NCCL_ASYNC_ERROR_HANDLING"] = "0" torch.distributed.init_process_group(...) ``` -1. 在完全反向捕获之前，DDP必须在侧流上下文中构建: +1. 在完全反向捕获之前，DDP 必须在侧流上下文中构建: ```py with torch.cuda.stream(s): model = DistributedDataParallel(model) ``` -1. 在捕获之前，您的预热必须至少运行11次启用DDP的急切迭代。 +1. 在捕获之前，您的预热必须至少运行 11 次启用 DDP 的急切迭代。 ### 图内存管理[](#graph-memory-management "跳转到此标题") -捕获的图形在每次重播时都会作用于相同的虚拟地址。如果PyTorch释放内存，后续的重播可能会导致非法内存访问。如果PyTorch将内存重新分配给新张量，重播可能会破坏这些张量看到的值。因此，图形使用的虚拟地址必须在重播过程中保留给图形。PyTorch缓存分配器通过检测捕获正在进行并从图形私有内存池中满足捕获的分配来实现这一点。私有池会一直保持活动，直到其[`CUDAGraph`](../generated/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph "torch.cuda.CUDAGraph")对象和捕获期间创建的所有张量超出范围。 +捕获的图形在每次重播时都会作用于相同的虚拟地址。如果 PyTorch 释放内存，后续的重播可能会导致非法内存访问。如果 PyTorch 将内存重新分配给新张量，重播可能会破坏这些张量看到的值。因此，图形使用的虚拟地址必须在重播过程中保留给图形。PyTorch 缓存分配器通过检测捕获正在进行并从图形私有内存池中满足捕获的分配来实现这一点。私有池会一直保持活动，直到其`CUDAGraph`对象和捕获期间创建的所有张量超出范围。 私有池会自动维护。默认情况下，分配器为每个捕获创建一个单独的私有池。如果捕获多个图形，这种保守的方法确保图形重播永远不会破坏彼此的值，但有时会不必要地浪费内存。 #### 跨捕获共享内存[](#sharing-memory-across-captures "跳转到此标题") -为了节省存储在私有池中的内存，[`torch.cuda.graph`](../generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph") 和 [`torch.cuda.make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables") 可选地允许不同的捕获共享同一个私有池。如果你知道一组图形将始终按照它们被捕获的顺序重播，并且永远不会同时重播，那么共享一个私有池是安全的。 +为了节省存储在私有池中的内存，`torch.cuda.graph` 和 `torch.cuda.make_graphed_callables()` 可选地允许不同的捕获共享同一个私有池。如果你知道一组图形将始终按照它们被捕获的顺序重播，并且永远不会同时重播，那么共享一个私有池是安全的。 -[`torch.cuda.graph`](../generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph") 的 `pool` 参数是使用特定私有池的提示，并且可以用于跨图形共享内存，如下所示： +`torch.cuda.graph` 的 `pool` 参数是使用特定私有池的提示，并且可以用于跨图形共享内存，如下所示： ```py g1 = torch.cuda.CUDAGraph() @@ -845,6 +845,6 @@ g1.replay() g2.replay() ``` -使用 [`torch.cuda.make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")，如果你想要为多个可调用对象创建图形，并且知道它们将始终按照相同顺序运行（并且永远不会同时运行），请将它们作为元组传递，按照实际工作负载中将要运行的顺序，[`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables") 将使用共享的私有池捕获它们的图形。 +使用 `torch.cuda.make_graphed_callables()`，如果你想要为多个可调用对象创建图形，并且知道它们将始终按照相同顺序运行（并且永远不会同时运行），请将它们作为元组传递，按照实际工作负载中将要运行的顺序，`make_graphed_callables()` 将使用共享的私有池捕获它们的图形。 -如果在实际工作负载中，你的可调用对象将按照偶尔变化的顺序运行，或者将同时运行，那么将它们作为元组传递给单个 [`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables") 调用是不允许的。相反，你必须为每个可调用对象单独调用 [`make_graphed_callables()`](../generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables")。 +如果在实际工作负载中，你的可调用对象将按照偶尔变化的顺序运行，或者将同时运行，那么将它们作为元组传递给单个 `make_graphed_callables()` 调用是不允许的。相反，你必须为每个可调用对象单独调用 `make_graphed_callables()`。 diff --git a/totrans/doc22_013.md b/totrans/doc22_013.md index 62abc38f..b2db2ba7 100644 --- a/totrans/doc22_013.md +++ b/totrans/doc22_013.md @@ -1,16 +1,16 @@ # 分布式数据并行 -> 原文：[https://pytorch.org/docs/stable/notes/ddp.html](https://pytorch.org/docs/stable/notes/ddp.html) +> 原文：[`pytorch.org/docs/stable/notes/ddp.html`](https://pytorch.org/docs/stable/notes/ddp.html) 警告 -[`torch.nn.parallel.DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")的实现随时间推移而发展。本设计说明是基于v1.4状态编写的。 +`torch.nn.parallel.DistributedDataParallel`的实现随时间推移而发展。本设计说明是基于 v1.4 状态编写的。 -[`torch.nn.parallel.DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")（DDP）透明地执行分布式数据并行训练。本页描述了它的工作原理并揭示了实现细节。 +`torch.nn.parallel.DistributedDataParallel`（DDP）透明地执行分布式数据并行训练。本页描述了它的工作原理并揭示了实现细节。 ## 示例 -让我们从一个简单的[`torch.nn.parallel.DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")示例开始。这个示例使用一个[`torch.nn.Linear`](../generated/torch.nn.Linear.html#torch.nn.Linear "torch.nn.Linear")作为本地模型，将其与DDP包装起来，然后在DDP模型上运行一次前向传递，一次反向传递和一个优化器步骤。之后，本地模型上的参数将被更新，并且不同进程上的所有模型应该完全相同。 +让我们从一个简单的`torch.nn.parallel.DistributedDataParallel`示例开始。这个示例使用一个`torch.nn.Linear`作为本地模型，将其与 DDP 包装起来，然后在 DDP 模型上运行一次前向传递，一次反向传递和一个优化器步骤。之后，本地模型上的参数将被更新，并且不同进程上的所有模型应该完全相同。 ```py import torch @@ -56,7 +56,7 @@ if __name__=="__main__": main() ``` -DDP与TorchDynamo一起使用。当与TorchDynamo一起使用时，在编译模型之前应用DDP模型包装器，以便torchdynamo可以根据DDP桶大小应用`DDPOptimizer`（基于DDP桶大小的图断点优化）。 （有关更多信息，请参见[TorchDynamo DDPOptimizer](./ddp.html#torchdynamo-ddpoptimizer)。） +DDP 与 TorchDynamo 一起使用。当与 TorchDynamo 一起使用时，在编译模型之前应用 DDP 模型包装器，以便 torchdynamo 可以根据 DDP 桶大小应用`DDPOptimizer`（基于 DDP 桶大小的图断点优化）。 （有关更多信息，请参见 TorchDynamo DDPOptimizer。） ```py ddp_model = DDP(model, device_ids=[rank]) @@ -65,37 +65,37 @@ ddp_model = torch.compile(ddp_model) ## 内部设计 -本节通过深入探讨每个迭代步骤的细节，揭示了[`torch.nn.parallel.DistributedDataParallel`](../generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")的内部工作原理。 +本节通过深入探讨每个迭代步骤的细节，揭示了`torch.nn.parallel.DistributedDataParallel`的内部工作原理。 -+ **先决条件**：DDP依赖于c10d`ProcessGroup`进行通信。因此，应用程序在构造DDP之前必须创建`ProcessGroup`实例。 ++ **先决条件**：DDP 依赖于 c10d`ProcessGroup`进行通信。因此，应用程序在构造 DDP 之前必须创建`ProcessGroup`实例。 -+ **构造**：DDP构造函数接受对本地模块的引用，并从排名为0的进程向组中的所有其他进程广播`state_dict()`，以确保所有模型副本从完全相同的状态开始。然后，每个DDP进程创建一个本地的`Reducer`，后者将在反向传递期间负责梯度同步。为了提高通信效率，`Reducer`将参数梯度组织成桶，并一次减少一个桶。可以通过在DDP构造函数中设置bucket_cap_mb参数来配置桶大小。参数梯度到桶的映射是在构造时确定的，基于桶大小限制和参数大小。模型参数按照给定模型的`Model.parameters()`的（大致）相反顺序分配到桶中。使用相反顺序的原因是因为DDP期望梯度在反向传递期间以大致相同的顺序准备就绪。下面的图显示了一个示例。请注意，`grad0`和`grad1`在`bucket1`中，另外两个梯度在`bucket0`中。当然，这种假设可能并不总是正确，当发生这种情况时，可能会影响DDP反向传递速度，因为`Reducer`无法在可能的最早时间开始通信。除了分桶，`Reducer`还在构造过程中注册自动求导钩子，每个参数一个钩子。这些钩子将在梯度准备就绪时在反向传递期间触发。 ++ **构造**：DDP 构造函数接受对本地模块的引用，并从排名为 0 的进程向组中的所有其他进程广播`state_dict()`，以确保所有模型副本从完全相同的状态开始。然后，每个 DDP 进程创建一个本地的`Reducer`，后者将在反向传递期间负责梯度同步。为了提高通信效率，`Reducer`将参数梯度组织成桶，并一次减少一个桶。可以通过在 DDP 构造函数中设置 bucket_cap_mb 参数来配置桶大小。参数梯度到桶的映射是在构造时确定的，基于桶大小限制和参数大小。模型参数按照给定模型的`Model.parameters()`的（大致）相反顺序分配到桶中。使用相反顺序的原因是因为 DDP 期望梯度在反向传递期间以大致相同的顺序准备就绪。下面的图显示了一个示例。请注意，`grad0`和`grad1`在`bucket1`中，另外两个梯度在`bucket0`中。当然，这种假设可能并不总是正确，当发生这种情况时，可能会影响 DDP 反向传递速度，因为`Reducer`无法在可能的最早时间开始通信。除了分桶，`Reducer`还在构造过程中注册自动求导钩子，每个参数一个钩子。这些钩子将在梯度准备就绪时在反向传递期间触发。 -+ **前向传播**：DDP接受输入并将其传递给本地模型，然后分析本地模型的输出，如果`find_unused_parameters`设置为`True`。此模式允许在模型的子图上运行反向传播，DDP通过从模型输出遍历自动求导图并标记所有未使用的参数为准备好进行减少。在反向传播期间，`Reducer`只会等待未准备好的参数，但仍会减少所有桶。将参数梯度标记为准备好不会帮助DDP跳过桶，但它将防止DDP在反向传播期间永远等待缺失的梯度。请注意，遍历自动求导图会引入额外的开销，因此应用程序只应在必要时将`find_unused_parameters`设置为`True`。 ++ **前向传播**：DDP 接受输入并将其传递给本地模型，然后分析本地模型的输出，如果`find_unused_parameters`设置为`True`。此模式允许在模型的子图上运行反向传播，DDP 通过从模型输出遍历自动求导图并标记所有未使用的参数为准备好进行减少。在反向传播期间，`Reducer`只会等待未准备好的参数，但仍会减少所有桶。将参数梯度标记为准备好不会帮助 DDP 跳过桶，但它将防止 DDP 在反向传播期间永远等待缺失的梯度。请注意，遍历自动求导图会引入额外的开销，因此应用程序只应在必要时将`find_unused_parameters`设置为`True`。 -+ **反向传播**：`backward()`函数直接在损失`Tensor`上调用，这是DDP无法控制的，DDP在构造时使用的自动求导钩子来触发梯度同步。当一个梯度准备就绪时，其对应的DDP钩子将触发该梯度累加器上的梯度，并且DDP将标记该参数梯度为准备好进行减少。当一个桶中的梯度都准备就绪时，`Reducer`会在该桶上启动一个异步的`allreduce`来计算所有进程中梯度的平均值。当所有桶都准备就绪时，`Reducer`将阻塞等待所有`allreduce`操作完成。完成后，平均梯度将写入所有参数的`param.grad`字段。因此，在反向传播之后，不同DDP进程中相应参数的grad字段应该是相同的。 ++ **反向传播**：`backward()`函数直接在损失`Tensor`上调用，这是 DDP 无法控制的，DDP 在构造时使用的自动求导钩子来触发梯度同步。当一个梯度准备就绪时，其对应的 DDP 钩子将触发该梯度累加器上的梯度，并且 DDP 将标记该参数梯度为准备好进行减少。当一个桶中的梯度都准备就绪时，`Reducer`会在该桶上启动一个异步的`allreduce`来计算所有进程中梯度的平均值。当所有桶都准备就绪时，`Reducer`将阻塞等待所有`allreduce`操作完成。完成后，平均梯度将写入所有参数的`param.grad`字段。因此，在反向传播之后，不同 DDP 进程中相应参数的 grad 字段应该是相同的。 -+ **优化器步骤**：从优化器的角度来看，它正在优化一个本地模型。所有DDP进程上的模型副本可以保持同步，因为它们都从相同的状态开始，并且它们在每次迭代中具有相同的平均梯度。 ++ **优化器步骤**：从优化器的角度来看，它正在优化一个本地模型。所有 DDP 进程上的模型副本可以保持同步，因为它们都从相同的状态开始，并且它们在每次迭代中具有相同的平均梯度。 -[![ddp_grad_sync.png](../Images/7fd0c1da1ad18ef7e8187a73ace04695.png)](https://user-images.githubusercontent.com/16999635/72401724-d296d880-371a-11ea-90ab-737f86543df9.png) +![ddp_grad_sync.png](https://user-images.githubusercontent.com/16999635/72401724-d296d880-371a-11ea-90ab-737f86543df9.png) 注意 -DDP要求所有进程上的`Reducer`实例以完全相同的顺序调用`allreduce`，这是通过始终按照桶索引顺序而不是实际桶准备就绪顺序来运行`allreduce`来实现的。跨进程的`allreduce`顺序不匹配可能导致错误的结果或DDP反向传播挂起。 +DDP 要求所有进程上的`Reducer`实例以完全相同的顺序调用`allreduce`，这是通过始终按照桶索引顺序而不是实际桶准备就绪顺序来运行`allreduce`来实现的。跨进程的`allreduce`顺序不匹配可能导致错误的结果或 DDP 反向传播挂起。 ## 实现 -以下是DDP实现组件的指针。堆叠图显示了代码的结构。 +以下是 DDP 实现组件的指针。堆叠图显示了代码的结构。 ### ProcessGroup -+ [ProcessGroup.hpp](https://github.com/pytorch/pytorch/blob/v1.7.0/torch/lib/c10d/ProcessGroup.hpp)：包含所有进程组实现的抽象API。`c10d`库提供了3种开箱即用的实现，即ProcessGroupGloo、ProcessGroupNCCL和ProcessGroupMPI。`DistributedDataParallel`使用`ProcessGroup::broadcast()`在初始化期间从排名为0的进程向其他进程发送模型状态，并使用`ProcessGroup::allreduce()`来求和梯度。 ++ [ProcessGroup.hpp](https://github.com/pytorch/pytorch/blob/v1.7.0/torch/lib/c10d/ProcessGroup.hpp)：包含所有进程组实现的抽象 API。`c10d`库提供了 3 种开箱即用的实现，即 ProcessGroupGloo、ProcessGroupNCCL 和 ProcessGroupMPI。`DistributedDataParallel`使用`ProcessGroup::broadcast()`在初始化期间从排名为 0 的进程向其他进程发送模型状态，并使用`ProcessGroup::allreduce()`来求和梯度。 + [Store.hpp](https://github.com/pytorch/pytorch/blob/v1.7.0/torch/lib/c10d/Store.hpp)：协助进程组实例的会合服务找到彼此。 ### DistributedDataParallel -+ [distributed.py](https://github.com/pytorch/pytorch/blob/v1.7.0/torch/nn/parallel/distributed.py)：是DDP的Python入口点。它实现了初始化步骤和`nn.parallel.DistributedDataParallel`模块的`forward`函数，该函数调用C++库。其`_sync_param`函数在一个DDP进程在多个设备上工作时执行进程内参数同步，并且它还会将模型缓冲区从排名为0的进程广播到所有其他进程。进程间参数同步发生在`Reducer.cpp`中。 ++ [distributed.py](https://github.com/pytorch/pytorch/blob/v1.7.0/torch/nn/parallel/distributed.py)：是 DDP 的 Python 入口点。它实现了初始化步骤和`nn.parallel.DistributedDataParallel`模块的`forward`函数，该函数调用 C++库。其`_sync_param`函数在一个 DDP 进程在多个设备上工作时执行进程内参数同步，并且它还会将模型缓冲区从排名为 0 的进程广播到所有其他进程。进程间参数同步发生在`Reducer.cpp`中。 + [comm.h](https://github.com/pytorch/pytorch/blob/v1.7.0/torch/csrc/distributed/c10d/comm.h)：实现了合并广播辅助函数，用于在初始化期间广播模型状态并在前向传递之前同步模型缓冲区。 @@ -105,16 +105,16 @@ DDP要求所有进程上的`Reducer`实例以完全相同的顺序调用`allredu + `autograd_hook()`函数将在梯度准备就绪时被自动求导引擎调用。 - + `prepare_for_backward()`在`distributed.py`中的DDP前向传递结束时被调用。当在DDP构造函数中将`find_unused_parameters`设置为`True`时，它会遍历自动求导图以找到未使用的参数。 + + `prepare_for_backward()`在`distributed.py`中的 DDP 前向传递结束时被调用。当在 DDP 构造函数中将`find_unused_parameters`设置为`True`时，它会遍历自动求导图以找到未使用的参数。 -[![ddp_code.png](../Images/0b2511513fe6a3326d13ebd545cfb730.png)](https://user-images.githubusercontent.com/16999635/72313120-4e7c1c80-3658-11ea-9c6d-44336b2daeac.png) +![ddp_code.png](https://user-images.githubusercontent.com/16999635/72313120-4e7c1c80-3658-11ea-9c6d-44336b2daeac.png) ### TorchDynamo DDPOptimizer -DDP的性能优势来自在反向传递期间将allreduce集体操作与计算重叠。当与TorchDynamo一起使用时，AotAutograd会阻止这种重叠，因为它用于编译整个前向和整个反向图形，这会导致在整个优化的反向计算完成后，梯度同步操作由自动求导钩子在之后启动。 +DDP 的性能优势来自在反向传递期间将 allreduce 集体操作与计算重叠。当与 TorchDynamo 一起使用时，AotAutograd 会阻止这种重叠，因为它用于编译整个前向和整个反向图形，这会导致在整个优化的反向计算完成后，梯度同步操作由自动求导钩子在之后启动。 -TorchDynamo的DDPOptimizer通过在反向传递期间在DDP的allreduce桶的逻辑边界处中断前向图来帮助。注意：目标是在反向传递期间中断图形，最简单的实现方式是在前向图形中断，然后在每个部分上调用AotAutograd和编译。这允许DDP的allreduce钩子在反向传递的各个部分之间触发，并安排通信与计算重叠。 +TorchDynamo 的 DDPOptimizer 通过在反向传递期间在 DDP 的 allreduce 桶的逻辑边界处中断前向图来帮助。注意：目标是在反向传递期间中断图形，最简单的实现方式是在前向图形中断，然后在每个部分上调用 AotAutograd 和编译。这允许 DDP 的 allreduce 钩子在反向传递的各个部分之间触发，并安排通信与计算重叠。 查看[这篇博客文章](https://dev-discuss.pytorch.org/t/torchdynamo-update-9-making-ddp-work-with-torchdynamo/860/1)以获取更深入的解释和实验结果，或者在[torch/_dynamo/optimizations/distributed.py](https://github.com/pytorch/pytorch/blob/4908a12542798a3e8641faae6b74f068fdfc6778/torch/_dynamo/optimizations/distributed.py#L56)中阅读文档和代码 -要调试DDPOptimizer，请将torch._dynamo.config.log_level设置为DEBUG（用于完整图形转储）或INFO（用于有关桶边界的基本信息）。要禁用DDPOptimizer，请将torch._dynamo.config.optimize_ddp设置为False。DDP和TorchDynamo应该在没有DDPOptimizer的情况下仍能正常工作，但性能会下降。 +要调试 DDPOptimizer，请将 torch._dynamo.config.log_level 设置为 DEBUG（用于完整图形转储）或 INFO（用于有关桶边界的基本信息）。要禁用 DDPOptimizer，请将 torch._dynamo.config.optimize_ddp 设置为 False。DDP 和 TorchDynamo 应该在没有 DDPOptimizer 的情况下仍能正常工作，但性能会下降。 diff --git a/totrans/doc22_014.md b/totrans/doc22_014.md index d0c1f871..a9ae73d5 100644 --- a/totrans/doc22_014.md +++ b/totrans/doc22_014.md @@ -1,54 +1,54 @@ -# 扩展PyTorch +# 扩展 PyTorch -> 原文：[https://pytorch.org/docs/stable/notes/extending.html](https://pytorch.org/docs/stable/notes/extending.html) +> 原文：[`pytorch.org/docs/stable/notes/extending.html`](https://pytorch.org/docs/stable/notes/extending.html) -在本说明中，我们将介绍扩展[`torch.nn`](../nn.html#module-torch.nn "torch.nn")、[`torch.autograd`](../autograd.html#module-torch.autograd "torch.autograd")、[`torch`](../torch.html#module-torch "torch")以及编写自定义C++扩展的方法。 +在本说明中，我们将介绍扩展`torch.nn`、`torch.autograd`、`torch`以及编写自定义 C++扩展的方法。 -## 扩展[`torch.autograd`](../autograd.html#module-torch.autograd "torch.autograd")[](#extending-torch-autograd "跳转到此标题的永久链接") +## 扩展`torch.autograd`[](#extending-torch-autograd "跳转到此标题的永久链接") -向[`autograd`](../autograd.html#module-torch.autograd "torch.autograd")添加操作需要为每个操作实现一个新的[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")子类。请记住，`autograd`使用`Function`来编码操作历史并计算梯度。 +向`autograd`添加操作需要为每个操作实现一个新的`Function`子类。请记住，`autograd`使用`Function`来编码操作历史并计算梯度。 本文档的第一部分侧重于反向模式自动微分，因为它是最广泛使用的功能。文末的一节讨论了前向模式自动微分的扩展。 ### 何时使用 -一般来说，如果您想在模型中执行不可微分的计算或依赖于非PyTorch库（例如NumPy），但仍希望您的操作与其他操作链接并与autograd引擎一起工作，则实现自定义函数。 +一般来说，如果您想在模型中执行不可微分的计算或依赖于非 PyTorch 库（例如 NumPy），但仍希望您的操作与其他操作链接并与 autograd 引擎一起工作，则实现自定义函数。 -在某些情况下，自定义函数也可以用于提高性能和内存使用：如果您使用[C++扩展](https://pytorch.org/tutorials/advanced/cpp_extension.html)实现了前向和反向传递，您可以将它们包装在[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")中，以与autograd引擎进行交互。如果您想减少为反向传播保存的缓冲区数量，可以使用自定义函数将操作组合在一起。 +在某些情况下，自定义函数也可以用于提高性能和内存使用：如果您使用[C++扩展](https://pytorch.org/tutorials/advanced/cpp_extension.html)实现了前向和反向传递，您可以将它们包装在`Function`中，以与 autograd 引擎进行交互。如果您想减少为反向传播保存的缓冲区数量，可以使用自定义函数将操作组合在一起。 ### 何时不使用 -如果您已经可以使用PyTorch内置操作编写函数，则其反向图（很可能）已经能够被autograd记录。在这种情况下，您不需要自己实现反向函数。考虑使用普通的Python函数。 +如果您已经可以使用 PyTorch 内置操作编写函数，则其反向图（很可能）已经能够被 autograd 记录。在这种情况下，您不需要自己实现反向函数。考虑使用普通的 Python 函数。 -如果您需要保持状态，即可训练参数，您应该（也）使用自定义模块。有关在[`torch.nn`](../nn.html#module-torch.nn "torch.nn")上扩展的更多信息，请参阅下面的部分。 +如果您需要保持状态，即可训练参数，您应该（也）使用自定义模块。有关在`torch.nn`上扩展的更多信息，请参阅下面的部分。 如果您想在反向传播过程中更改梯度或执行副作用，请考虑注册一个[tensor](https://pytorch.org/docs/stable/generated/torch.Tensor.register_hook.html#torch.Tensor.register_hook)或[Module](https://pytorch.org/docs/stable/notes/modules.html#module-hooks) hook。 ### 如何使用 -按照以下步骤进行：1. 子类化[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")并实现[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")，（可选）`setup_context()`和[`backward()`](../generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")方法。2. 在ctx参数上调用适当的方法。3. 声明您的函数是否支持[双向传播](https://pytorch.org/tutorials/intermediate/custom_function_double_backward_tutorial.html)。4. 使用gradcheck验证您的梯度是否正确。 +按照以下步骤进行：1. 子类化`Function`并实现`forward()`，（可选）`setup_context()`和`backward()`方法。2. 在 ctx 参数上调用适当的方法。3. 声明您的函数是否支持[双向传播](https://pytorch.org/tutorials/intermediate/custom_function_double_backward_tutorial.html)。4. 使用 gradcheck 验证您的梯度是否正确。 -**步骤1：**在子类化[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")后，您需要定义3个方法： +**步骤 1：**在子类化`Function`后，您需要定义 3 个方法： -+ [`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 是执行操作的代码。它可以接受任意数量的参数，其中一些是可选的，如果您指定了默认值。这里接受所有类型的 Python 对象。跟踪历史记录的 `Tensor` 参数（即具有 `requires_grad=True` 的参数）在调用之前将被转换为不跟踪历史记录的参数，并且它们的使用将在图中注册。请注意，此逻辑不会遍历列表/字典/任何其他数据结构，只会考虑直接作为调用参数的张量。您可以返回单个 `Tensor` 输出，或者如果有多个输出，则可以返回张量的 [`tuple`](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")。此外，请参考 [`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function") 的文档，以查找只能从 [`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 中调用的有用方法的描述。 ++ `forward()` 是执行操作的代码。它可以接受任意数量的参数，其中一些是可选的，如果您指定了默认值。这里接受所有类型的 Python 对象。跟踪历史记录的 `Tensor` 参数（即具有 `requires_grad=True` 的参数）在调用之前将被转换为不跟踪历史记录的参数，并且它们的使用将在图中注册。请注意，此逻辑不会遍历列表/字典/任何其他数据结构，只会考虑直接作为调用参数的张量。您可以返回单个 `Tensor` 输出，或者如果有多个输出，则可以返回张量的 [`tuple`](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")。此外，请参考 `Function` 的文档，以查找只能从 `forward()` 中调用的有用方法的描述。 -+ `setup_context()`（可选）。可以编写一个接受 `ctx` 对象的“组合” [`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 或（从 PyTorch 2.0 开始）一个不接受 `ctx` 的单独 [`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 和一个 `setup_context()` 方法，在其中进行 `ctx` 修改。[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 应该包含计算，而 `setup_context()` 应该只负责 `ctx` 的修改（不包含任何计算）。一般来说，单独的 [`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 和 `setup_context()` 更接近于 PyTorch 原生操作的工作方式，因此更具有与各种 PyTorch 子系统的可组合性。有关更多详细信息，请参见[组合或分离的 forward() 和 setup_context()](#combining-forward-context)。 ++ `setup_context()`（可选）。可以编写一个接受 `ctx` 对象的“组合” `forward()` 或（从 PyTorch 2.0 开始）一个不接受 `ctx` 的单独 `forward()` 和一个 `setup_context()` 方法，在其中进行 `ctx` 修改。`forward()` 应该包含计算，而 `setup_context()` 应该只负责 `ctx` 的修改（不包含任何计算）。一般来说，单独的 `forward()` 和 `setup_context()` 更接近于 PyTorch 原生操作的工作方式，因此更具有与各种 PyTorch 子系统的可组合性。有关更多详细信息，请参见组合或分离的 forward() 和 setup_context()。 -+ [`backward()`](../generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")（或 `vjp()`）定义了梯度公式。它将作为输出的数量给出与之对应的梯度的 `Tensor` 参数，每个参数表示相对于该输出的梯度。重要的是绝对不要就地修改这些参数。它应该返回与输入的数量相同的张量，每个张量包含相对于其对应输入的梯度。如果您的输入不需要梯度（`needs_input_grad` 是一个布尔值元组，指示每个输入是否需要梯度计算），或者是非 `Tensor` 对象，您可以返回 `python:None`。此外，如果您在 [`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 中有可选参数，您可以返回比输入数量更多的梯度，只要它们都是 [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.12)")。 ++ `backward()`（或 `vjp()`）定义了梯度公式。它将作为输出的数量给出与之对应的梯度的 `Tensor` 参数，每个参数表示相对于该输出的梯度。重要的是绝对不要就地修改这些参数。它应该返回与输入的数量相同的张量，每个张量包含相对于其对应输入的梯度。如果您的输入不需要梯度（`needs_input_grad` 是一个布尔值元组，指示每个输入是否需要梯度计算），或者是非 `Tensor` 对象，您可以返回 `python:None`。此外，如果您在 `forward()` 中有可选参数，您可以返回比输入数量更多的梯度，只要它们都是 [`None`](https://docs.python.org/3/library/constants.html#None "(in Python v3.12)")。 -**步骤 2：** 您有责任正确使用 `ctx` 中的函数，以确保新的 [`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function") 与自动求导引擎正常工作。 +**步骤 2：** 您有责任正确使用 `ctx` 中的函数，以确保新的 `Function` 与自动求导引擎正常工作。 -+ [`save_for_backward()`](../generated/torch.autograd.function.FunctionCtx.save_for_backward.html#torch.autograd.function.FunctionCtx.save_for_backward "torch.autograd.function.FunctionCtx.save_for_backward")必须用于保存在反向传播中使用的任何张量。非张量应直接存储在ctx上。如果保存了既不是输入也不是输出的张量以进行反向传播，您的[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")可能不支持双向传播（参见步骤3）。 ++ `save_for_backward()`必须用于保存在反向传播中使用的任何张量。非张量应直接存储在 ctx 上。如果保存了既不是输入也不是输出的张量以进行反向传播，您的`Function`可能不支持双向传播（参见步骤 3）。 -+ [`mark_dirty()`](../generated/torch.autograd.function.FunctionCtx.mark_dirty.html#torch.autograd.function.FunctionCtx.mark_dirty "torch.autograd.function.FunctionCtx.mark_dirty")必须用于标记由前向函数就地修改的任何输入。 ++ `mark_dirty()`必须用于标记由前向函数就地修改的任何输入。 -+ [`mark_non_differentiable()`](../generated/torch.autograd.function.FunctionCtx.mark_non_differentiable.html#torch.autograd.function.FunctionCtx.mark_non_differentiable "torch.autograd.function.FunctionCtx.mark_non_differentiable")必须用于告诉引擎输出是否不可微分。默认情况下，所有可微分类型的输出张量都将被设置为需要梯度。不可微分类型的张量（即整数类型）永远不会被标记为需要梯度。 ++ `mark_non_differentiable()`必须用于告诉引擎输出是否不可微分。默认情况下，所有可微分类型的输出张量都将被设置为需要梯度。不可微分类型的张量（即整数类型）永远不会被标记为需要梯度。 -+ [`set_materialize_grads()`](../generated/torch.autograd.function.FunctionCtx.set_materialize_grads.html#torch.autograd.function.FunctionCtx.set_materialize_grads "torch.autograd.function.FunctionCtx.set_materialize_grads")可用于告诉自动求导引擎在输出不依赖于输入的情况下优化梯度计算，方法是不将传递给反向函数的梯度张量实例化。也就是说，如果设置为False，Python中的None对象或C++中的“未定义张量”（对于其defined()为False的张量x）将不会在调用反向传播之前转换为填充了零的张量，因此您的代码将需要处理这些对象，就好像它们是填充了零的张量一样。此设置的默认值为True。 ++ `set_materialize_grads()`可用于告诉自动求导引擎在输出不依赖于输入的情况下优化梯度计算，方法是不将传递给反向函数的梯度张量实例化。也就是说，如果设置为 False，Python 中的 None 对象或 C++中的“未定义张量”（对于其 defined()为 False 的张量 x）将不会在调用反向传播之前转换为填充了零的张量，因此您的代码将需要处理这些对象，就好像它们是填充了零的张量一样。此设置的默认值为 True。 -**步骤3：** 如果您的[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")不支持双向传播，您应该通过在反向传播中使用`once_differentiable()`来显式声明这一点。使用这个装饰器，尝试通过您的函数执行双向传播将产生错误。有关双向传播的更多信息，请参阅我们的双向传播教程。 +**步骤 3：** 如果您的`Function`不支持双向传播，您应该通过在反向传播中使用`once_differentiable()`来显式声明这一点。使用这个装饰器，尝试通过您的函数执行双向传播将产生错误。有关双向传播的更多信息，请参阅我们的双向传播教程。 -**步骤4：** 建议您使用[`torch.autograd.gradcheck()`](../autograd.html#module-torch.autograd.gradcheck "torch.autograd.gradcheck")来检查您的反向函数是否正确计算了前向梯度，方法是使用您的反向函数计算雅可比矩阵，并将其值逐个元素与使用有限差分数值计算的雅可比矩阵进行比较。 +**步骤 4：** 建议您使用`torch.autograd.gradcheck()`来检查您的反向函数是否正确计算了前向梯度，方法是使用您的反向函数计算雅可比矩阵，并将其值逐个元素与使用有限差分数值计算的雅可比矩阵进行比较。 ### 示例 @@ -131,7 +131,7 @@ class MulConstant(Function): return grad_output * ctx.constant, None ``` -在这里，我们通过调用set_materialize_grads(False)来优化上面的示例： +在这里，我们通过调用 set_materialize_grads(False)来优化上面的示例： ```py class MulConstant(Function): @@ -157,7 +157,7 @@ class MulConstant(Function): return grad_output * ctx.constant, None ``` -如果您需要在[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")中计算的“中间”张量被保存，要么它们必须作为输出返回，要么结合`forward`和`setup_context()`（参见[合并或分开forward()和setup_context()](#combining-forward-context)）。请注意，这意味着如果您希望梯度通过这些中间值流动，您需要为它们定义梯度公式（也请参阅[双向传播教程](https://pytorch.org/tutorials/intermediate/custom_function_double_backward_tutorial.html)）： +如果您需要在`forward()`中计算的“中间”张量被保存，要么它们必须作为输出返回，要么结合`forward`和`setup_context()`（参见合并或分开 forward()和 setup_context()）。请注意，这意味着如果您希望梯度通过这些中间值流动，您需要为它们定义梯度公式（也请参阅[双向传播教程](https://pytorch.org/tutorials/intermediate/custom_function_double_backward_tutorial.html)）： ```py class MyCube(torch.autograd.Function): @@ -192,7 +192,7 @@ def my_cube(x): 注意 -传递给`backward`的输入，即`grad_output`，也可以是跟踪历史记录的张量。因此，如果`backward`是通过可微操作实现的（例如，调用另一个自定义[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")），高阶导数将起作用。在这种情况下，使用`save_for_backward`保存的张量也可以在反向中使用，并且梯度会回流，但在`ctx`中保存的张量不会有梯度回流。如果您需要梯度回流到在`ctx`中保存的张量，您应该将其作为自定义`Function`的输出并使用`save_for_backward`保存它。 +传递给`backward`的输入，即`grad_output`，也可以是跟踪历史记录的张量。因此，如果`backward`是通过可微操作实现的（例如，调用另一个自定义`Function`），高阶导数将起作用。在这种情况下，使用`save_for_backward`保存的张量也可以在反向中使用，并且梯度会回流，但在`ctx`中保存的张量不会有梯度回流。如果您需要梯度回流到在`ctx`中保存的张量，您应该将其作为自定义`Function`的输出并使用`save_for_backward`保存它。 您可能希望检查您实现的反向方法是否实际计算了函数的导数。可以通过使用小的有限差分进行数值近似来进行比较： @@ -207,21 +207,21 @@ test = gradcheck(linear, input, eps=1e-6, atol=1e-4) print(test) ``` -有关有限差分梯度比较的更多详细信息，请参见[数值梯度检查](../autograd.html#grad-check)。如果您的函数用于高阶导数（对反向传递进行微分），则可以使用同一软件包中的`gradgradcheck`函数来检查高阶导数。 +有关有限差分梯度比较的更多详细信息，请参见数值梯度检查。如果您的函数用于高阶导数（对反向传递进行微分），则可以使用同一软件包中的`gradgradcheck`函数来检查高阶导数。 -### 合并或单独的[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和`setup_context()`[](#combined-or-separate-forward-and-setup-context "Permalink to this heading") +### 合并或单独的`forward()`和`setup_context()`[](#combined-or-separate-forward-and-setup-context "Permalink to this heading") -有两种主要方法来定义[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")。要么： +有两种主要方法来定义`Function`。要么： -+ 定义一个结合了前向计算逻辑和`setup_context()`的[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") ++ 定义一个结合了前向计算逻辑和`setup_context()`的`forward()` -+ （截至PyTorch 2.0）定义一个单独的[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和`setup_context()` ++ （截至 PyTorch 2.0）定义一个单独的`forward()`和`setup_context()` -我们推荐第二种选项（单独的[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和`setup_context()`），因为这更接近PyTorch原生操作的实现方式，并且与[`torch.func`](../func.api.html#module-torch.func "torch.func")转换组合。但是，我们计划支持两种方法；结合[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和`setup_context()`：会更加灵活，因为您可以保存中间结果而无需将它们作为输出返回。 +我们推荐第二种选项（单独的`forward()`和`setup_context()`），因为这更接近 PyTorch 原生操作的实现方式，并且与`torch.func`转换组合。但是，我们计划支持两种方法；结合`forward()`和`setup_context()`：会更加灵活，因为您可以保存中间结果而无需将它们作为输出返回。 -有关如何定义具有单独[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和`setup_context()`的[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的详细信息，请参见前一节。 +有关如何定义具有单独`forward()`和`setup_context()`的`Function`的详细信息，请参见前一节。 -以下是如何定义一个带有合并[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和`setup_context()`的[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的示例： +以下是如何定义一个带有合并`forward()`和`setup_context()`的`Function`的示例： ```py class LinearFunction(Function): @@ -250,39 +250,39 @@ class LinearFunction(Function): return grad_input, grad_weight, grad_bias ``` ### 正向模式 AD -覆盖正向模式 AD 公式具有非常相似的 API，但有一些不同的微妙之处。您可以实现[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")函数。 +覆盖正向模式 AD 公式具有非常相似的 API，但有一些不同的微妙之处。您可以实现`jvp()`函数。 -它将被给予与输入相同数量的`Tensor`参数，每个参数代表相对于该输入的梯度。它应返回与输出相同数量的张量，每个张量包含相对于其对应输出的梯度。[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")将在[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")方法之后，在`apply()`返回之前调用。 +它将被给予与输入相同数量的`Tensor`参数，每个参数代表相对于该输入的梯度。它应返回与输出相同数量的张量，每个张量包含相对于其对应输出的梯度。`jvp()`将在`forward()`方法之后，在`apply()`返回之前调用。 -[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")与[`backward()`](../generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")函数有一些微妙的区别： +`jvp()`与`backward()`函数有一些微妙的区别： -+ 您可以使用ctx将任何数据从[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")传递到[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")函数。如果该状态在[`backward()`](../generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")中不需要，您可以在[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")函数末尾通过`del ctx.foo`显式释放它。 ++ 您可以使用 ctx 将任何数据从`forward()`传递到`jvp()`函数。如果该状态在`backward()`中不需要，您可以在`jvp()`函数末尾通过`del ctx.foo`显式释放它。 -+ [`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")的实现必须是反向可微的，或者明确检查给定的前向模式梯度中是否有`requires_grad`设置。 ++ `jvp()`的实现必须是反向可微的，或者明确检查给定的前向模式梯度中是否有`requires_grad`设置。 -+ [`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")函数必须匹配[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")的视图/原地行为。例如，如果第`i`个输入被原地修改，则第`i`个梯度必须被原地更新。同样，如果第`j`个输出是第`k`个输入的视图。那么返回的第`j`个输出梯度必须是给定第`k`个输入梯度的视图。 ++ `jvp()`函数必须匹配`forward()`的视图/原地行为。例如，如果第`i`个输入被原地修改，则第`i`个梯度必须被原地更新。同样，如果第`j`个输出是第`k`个输入的视图。那么返回的第`j`个输出梯度必须是给定第`k`个输入梯度的视图。 -+ 因为用户无法指定需要计算哪个梯度，[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")函数应始终计算所有输出的梯度。 ++ 因为用户无法指定需要计算哪个梯度，`jvp()`函数应始终计算所有输出的梯度。 -+ 前向模式梯度确实遵守[`set_materialize_grads()`](../generated/torch.autograd.function.FunctionCtx.set_materialize_grads.html#torch.autograd.function.FunctionCtx.set_materialize_grads "torch.autograd.function.FunctionCtx.set_materialize_grads")设置的标志，当禁用时，您可以获得None输入梯度。 ++ 前向模式梯度确实遵守`set_materialize_grads()`设置的标志，当禁用时，您可以获得 None 输入梯度。 -### [`torch.func`](../func.api.html#module-torch.func "torch.func")转换和/或[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")[](#torch-func-transforms-and-or-torch-vmap "跳转到此标题的永久链接") +### `torch.func`转换和/或`torch.vmap()`[](#torch-func-transforms-and-or-torch-vmap "跳转到此标题的永久链接") -有关详细信息，请参阅[使用autograd.Function扩展torch.func](extending.func.html#func-autograd-function)。 +有关详细信息，请参阅使用 autograd.Function 扩展 torch.func。 -## 扩展[`torch.nn`](../nn.html#module-torch.nn "torch.nn")[](#extending-torch-nn "跳转到此标题的永久链接") +## 扩展`torch.nn`[](#extending-torch-nn "跳转到此标题的永久链接") -[`nn`](../nn.html#module-torch.nn "torch.nn")导出两种接口 - 模块及其功能版本。您可以以两种方式扩展它，但我们建议对所有包含任何参数或缓冲区的层使用模块，并建议对参数为空的操作（如激活函数、池化等）使用功能形式。 +`nn`导出两种接口 - 模块及其功能版本。您可以以两种方式扩展它，但我们建议对所有包含任何参数或缓冲区的层使用模块，并建议对参数为空的操作（如激活函数、池化等）使用功能形式。 在上面的部分中已经完全涵盖了添加操作的功能版本。 -### 添加一个[`Module`](../generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")[](#adding-a-module "跳转到此标题的永久链接") +### 添加一个`Module`[](#adding-a-module "跳转到此标题的永久链接") -由于[`nn`](../nn.html#module-torch.nn "torch.nn")大量使用[`autograd`](../autograd.html#module-torch.autograd "torch.autograd")，添加一个新的[`Module`](../generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")需要实现一个执行操作并能计算梯度的[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")。从现在开始，让我们假设我们想要实现一个`Linear`模块，并且我们已经按照上面的列表实现了该函数。添加这个需要非常少的代码。现在，需要实现两个函数： +由于`nn`大量使用`autograd`，添加一个新的`Module`需要实现一个执行操作并能计算梯度的`Function`。从现在开始，让我们假设我们想要实现一个`Linear`模块，并且我们已经按照上面的列表实现了该函数。添加这个需要非常少的代码。现在，需要实现两个函数： + `__init__`（*可选*）- 接受参数，如内核大小、特征数量等，并初始化参数和缓冲区。 -+ [`forward()`](../generated/torch.nn.Module.html#torch.nn.Module.forward "torch.nn.Module.forward") - 实例化一个[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")并使用它执行操作。它与上面显示的功能包装器非常相似。 ++ `forward()` - 实例化一个`Function`并使用它执行操作。它与上面显示的功能包装器非常相似。 这是如何实现`Linear`模块的方法： @@ -325,19 +325,19 @@ class Linear(nn.Module): ) ``` -## 扩展[`torch`](../torch.html#module-torch "torch") Python API[](#extending-torch-python-api "Permalink to this heading") +## 扩展`torch` Python API[](#extending-torch-python-api "Permalink to this heading") -您可以通过定义一个具有与`Tensor`匹配的方法的自定义类来创建模拟`Tensor`的自定义类型。但是如果您希望能够将这些类型传递给像[`torch.add()`](../generated/torch.add.html#torch.add "torch.add")这样的顶层[`torch`](../torch.html#module-torch "torch")命名空间中接受`Tensor`操作数的函数，该怎么办？ +您可以通过定义一个具有与`Tensor`匹配的方法的自定义类来创建模拟`Tensor`的自定义类型。但是如果您希望能够将这些类型传递给像`torch.add()`这样的顶层`torch`命名空间中接受`Tensor`操作数的函数，该怎么办？ -如果您的自定义Python类型定义了一个名为`__torch_function__`的方法，PyTorch将在将您的自定义类的实例传递给[`torch`](../torch.html#module-torch "torch")命名空间中的函数时调用您的`__torch_function__`实现。这使得可以为[`torch`](../torch.html#module-torch "torch")命名空间中的任何函数定义自定义实现，您的`__torch_function__`实现可以调用这些函数，使您的用户能够利用已经为`Tensor`编写的现有PyTorch工作流程来使用您的自定义类型。这适用于与`Tensor`无关的“鸭子”类型以及`Tensor`的用户定义子类。 +如果您的自定义 Python 类型定义了一个名为`__torch_function__`的方法，PyTorch 将在将您的自定义类的实例传递给`torch`命名空间中的函数时调用您的`__torch_function__`实现。这使得可以为`torch`命名空间中的任何函数定义自定义实现，您的`__torch_function__`实现可以调用这些函数，使您的用户能够利用已经为`Tensor`编写的现有 PyTorch 工作流程来使用您的自定义类型。这适用于与`Tensor`无关的“鸭子”类型以及`Tensor`的用户定义子类。 -### 使用类似`Tensor`的类型扩展[`torch`](../torch.html#module-torch "torch") +### 使用类似`Tensor`的类型扩展`torch` 注意 -这个功能受到了NumPy `__array_function__`协议的启发。有关更多详细信息，请参阅[NumPy文档](https://numpy.org/doc/stable/user/basics.dispatch.html#basics-dispatch)和[NEP-0018](https://numpy.org/neps/nep-0018-array-function-protocol.html)。 +这个功能受到了 NumPy `__array_function__`协议的启发。有关更多详细信息，请参阅[NumPy 文档](https://numpy.org/doc/stable/user/basics.dispatch.html#basics-dispatch)和[NEP-0018](https://numpy.org/neps/nep-0018-array-function-protocol.html)。 -为了具体化这一点，让我们从一个简单的示例开始，说明API分发机制。我们将创建一个自定义类型，表示一个二维标量张量，由对角线条目的顺序`N`和值`value`参数化： +为了具体化这一点，让我们从一个简单的示例开始，说明 API 分发机制。我们将创建一个自定义类型，表示一个二维标量张量，由对角线条目的顺序`N`和值`value`参数化： ```py class ScalarTensor(object): @@ -366,7 +366,7 @@ tensor([[2., 0., 0., 0., 0.], [0., 0., 0., 0., 2.]]) ``` -如果我们尝试使用[`torch`](../torch.html#module-torch "torch") API中的这个对象，我们将遇到问题： +如果我们尝试使用`torch` API 中的这个对象，我们将遇到问题： ```py >>> import torch @@ -398,14 +398,14 @@ class ScalarTensor(object): for t in types ): return NotImplemented - return HANDLED_FUNCTIONS[func](*args, **kwargs) + return HANDLED_FUNCTIONSfunc ``` -`__torch_function__`方法接受四个参数：`func`，被覆盖的torch API函数的引用，`types`，实现`__torch_function__`的Tensor-like类型的类型列表，`args`，传递给函数的参数元组，以及`kwargs`，传递给函数的关键字参数字典。它使用一个名为`HANDLED_FUNCTIONS`的全局分发表来存储自定义实现。这个字典的键是`torch`命名空间中的函数，值是`ScalarTensor`的实现。 +`__torch_function__`方法接受四个参数：`func`，被覆盖的 torch API 函数的引用，`types`，实现`__torch_function__`的 Tensor-like 类型的类型列表，`args`，传递给函数的参数元组，以及`kwargs`，传递给函数的关键字参数字典。它使用一个名为`HANDLED_FUNCTIONS`的全局分发表来存储自定义实现。这个字典的键是`torch`命名空间中的函数，值是`ScalarTensor`的实现。 注意 -使用全局分派表不是`__torch_function__` API的强制部分，它只是一种有用的设计模式，用于构建您的覆盖实现。 +使用全局分派表不是`__torch_function__` API 的强制部分，它只是一种有用的设计模式，用于构建您的覆盖实现。 这个类定义并不足以使`torch.mean`在我们传递`ScalarTensor`时执行正确的操作 - 我们还需要为`ScalarTensor`操作数定义一个`torch.mean`实现，并将该实现添加到`HANDLED_FUNCTIONS`分派表字典中。一种方法是定义一个装饰器： @@ -436,7 +436,7 @@ def mean(input): 0.4 ``` -当然，`torch.mean`是最简单的覆盖函数的一个例子，因为它只接受一个操作数。我们可以使用相同的机制来覆盖接受多个操作数的函数，其中任何一个可能是定义了`__torch_function__`的张量或类似张量，例如[`torch.add()`](../generated/torch.add.html#torch.add "torch.add")： +当然，`torch.mean`是最简单的覆盖函数的一个例子，因为它只接受一个操作数。我们可以使用相同的机制来覆盖接受多个操作数的函数，其中任何一个可能是定义了`__torch_function__`的张量或类似张量，例如`torch.add()`： ```py def ensure_tensor(data): @@ -467,16 +467,16 @@ tensor([[3., 1.], [1., 3.]]) ``` -请注意，我们的`add`实现不像[`torch.add()`](../generated/torch.add.html#torch.add "torch.add")那样将`alpha`或`out`作为关键字参数： +请注意，我们的`add`实现不像`torch.add()`那样将`alpha`或`out`作为关键字参数： ```py >>> torch.add(s, s, alpha=2) TypeError: add() got an unexpected keyword argument 'alpha' ``` -为了速度和灵活性，`__torch_function__`分派机制不会检查覆盖函数的签名是否与在[`torch`](../torch.html#module-torch "torch") API中被覆盖的函数的签名匹配。对于一些应用程序，忽略可选参数可能是可以的，但为了确保与`Tensor`的完全兼容性，torch API函数的用户实现应该确保精确模拟被覆盖的函数的API。 +为了速度和灵活性，`__torch_function__`分派机制不会检查覆盖函数的签名是否与在`torch` API 中被覆盖的函数的签名匹配。对于一些应用程序，忽略可选参数可能是可以的，但为了确保与`Tensor`的完全兼容性，torch API 函数的用户实现应该确保精确模拟被覆盖的函数的 API。 -[`torch`](../torch.html#module-torch "torch") API中没有显式覆盖的函数将从`__torch_function__`返回`NotImplemented`。如果所有具有在其上定义了`__torch_function__`的操作数都返回`NotImplemented`，PyTorch将引发`TypeError`。这意味着大多数情况下，对于没有特定类型的显式覆盖的操作，当传递这种类型的实例时将引发`TypeError`： +`torch` API 中没有显式覆盖的函数将从`__torch_function__`返回`NotImplemented`。如果所有具有在其上定义了`__torch_function__`的操作数都返回`NotImplemented`，PyTorch 将引发`TypeError`。这意味着大多数情况下，对于没有特定类型的显式覆盖的操作，当传递这种类型的实例时将引发`TypeError`： ```py >>> torch.mul(s, 3) @@ -484,9 +484,9 @@ TypeError: no implementation found for 'torch.mul' on types that implement __torch_function__: [ScalarTensor] ``` -实际上，这意味着如果您想要使用类似这样的`__torch_function__`实现来实现您的覆盖，您将需要显式实现完整的[`torch`](../torch.html#module-torch "torch") API或您关心的用例的整个API子集。这可能是一个很大的挑战，因为完整的[`torch`](../torch.html#module-torch "torch") API非常广泛。 +实际上，这意味着如果您想要使用类似这样的`__torch_function__`实现来实现您的覆盖，您将需要显式实现完整的`torch` API 或您关心的用例的整个 API 子集。这可能是一个很大的挑战，因为完整的`torch` API 非常广泛。 -另一个选择是对于未处理的操作不返回`NotImplemented`，而是在没有可用覆盖时将`Tensor`传递给原始[`torch`](../torch.html#module-torch "torch")函数。例如，如果我们将`ScalarTensor`的`__torch_function__`实现更改为以下内容： +另一个选择是对于未处理的操作不返回`NotImplemented`，而是在没有可用覆盖时将`Tensor`传递给原始`torch`函数。例如，如果我们将`ScalarTensor`的`__torch_function__`实现更改为以下内容： ```py @classmethod @@ -499,10 +499,10 @@ def __torch_function__(cls, func, types, args=(), kwargs=None): ): args = [a.tensor() if hasattr(a, 'tensor') else a for a in args] return func(*args, **kwargs) - return HANDLED_FUNCTIONS[func](*args, **kwargs) + return HANDLED_FUNCTIONSfunc ``` -然后[`torch.mul()`](../generated/torch.mul.html#torch.mul "torch.mul")将正常工作，尽管返回类型始终是`Tensor`而不是`ScalarTensor`，即使两个操作数都是`ScalarTensor`实例： +然后`torch.mul()`将正常工作，尽管返回类型始终是`Tensor`而不是`ScalarTensor`，即使两个操作数都是`ScalarTensor`实例： ```py >>> s = ScalarTensor(2, 2) @@ -511,13 +511,13 @@ tensor([[4., 0.], [0., 4.]]) ``` -另请参见下面的`MetadataTensor`示例，以了解这种模式的另一种变体，但是始终返回`MetadataTensor`以通过[`torch`](../torch.html#module-torch "torch") API中的操作传播元数据。 +另请参见下面的`MetadataTensor`示例，以了解这种模式的另一种变体，但是始终返回`MetadataTensor`以通过`torch` API 中的操作传播元数据。 -`__torch_function__`协议旨在完全覆盖API，部分覆盖可能会导致不良结果，特别是某些函数引发`TypeError`。这对于子类尤其重要，其中torch.add、torch.Tensor.__add__和torch.Tensor.add这三个函数必须被覆盖，即使它们返回完全相同的结果。未能这样做也可能导致无限递归。如果需要从`torch.Tensor`子类实现一个函数，他们必须在实现中使用`super().__torch_function__`。 +`__torch_function__`协议旨在完全覆盖 API，部分覆盖可能会导致不良结果，特别是某些函数引发`TypeError`。这对于子类尤其重要，其中 torch.add、torch.Tensor.__add__ 和 torch.Tensor.add 这三个函数必须被覆盖，即使它们返回完全相同的结果。未能这样做也可能导致无限递归。如果需要从`torch.Tensor`子类实现一个函数，他们必须在实现中使用`super().__torch_function__`。 ### 子类化`torch.Tensor` -从1.7.0版本开始，在`torch.Tensor`上的方法和公共`torch.*`命名空间中应用于`torch.Tensor`子类的函数将返回子类实例而不是`torch.Tensor`实例： +从 1.7.0 版本开始，在`torch.Tensor`上的方法和公共`torch.*`命名空间中应用于`torch.Tensor`子类的函数将返回子类实例而不是`torch.Tensor`实例： ```py >>> class SubTensor(torch.Tensor): @@ -555,13 +555,13 @@ class LoggingTensor(torch.Tensor): return super().__torch_function__(func, types, args, kwargs) ``` -但是，如果希望在Tensor子类上覆盖一个方法，可以直接覆盖该方法（为子类定义它），或者使用`__torch_function__`并与`func`匹配。 +但是，如果希望在 Tensor 子类上覆盖一个方法，可以直接覆盖该方法（为子类定义它），或者使用`__torch_function__`并与`func`匹配。 -在子类的`__torch_function__`中，应该始终调用`super().__torch_function__(func, ...)`而不是直接调用`func`，这是在1.7.0版本之前的情况。未能这样做可能导致`func`递归回到`__torch_function__`，从而导致无限递归。 +在子类的`__torch_function__`中，应该始终调用`super().__torch_function__(func, ...)`而不是直接调用`func`，这是在 1.7.0 版本之前的情况。未能这样做可能导致`func`递归回到`__torch_function__`，从而导致无限递归。 -### 使用`Tensor`包装类型扩展[`torch`](../torch.html#module-torch "torch") +### 使用`Tensor`包装类型扩展`torch` -另一个有用的情况是一个类型包装了一个`Tensor`，可以作为属性或通过子类化。下面我们实现了这种类型的一个特殊情况，一个`MetadataTensor`，它将元数据字典附加到通过[`torch`](../torch.html#module-torch "torch")操作传播的`Tensor`上。由于这是对完整[`torch`](../torch.html#module-torch "torch") API的一种通用包装，我们不需要单独实现每个覆盖，因此可以使`__torch_function__`实现更宽松，允许进行更多操作： +另一个有用的情况是一个类型包装了一个`Tensor`，可以作为属性或通过子类化。下面我们实现了这种类型的一个特殊情况，一个`MetadataTensor`，它将元数据字典附加到通过`torch`操作传播的`Tensor`上。由于这是对完整`torch` API 的一种通用包装，我们不需要单独实现每个覆盖，因此可以使`__torch_function__`实现更宽松，允许进行更多操作： ```py class MetadataTensor(object): @@ -583,7 +583,7 @@ class MetadataTensor(object): return MetadataTensor(ret, metadata=metadatas[0]) ``` -这个简单的实现不一定适用于[`torch`](../torch.html#module-torch "torch") API中的每个函数，但足以捕捉大多数常见操作： +这个简单的实现不一定适用于`torch` API 中的每个函数，但足以捕捉大多数常见操作： ```py >>> metadata = {'owner': 'Ministry of Silly Walks'} @@ -607,19 +607,19 @@ tensor([[1, 4], ### 在定义了`__torch_function__`的多个类型上进行操作 -可以使用具有各自`__torch_function__`实现的多个不同类型的torch API，但必须特别小心。在这种情况下，规则是： +可以使用具有各自`__torch_function__`实现的多个不同类型的 torch API，但必须特别小心。在这种情况下，规则是： + 调度操作会收集每个操作数的所有不同的`__torch_function__`实现，并按顺序调用它们：子类优先于超类，否则按照操作符表达式中的从左到右顺序。 + 如果返回的值不是`NotImplemented`，则将该值作为结果返回。实现可以通过返回`NotImplemented`来注册他们不实现的操作。 -+ 如果所有的`__torch_function__`实现都返回`NotImplemented`，PyTorch会引发`TypeError`。 ++ 如果所有的`__torch_function__`实现都返回`NotImplemented`，PyTorch 会引发`TypeError`。 -### 测试PyTorch API的覆盖范围 +### 测试 PyTorch API 的覆盖范围 -实现`__torch_function__`的一个麻烦之处在于，如果某些操作有覆盖而其他操作没有覆盖，用户最多会看到不一致的体验，或者在运行时使用没有覆盖的函数时会看到错误。为了简化这个过程，PyTorch提供了一个面向开发者的API，用于确保对`__torch_function__`覆盖的全面支持。这个API是私有的，可能在未来会发生变化而没有警告。 +实现`__torch_function__`的一个麻烦之处在于，如果某些操作有覆盖而其他操作没有覆盖，用户最多会看到不一致的体验，或者在运行时使用没有覆盖的函数时会看到错误。为了简化这个过程，PyTorch 提供了一个面向开发者的 API，用于确保对`__torch_function__`覆盖的全面支持。这个 API 是私有的，可能在未来会发生变化而没有警告。 -首先，要获取所有可重写函数的列表，请使用`torch.overrides._get_overridable_functions`。这将返回一个字典，其键是`PyTorch` Python API中的命名空间，其值是该命名空间中可以被覆盖的函数列表。例如，让我们打印`torch.nn.functional`中可以被覆盖的前5个函数的名称： +首先，要获取所有可重写函数的列表，请使用`torch.overrides._get_overridable_functions`。这将返回一个字典，其键是`PyTorch` Python API 中的命名空间，其值是该命名空间中可以被覆盖的函数列表。例如，让我们打印`torch.nn.functional`中可以被覆盖的前 5 个函数的名称： ```py >>> from torch.overrides import get_overridable_functions @@ -630,7 +630,7 @@ tensor([[1, 4], 'adaptive_max_pool1d', 'adaptive_max_pool1d_with_indices'] ``` -这些函数的列表使得可以迭代所有可重写的函数，然而在实践中，这并不足以为所有这些函数编写测试，而不是费力地手动复制每个测试的每个函数的签名。为了简化这个过程，`torch.overrides._get_testing_overrides`函数返回一个字典，将`PyTorch` API中可重写的函数映射到具有与原始函数相同签名的虚拟lambda函数，但无条件返回-1。这些函数最有用的用法是与`inspect`一起使用，以分析原始`PyTorch`函数的函数签名： +这些函数的列表使得可以迭代所有可重写的函数，然而在实践中，这并不足以为所有这些函数编写测试，而不是费力地手动复制每个测试的每个函数的签名。为了简化这个过程，`torch.overrides._get_testing_overrides`函数返回一个字典，将`PyTorch` API 中可重写的函数映射到具有与原始函数相同签名的虚拟 lambda 函数，但无条件返回-1。这些函数最有用的用法是与`inspect`一起使用，以分析原始`PyTorch`函数的函数签名： ```py >>> import inspect @@ -641,13 +641,13 @@ tensor([[1, 4], ``` -最后，`torch.overrides.get_ignored_functions`返回一个函数元组，这些函数明确不能被`__torch_function__`覆盖。这个列表可以用来确认通过`get_overridable_functions`返回的字典中不存在的函数不能被覆盖。## 扩展[`torch`](../torch.html#module-torch "torch")本机API +最后，`torch.overrides.get_ignored_functions`返回一个函数元组，这些函数明确不能被`__torch_function__`覆盖。这个列表可以用来确认通过`get_overridable_functions`返回的字典中不存在的函数不能被覆盖。## 扩展`torch`本机 API -虽然`__torch_function__`允许有效地扩展PyTorch的纯Python组件的行为，但它不允许扩展用C++实现的PyTorch的部分。为此，`Tensor`子类还可以定义`__torch_dispatch__`，它将能够在C++级别覆盖行为。 +虽然`__torch_function__`允许有效地扩展 PyTorch 的纯 Python 组件的行为，但它不允许扩展用 C++实现的 PyTorch 的部分。为此，`Tensor`子类还可以定义`__torch_dispatch__`，它将能够在 C++级别覆盖行为。 -要有效地使用这个功能，重要的是要了解PyTorch的本机部分是如何实现的。那里最重要的组件是我们称之为“调度程序”（最好的描述可以在这篇[博文](http://blog.ezyang.com/2020/09/lets-talk-about-the-pytorch-dispatcher/)中找到，尽管它略显过时）。正如其名称所示，它负责为特定函数调用调用正确的后端函数。例如，当调用`torch.add(a, b)`时，调度程序将检查两个参数，找出应该为这个特定调用使用哪个“特征”（自动微分、自动转换、功能化等）和哪个“后端”（CPU、CUDA、MPS等），最后调用所有正确的内核。内核经常做的一件事是“重新调度”。例如，当在GPU上运行神经网络时，第一个调用将是处理任何潜在自动转换逻辑并重新调度的自动转换内核。接下来的特性将是自动微分，它将正确地创建自动微分图，然后重新调度。最后，我们到达CUDA的后端内核，它将启动正确的CUDA内核并返回最终结果。在退出时，自动微分将把图附加到输出上，最后，自动转换将有机会在退出时进行任何必要的更新。 +要有效地使用这个功能，重要的是要了解 PyTorch 的本机部分是如何实现的。那里最重要的组件是我们称之为“调度程序”（最好的描述可以在这篇[博文](http://blog.ezyang.com/2020/09/lets-talk-about-the-pytorch-dispatcher/)中找到，尽管它略显过时）。正如其名称所示，它负责为特定函数调用调用正确的后端函数。例如，当调用`torch.add(a, b)`时，调度程序将检查两个参数，找出应该为这个特定调用使用哪个“特征”（自动微分、自动转换、功能化等）和哪个“后端”（CPU、CUDA、MPS 等），最后调用所有正确的内核。内核经常做的一件事是“重新调度”。例如，当在 GPU 上运行神经网络时，第一个调用将是处理任何潜在自动转换逻辑并重新调度的自动转换内核。接下来的特性将是自动微分，它将正确地创建自动微分图，然后重新调度。最后，我们到达 CUDA 的后端内核，它将启动正确的 CUDA 内核并返回最终结果。在退出时，自动微分将把图附加到输出上，最后，自动转换将有机会在退出时进行任何必要的更新。 -调度程序的一个配置是调用所有这些特征和后端键的顺序。最新的列表及其顺序可以在`DispatchKey.h`文件中的`DispatchKey`枚举中找到。为了扩展torch，本讨论中排序的重要子集是： +调度程序的一个配置是调用所有这些特征和后端键的顺序。最新的列表及其顺序可以在`DispatchKey.h`文件中的`DispatchKey`枚举中找到。为了扩展 torch，本讨论中排序的重要子集是： vmap -> Autocast -> Autograd -> ZeroTensor -> Neg/Conj -> Functionalize -> Python -> Backends @@ -657,21 +657,21 @@ vmap -> Autocast -> Autograd -> ZeroTensor -> Neg/Conj -> Functionalize -> Pytho + 这段代码“在所有功能之下”运行。因此，它只负责生成每个张量的输出值（可以，也应该，忽略所有高级功能，如自动求导、自动转换等），就像常规后端一样。 -+ 如果任何高级功能实现了给定的函数而没有重新调度，它将永远不会到达`Python`键，因此`__torch_dispatch__`回调将永远不会被触发。这特别发生在CompositeImplicitAutograd函数中，这些函数在自动求导级别上进行评估而不进行重新调度。这是因为CompositeImplicitAutograd函数通过隐式调用其他本地操作来指定其自动求导公式，因此在自动求导级别上，函数被分解为其本地操作，而这些操作被评估。 ++ 如果任何高级功能实现了给定的函数而没有重新调度，它将永远不会到达`Python`键，因此`__torch_dispatch__`回调将永远不会被触发。这特别发生在 CompositeImplicitAutograd 函数中，这些函数在自动求导级别上进行评估而不进行重新调度。这是因为 CompositeImplicitAutograd 函数通过隐式调用其他本地操作来指定其自动求导公式，因此在自动求导级别上，函数被分解为其本地操作，而这些操作被评估。 -+ 在回调到Python并包装结果时，与常规PyTorch Python/C++绑定相同的转换被使用。特别是，一些对象无法在Python中表示，需要特殊处理（例如未定义的张量变为None）。 ++ 在回调到 Python 并包装结果时，与常规 PyTorch Python/C++绑定相同的转换被使用。特别是，一些对象无法在 Python 中表示，需要特殊处理（例如未定义的张量变为 None）。 -+ 我们的本地函数是惰性填充的，作为可调用的Python对象，以便从Python轻松与它们交互，命名空间为`torch.ops.{namespace}.{func_name}.{overload_name}`。给定给`__torch_dispatch__`的`func`对象始终是来自此命名空间的条目。这个命名空间可以用于直接调用本地操作，绕过通常的Python API和绑定代码。 ++ 我们的本地函数是惰性填充的，作为可调用的 Python 对象，以便从 Python 轻松与它们交互，命名空间为`torch.ops.{namespace}.{func_name}.{overload_name}`。给定给`__torch_dispatch__`的`func`对象始终是来自此命名空间的条目。这个命名空间可以用于直接调用本地操作，绕过通常的 Python API 和绑定代码。 -类似于`__torch_function__`能够介入torch的所有Python API和Tensor方法，`__torch_dispatch__`能够拦截所有对aten本地API的调用。请注意，在进入调度程序之前，所有张量上的方法都会转换为函数调用，因此在这里会显示为函数调用：`torch.add(a, 2)`和`a + 2`将导致完全相同的aten调用。这些函数的大部分在`native_functions.yaml`中定义，该文件指定了这些函数的属性以及它们的后端实现。它们的实现以及指定的特性随后会通过codegen自动注册。一些更奇特的函数或特性也会在C++代码库的其他位置或用户定义的C++扩展中注册。 +类似于`__torch_function__`能够介入 torch 的所有 Python API 和 Tensor 方法，`__torch_dispatch__`能够拦截所有对 aten 本地 API 的调用。请注意，在进入调度程序之前，所有张量上的方法都会转换为函数调用，因此在这里会显示为函数调用：`torch.add(a, 2)`和`a + 2`将导致完全相同的 aten 调用。这些函数的大部分在`native_functions.yaml`中定义，该文件指定了这些函数的属性以及它们的后端实现。它们的实现以及指定的特性随后会通过 codegen 自动注册。一些更奇特的函数或特性也会在 C++代码库的其他位置或用户定义的 C++扩展中注册。 -还可以使用[`torch.library`](../library.html#module-torch.library "torch.library")添加新的本地函数。这个Python特性允许定义和/或添加新的实现到本地函数。这可以用于添加缺失的内核、替换现有的内核或定义全新的本地函数。 +还可以使用`torch.library`添加新的本地函数。这个 Python 特性允许定义和/或添加新的实现到本地函数。这可以用于添加缺失的内核、替换现有的内核或定义全新的本地函数。 您可以在[subclass zoo](https://github.com/albanD/subclass_zoo)存储库中找到许多基于`__torch_dispatch__`的子类的示例。 -## 通过Modes扩展所有[`torch`](../torch.html#module-torch "torch") API[](#extending-all-torch-api-with-modes "Permalink to this heading")。 +## 通过 Modes 扩展所有`torch` API[](#extending-all-torch-api-with-modes "Permalink to this heading")。 -不幸的是，有些函数不接受张量输入。这意味着上面描述的子类方法无法用于覆盖PyTorch的所有函数的行为。此外，如果用例要求拦截每个函数调用，将每个张量更改为子类可能会过于侵入性。 +不幸的是，有些函数不接受张量输入。这意味着上面描述的子类方法无法用于覆盖 PyTorch 的所有函数的行为。此外，如果用例要求拦截每个函数调用，将每个张量更改为子类可能会过于侵入性。 为了解决这种用例，我们引入了“模式”概念。这些模式用于`__torch_function__`和`__torch_dispatch__`覆盖，分别通过继承`torch.overrides.TorchFunctionMode`和`torch.utils._python_dispatch.TorchDispatchMode`创建，并用作上下文管理器。 @@ -738,8 +738,8 @@ Dispatch Log: aten.detach.default(*(tensor([2., 2., 2., 2., 2., 2., 2., 2., 2., Dispatch Log: aten.detach.default(*(tensor([2., 2., 2., 2., 2., 2., 2., 2., 2., 2.]),), **{}) ``` -## 编写自定义C++扩展[](#writing-custom-c-extensions "跳转到此标题的永久链接") +## 编写自定义 C++扩展[](#writing-custom-c-extensions "跳转到此标题的永久链接") -查看这个[PyTorch教程](https://pytorch.org/tutorials/advanced/cpp_extension.html)以获取详细解释和示例。 +查看这个[PyTorch 教程](https://pytorch.org/tutorials/advanced/cpp_extension.html)以获取详细解释和示例。 -文档可在[torch.utils.cpp_extension](../cpp_extension.html)找到。 +文档可在 torch.utils.cpp_extension 找到。 diff --git a/totrans/doc22_015.md b/totrans/doc22_015.md index 5b4aa571..7eda2370 100644 --- a/totrans/doc22_015.md +++ b/totrans/doc22_015.md @@ -1,48 +1,48 @@ -# 使用autograd.Function扩展torch.func +# 使用 autograd.Function 扩展 torch.func -> 原文：[https://pytorch.org/docs/stable/notes/extending.func.html](https://pytorch.org/docs/stable/notes/extending.func.html) +> 原文：[`pytorch.org/docs/stable/notes/extending.func.html`](https://pytorch.org/docs/stable/notes/extending.func.html) -因此，您希望使用[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")与[`torch.func`](../func.api.html#module-torch.func "torch.func")转换，如[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")、[`torch.func.grad()`](../generated/torch.func.grad.html#torch.func.grad "torch.func.grad")等。 +因此，您希望使用`torch.autograd.Function`与`torch.func`转换，如`torch.vmap()`、`torch.func.grad()`等。 有两种主要用例： -+ 您希望调用不包含PyTorch操作的代码，并使其与函数转换一起工作。也就是说，[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的forward/backward等调用其他系统（如C++、CUDA、numpy）的函数。 ++ 您希望调用不包含 PyTorch 操作的代码，并使其与函数转换一起工作。也就是说，`torch.autograd.Function`的 forward/backward 等调用其他系统（如 C++、CUDA、numpy）的函数。 -+ 您希望指定自定义梯度规则，类似于JAX的[custom_vjp/custom_jvp](https://jax.readthedocs.io/en/latest/notebooks/Custom_derivative_rules_for_Python_code.html) ++ 您希望指定自定义梯度规则，类似于 JAX 的[custom_vjp/custom_jvp](https://jax.readthedocs.io/en/latest/notebooks/Custom_derivative_rules_for_Python_code.html) -PyTorch将这两个概念结合到[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")中。 +PyTorch 将这两个概念结合到`torch.autograd.Function`中。 ## 基本用法 -本指南假定您熟悉[扩展torch.autograd](extending.html#extending-autograd)，该指南解释了如何使用[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")。 +本指南假定您熟悉扩展 torch.autograd，该指南解释了如何使用`torch.autograd.Function`。 -[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")可以有一个接受ctx对象的[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")，或者可以有单独的不接受`ctx`的[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和一个修改`ctx`对象的`setup_context()`静态方法。 +`torch.autograd.Function`可以有一个接受 ctx 对象的`forward()`，或者可以有单独的不接受`ctx`的`forward()`和一个修改`ctx`对象的`setup_context()`静态方法。 只有后者支持函数转换： -+ [`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")是执行操作的代码，不应接受`ctx`对象。 ++ `forward()`是执行操作的代码，不应接受`ctx`对象。 + `setup_context(ctx, inputs, output)`是您可以在其中调用`ctx`上的方法的代码。在这里，您应该保存张量以进行反向传播（通过调用`ctx.save_for_backward(*tensors)`），或保存非张量（通过将它们分配给`ctx`对象）。 -因为`setup_context()`只接受`inputs`和`output`，所以只能保存输入或输出中的对象（如张量）或从中派生的量（如`Tensor.shape`）。如果您希望保存来自[`Function.forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")的非输入中间激活以进行反向传播，则需要将其作为输出从[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")返回，以便它传递给`setup_context()`。 +因为`setup_context()`只接受`inputs`和`output`，所以只能保存输入或输出中的对象（如张量）或从中派生的量（如`Tensor.shape`）。如果您希望保存来自`Function.forward()`的非输入中间激活以进行反向传播，则需要将其作为输出从`forward()`返回，以便它传递给`setup_context()`。 根据转换， -+ 要支持反向模式自动微分（[`torch.func.grad()`](../generated/torch.func.grad.html#torch.func.grad "torch.func.grad")、[`torch.func.vjp()`](../generated/torch.func.vjp.html#torch.func.vjp "torch.func.vjp"))，[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")需要一个[`backward()`](../generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")静态方法。 ++ 要支持反向模式自动微分（`torch.func.grad()`、`torch.func.vjp()`)，`torch.autograd.Function`需要一个`backward()`静态方法。 -+ 要支持[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")，[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")需要一个[`vmap()`](../generated/torch.autograd.Function.vmap.html#torch.autograd.Function.vmap "torch.autograd.Function.vmap")静态方法。 ++ 要支持`torch.vmap()`，`torch.autograd.Function`需要一个`vmap()`静态方法。 -+ 为了支持[`torch.func.jvp()`](../generated/torch.func.jvp.html#torch.func.jvp "torch.func.jvp")，[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")需要一个[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp") staticmethod。 ++ 为了支持`torch.func.jvp()`，`torch.autograd.Function`需要一个`jvp()` staticmethod。 -+ 支持变换的组合（例如[`torch.func.jacrev()`](../generated/torch.func.jacrev.html#torch.func.jacrev "torch.func.jacrev")，[`torch.func.jacfwd()`](../generated/torch.func.jacfwd.html#torch.func.jacfwd "torch.func.jacfwd")，[`torch.func.hessian()`](../generated/torch.func.hessian.html#torch.func.hessian "torch.func.hessian")) - 您可能需要上述多个。 ++ 支持变换的组合（例如`torch.func.jacrev()`，`torch.func.jacfwd()`，`torch.func.hessian()`) - 您可能需要上述多个。 -为了使[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")能够任意与函数变换组合，我们建议除了[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")和`setup_context()`之外的所有其他staticmethod必须是可转换的：也就是说，它们必须仅由PyTorch操作符组成或调用其他[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")（可能调用C++/CUDA等）。 +为了使`torch.autograd.Function`能够任意与函数变换组合，我们建议除了`forward()`和`setup_context()`之外的所有其他 staticmethod 必须是可转换的：也就是说，它们必须仅由 PyTorch 操作符组成或调用其他`torch.autograd.Function`（可能调用 C++/CUDA 等）。 让我们看一些常见用例的例子。 -### 示例1：autograd.Function调用另一个系统[](#example-1-autograd-function-calls-into-another-system "Permalink to this heading") +### 示例 1：autograd.Function 调用另一个系统[](#example-1-autograd-function-calls-into-another-system "Permalink to this heading") -一个常见情况是一个同时调用另一个系统（如C++，CUDA，numpy，triton）的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")，同时具有forward()和backward()。 +一个常见情况是一个同时调用另一个系统（如 C++，CUDA，numpy，triton）的`torch.autograd.Function`，同时具有 forward()和 backward()。 ```py import torch @@ -142,19 +142,19 @@ grad_x = torch.func.grad(lambda x: numpy_sort(x).sum())(x) assert torch.allclose(grad_x, torch.ones_like(x)) ``` -### 示例2：autograd.Function指定自定义梯度规则[](#example-2-autograd-function-specifies-custom-gradient-rules "Permalink to this heading") +### 示例 2：autograd.Function 指定自定义梯度规则[](#example-2-autograd-function-specifies-custom-gradient-rules "Permalink to this heading") -另一个常见情况是一个使用PyTorch操作实现的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")。PyTorch能够自动为PyTorch操作计算梯度，但也许我们希望自定义梯度的计算方式。我们可能希望自定义反向传递与PyTorch给出的不同的原因有： +另一个常见情况是一个使用 PyTorch 操作实现的`torch.autograd.Function`。PyTorch 能够自动为 PyTorch 操作计算梯度，但也许我们希望自定义梯度的计算方式。我们可能希望自定义反向传递与 PyTorch 给出的不同的原因有： + 提高数值稳定性 + 更改反向传递的性能特征 -+ 更改如何处理边缘情况（例如nans，inf） ++ 更改如何处理边缘情况（例如 nans，inf） + 修改梯度（例如梯度裁剪） -这里有一个关于函数`y = x ** 3`的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的示例，我们在其中改变了性能特征（一些在反向传递期间通常会发生的计算，计算dx，现在发生在正向传递中）。 +这里有一个关于函数`y = x ** 3`的`torch.autograd.Function`的示例，我们在其中改变了性能特征（一些在反向传递期间通常会发生的计算，计算 dx，现在发生在正向传递中）。 ```py class MyCube(torch.autograd.Function): @@ -202,31 +202,31 @@ assert torch.allclose(ggx, 6 * x) 警告 -请仔细阅读这些关于[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的限制与torch.func变换。我们无法捕捉许多这些情况并优雅地报错，因此它们将导致未定义的行为。 +请仔细阅读这些关于`torch.autograd.Function`的限制与 torch.func 变换。我们无法捕捉许多这些情况并优雅地报错，因此它们将导致未定义的行为。 -请不要在[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的方法中捕获正在转换的张量，这些张量具有requires_grad=True或是双重张量。完全安全的方法是确保[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的任何方法中使用的唯一张量必须直接作为输入（或通过ctx对象）传递，而不是来自[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")外部的。 +请不要在`torch.autograd.Function`的方法中捕获正在转换的张量，这些张量具有 requires_grad=True 或是双重张量。完全安全的方法是确保`torch.autograd.Function`的任何方法中使用的唯一张量必须直接作为输入（或通过 ctx 对象）传递，而不是来自`torch.autograd.Function`外部的。 -[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")不处理pytrees中的张量（可能包含或不包含张量的任意嵌套Python数据结构）。为了让这些张量被autograd跟踪，它们必须直接作为参数传递给[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")。这与jax.{custom_vjp, custom_jvp}相反，后者接受pytrees。 +`torch.autograd.Function`不处理 pytrees 中的张量（可能包含或不包含张量的任意嵌套 Python 数据结构）。为了让这些张量被 autograd 跟踪，它们必须直接作为参数传递给`torch.autograd.Function`。这与 jax.{custom_vjp, custom_jvp}相反，后者接受 pytrees。 -请只使用[`save_for_backward()`](../generated/torch.autograd.function.FunctionCtx.save_for_backward.html#torch.autograd.function.FunctionCtx.save_for_backward "torch.autograd.function.FunctionCtx.save_for_backward")或`save_for_forward()`来保存张量。请不要直接将张量或张量集合分配到ctx对象上 - 这些张量将不会被跟踪 +请只使用`save_for_backward()`或`save_for_forward()`来保存张量。请不要直接将张量或张量集合分配到 ctx 对象上 - 这些张量将不会被跟踪 -## [`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")支持[](#torch-vmap-support "Permalink to this heading") +## `torch.vmap()`支持[](#torch-vmap-support "Permalink to this heading") -要使用[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")与[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")，您必须： +要使用`torch.autograd.Function`与`torch.vmap()`，您必须： -+ 提供一个[`vmap()`](../generated/torch.autograd.Function.vmap.html#torch.autograd.Function.vmap "torch.autograd.Function.vmap")静态方法，告诉我们[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")在[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")下的行为 ++ 提供一个`vmap()`静态方法，告诉我们`torch.autograd.Function`在`torch.vmap()`下的行为 + 通过设置`generate_vmap_rule=True`来要求我们自动生成它。 -### 自动生成一个vmap规则[](#automatically-generate-a-vmap-rule "Permalink to this heading") +### 自动生成一个 vmap 规则[](#automatically-generate-a-vmap-rule "Permalink to this heading") -如果您的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")满足以下额外约束条件，则我们可以为其生成一个vmap规则。如果不满足约束条件或者希望在vmap下自定义行为，请手动定义一个vmap静态方法（请参见下一节）。 +如果您的`torch.autograd.Function`满足以下额外约束条件，则我们可以为其生成一个 vmap 规则。如果不满足约束条件或者希望在 vmap 下自定义行为，请手动定义一个 vmap 静态方法（请参见下一节）。 警告 我们无法轻松检查以下约束条件并优雅地报错。违反约束条件可能导致未定义的行为。 -+ [`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")、[`backward()`](../generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")（如果存在）和[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")（如果存在）静态方法必须通过[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")进行转换。也就是说，它们必须仅包含PyTorch操作（而不是例如NumPy或自定义CUDA内核）。 ++ `torch.autograd.Function`的`forward()`、`backward()`（如果存在）和`jvp()`（如果存在）静态方法必须通过`torch.vmap()`进行转换。也就是说，它们必须仅包含 PyTorch 操作（而不是例如 NumPy 或自定义 CUDA 内核）。 示例： @@ -263,29 +263,29 @@ result = torch.vmap(my_cube)(x) assert torch.allclose(result, x ** 3) ``` -### 定义vmap静态方法[](#defining-the-vmap-staticmethod "Permalink to this heading") +### 定义 vmap 静态方法[](#defining-the-vmap-staticmethod "Permalink to this heading") -如果您的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")调用另一个系统（如NumPy、C++、CUDA、triton），那么为了使其与[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")或使用它的转换一起工作，您需要手动定义一个[`vmap()`](../generated/torch.autograd.Function.vmap.html#torch.autograd.Function.vmap "torch.autograd.Function.vmap")静态方法。 +如果您的`torch.autograd.Function`调用另一个系统（如 NumPy、C++、CUDA、triton），那么为了使其与`torch.vmap()`或使用它的转换一起工作，您需要手动定义一个`vmap()`静态方法。 -根据您想要使用的转换和用例，您可能不需要为所有的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")添加一个[`vmap()`](../generated/torch.autograd.Function.vmap.html#torch.autograd.Function.vmap "torch.autograd.Function.vmap")静态方法： +根据您想要使用的转换和用例，您可能不需要为所有的`torch.autograd.Function`添加一个`vmap()`静态方法： -+ 例如，[`torch.func.jacrev()`](../generated/torch.func.jacrev.html#torch.func.jacrev "torch.func.jacrev")在反向传播中执行[`vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")。因此，如果您只对使用[`torch.func.jacrev()`](../generated/torch.func.jacrev.html#torch.func.jacrev "torch.func.jacrev")感兴趣，则只需要将[`backward()`](../generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")静态方法设置为可vmapped。 ++ 例如，`torch.func.jacrev()`在反向传播中执行`vmap()`。因此，如果您只对使用`torch.func.jacrev()`感兴趣，则只需要将`backward()`静态方法设置为可 vmapped。 -我们建议确保所有的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")都支持[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")，尤其是如果您正在编写第三方库，并且希望您的[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")能够与所有组合的[`torch.func()`](../func.api.html#module-torch.func "torch.func")转换一起使用。 +我们建议确保所有的`torch.autograd.Function`都支持`torch.vmap()`，尤其是如果您正在编写第三方库，并且希望您的`torch.autograd.Function`能够与所有组合的`torch.func()`转换一起使用。 -从概念上讲，vmap静态方法负责定义[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")在[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")下应该如何行为。也就是说，它定义了如何将[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")转换为在具有额外维度（正在被vmapped覆盖的维度）的输入上运行。这类似于PyTorch操作上实现[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")的方式：对于每个操作，我们定义一个vmap规则（有时也称为“批处理规则”）。 +从概念上讲，vmap 静态方法负责定义`forward()`在`torch.vmap()`下应该如何行为。也就是说，它定义了如何将`forward()`转换为在具有额外维度（正在被 vmapped 覆盖的维度）的输入上运行。这类似于 PyTorch 操作上实现`torch.vmap()`的方式：对于每个操作，我们定义一个 vmap 规则（有时也称为“批处理规则”）。 -这里是如何定义[`vmap()`](../generated/torch.autograd.Function.vmap.html#torch.autograd.Function.vmap "torch.autograd.Function.vmap")静态方法的： +这里是如何定义`vmap()`静态方法的： -+ 签名是`vmap(info, in_dims: Tuple[Optional[int]], *args)`，其中`*args`与[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")的参数相同。 ++ 签名是`vmap(info, in_dims: Tuple[Optional[int]], *args)`，其中`*args`与`forward()`的参数相同。 -+ vmap静态方法负责定义[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")在[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")下应该如何行为。也就是说，给定具有额外维度（由`in_dims`指定）的输入，我们如何计算[`forward()`](../generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")的批处理版本？ ++ vmap 静态方法负责定义`forward()`在`torch.vmap()`下应该如何行为。也就是说，给定具有额外维度（由`in_dims`指定）的输入，我们如何计算`forward()`的批处理版本？ -+ 对于`args`中的每个参数，`in_dims`都有一个相应的`Optional[int]`。如果参数不是张量或参数不是被vmapped覆盖的，则为`None`，否则，它是一个整数，指定正在被vmapped覆盖的张量的维度。 ++ 对于`args`中的每个参数，`in_dims`都有一个相应的`Optional[int]`。如果参数不是张量或参数不是被 vmapped 覆盖的，则为`None`，否则，它是一个整数，指定正在被 vmapped 覆盖的张量的维度。 -+ `info`是一组额外的元数据，可能会有所帮助：`info.batch_size`指定了正在进行vmapped的维度的大小，而`info.randomness`是传递给[`torch.vmap()`](../generated/torch.vmap.html#torch.vmap "torch.vmap")的`randomness`选项。 ++ `info`是一组额外的元数据，可能会有所帮助：`info.batch_size`指定了正在进行 vmapped 的维度的大小，而`info.randomness`是传递给`torch.vmap()`的`randomness`选项。 -+ vmap静态方法的返回值是一个元组`(output, out_dims)`。与`in_dims`类似，`out_dims`应该与`output`的结构相同，并且包含一个`out_dim`，指定输出是否具有vmapped维度以及其索引。 ++ vmap 静态方法的返回值是一个元组`(output, out_dims)`。与`in_dims`类似，`out_dims`应该与`output`的结构相同，并且包含一个`out_dim`，指定输出是否具有 vmapped 维度以及其索引。 示例： @@ -414,14 +414,14 @@ assert torch.allclose(result, numpy_sort(result, 1)) 注意 -vmap静态方法应该旨在保留整个[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")的语义。也就是说，（伪代码）`grad(vmap(MyFunc))`应该可以替换为`grad(map(MyFunc))`。 +vmap 静态方法应该旨在保留整个`Function`的语义。也就是说，（伪代码）`grad(vmap(MyFunc))`应该可以替换为`grad(map(MyFunc))`。 -如果您的autograd.Function在反向传播中具有任何自定义行为，请记住这一点。 +如果您的 autograd.Function 在反向传播中具有任何自定义行为，请记住这一点。 注意 -为一个PyTorch能够通过`generate_vmap_rule=True`生成vmap规则的[`Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")编写自定义vmap静态方法是一个合法的用例。如果生成的vmap规则不符合您的预期语义，您可能希望这样做。 +为一个 PyTorch 能够通过`generate_vmap_rule=True`生成 vmap 规则的`Function`编写自定义 vmap 静态方法是一个合法的用例。如果生成的 vmap 规则不符合您的预期语义，您可能希望这样做。 -## [`torch.func.jvp()`](../generated/torch.func.jvp.html#torch.func.jvp "torch.func.jvp") 支持 +## `torch.func.jvp()` 支持 -为了支持正向模式自动微分，一个[`torch.autograd.Function`](../autograd.html#torch.autograd.Function "torch.autograd.Function")必须有一个[`jvp()`](../generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp")静态方法。请参阅[正向模式自动微分](extending.html#forward-ad-autograd-function)获取详细信息。 +为了支持正向模式自动微分，一个`torch.autograd.Function`必须有一个`jvp()`静态方法。请参阅正向模式自动微分获取详细信息。 diff --git a/totrans/doc22_016.md b/totrans/doc22_016.md index 8f3a043c..fdb8c0b4 100644 --- a/totrans/doc22_016.md +++ b/totrans/doc22_016.md @@ -1,10 +1,10 @@ # 常见问题 -> 原文：[https://pytorch.org/docs/stable/notes/faq.html](https://pytorch.org/docs/stable/notes/faq.html) +> 原文：[`pytorch.org/docs/stable/notes/faq.html`](https://pytorch.org/docs/stable/notes/faq.html) -## 我的模型报告“cuda运行时错误(2)：内存不足”[](#my-model-reports-cuda-runtime-error-2-out-of-memory "跳转到此标题的永久链接") +## 我的模型报告“cuda 运行时错误(2)：内存不足”[](#my-model-reports-cuda-runtime-error-2-out-of-memory "跳转到此标题的永久链接") -正如错误消息所示，您的GPU上的内存已耗尽。由于我们在PyTorch中经常处理大量数据，小错误可能迅速导致程序使用完所有GPU的内存；幸运的是，在这些情况下修复通常很简单。以下是一些常见的检查事项： +正如错误消息所示，您的 GPU 上的内存已耗尽。由于我们在 PyTorch 中经常处理大量数据，小错误可能迅速导致程序使用完所有 GPU 的内存；幸运的是，在这些情况下修复通常很简单。以下是一些常见的检查事项： **不要在整个训练循环中积累历史。**默认情况下，涉及需要梯度的变量的计算将保留历史记录。这意味着您应该避免在超出训练循环的计算中使用这些变量，例如跟踪统计数据。相反，您应该分离变量或访问其基础数据。 @@ -21,11 +21,11 @@ for i in range(10000): total_loss += loss ``` -在这里，`total_loss`在整个训练循环中积累历史，因为`loss`是一个具有自动求导历史的可微变量。您可以通过编写total_loss += float(loss)来修复这个问题。 +在这里，`total_loss`在整个训练循环中积累历史，因为`loss`是一个具有自动求导历史的可微变量。您可以通过编写 total_loss += float(loss)来修复这个问题。 此问题的其他实例：[1](https://discuss.pytorch.org/t/resolved-gpu-out-of-memory-error-with-batch-size-1/3719)。 -**不要保留不需要的张量和变量。**如果将Tensor或Variable分配给本地变量，Python将不会释放，直到本地变量超出作用域。您可以通过使用`del x`来释放此引用。同样，如果将Tensor或Variable分配给对象的成员变量，直到对象超出作用域，它将不会释放。如果不保留不需要的临时变量，您将获得最佳的内存使用情况。 +**不要保留不需要的张量和变量。**如果将 Tensor 或 Variable 分配给本地变量，Python 将不会释放，直到本地变量超出作用域。您可以通过使用`del x`来释放此引用。同样，如果将 Tensor 或 Variable 分配给对象的成员变量，直到对象超出作用域，它将不会释放。如果不保留不需要的临时变量，您将获得最佳的内存使用情况。 本地变量的作用域可能比您预期的要大。例如： @@ -39,19 +39,19 @@ return output 在这里，`intermediate`即使在`h`执行时仍然存在，因为其作用域延伸到循环结束之后。为了更早释放它，您应该在完成后`del intermediate`。 -**避免在太大的序列上运行RNN。**通过RNN进行反向传播所需的内存量与RNN输入的长度成线性关系；因此，如果尝试向RNN提供太长的序列，将会耗尽内存。 +**避免在太大的序列上运行 RNN。**通过 RNN 进行反向传播所需的内存量与 RNN 输入的长度成线性关系；因此，如果尝试向 RNN 提供太长的序列，将会耗尽内存。 -这种现象的技术术语是[时间反向传播](https://en.wikipedia.org/wiki/Backpropagation_through_time)，有很多关于如何实现截断BPTT的参考资料，包括在[word语言模型](https://github.com/pytorch/examples/tree/master/word_language_model)示例中；截断由`repackage`函数处理，如[this forum post](https://discuss.pytorch.org/t/help-clarifying-repackage-hidden-in-word-language-model/226)中所述。 +这种现象的技术术语是[时间反向传播](https://en.wikipedia.org/wiki/Backpropagation_through_time)，有很多关于如何实现截断 BPTT 的参考资料，包括在[word 语言模型](https://github.com/pytorch/examples/tree/master/word_language_model)示例中；截断由`repackage`函数处理，如[this forum post](https://discuss.pytorch.org/t/help-clarifying-repackage-hidden-in-word-language-model/226)中所述。 **不要使用太大的线性层。**线性层`nn.Linear(m, n)`使用$O(nm)$O(nm)内存：也就是说，权重的内存需求与特征数量呈二次比例。通过这种方式很容易[耗尽内存](https://github.com/pytorch/pytorch/issues/958)（请记住，您至少需要两倍于权重大小的内存，因为您还需要存储梯度）。 **考虑使用检查点。**您可以通过使用[checkpoint](https://pytorch.org/docs/stable/checkpoint.html)来在内存和计算之间进行权衡。 -## 我的GPU内存没有正确释放[](#my-gpu-memory-isn-t-freed-properly "跳转到此标题的永久链接") +## 我的 GPU 内存没有正确释放[](#my-gpu-memory-isn-t-freed-properly "跳转到此标题的永久链接") -PyTorch使用缓存内存分配器来加速内存分配。因此，`nvidia-smi`中显示的值通常不反映真实的内存使用情况。有关GPU内存管理的更多详细信息，请参见[内存管理](cuda.html#cuda-memory-management)。 +PyTorch 使用缓存内存分配器来加速内存分配。因此，`nvidia-smi`中显示的值通常不反映真实的内存使用情况。有关 GPU 内存管理的更多详细信息，请参见内存管理。 -如果即使在Python退出后GPU内存仍未释放，很可能仍有一些Python子进程在运行。您可以通过`ps -elf | grep python`找到它们，并使用`kill -9 [pid]`手动杀死它们。 +如果即使在 Python 退出后 GPU 内存仍未释放，很可能仍有一些 Python 子进程在运行。您可以通过`ps -elf | grep python`找到它们，并使用`kill -9 [pid]`手动杀死它们。 ## 我的内存不足异常处理程序无法分配内存[](#my-out-of-memory-exception-handler-can-t-allocate-memory "跳转到此标题") @@ -65,7 +65,7 @@ except RuntimeError: # Out of memory run_model(1) ``` -但是发现当内存不足时，您的恢复代码也无法分配。这是因为Python异常对象保留了引用到引发错误的堆栈帧。这会阻止原始张量对象被释放。解决方案是将OOM恢复代码移出`except`子句。 +但是发现当内存不足时，您的恢复代码也无法分配。这是因为 Python 异常对象保留了引用到引发错误的堆栈帧。这会阻止原始张量对象被释放。解决方案是将 OOM 恢复代码移出`except`子句。 ```py oom = False @@ -81,9 +81,9 @@ if oom: ## 我的数据加载器工作程序返回相同的随机数[](#my-data-loader-workers-return-identical-random-numbers "跳转到此标题") -您可能正在使用其他库在数据集中生成随机数，并且工作程序子进程是通过`fork`启动的。请查看[`torch.utils.data.DataLoader`](../data.html#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的文档，了解如何使用其`worker_init_fn`选项正确设置工作程序中的随机种子。## 我的循环网络无法与数据并行性一起工作[](#my-recurrent-network-doesn-t-work-with-data-parallelism "跳转到此标题") +您可能正在使用其他库在数据集中生成随机数，并且工作程序子进程是通过`fork`启动的。请查看`torch.utils.data.DataLoader`的文档，了解如何使用其`worker_init_fn`选项正确设置工作程序中的随机种子。## 我的循环网络无法与数据并行性一起工作[](#my-recurrent-network-doesn-t-work-with-data-parallelism "跳转到此标题") -在使用[`Module`](../generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")与[`DataParallel`](../generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel")或[`data_parallel()`](../nn.html#module-torch.nn.parallel.data_parallel "torch.nn.parallel.data_parallel")时，使用`pack sequence -> recurrent network -> unpack sequence`模式存在一个微妙之处。每个设备上的`forward()`的输入只会是整个输入的一部分。因为解包操作[`torch.nn.utils.rnn.pad_packed_sequence()`](../generated/torch.nn.utils.rnn.pad_packed_sequence.html#torch.nn.utils.rnn.pad_packed_sequence "torch.nn.utils.rnn.pad_packed_sequence")默认只填充到它看到的最长输入，即该特定设备上的最长输入，当结果被收集在一起时会发生大小不匹配。因此，您可以利用[`pad_packed_sequence()`](../generated/torch.nn.utils.rnn.pad_packed_sequence.html#torch.nn.utils.rnn.pad_packed_sequence "torch.nn.utils.rnn.pad_packed_sequence")的`total_length`参数，以确保`forward()`调用返回相同长度的序列。例如，您可以编写： +在使用`Module`与`DataParallel`或`data_parallel()`时，使用`pack sequence -> recurrent network -> unpack sequence`模式存在一个微妙之处。每个设备上的`forward()`的输入只会是整个输入的一部分。因为解包操作`torch.nn.utils.rnn.pad_packed_sequence()`默认只填充到它看到的最长输入，即该特定设备上的最长输入，当结果被收集在一起时会发生大小不匹配。因此，您可以利用`pad_packed_sequence()`的`total_length`参数，以确保`forward()`调用返回相同长度的序列。例如，您可以编写： ```py from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence diff --git a/totrans/doc22_017.md b/totrans/doc22_017.md index 33f436e5..b03bc1c9 100644 --- a/totrans/doc22_017.md +++ b/totrans/doc22_017.md @@ -1,14 +1,14 @@ -# Gradcheck机制 +# Gradcheck 机制 -> [https://pytorch.org/docs/stable/notes/gradcheck.html](https://pytorch.org/docs/stable/notes/gradcheck.html) +> [`pytorch.org/docs/stable/notes/gradcheck.html`](https://pytorch.org/docs/stable/notes/gradcheck.html) -本说明概述了[`gradcheck()`](../autograd.html#module-torch.autograd.gradcheck)和`gradgradcheck()`函数的工作原理。 +本说明概述了`gradcheck()`和`gradgradcheck()`函数的工作原理。 -它将涵盖实数和复数值函数的前向和反向模式AD，以及高阶导数。本说明还涵盖了gradcheck的默认行为以及传递`fast_mode=True`参数的情况（以下简称为快速gradcheck）。 +它将涵盖实数和复数值函数的前向和反向模式 AD，以及高阶导数。本说明还涵盖了 gradcheck 的默认行为以及传递`fast_mode=True`参数的情况（以下简称为快速 gradcheck）。 + [符号和背景信息] -+ [默认的反向模式gradcheck行为] ++ [默认的反向模式 gradcheck 行为] + [实数到实数函数] @@ -16,15 +16,15 @@ + [具有复数输出的函数] -+ [快速反向模式gradcheck] ++ [快速反向模式 gradcheck] - + [实数到实数函数的快速gradcheck] + + [实数到实数函数的快速 gradcheck] - + [复数到实数函数的快速gradcheck] + + [复数到实数函数的快速 gradcheck] - + [具有复数输出的函数的快速gradcheck] + + [具有复数输出的函数的快速 gradcheck] -+ [Gradgradcheck实现] ++ [Gradgradcheck 实现] ## [符号和背景信息] @@ -38,23 +38,23 @@ 1. $g: \mathcal{C}^N \to \mathcal{R}^M$是我们的基本复数到实数函数，使得$y = g(z)$。 -对于简单的实数到实数情况，我们将与$f$相关的雅可比矩阵记为$J_f$，大小为$M \times N$。这个矩阵包含所有偏导数，使得位置$(i, j)$处的条目包含$\frac{\partial y_i}{\partial x_j}$。然后，反向模式AD计算给定大小为$M$的向量$v$的数量$v^T J_f$。另一方面，前向模式AD计算给定大小为$N$的向量$u$的数量$J_f u$。 +对于简单的实数到实数情况，我们将与$f$相关的雅可比矩阵记为$J_f$，大小为$M \times N$。这个矩阵包含所有偏导数，使得位置$(i, j)$处的条目包含$\frac{\partial y_i}{\partial x_j}$。然后，反向模式 AD 计算给定大小为$M$的向量$v$的数量$v^T J_f$。另一方面，前向模式 AD 计算给定大小为$N$的向量$u$的数量$J_f u$。 -对于包含复数值的函数，情况要复杂得多。我们这里只提供概要，完整描述可以在[复数数值的Autograd](autograd.html#complex-autograd-doc)中找到。 +对于包含复数值的函数，情况要复杂得多。我们这里只提供概要，完整描述可以在复数数值的 Autograd 中找到。 -满足复数可微性（柯西-黎曼方程）的约束对于所有实值损失函数来说太过严格，因此我们选择使用Wirtinger微积分。在Wirtinger微积分的基本设置中，链式法则要求同时访问Wirtinger导数（以下称为$W$）和共轭Wirtinger导数（以下称为$CW$）。由于一般情况下，尽管它们的名称如此，但$W$和$CW$都需要传播，因为它们不是彼此的复共轭。 +满足复数可微性（柯西-黎曼方程）的约束对于所有实值损失函数来说太过严格，因此我们选择使用 Wirtinger 微积分。在 Wirtinger 微积分的基本设置中，链式法则要求同时访问 Wirtinger 导数（以下称为$W$）和共轭 Wirtinger 导数（以下称为$CW$）。由于一般情况下，尽管它们的名称如此，但$W$和$CW$都需要传播，因为它们不是彼此的复共轭。 -为了避免传播两个值，对于反向模式AD，我们总是假设正在计算导数的函数要么是实值函数，要么是更大的实值函数的一部分。这个假设意味着我们在反向传递过程中计算的所有中间梯度也与实值函数相关联。在实践中，当进行优化时，这个假设并不具限制性，因为这样的问题需要实值目标（复数之间没有自然的排序）。 +为了避免传播两个值，对于反向模式 AD，我们总是假设正在计算导数的函数要么是实值函数，要么是更大的实值函数的一部分。这个假设意味着我们在反向传递过程中计算的所有中间梯度也与实值函数相关联。在实践中，当进行优化时，这个假设并不具限制性，因为这样的问题需要实值目标（复数之间没有自然的排序）。 -在这种假设下，使用$W$和$CW$的定义，我们可以展示$W = CW^*$，因此只需要“通过图形向后传递”两个值中的一个，另一个可以轻松恢复。为了简化内部计算，PyTorch使用$2 * CW$作为向后传递和用户请求梯度时返回的值。类似于实数情况，当输出实际上在$\mathcal{R}^M$时，反向模式AD不会计算$2 * CW$，而只会计算$v^T (2 * CW)$，其中$v \in \mathcal{R}^M$。 +在这种假设下，使用$W$和$CW$的定义，我们可以展示$W = CW^*$，因此只需要“通过图形向后传递”两个值中的一个，另一个可以轻松恢复。为了简化内部计算，PyTorch 使用$2 * CW$作为向后传递和用户请求梯度时返回的值。类似于实数情况，当输出实际上在$\mathcal{R}^M$时，反向模式 AD 不会计算$2 * CW$，而只会计算$v^T (2 * CW)$，其中$v \in \mathcal{R}^M$。 -对于前向模式AD，我们使用类似的逻辑，假设函数是更大函数的一部分，其输入在$\mathcal{R}$中。在这种假设下，我们可以做出类似的声明，即每个中间结果对应于一个输入在$\mathcal{R}$中的函数，并且在这种情况下，使用$W$和$CW$的定义，我们可以展示中间函数的$W = CW$。为了确保前向和后向模式在一维函数的基本情况下计算相同的量，前向模式还计算$2 * CW$。类似于实数情况，当输入实际上在$\mathcal{R}^N$时，前向模式AD不会计算$2 * CW$，而只会计算$(2 * CW) u$，其中$u \in \mathcal{R}^N$。 +对于前向模式 AD，我们使用类似的逻辑，假设函数是更大函数的一部分，其输入在$\mathcal{R}$中。在这种假设下，我们可以做出类似的声明，即每个中间结果对应于一个输入在$\mathcal{R}$中的函数，并且在这种情况下，使用$W$和$CW$的定义，我们可以展示中间函数的$W = CW$。为了确保前向和后向模式在一维函数的基本情况下计算相同的量，前向模式还计算$2 * CW$。类似于实数情况，当输入实际上在$\mathcal{R}^N$时，前向模式 AD 不会计算$2 * CW$，而只会计算$(2 * CW) u$，其中$u \in \mathcal{R}^N$。 -## [默认反向模式gradcheck行为](#id3) +## 默认反向模式 gradcheck 行为 -### [实数到实数函数](#id4) +### 实数到实数函数 -为了测试一个函数$f: \mathcal{R}^N \to \mathcal{R}^M, x \to y$，我们以两种方式重建大小为$M \times N$的完整雅可比矩阵$J_f$：分析和数值。分析版本使用我们的反向模式AD，而数值版本使用有限差分。然后，逐个元素比较这两个重建的雅可比矩阵是否相等。 +为了测试一个函数$f: \mathcal{R}^N \to \mathcal{R}^M, x \to y$，我们以两种方式重建大小为$M \times N$的完整雅可比矩阵$J_f$：分析和数值。分析版本使用我们的反向模式 AD，而数值版本使用有限差分。然后，逐个元素比较这两个重建的雅可比矩阵是否相等。 #### 默认实数输入数值评估 @@ -68,11 +68,11 @@ $\frac{\partial y}{\partial x} \approx \frac{f(x + eps) - f(x - eps)}{2 * eps}$ #### 默认实数输入分析评估 -对于分析评估，我们使用如上所述的事实，即反向模式AD计算$v^T J_f$。对于具有单个输出的函数，我们简单地使用$v = 1$来通过单个反向传递恢复完整的雅可比矩阵。 +对于分析评估，我们使用如上所述的事实，即反向模式 AD 计算$v^T J_f$。对于具有单个输出的函数，我们简单地使用$v = 1$来通过单个反向传递恢复完整的雅可比矩阵。 -对于具有多个输出的函数，我们使用一个for循环，迭代输出，其中每个$v$是一个依次对应于每个输出的one-hot向量。这样可以逐行重建$J_f$矩阵。 +对于具有多个输出的函数，我们使用一个 for 循环，迭代输出，其中每个$v$是一个依次对应于每个输出的 one-hot 向量。这样可以逐行重建$J_f$矩阵。 -### [复数到实数函数](#id5) +### 复数到实数函数 为了测试一个函数 $g: \mathcal{C}^N \to \mathcal{R}^M, z \to y$，其中 $z = a + i b$，我们重建包含 $2 * CW$ 的（复数值）矩阵。 @@ -107,7 +107,7 @@ d[d_idx] = grad_out.conjugate() * conj_w_d + grad_out * w_d.conj() 由于反向模式 AD 已经精确计算了两倍的 $CW$ 导数，因此我们在这里与实数到实数情况一样使用相同的技巧，并在有多个实数输出时逐行重建矩阵。 -### [具有复数输出的函数](#id6) +### 具有复数输出的函数 在这种情况下，用户提供的函数不符合自动微分的假设，即我们为其计算反向 AD 的函数是实值的。这意味着直接在这个函数上使用自动微分是不明确定义的。为了解决这个问题，我们将测试函数 $h: \mathcal{P}^N \to \mathcal{C}^M$（其中 $\mathcal{P}$ 可以是 $\mathcal{R}$ 或 $\mathcal{C}$）替换为两个函数：$hr$ 和 $hi$，使得： @@ -117,13 +117,13 @@ $\begin{aligned} hr(q) &:= real(f(q)) \\ hi(q) &:= imag(f(q)) \end{aligned}$ 请注意，截至撰写时，代码并没有显式创建这些函数，而是通过将 $\text{grad\_out}$ 参数传递给不同的函数，手动使用 $real$ 或 $imag$ 函数执行链式规则。当 $\text{grad\_out} = 1$ 时，我们考虑 $hr$。当 $\text{grad\_out} = 1j$ 时，我们考虑 $hi$。 -## [快速反向模式梯度检查](#id7) +## 快速反向模式梯度检查 尽管上述梯度检查的公式很好，为了确保正确性和可调试性，它非常慢，因为它重建了完整的雅可比矩阵。本节介绍了一种以更快的方式执行梯度检查的方法，而不影响其正确性。通过在检测到错误时添加特殊逻辑，可以恢复可调试性。在这种情况下，我们可以运行重建完整矩阵的默认版本，以向用户提供完整的细节。 这里的高级策略是找到一个标量量，可以通过数值和解析方法高效计算，并且能够很好地代表慢梯度检查计算的完整矩阵，以确保它能够捕捉雅可比矩阵中的任何差异。 -### [实数到实数函数的快速梯度检查](#id8) +### 实数到实数函数的快速梯度检查 我们想要计算的标量量是给定随机向量 $v \in \mathcal{R}^M$ 和随机单位范数向量 $u \in \mathcal{R}^N$ 时的 $v^T J_f u$。 @@ -157,7 +157,7 @@ $\begin{aligned} s &= 2 * v^T (real(CW) ur + i * imag(CW) ui) \\ &= 2 * v^T (\fr 对于分析情况，事情更简单，我们将公式重写为： -[复杂到实数函数的快速梯度检查](#id9) +复杂到实数函数的快速梯度检查 因此，我们可以利用反向模式自动微分提供的有效方法来计算$v^T (2 * CW)$，然后在重建最终复数标量$s$之前，将实部与$ur$和虚部与$ui$进行点积。 @@ -169,11 +169,11 @@ $\begin{aligned} 2*CW u' &= (\frac{\partial y}{\partial a} + i \frac{\partial y} 这将需要四次实数到实数有限差分的评估（与上述方法相比多两倍）。由于这种方法没有更多的自由度（相同数量的实值变量），我们尝试在这里获得最快的评估，因此使用上述的另一种公式。 -### [对于具有复杂输出的函数的快速 gradcheck](#id10)[](#fast-gradcheck-for-functions-with-complex-outputs "跳转到本标题") +### 对于具有复杂输出的函数的快速 gradcheck[](#fast-gradcheck-for-functions-with-complex-outputs "跳转到本标题") 就像在慢速情况下一样，我们考虑两个实值函数，并对每个函数使用上面的适当规则。 -## [Gradgradcheck 实现](#id11)[](#gradgradcheck-implementation "跳转到本标题") +## Gradgradcheck 实现[](#gradgradcheck-implementation "跳转到本标题") PyTorch 还提供了一个工具来验证二阶梯度。这里的目标是确保反向实现也是正确可微的，并计算正确的结果。 diff --git a/totrans/doc22_018.md b/totrans/doc22_018.md index ad7fe935..6f984d63 100644 --- a/totrans/doc22_018.md +++ b/totrans/doc22_018.md @@ -1,14 +1,14 @@ # HIP（ROCm）语义 -> 原文：[https://pytorch.org/docs/stable/notes/hip.html](https://pytorch.org/docs/stable/notes/hip.html) +> 原文：[`pytorch.org/docs/stable/notes/hip.html`](https://pytorch.org/docs/stable/notes/hip.html) -ROCm™是AMD的开源软件平台，用于GPU加速的高性能计算和机器学习。HIP是ROCm的C++方言，旨在简化将CUDA应用程序转换为可移植的C++代码。在将现有CUDA应用程序（如PyTorch）转换为可移植的C++以及需要在AMD和NVIDIA之间实现可移植性的新项目中使用HIP。 +ROCm™是 AMD 的开源软件平台，用于 GPU 加速的高性能计算和机器学习。HIP 是 ROCm 的 C++方言，旨在简化将 CUDA 应用程序转换为可移植的 C++代码。在将现有 CUDA 应用程序（如 PyTorch）转换为可移植的 C++以及需要在 AMD 和 NVIDIA 之间实现可移植性的新项目中使用 HIP。 -## HIP接口重用CUDA接口 +## HIP 接口重用 CUDA 接口 -PyTorch for HIP有意重用现有的[`torch.cuda`](../cuda.html#module-torch.cuda)接口。这有助于加速现有PyTorch代码和模型的移植，因为几乎不需要进行任何代码更改。 +PyTorch for HIP 有意重用现有的`torch.cuda`接口。这有助于加速现有 PyTorch 代码和模型的移植，因为几乎不需要进行任何代码更改。 -来自[CUDA语义](cuda.html#cuda-semantics)的示例将在HIP上完全相同： +来自 CUDA 语义的示例将在 HIP 上完全相同： ```py cuda = torch.device('cuda') # Default HIP device @@ -44,30 +44,30 @@ with torch.cuda.device(1): e = torch.randn(2).to(cuda2) f = torch.randn(2).cuda(cuda2) # d.device, e.device, and f.device are all device(type='cuda', index=2) -```## 检查HIP +```## 检查 HIP -无论您是在CUDA还是HIP上使用PyTorch，调用[`is_available()`](../generated/torch.cuda.is_available.html#torch.cuda.is_available)的结果都将是相同的。如果您使用已构建有GPU支持的PyTorch，它将返回True。如果您必须检查正在使用的PyTorch版本，请参考下面的示例： +无论您是在 CUDA 还是 HIP 上使用 PyTorch，调用`is_available()`的结果都将是相同的。如果您使用已构建有 GPU 支持的 PyTorch，它将返回 True。如果您必须检查正在使用的 PyTorch 版本，请参考下面的示例： ```py if torch.cuda.is_available() and torch.version.hip: # do something specific for HIP elif torch.cuda.is_available() and torch.version.cuda: # do something specific for CUDA -```## ROCm上的TensorFloat-32(TF32) +```## ROCm 上的 TensorFloat-32(TF32) -ROCm上不支持TF32。## 内存管理 +ROCm 上不支持 TF32。## 内存管理 -PyTorch使用缓存内存分配器来加速内存分配。这允许快速的内存释放而无需设备同步。然而，分配器管理的未使用内存仍会显示为在`rocm-smi`中使用。您可以使用[`memory_allocated()`](../generated/torch.cuda.memory_allocated.html#torch.cuda.memory_allocated)和[`max_memory_allocated()`](../generated/torch.cuda.max_memory_allocated.html#torch.cuda.max_memory_allocated)来监视张量占用的内存，并使用[`memory_reserved()`](../generated/torch.cuda.memory_reserved.html#torch.cuda.memory_reserved)和[`max_memory_reserved()`](../generated/torch.cuda.max_memory_reserved.html#torch.cuda.max_memory_reserved)来监视缓存分配器管理的总内存量。调用[`empty_cache()`](../generated/torch.cuda.empty_cache.html#torch.cuda.empty_cache)会释放PyTorch中所有**未使用**的缓存内存，以便其他GPU应用程序可以使用。然而，张量占用的GPU内存不会被释放，因此不能增加供PyTorch使用的GPU内存量。 +PyTorch 使用缓存内存分配器来加速内存分配。这允许快速的内存释放而无需设备同步。然而，分配器管理的未使用内存仍会显示为在`rocm-smi`中使用。您可以使用`memory_allocated()`和`max_memory_allocated()`来监视张量占用的内存，并使用`memory_reserved()`和`max_memory_reserved()`来监视缓存分配器管理的总内存量。调用`empty_cache()`会释放 PyTorch 中所有**未使用**的缓存内存，以便其他 GPU 应用程序可以使用。然而，张量占用的 GPU 内存不会被释放，因此不能增加供 PyTorch 使用的 GPU 内存量。 -对于更高级的用户，我们通过[`memory_stats()`](../generated/torch.cuda.memory_stats.html#torch.cuda.memory_stats)提供更全面的内存基准测试。我们还提供通过[`memory_snapshot()`](../generated/torch.cuda.memory_snapshot.html#torch.cuda.memory_snapshot)捕获内存分配器状态的完整快照的能力，这可以帮助您了解代码产生的底层分配模式。 +对于更高级的用户，我们通过`memory_stats()`提供更全面的内存基准测试。我们还提供通过`memory_snapshot()`捕获内存分配器状态的完整快照的能力，这可以帮助您了解代码产生的底层分配模式。 -要调试内存错误，请在环境中设置`PYTORCH_NO_CUDA_MEMORY_CACHING=1`以禁用缓存。## hipFFT/rocFFT计划缓存 +要调试内存错误，请在环境中设置`PYTORCH_NO_CUDA_MEMORY_CACHING=1`以禁用缓存。## hipFFT/rocFFT 计划缓存 -不支持设置hipFFT/rocFFT计划的缓存大小。## torch.distributed后端 +不支持设置 hipFFT/rocFFT 计划的缓存大小。## torch.distributed 后端 -目前，仅支持“nccl”和“gloo”后端的torch.distributed在ROCm上。## C++中的CUDA API到HIP API映射 +目前，仅支持“nccl”和“gloo”后端的 torch.distributed 在 ROCm 上。## C++中的 CUDA API 到 HIP API 映射 -请参考：[https://rocmdocs.amd.com/en/latest/Programming_Guides/HIP_API_Guide.html](https://rocmdocs.amd.com/en/latest/Programming_Guides/HIP_API_Guide.html) +请参考：[`rocmdocs.amd.com/en/latest/Programming_Guides/HIP_API_Guide.html`](https://rocmdocs.amd.com/en/latest/Programming_Guides/HIP_API_Guide.html) 注意：CUDA_VERSION 宏、cudaRuntimeGetVersion 和 cudaDriverGetVersion API 的语义映射与 HIP_VERSION 宏、hipRuntimeGetVersion 和 hipDriverGetVersion API 的值不同。在进行版本检查时，请不要混用它们。 @@ -89,7 +89,7 @@ PyTorch使用缓存内存分配器来加速内存分配。这允许快速的内 ## 参考 CUDA 语义文档[](#refer-to-cuda-semantics-doc "跳转到此标题") -对于此处未列出的任何部分，请参考 CUDA 语义文档：[CUDA 语义](cuda.html#cuda-semantics) +对于此处未列出的任何部分，请参考 CUDA 语义文档：CUDA 语义 ## 启用内核断言 diff --git a/totrans/doc22_019.md b/totrans/doc22_019.md index 0d032cb3..b3f0b15a 100644 --- a/totrans/doc22_019.md +++ b/totrans/doc22_019.md @@ -1,26 +1,26 @@ # 大规模部署的功能 -> 原文：[https://pytorch.org/docs/stable/notes/large_scale_deployments.html](https://pytorch.org/docs/stable/notes/large_scale_deployments.html) +> 原文：[`pytorch.org/docs/stable/notes/large_scale_deployments.html`](https://pytorch.org/docs/stable/notes/large_scale_deployments.html) -+ [全局操作符分析](#fleet-wide-operator-profiling) ++ 全局操作符分析 -+ [API 使用日志记录](#api-usage-logging) ++ API 使用日志记录 -+ [将元数据附加到保存的 TorchScript 模型](#attaching-metadata-to-saved-torchscript-models) ++ 将元数据附加到保存的 TorchScript 模型 -+ [构建环境注意事项](#build-environment-considerations) ++ 构建环境注意事项 -+ [常见扩展点](#common-extension-points) ++ 常见扩展点 本说明介绍了在更大系统中运行 PyTorch 或在更大组织中操作使用 PyTorch 的多个系统时可能有用的几个扩展点和技巧。 -这并不涵盖将模型部署到生产环境的主题。请查看 [`torch.jit`](../jit.html#module-torch.jit "torch.jit") 或其中一个相应的教程。 +这并不涵盖将模型部署到生产环境的主题。请查看 `torch.jit` 或其中一个相应的教程。 该说明假定您要么在组织中从源代码构建 PyTorch，要么具有在 PyTorch 使用时加载附加代码的静态链接能力。因此，许多钩子都公开为可以在集中位置触发一次的 C++ API，例如在静态初始化代码中。 -## [全局操作符分析](#id1)[](#fleet-wide-operator-profiling "跳转到此标题") +## 全局操作符分析[](#fleet-wide-operator-profiling "跳转到此标题") -PyTorch 自带 [`torch.autograd.profiler`](../autograd.html#module-torch.autograd.profiler "torch.autograd.profiler")，能够按需测量各个操作符所花费的时间。可以使用相同的机制对运行 PyTorch 的任何进程进行“始终开启”测量。这对于收集在给定进程或整个机器集上运行的 PyTorch 工作负载信息可能很有用。 +PyTorch 自带 `torch.autograd.profiler`，能够按需测量各个操作符所花费的时间。可以使用相同的机制对运行 PyTorch 的任何进程进行“始终开启”测量。这对于收集在给定进程或整个机器集上运行的 PyTorch 工作负载信息可能很有用。 可以使用 `torch::addGlobalCallback` 为任何操作符调用添加新的回调。钩子将使用描述调用上下文（例如名称）的 `torch::RecordFunction` 结构进行调用。如果启用，`RecordFunction::inputs()` 包含作为 `torch::IValue` 变体类型表示的函数参数。请注意，输入日志记录相对昂贵，因此必须显式启用。 @@ -57,7 +57,7 @@ void onFunctionExit(const RecordFunction& fn) { } ``` -## [API 使用日志记录](#id2) +## API 使用日志记录 在更广泛的生态系统中运行时，例如在托管作业调度程序中，跟踪调用特定 PyTorch API 的二进制文件通常很有用。在几个重要的 API 点注入了简单的仪器，触发给定的回调。因为通常 PyTorch 在一次性的 Python 脚本中被调用，所以对于每个 API，回调只会在给定进程中触发一次。 @@ -71,13 +71,13 @@ SetAPIUsageLogger([](const std::string& event_name) { 开发者注意：可以在 C++ 代码中使用 `C10_LOG_API_USAGE_ONCE("my_api")` 或在 Python 中使用 `torch._C._log_api_usage_once("my.api")` 来添加新的 API 触发点。 -## [将元数据附加到保存的TorchScript模型](#id3)[](#attaching-metadata-to-saved-torchscript-models "跳转到此标题") +## 将元数据附加到保存的 TorchScript 模型[](#attaching-metadata-to-saved-torchscript-models "跳转到此标题") -TorchScript模块可以保存为捆绑序列化参数和模块代码的存档文件，作为TorchScript（参见[`torch.jit.save()`](../generated/torch.jit.save.html#torch.jit.save "torch.jit.save")）。通常方便将附加信息与模型一起捆绑，例如，模型生产者的描述或辅助工件。 +TorchScript 模块可以保存为捆绑序列化参数和模块代码的存档文件，作为 TorchScript（参见`torch.jit.save()`）。通常方便将附加信息与模型一起捆绑，例如，模型生产者的描述或辅助工件。 -可以通过将`_extra_files`参数传递给[`torch.jit.save()`](../generated/torch.jit.save.html#torch.jit.save "torch.jit.save")和`torch::jit::load`来在保存过程中存储和检索任意二进制数据块。由于TorchScript文件是常规ZIP存档，额外信息被存储为存档的`extra/`目录中的常规文件。 +可以通过将`_extra_files`参数传递给`torch.jit.save()`和`torch::jit::load`来在保存过程中存储和检索任意二进制数据块。由于 TorchScript 文件是常规 ZIP 存档，额外信息被存储为存档的`extra/`目录中的常规文件。 -还有一个全局钩子，允许在当前进程中的任何TorchScript存档上附加额外文件。类似于数字相机生成的JPEG元数据，可能有助于使用生产者元数据标记模型。示例用法可能如下： +还有一个全局钩子，允许在当前进程中的任何 TorchScript 存档上附加额外文件。类似于数字相机生成的 JPEG 元数据，可能有助于使用生产者元数据标记模型。示例用法可能如下： ```py SetExportModuleExtraFilesHook([](const Module&) { @@ -87,14 +87,14 @@ SetExportModuleExtraFilesHook([](const Module&) { }); ``` -## [构建环境考虑](#id4)[](#build-environment-considerations "跳转到此标题") +## 构建环境考虑[](#build-environment-considerations "跳转到此标题") -TorchScript的编译需要访问原始的Python文件，因为它使用Python的`inspect.getsource`调用。在某些生产环境中，可能需要显式部署`.py`文件以及预编译的`.pyc`文件。 +TorchScript 的编译需要访问原始的 Python 文件，因为它使用 Python 的`inspect.getsource`调用。在某些生产环境中，可能需要显式部署`.py`文件以及预编译的`.pyc`文件。 -## [常见扩展点](#id5)[](#common-extension-points "跳转到此标题") +## 常见扩展点[](#common-extension-points "跳转到此标题") -PyTorch的API通常松散耦合，很容易用专门版本替换组件。常见的扩展点包括： +PyTorch 的 API 通常松散耦合，很容易用专门版本替换组件。常见的扩展点包括： -+ 在C++中实现的自定义运算符 - 详细信息请参阅[教程](https://pytorch.org/tutorials/advanced/cpp_extension.html)。 ++ 在 C++中实现的自定义运算符 - 详细信息请参阅[教程](https://pytorch.org/tutorials/advanced/cpp_extension.html)。 -+ 通常可以通过调用相应的Python库直接集成自定义数据读取。通过扩展[`Dataset`](../data.html#torch.utils.data.Dataset "torch.utils.data.Dataset")或[`IterableDataset`](../data.html#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")，可以利用[`torch.utils.data`](../data.html#module-torch.utils.data "torch.utils.data")的现有功能。 ++ 通常可以通过调用相应的 Python 库直接集成自定义数据读取。通过扩展`Dataset`或`IterableDataset`，可以利用`torch.utils.data`的现有功能。 diff --git a/totrans/doc22_020.md b/totrans/doc22_020.md index c831c97f..9ad640cc 100644 --- a/totrans/doc22_020.md +++ b/totrans/doc22_020.md @@ -1,46 +1,46 @@ # 模块 -> 原文：[https://pytorch.org/docs/stable/notes/modules.html](https://pytorch.org/docs/stable/notes/modules.html) +> 原文：[`pytorch.org/docs/stable/notes/modules.html`](https://pytorch.org/docs/stable/notes/modules.html) -PyTorch使用模块来表示神经网络。模块是： +PyTorch 使用模块来表示神经网络。模块是： -+ **有状态计算的构建块。** PyTorch提供了一个强大的模块库，并且可以轻松定义新的自定义模块，从而可以轻松构建复杂的多层神经网络。 ++ **有状态计算的构建块。** PyTorch 提供了一个强大的模块库，并且可以轻松定义新的自定义模块，从而可以轻松构建复杂的多层神经网络。 -+ **与PyTorch的** [autograd](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html) **系统紧密集成。** 模块使得为PyTorch的优化器指定可学习参数变得简单。 ++ **与 PyTorch 的** [autograd](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html) **系统紧密集成。** 模块使得为 PyTorch 的优化器指定可学习参数变得简单。 -+ **易于使用和转换。** 模块易于保存和恢复，在CPU / GPU / TPU设备之间传输，修剪，量化等。 ++ **易于使用和转换。** 模块易于保存和恢复，在 CPU / GPU / TPU 设备之间传输，修剪，量化等。 -本说明描述了模块，并适用于所有PyTorch用户。由于模块对于PyTorch非常重要，因此本说明中的许多主题在其他说明或教程中有详细介绍，并在此处提供了许多文档的链接。 +本说明描述了模块，并适用于所有 PyTorch 用户。由于模块对于 PyTorch 非常重要，因此本说明中的许多主题在其他说明或教程中有详细介绍，并在此处提供了许多文档的链接。 -+ [一个简单的自定义模块](#a-simple-custom-module) ++ 一个简单的自定义模块 -+ [模块作为构建块](#modules-as-building-blocks) ++ 模块作为构建块 -+ [使用模块进行神经网络训练](#neural-network-training-with-modules) ++ 使用模块进行神经网络训练 -+ [模块状态](#module-state) ++ 模块状态 -+ [模块初始化](#module-initialization) ++ 模块初始化 -+ [模块钩子](#module-hooks) ++ 模块钩子 -+ [高级功能](#advanced-features) ++ 高级功能 - + [分布式训练](#distributed-training) + + 分布式训练 - + [性能分析](#profiling-performance) + + 性能分析 - + [使用量化改善性能](#improving-performance-with-quantization) + + 使用量化改善性能 - + [使用修剪改善内存使用情况](#improving-memory-usage-with-pruning) + + 使用修剪改善内存使用情况 - + [参数化](#parametrizations) + + 参数化 - + [使用FX转换模块](#transforming-modules-with-fx) + + 使用 FX 转换模块 -## [一个简单的自定义模块](#id4)[](#a-simple-custom-module "跳转到此标题") +## 一个简单的自定义模块[](#a-simple-custom-module "跳转到此标题") -要开始，让我们看一个更简单的自定义版本PyTorch的[`Linear`](../generated/torch.nn.Linear.html#torch.nn.Linear "torch.nn.Linear")模块。该模块对其输入应用仿射变换。 +要开始，让我们看一个更简单的自定义版本 PyTorch 的`Linear`模块。该模块对其输入应用仿射变换。 ```py import torch @@ -58,11 +58,11 @@ class MyLinear(nn.Module): 这个简单的模块具有以下模块的基本特征： -+ **它继承自基本的Module类。** 所有模块都应该子类化[`Module`](../generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")以便与其他模块组合。 ++ **它继承自基本的 Module 类。** 所有模块都应该子类化`Module`以便与其他模块组合。 -+ **它定义了在计算中使用的一些“状态”。** 在这里，状态包括随机初始化的`weight`和`bias`张量，用于定义仿射变换。因为每个都被定义为[`Parameter`](../generated/torch.nn.parameter.Parameter.html#torch.nn.parameter.Parameter "torch.nn.parameter.Parameter")，它们被*注册*到模块中，并将自动跟踪并从调用[`parameters()`](../generated/torch.nn.Module.html#torch.nn.Module.parameters "torch.nn.Module.parameters")返回。参数可以被认为是模块计算的“可学习”部分（稍后会详细介绍）。请注意，模块不需要具有状态，也可以是无状态的。 ++ **它定义了在计算中使用的一些“状态”。** 在这里，状态包括随机初始化的`weight`和`bias`张量，用于定义仿射变换。因为每个都被定义为`Parameter`，它们被*注册*到模块中，并将自动跟踪并从调用`parameters()`返回。参数可以被认为是模块计算的“可学习”部分（稍后会详细介绍）。请注意，模块不需要具有状态，也可以是无状态的。 -+ **它定义了一个执行计算的forward()函数。** 对于这个仿射变换模块，输入与`weight`参数进行矩阵乘法（使用`@`简写符号）并加上`bias`参数以产生输出。更一般地，模块的`forward()`实现可以执行涉及任意数量输入和输出的任意计算。 ++ **它定义了一个执行计算的 forward()函数。** 对于这个仿射变换模块，输入与`weight`参数进行矩阵乘法（使用`@`简写符号）并加上`bias`参数以产生输出。更一般地，模块的`forward()`实现可以执行涉及任意数量输入和输出的任意计算。 这个简单的模块演示了模块如何将状态和计算打包在一起。可以构建并调用此模块的实例： @@ -73,9 +73,9 @@ m(sample_input) : tensor([-0.3037, -1.0413, -4.2057], grad_fn=) ``` -请注意，模块本身是可调用的，调用它会调用其`forward()`函数。这个名称是指“前向传播”和“反向传播”的概念，这些概念适用于每个模块。 “前向传播”负责将模块表示的计算应用于给定的输入（如上面的代码片段所示）。 “反向传播”计算模块输出相对于其输入的梯度，这些梯度可以用于通过梯度下降方法“训练”参数。PyTorch的自动求导系统会自动处理这个反向传播计算，因此不需要为每个模块手动实现`backward()`函数。通过连续的前向/反向传播训练模块参数的过程在[使用模块进行神经网络训练](#neural-network-training-with-modules)中有详细介绍。 +请注意，模块本身是可调用的，调用它会调用其`forward()`函数。这个名称是指“前向传播”和“反向传播”的概念，这些概念适用于每个模块。 “前向传播”负责将模块表示的计算应用于给定的输入（如上面的代码片段所示）。 “反向传播”计算模块输出相对于其输入的梯度，这些梯度可以用于通过梯度下降方法“训练”参数。PyTorch 的自动求导系统会自动处理这个反向传播计算，因此不需要为每个模块手动实现`backward()`函数。通过连续的前向/反向传播训练模块参数的过程在使用模块进行神经网络训练中有详细介绍。 -可以通过调用[`parameters()`](../generated/torch.nn.Module.html#torch.nn.Module.parameters "torch.nn.Module.parameters")或[`named_parameters()`](../generated/torch.nn.Module.html#torch.nn.Module.named_parameters "torch.nn.Module.named_parameters")来迭代模块注册的完整参数集，后者包括每个参数的名称： +可以通过调用`parameters()`或`named_parameters()`来迭代模块注册的完整参数集，后者包括每个参数的名称： ```py for parameter in m.named_parameters(): @@ -89,11 +89,11 @@ tensor([[ 1.0597, 1.1796, 0.8247], tensor([ 0.3634, 0.2015, -0.8525], requires_grad=True)) ``` -通常，模块注册的参数是模块计算的方面，应该是“可学习的”。本笔记的后面部分展示了如何使用PyTorch的优化器更新这些参数。然而，在此之前，让我们首先看一下模块如何与其他模块组合。 +通常，模块注册的参数是模块计算的方面，应该是“可学习的”。本笔记的后面部分展示了如何使用 PyTorch 的优化器更新这些参数。然而，在此之前，让我们首先看一下模块如何与其他模块组合。 -## [模块作为构建模块](#id5)[](#modules-as-building-blocks "跳转到此标题") +## 模块作为构建模块[](#modules-as-building-blocks "跳转到此标题") -模块可以包含其他模块，使它们成为开发更复杂功能的有用构建模块。最简单的方法是使用[`Sequential`](../generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")模块。它允许我们将多个模块链接在一起： +模块可以包含其他模块，使它们成为开发更复杂功能的有用构建模块。最简单的方法是使用`Sequential`模块。它允许我们将多个模块链接在一起： ```py net = nn.Sequential( @@ -107,7 +107,7 @@ net(sample_input) : tensor([-0.6749], grad_fn=) ``` -请注意，[`Sequential`](../generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")会自动将第一个`MyLinear`模块的输出作为输入传递给[`ReLU`](../generated/torch.nn.ReLU.html#torch.nn.ReLU "torch.nn.ReLU")，并将其输出作为输入传递给第二个`MyLinear`模块。如所示，它仅限于按顺序链接具有单个输入和输出的模块。 +请注意，`Sequential`会自动将第一个`MyLinear`模块的输出作为输入传递给`ReLU`，并将其输出作为输入传递给第二个`MyLinear`模块。如所示，它仅限于按顺序链接具有单个输入和输出的模块。 通常，建议为超出最简单用例的任何内容定义自定义模块，因为这样可以完全灵活地使用子模块进行模块的计算。 @@ -128,7 +128,7 @@ class Net(nn.Module): return x ``` -这个模块由两个“子模块”（`l0`和`l1`）组成，它们定义了神经网络的层，并在模块的`forward()`方法中用于计算。通过调用[`children()`](../generated/torch.nn.Module.html#torch.nn.Module.children "torch.nn.Module.children")或[`named_children()`](../generated/torch.nn.Module.html#torch.nn.Module.named_children "torch.nn.Module.named_children")可以迭代模块的直接子模块： +这个模块由两个“子模块”（`l0`和`l1`）组成，它们定义了神经网络的层，并在模块的`forward()`方法中用于计算。通过调用`children()`或`named_children()`可以迭代模块的直接子模块： ```py net = Net() @@ -138,7 +138,7 @@ for child in net.named_children(): ('l1', MyLinear()) ``` -要深入到不仅仅是直接子模块，[`modules()`](../generated/torch.nn.Module.html#torch.nn.Module.modules "torch.nn.Module.modules")和[`named_modules()`](../generated/torch.nn.Module.html#torch.nn.Module.named_modules "torch.nn.Module.named_modules") *递归*迭代一个模块及其子模块： +要深入到不仅仅是直接子模块，`modules()`和`named_modules()` *递归*迭代一个模块及其子模块： ```py class BigNet(nn.Module): @@ -168,7 +168,7 @@ for module in big_net.named_modules(): ('net.l1', MyLinear()) ``` -有时，模块需要动态定义子模块。[`ModuleList`](../generated/torch.nn.ModuleList.html#torch.nn.ModuleList "torch.nn.ModuleList")和[`ModuleDict`](../generated/torch.nn.ModuleDict.html#torch.nn.ModuleDict "torch.nn.ModuleDict")模块在这里很有用；它们从列表或字典中注册子模块： +有时，模块需要动态定义子模块。`ModuleList`和`ModuleDict`模块在这里很有用；它们从列表或字典中注册子模块： ```py class DynamicNet(nn.Module): @@ -184,7 +184,7 @@ class DynamicNet(nn.Module): def forward(self, x, act): for linear in self.linears: x = linear(x) - x = self.activations[act](x) + x = self.activationsact x = self.final(x) return x @@ -193,7 +193,7 @@ sample_input = torch.randn(4) output = dynamic_net(sample_input, 'relu') ``` -运行上述代码片段后，请注意网络的参数已经发生了变化。特别是，检查`l1`的`weight`参数的值，现在它的值更接近0（这是可以预期的）： +运行上述代码片段后，请注意网络的参数已经发生了变化。特别是，检查`l1`的`weight`参数的值，现在它的值更接近 0（这是可以预期的）： ```py for parameter in dynamic_net.named_parameters(): @@ -225,7 +225,7 @@ tensor([[ 0.2509], [-0.5052], [ 0.3088], [-1.4951]], requires_grad=True)) tensor([0.3381], requires_grad=True)) ``` -还可以使用[`to()`](../generated/torch.nn.Module.html#torch.nn.Module.to "torch.nn.Module.to")将所有参数移动到不同的设备或更改它们的精度： +还可以使用`to()`将所有参数移动到不同的设备或更改它们的精度： ```py # Move all parameters to a CUDA device @@ -238,7 +238,7 @@ dynamic_net(torch.randn(5, device='cuda', dtype=torch.float64)) : tensor([6.5166], device='cuda:0', dtype=torch.float64, grad_fn=) ``` -更一般地，可以使用[`apply()`](../generated/torch.nn.Module.html#torch.nn.Module.apply "torch.nn.Module.apply")函数将任意函数递归地应用到模块及其子模块上。例如，要对模块及其子模块的参数应用自定义初始化： +更一般地，可以使用`apply()`函数将任意函数递归地应用到模块及其子模块上。例如，要对模块及其子模块的参数应用自定义初始化： ```py # Define a function to initialize Linear weights. @@ -253,19 +253,19 @@ def init_weights(m): dynamic_net.apply(init_weights) ``` -这些示例展示了如何通过模块组合和方便操作来构建复杂的神经网络。为了快速简便地构建神经网络而减少样板代码，PyTorch提供了一个大型的高性能模块库，位于[`torch.nn`](../nn.html#module-torch.nn "torch.nn")命名空间中，执行常见的神经网络操作，如池化、卷积、损失函数等。 +这些示例展示了如何通过模块组合和方便操作来构建复杂的神经网络。为了快速简便地构建神经网络而减少样板代码，PyTorch 提供了一个大型的高性能模块库，位于`torch.nn`命名空间中，执行常见的神经网络操作，如池化、卷积、损失函数等。 在接下来的部分，我们将给出一个完整的训练神经网络的示例。 更多信息，请查看： -+ 对于任何给定的模块，其参数包括其直接参数以及所有子模块的参数。这意味着调用[`parameters()`](../generated/torch.nn.Module.html#torch.nn.Module.parameters "torch.nn.Module.parameters")和[`named_parameters()`](../generated/torch.nn.Module.html#torch.nn.Module.named_parameters "torch.nn.Module.named_parameters")将递归包括子参数，方便地优化网络中的所有参数： ++ 对于任何给定的模块，其参数包括其直接参数以及所有子模块的参数。这意味着调用`parameters()`和`named_parameters()`将递归包括子参数，方便地优化网络中的所有参数： -+ 定义神经网络模块：[https://pytorch.org/tutorials/beginner/examples_nn/polynomial_module.html](https://pytorch.org/tutorials/beginner/examples_nn/polynomial_module.html) ++ 定义神经网络模块：[`pytorch.org/tutorials/beginner/examples_nn/polynomial_module.html`](https://pytorch.org/tutorials/beginner/examples_nn/polynomial_module.html) -## [使用模块进行神经网络训练](#id6)[](#neural-network-training-with-modules "跳转到此标题的永久链接") +## 使用模块进行神经网络训练[](#neural-network-training-with-modules "跳转到此标题的永久链接") -构建完网络后，需要对其进行训练，并且可以使用PyTorch的优化器之一从[`torch.optim`](../optim.html#module-torch.optim "torch.optim")中轻松优化其参数： +构建完网络后，需要对其进行训练，并且可以使用 PyTorch 的优化器之一从`torch.optim`中轻松优化其参数： ```py # Create the network (from previous section) and optimizer @@ -289,11 +289,11 @@ net.eval() ... ``` -在这个简化的示例中，网络学习简单地输出零，因为任何非零输出都会根据其绝对值“受到惩罚”，使用[`torch.abs()`](../generated/torch.abs.html#torch.abs "torch.abs")作为损失函数。虽然这不是一个非常有趣的任务，但训练的关键部分都在其中： +在这个简化的示例中，网络学习简单地输出零，因为任何非零输出都会根据其绝对值“受到惩罚”，使用`torch.abs()`作为损失函数。虽然这不是一个非常有趣的任务，但训练的关键部分都在其中： + 创建一个网络。 -+ PyTorch提供的模块库：[torch.nn](https://pytorch.org/docs/stable/nn.html) ++ PyTorch 提供的模块库：[torch.nn](https://pytorch.org/docs/stable/nn.html) + 一个训练循环… @@ -305,9 +305,9 @@ net.eval() + 将网络的参数梯度置零， - + 调用loss.backward()来更新参数的梯度， + + 调用 loss.backward()来更新参数的梯度， - + 调用optimizer.step()将梯度应用到参数上。 + + 调用 optimizer.step()将梯度应用到参数上。 运行网络， @@ -319,7 +319,7 @@ tensor([[-0.0013], [-0.0008]], requires_grad=True) ``` -请注意，上述过程完全在网络模块处于“训练模式”时完成。模块默认为训练模式，并可以使用[`train()`](../generated/torch.nn.Module.html#torch.nn.Module.train "torch.nn.Module.train")和[`eval()`](../generated/torch.nn.Module.html#torch.nn.Module.eval "torch.nn.Module.eval")在训练和评估模式之间切换。它们在不同模式下的行为可能不同。例如，`BatchNorm`模块在训练期间维护一个运行时均值和方差，在评估模式下不会更新。通常，在训练期间模块应该处于训练模式，并且只有在推断或评估时才切换到评估模式。下面是一个在两种模式之间表现不同的自定义模块的示例： +请注意，上述过程完全在网络模块处于“训练模式”时完成。模块默认为训练模式，并可以使用`train()`和`eval()`在训练和评估模式之间切换。它们在不同模式下的行为可能不同。例如，`BatchNorm`模块在训练期间维护一个运行时均值和方差，在评估模式下不会更新。通常，在训练期间模块应该处于训练模式，并且只有在推断或评估时才切换到评估模式。下面是一个在两种模式之间表现不同的自定义模块的示例： ```py class ModalModule(nn.Module): @@ -346,13 +346,13 @@ print('evaluation mode output: {}'.format(m(x))) 训练神经网络通常会很棘手。更多信息，请查看： -+ 使用优化器：[https://pytorch.org/tutorials/beginner/examples_nn/two_layer_net_optim.html](https://pytorch.org/tutorials/beginner/examples_nn/two_layer_net_optim.html)。 ++ 使用优化器：[`pytorch.org/tutorials/beginner/examples_nn/two_layer_net_optim.html`](https://pytorch.org/tutorials/beginner/examples_nn/two_layer_net_optim.html)。 -+ 神经网络训练：[https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html) ++ 神经网络训练：[`pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html`](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html) -+ 自动求导简介：[https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html) ++ 自动求导简介：[`pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html`](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html) -## [模块状态](#id7) +## 模块状态 在前一节中，我们演示了训练模块的“参数”或计算的可学习部分。现在，如果我们想将训练好的模型保存到磁盘，可以通过保存其`state_dict`（即“状态字典”）来实现： @@ -368,7 +368,7 @@ new_net.load_state_dict(torch.load('net.pt')) : ``` -模块的`state_dict`包含影响其计算的状态。这包括但不限于模块的参数。对于某些模块，除了参数之外还有影响模块计算但不可学习的状态可能很有用。对于这种情况，PyTorch提供了“缓冲区”的概念，包括“持久性”和“非持久性”。以下是模块可能具有的各种类型状态的概述： +模块的`state_dict`包含影响其计算的状态。这包括但不限于模块的参数。对于某些模块，除了参数之外还有影响模块计算但不可学习的状态可能很有用。对于这种情况，PyTorch 提供了“缓冲区”的概念，包括“持久性”和“非持久性”。以下是模块可能具有的各种类型状态的概述： + **参数**：计算的可学习部分；包含在`state_dict`中 @@ -378,7 +378,7 @@ new_net.load_state_dict(torch.load('net.pt')) + **非持久性**缓冲区：不包含在`state_dict`中（即在序列化时被排除） -以一个简单的维护运行均值的模块为例，我们希望运行均值的当前值被视为模块的`state_dict`的一部分，以便在加载模块的序列化形式时恢复，但我们不希望它是可学习的。以下代码片段展示了如何使用[`register_buffer()`](../generated/torch.nn.Module.html#torch.nn.Module.register_buffer "torch.nn.Module.register_buffer")来实现这一点： +以一个简单的维护运行均值的模块为例，我们希望运行均值的当前值被视为模块的`state_dict`的一部分，以便在加载模块的序列化形式时恢复，但我们不希望它是可学习的。以下代码片段展示了如何使用`register_buffer()`来实现这一点： ```py class RunningMean(nn.Module): @@ -416,14 +416,14 @@ assert(torch.all(m.mean == m_loaded.mean)) self.register_buffer('unserialized_thing', torch.randn(5), persistent=False) ``` -模型范围内使用[`to()`](../generated/torch.nn.Module.html#torch.nn.Module.to "torch.nn.Module.to")应用的设备/数据类型更改会影响持久性和非持久性缓冲区： +模型范围内使用`to()`应用的设备/数据类型更改会影响持久性和非持久性缓冲区： ```py # Moves all module parameters and buffers to the specified device / dtype m.to(device='cuda', dtype=torch.float64) ``` -可以使用[`buffers()`](../generated/torch.nn.Module.html#torch.nn.Module.buffers "torch.nn.Module.buffers")或[`named_buffers()`](../generated/torch.nn.Module.html#torch.nn.Module.named_buffers "torch.nn.Module.named_buffers")迭代模块的缓冲区。 +可以使用`buffers()`或`named_buffers()`迭代模块的缓冲区。 ```py for buffer in m.named_buffers(): @@ -495,15 +495,15 @@ print(m_loaded.state_dict()) 更多信息，请查看： -+ 保存和加载：[https://pytorch.org/tutorials/beginner/saving_loading_models.html](https://pytorch.org/tutorials/beginner/saving_loading_models.html) ++ 保存和加载：[`pytorch.org/tutorials/beginner/saving_loading_models.html`](https://pytorch.org/tutorials/beginner/saving_loading_models.html) -+ 序列化语义：[https://pytorch.org/docs/main/notes/serialization.html](https://pytorch.org/docs/main/notes/serialization.html) ++ 序列化语义：[`pytorch.org/docs/main/notes/serialization.html`](https://pytorch.org/docs/main/notes/serialization.html) -+ 什么是状态字典？[https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.html](https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.html) ++ 什么是状态字典？[`pytorch.org/tutorials/recipes/recipes/what_is_state_dict.html`](https://pytorch.org/tutorials/recipes/recipes/what_is_state_dict.html) -## [模块初始化](#id8)[](#module-initialization "跳转到此标题") +## 模块初始化[](#module-initialization "跳转到此标题") -默认情况下，由[`torch.nn`](../nn.html#module-torch.nn "torch.nn")提供的模块的参数和浮点缓冲区在模块实例化时作为32位浮点值在CPU上初始化，使用的初始化方案是根据模块类型的历史表现确定的。对于某些用例，可能希望使用不同的数据类型、设备（例如GPU）或初始化技术进行初始化。 +默认情况下，由`torch.nn`提供的模块的参数和浮点缓冲区在模块实例化时作为 32 位浮点值在 CPU 上初始化，使用的初始化方案是根据模块类型的历史表现确定的。对于某些用例，可能希望使用不同的数据类型、设备（例如 GPU）或初始化技术进行初始化。 示例： @@ -527,27 +527,27 @@ print(m.running_mean) : tensor([0., 0., 0.], dtype=torch.float16) ``` -虽然模块编写者可以使用任何设备或dtype来初始化其自定义模块中的参数，但通常做法是默认使用`dtype=torch.float`和`device='cpu'`。您还可以通过遵循上述示例中展示的约定为自定义模块提供这些领域的完全灵活性，所有[`torch.nn`](../nn.html#module-torch.nn "torch.nn")模块都遵循这一约定： +虽然模块编写者可以使用任何设备或 dtype 来初始化其自定义模块中的参数，但通常做法是默认使用`dtype=torch.float`和`device='cpu'`。您还可以通过遵循上述示例中展示的约定为自定义模块提供这些领域的完全灵活性，所有`torch.nn`模块都遵循这一约定： -+ 为模块注册的任何参数/缓冲提供一个`device`构造函数kwarg。 ++ 为模块注册的任何参数/缓冲提供一个`device`构造函数 kwarg。 -+ 为模块注册的任何参数/浮点缓冲提供一个`dtype`构造函数kwarg。 ++ 为模块注册的任何参数/浮点缓冲提供一个`dtype`构造函数 kwarg。 -+ 仅在模块的构造函数中对参数和缓冲使用初始化函数（即来自[`torch.nn.init`](../nn.html#module-torch.nn.init "torch.nn.init")的函数）。请注意，这仅在使用[`skip_init()`](../generated/torch.nn.utils.skip_init.html#torch.nn.utils.skip_init "torch.nn.utils.skip_init")时才需要；请参阅[此页面](https://pytorch.org/tutorials/prototype/skip_param_init.html#updating-modules-to-support-skipping-initialization)以获取解释。 ++ 仅在模块的构造函数中对参数和缓冲使用初始化函数（即来自`torch.nn.init`的函数）。请注意，这仅在使用`skip_init()`时才需要；请参阅[此页面](https://pytorch.org/tutorials/prototype/skip_param_init.html#updating-modules-to-support-skipping-initialization)以获取解释。 有关更多信息，请查看： -+ 跳过模块参数初始化：[https://pytorch.org/tutorials/prototype/skip_param_init.html](https://pytorch.org/tutorials/prototype/skip_param_init.html) ++ 跳过模块参数初始化：[`pytorch.org/tutorials/prototype/skip_param_init.html`](https://pytorch.org/tutorials/prototype/skip_param_init.html) -## [模块Hooks](#id9) +## 模块 Hooks -在[使用模块进行神经网络训练](#neural-network-training-with-modules)中，我们演示了模块的训练过程，该过程迭代地执行前向和后向传递，更新模块参数。为了更好地控制这个过程，PyTorch提供了“hooks”，可以在前向或后向传递过程中执行任意计算，甚至在需要时修改传递的方式。这种功能的一些有用示例包括调试、可视化激活、深入检查梯度等。可以将hooks添加到您自己没有编写的模块中，这意味着这种功能可以应用于第三方或PyTorch提供的模块。 +在使用模块进行神经网络训练中，我们演示了模块的训练过程，该过程迭代地执行前向和后向传递，更新模块参数。为了更好地控制这个过程，PyTorch 提供了“hooks”，可以在前向或后向传递过程中执行任意计算，甚至在需要时修改传递的方式。这种功能的一些有用示例包括调试、可视化激活、深入检查梯度等。可以将 hooks 添加到您自己没有编写的模块中，这意味着这种功能可以应用于第三方或 PyTorch 提供的模块。 -PyTorch为模块提供了两种类型的hooks： +PyTorch 为模块提供了两种类型的 hooks： -+ **前向hooks**在前向传递期间调用。可以使用[`register_forward_pre_hook()`](../generated/torch.nn.Module.html#torch.nn.Module.register_forward_pre_hook "torch.nn.Module.register_forward_pre_hook")和[`register_forward_hook()`](../generated/torch.nn.Module.html#torch.nn.Module.register_forward_hook "torch.nn.Module.register_forward_hook")为给定模块安装这些hooks。这些hooks将分别在调用前向函数之前和之后调用。或者，可以使用类似的[`register_module_forward_pre_hook()`](../generated/torch.nn.modules.module.register_module_forward_pre_hook.html#torch.nn.modules.module.register_module_forward_pre_hook "torch.nn.modules.module.register_module_forward_pre_hook")和[`register_module_forward_hook()`](../generated/torch.nn.modules.module.register_module_forward_hook.html#torch.nn.modules.module.register_module_forward_hook "torch.nn.modules.module.register_module_forward_hook")函数全局安装这些hooks。 ++ **前向 hooks**在前向传递期间调用。可以使用`register_forward_pre_hook()`和`register_forward_hook()`为给定模块安装这些 hooks。这些 hooks 将分别在调用前向函数之前和之后调用。或者，可以使用类似的`register_module_forward_pre_hook()`和`register_module_forward_hook()`函数全局安装这些 hooks。 -+ **反向钩子**在反向传播过程中被调用。可以使用[`register_full_backward_pre_hook()`](../generated/torch.nn.Module.html#torch.nn.Module.register_full_backward_pre_hook "torch.nn.Module.register_full_backward_pre_hook")和[`register_full_backward_hook()`](../generated/torch.nn.Module.html#torch.nn.Module.register_full_backward_hook "torch.nn.Module.register_full_backward_hook")来安装这些钩子。这些钩子将在该模块的反向传播计算完成时被调用。[`register_full_backward_pre_hook()`](../generated/torch.nn.Module.html#torch.nn.Module.register_full_backward_pre_hook "torch.nn.Module.register_full_backward_pre_hook")允许用户访问输出的梯度，而[`register_full_backward_hook()`](../generated/torch.nn.Module.html#torch.nn.Module.register_full_backward_hook "torch.nn.Module.register_full_backward_hook")允许用户访问输入和输出的梯度。另外，可以使用[`register_module_full_backward_hook()`](../generated/torch.nn.modules.module.register_module_full_backward_hook.html#torch.nn.modules.module.register_module_full_backward_hook "torch.nn.modules.module.register_module_full_backward_hook")和[`register_module_full_backward_pre_hook()`](../generated/torch.nn.modules.module.register_module_full_backward_pre_hook.html#torch.nn.modules.module.register_module_full_backward_pre_hook "torch.nn.modules.module.register_module_full_backward_pre_hook")来全局安装所有模块的钩子。 ++ **反向钩子**在反向传播过程中被调用。可以使用`register_full_backward_pre_hook()`和`register_full_backward_hook()`来安装这些钩子。这些钩子将在该模块的反向传播计算完成时被调用。`register_full_backward_pre_hook()`允许用户访问输出的梯度，而`register_full_backward_hook()`允许用户访问输入和输出的梯度。另外，可以使用`register_module_full_backward_hook()`和`register_module_full_backward_pre_hook()`来全局安装所有模块的钩子。 所有的钩子都允许用户返回一个更新后的值，该值将在剩余的计算过程中使用。因此，这些钩子可以用来在常规模块的前向/后向过程中执行任意代码，或者修改一些输入/输出而无需更改模块的`forward()`函数。 @@ -623,30 +623,30 @@ print('x.grad with backwards hook: {}'.format(x.grad)) [42., 42., 42.]]) ``` -## [高级功能](#id10) +## 高级功能 -PyTorch还提供了几个更高级的功能，旨在与模块一起使用。所有这些功能都适用于自定义编写的模块，只是有一个小小的注意事项，即某些功能可能需要模块符合特定约束才能得到支持。这些功能的深入讨论以及相应的要求可以在下面的链接中找到。 +PyTorch 还提供了几个更高级的功能，旨在与模块一起使用。所有这些功能都适用于自定义编写的模块，只是有一个小小的注意事项，即某些功能可能需要模块符合特定约束才能得到支持。这些功能的深入讨论以及相应的要求可以在下面的链接中找到。 -### [分布式训练](#id11) +### 分布式训练 -PyTorch中存在各种分布式训练方法，既可以使用多个GPU进行训练，也可以跨多台机器进行训练。查看[分布式训练概述页面](https://pytorch.org/tutorials/beginner/dist_overview.html)以获取有关如何利用这些功能的详细信息。 +PyTorch 中存在各种分布式训练方法，既可以使用多个 GPU 进行训练，也可以跨多台机器进行训练。查看[分布式训练概述页面](https://pytorch.org/tutorials/beginner/dist_overview.html)以获取有关如何利用这些功能的详细信息。 -### [性能分析](#id12)[](#profiling-performance "跳转到此标题的永久链接") +### 性能分析[](#profiling-performance "跳转到此标题的永久链接") -[PyTorch性能分析器](https://pytorch.org/tutorials/beginner/profiler.html)可用于识别模型中的性能瓶颈。它可以测量和输出内存使用和时间消耗的性能特征。 +[PyTorch 性能分析器](https://pytorch.org/tutorials/beginner/profiler.html)可用于识别模型中的性能瓶颈。它可以测量和输出内存使用和时间消耗的性能特征。 -### [通过量化提高性能](#id13)[](#improving-performance-with-quantization "跳转到此标题的永久链接") +### 通过量化提高性能[](#improving-performance-with-quantization "跳转到此标题的永久链接") -将量化技术应用于模块可以通过使用比浮点精度更低的位宽来提高性能和内存使用。查看PyTorch提供的各种量化机制[这里](https://pytorch.org/docs/stable/quantization.html)。 +将量化技术应用于模块可以通过使用比浮点精度更低的位宽来提高性能和内存使用。查看 PyTorch 提供的各种量化机制[这里](https://pytorch.org/docs/stable/quantization.html)。 -### [通过修剪改善内存使用](#id14)[](#improving-memory-usage-with-pruning "跳转到此标题的永久链接") +### 通过修剪改善内存使用[](#improving-memory-usage-with-pruning "跳转到此标题的永久链接") -大型深度学习模型通常存在过度参数化的问题，导致内存使用量很高。为了解决这个问题，PyTorch提供了模型修剪的机制，可以帮助减少内存使用量同时保持任务准确性。[修剪教程](https://pytorch.org/tutorials/intermediate/pruning_tutorial.html)描述了如何利用PyTorch提供的修剪技术或根据需要定义自定义修剪技术。 +大型深度学习模型通常存在过度参数化的问题，导致内存使用量很高。为了解决这个问题，PyTorch 提供了模型修剪的机制，可以帮助减少内存使用量同时保持任务准确性。[修剪教程](https://pytorch.org/tutorials/intermediate/pruning_tutorial.html)描述了如何利用 PyTorch 提供的修剪技术或根据需要定义自定义修剪技术。 -### [参数化](#id15) +### 参数化 -对于某些应用程序，在模型训练过程中约束参数空间可能是有益的。例如，强制学习参数的正交性可以改善RNN的收敛性。PyTorch提供了一种应用[参数化](https://pytorch.org/tutorials/intermediate/parametrizations.html)的机制，还允许定义自定义约束。 +对于某些应用程序，在模型训练过程中约束参数空间可能是有益的。例如，强制学习参数的正交性可以改善 RNN 的收敛性。PyTorch 提供了一种应用[参数化](https://pytorch.org/tutorials/intermediate/parametrizations.html)的机制，还允许定义自定义约束。 -### [使用FX转换模块](#id16)[](#transforming-modules-with-fx "跳转到此标题") +### 使用 FX 转换模块[](#transforming-modules-with-fx "跳转到此标题") -PyTorch的[FX](https://pytorch.org/docs/stable/fx.html)组件提供了一种灵活的方式来通过直接操作模块计算图来转换模块。这可以用于以编程方式生成或操作各种用例的模块。要探索FX，请查看使用FX进行[卷积+批量归一化融合](https://pytorch.org/tutorials/intermediate/fx_conv_bn_fuser.html)和[CPU性能分析](https://pytorch.org/tutorials/intermediate/fx_profiling_tutorial.html)的示例。 +PyTorch 的[FX](https://pytorch.org/docs/stable/fx.html)组件提供了一种灵活的方式来通过直接操作模块计算图来转换模块。这可以用于以编程方式生成或操作各种用例的模块。要探索 FX，请查看使用 FX 进行[卷积+批量归一化融合](https://pytorch.org/tutorials/intermediate/fx_conv_bn_fuser.html)和[CPU 性能分析](https://pytorch.org/tutorials/intermediate/fx_profiling_tutorial.html)的示例。 diff --git a/totrans/doc22_021.md b/totrans/doc22_021.md index 70467489..4352e20f 100644 --- a/totrans/doc22_021.md +++ b/totrans/doc22_021.md @@ -1,10 +1,10 @@ -# MPS后端 +# MPS 后端 -> 原文：[https://pytorch.org/docs/stable/notes/mps.html](https://pytorch.org/docs/stable/notes/mps.html) +> 原文：[`pytorch.org/docs/stable/notes/mps.html`](https://pytorch.org/docs/stable/notes/mps.html) -`mps`设备使MacOS设备上的高性能训练成为可能，使用Metal编程框架。它引入了一个新设备，将机器学习计算图和基元映射到高效的Metal Performance Shaders图框架和分别由Metal Performance Shaders框架提供的调整过的内核。 +`mps`设备使 MacOS 设备上的高性能训练成为可能，使用 Metal 编程框架。它引入了一个新设备，将机器学习计算图和基元映射到高效的 Metal Performance Shaders 图框架和分别由 Metal Performance Shaders 框架提供的调整过的内核。 -新的MPS后端扩展了PyTorch生态系统，并为现有脚本提供了在GPU上设置和运行操作的能力。 +新的 MPS 后端扩展了 PyTorch 生态系统，并为现有脚本提供了在 GPU 上设置和运行操作的能力。 要开始使用，只需将您的张量和模块移动到`mps`设备上： diff --git a/totrans/doc22_022.md b/totrans/doc22_022.md index de499798..aee99867 100644 --- a/totrans/doc22_022.md +++ b/totrans/doc22_022.md @@ -1,44 +1,44 @@ # 多进程最佳实践 -> 原文：[https://pytorch.org/docs/stable/notes/multiprocessing.html](https://pytorch.org/docs/stable/notes/multiprocessing.html) +> 原文：[`pytorch.org/docs/stable/notes/multiprocessing.html`](https://pytorch.org/docs/stable/notes/multiprocessing.html) -[`torch.multiprocessing`](../multiprocessing.html#module-torch.multiprocessing "torch.multiprocessing")是Python的[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在Python v3.12中)")模块的一个替代品。它支持完全相同的操作，但扩展了它，使得通过[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在Python v3.12中)")发送的所有张量的数据都会移动到共享内存中，并且只会发送一个句柄给另一个进程。 +`torch.multiprocessing`是 Python 的[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在 Python v3.12 中)")模块的一个替代品。它支持完全相同的操作，但扩展了它，使得通过[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在 Python v3.12 中)")发送的所有张量的数据都会移动到共享内存中，并且只会发送一个句柄给另一个进程。 注意 -当一个[`Tensor`](../tensors.html#torch.Tensor "torch.Tensor")被发送到另一个进程时，[`Tensor`](../tensors.html#torch.Tensor "torch.Tensor")的数据是共享的。如果[`torch.Tensor.grad`](../generated/torch.Tensor.grad.html#torch.Tensor.grad "torch.Tensor.grad")不是`None`，它也是共享的。在将一个没有[`torch.Tensor.grad`](../generated/torch.Tensor.grad.html#torch.Tensor.grad "torch.Tensor.grad")字段的[`Tensor`](../tensors.html#torch.Tensor "torch.Tensor")发送到另一个进程后，它会创建一个标准的进程特定的`.grad` [`Tensor`](../tensors.html#torch.Tensor "torch.Tensor")，这个`.grad` [`Tensor`](../tensors.html#torch.Tensor "torch.Tensor")不会自动在所有进程之间共享，不像[`Tensor`](../tensors.html#torch.Tensor "torch.Tensor")的数据已经被共享了。 +当一个`Tensor`被发送到另一个进程时，`Tensor`的数据是共享的。如果`torch.Tensor.grad`不是`None`，它也是共享的。在将一个没有`torch.Tensor.grad`字段的`Tensor`发送到另一个进程后，它会创建一个标准的进程特定的`.grad` `Tensor`，这个`.grad` `Tensor`不会自动在所有进程之间共享，不像`Tensor`的数据已经被共享了。 -这允许实现各种训练方法，如Hogwild、A3C或其他需要异步操作的方法。 +这允许实现各种训练方法，如 Hogwild、A3C 或其他需要异步操作的方法。 -## 多进程中的CUDA +## 多进程中的 CUDA -CUDA运行时不支持`fork`启动方法；在子进程中使用CUDA需要`spawn`或`forkserver`启动方法。 +CUDA 运行时不支持`fork`启动方法；在子进程中使用 CUDA 需要`spawn`或`forkserver`启动方法。 注意 启动方法可以通过创建一个上下文`multiprocessing.get_context(...)`或直接使用`multiprocessing.set_start_method(...)`来设置。 -与CPU张量不同，发送进程需要保留原始张量，只要接收进程保留了张量的副本。这是在底层实现的，但需要用户遵循程序正确运行的最佳实践。例如，发送进程必须保持活动状态，只要消费者进程引用了张量，如果消费者进程通过致命信号异常退出，引用计数无法帮助您。请参阅[此部分](../multiprocessing.html#multiprocessing-cuda-sharing-details)。 +与 CPU 张量不同，发送进程需要保留原始张量，只要接收进程保留了张量的副本。这是在底层实现的，但需要用户遵循程序正确运行的最佳实践。例如，发送进程必须保持活动状态，只要消费者进程引用了张量，如果消费者进程通过致命信号异常退出，引用计数无法帮助您。请参阅此部分。 -另请参阅：[使用nn.parallel.DistributedDataParallel代替multiprocessing或nn.DataParallel](cuda.html#cuda-nn-ddp-instead) +另请参阅：使用 nn.parallel.DistributedDataParallel 代替 multiprocessing 或 nn.DataParallel ## 最佳实践和提示 ### 避免和解决死锁[](#avoiding-and-fighting-deadlocks "跳转到此标题") -当生成一个新进程时，有很多事情可能会出错，最常见的死锁原因是后台线程。如果有任何持有锁或导入模块的线程，并且调用了`fork`，那么子进程很可能处于损坏状态，并且会发生死锁或以不同方式失败。请注意，即使您没有，Python内置库也会 - 不需要查看比[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在Python v3.12中)")更远的地方。[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在Python v3.12中)")实际上是一个非常复杂的类，它生成多个线程用于序列化、发送和接收对象，它们也可能引起上述问题。如果您发现自己处于这种情况，请尝试使用`SimpleQueue`，它不使用任何额外的线程。 +当生成一个新进程时，有很多事情可能会出错，最常见的死锁原因是后台线程。如果有任何持有锁或导入模块的线程，并且调用了`fork`，那么子进程很可能处于损坏状态，并且会发生死锁或以不同方式失败。请注意，即使您没有，Python 内置库也会 - 不需要查看比[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在 Python v3.12 中)")更远的地方。[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在 Python v3.12 中)")实际上是一个非常复杂的类，它生成多个线程用于序列化、发送和接收对象，它们也可能引起上述问题。如果您发现自己处于这种情况，请尝试使用`SimpleQueue`，它不使用任何额外的线程。 我们正在尽力让您轻松使用，并确保这些死锁不会发生，但有些事情超出我们的控制。如果您遇到无法解决的问题，请尝试在论坛上寻求帮助，我们会看看是否可以解决。 ### 通过队列传递的缓冲区[](#reuse-buffers-passed-through-a-queue "跳转到此标题") -请记住，每次将[`Tensor`](../tensors.html#torch.Tensor "torch.Tensor")放入[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在Python v3.12中)")时，它必须被移动到共享内存中。如果已经是共享的，则不会执行任何操作，否则将产生额外的内存复制，可能会减慢整个过程的速度。即使您有一组进程向单个进程发送数据，也要让它发送缓冲区回来 - 这几乎是免费的，并且可以避免在发送下一批数据时进行复制。 +请记住，每次将`Tensor`放入[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在 Python v3.12 中)")时，它必须被移动到共享内存中。如果已经是共享的，则不会执行任何操作，否则将产生额外的内存复制，可能会减慢整个过程的速度。即使您有一组进程向单个进程发送数据，也要让它发送缓冲区回来 - 这几乎是免费的，并且可以避免在发送下一批数据时进行复制。 -### 异步多进程训练（例如Hogwild）[](#asynchronous-multiprocess-training-e-g-hogwild "跳转到此标题") +### 异步多进程训练（例如 Hogwild）[](#asynchronous-multiprocess-training-e-g-hogwild "跳转到此标题") -使用[`torch.multiprocessing`](../multiprocessing.html#module-torch.multiprocessing "torch.multiprocessing")，可以异步训练模型，参数可以始终共享，或者定期同步。在第一种情况下，我们建议发送整个模型对象，而在后一种情况下，我们建议只发送[`state_dict()`](../generated/torch.nn.Module.html#torch.nn.Module.state_dict "torch.nn.Module.state_dict")。 +使用`torch.multiprocessing`，可以异步训练模型，参数可以始终共享，或者定期同步。在第一种情况下，我们建议发送整个模型对象，而在后一种情况下，我们建议只发送`state_dict()`。 -我们建议使用[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在Python v3.12中)")来在进程之间传递各种PyTorch对象。例如，当使用`fork`启动方法时，可以继承已经在共享内存中的张量和存储，但这很容易出错，应谨慎使用，仅供高级用户使用。队列，即使它们有时不够优雅，也会在所有情况下正常工作。 +我们建议使用[`multiprocessing.Queue`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Queue "(在 Python v3.12 中)")来在进程之间传递各种 PyTorch 对象。例如，当使用`fork`启动方法时，可以继承已经在共享内存中的张量和存储，但这很容易出错，应谨慎使用，仅供高级用户使用。队列，即使它们有时不够优雅，也会在所有情况下正常工作。 警告 @@ -46,7 +46,7 @@ CUDA运行时不支持`fork`启动方法；在子进程中使用CUDA需要`spawn #### Hogwild -在[示例存储库](https://github.com/pytorch/examples/tree/master/mnist_hogwild)中可以找到一个具体的Hogwild实现，但为了展示代码的整体结构，下面也有一个最小示例： +在[示例存储库](https://github.com/pytorch/examples/tree/master/mnist_hogwild)中可以找到一个具体的 Hogwild 实现，但为了展示代码的整体结构，下面也有一个最小示例： ```py import torch.multiprocessing as mp @@ -73,41 +73,41 @@ if __name__ == '__main__': p.join() ``` -## 多进程中的CPU +## 多进程中的 CPU -不当的多进程可能导致CPU过度订阅，导致不同进程竞争CPU资源，导致效率低下。 +不当的多进程可能导致 CPU 过度订阅，导致不同进程竞争 CPU 资源，导致效率低下。 -本教程将解释什么是CPU过度订阅以及如何避免它。 +本教程将解释什么是 CPU 过度订阅以及如何避免它。 -### CPU过度订阅 +### CPU 过度订阅 -CPU过度订阅是一个技术术语，指的是分配给系统的虚拟CPU总数超过硬件上可用的虚拟CPU总数的情况。 +CPU 过度订阅是一个技术术语，指的是分配给系统的虚拟 CPU 总数超过硬件上可用的虚拟 CPU 总数的情况。 -这会导致CPU资源的严重争用。在这种情况下，进程之间频繁切换，增加了进程切换开销，降低了整个系统的效率。 +这会导致 CPU 资源的严重争用。在这种情况下，进程之间频繁切换，增加了进程切换开销，降低了整个系统的效率。 -在[Hogwild实现](https://github.com/pytorch/examples/tree/main/mnist_hogwild)中的代码示例中查看CPU过度订阅。 +在[Hogwild 实现](https://github.com/pytorch/examples/tree/main/mnist_hogwild)中的代码示例中查看 CPU 过度订阅。 -在CPU上使用4个进程运行以下命令的训练示例： +在 CPU 上使用 4 个进程运行以下命令的训练示例： ```py python main.py --num-processes 4 ``` -假设机器上有N个虚拟CPU可用，执行上述命令将生成4个子进程。每个子进程将为自己分配N个虚拟CPU，导致需要4*N个虚拟CPU。然而，机器上只有N个虚拟CPU可用。因此，不同的进程将竞争资源，导致频繁的进程切换。 +假设机器上有 N 个虚拟 CPU 可用，执行上述命令将生成 4 个子进程。每个子进程将为自己分配 N 个虚拟 CPU，导致需要 4*N 个虚拟 CPU。然而，机器上只有 N 个虚拟 CPU 可用。因此，不同的进程将竞争资源，导致频繁的进程切换。 -以下观察结果表明存在CPU过度订阅： +以下观察结果表明存在 CPU 过度订阅： -1. 高CPU利用率：通过使用`htop`命令，您可以观察到CPU利用率始终很高，经常达到或超过其最大容量。这表明对CPU资源的需求超过了可用的物理核心，导致进程之间的争用和竞争。 +1. 高 CPU 利用率：通过使用`htop`命令，您可以观察到 CPU 利用率始终很高，经常达到或超过其最大容量。这表明对 CPU 资源的需求超过了可用的物理核心，导致进程之间的争用和竞争。 -1. 低系统效率下的频繁上下文切换：在CPU过度订阅的情况下，进程竞争CPU时间，操作系统需要快速在不同进程之间切换以公平分配资源。这种频繁的上下文切换会增加开销并降低整个系统的效率。 +1. 低系统效率下的频繁上下文切换：在 CPU 过度订阅的情况下，进程竞争 CPU 时间，操作系统需要快速在不同进程之间切换以公平分配资源。这种频繁的上下文切换会增加开销并降低整个系统的效率。 -### 避免CPU过度订阅 +### 避免 CPU 过度订阅 -避免CPU过度订阅的一个好方法是适当的资源分配。确保同时运行的进程或线程数量不超过可用的CPU资源。 +避免 CPU 过度订阅的一个好方法是适当的资源分配。确保同时运行的进程或线程数量不超过可用的 CPU 资源。 在这种情况下，一个解决方案是在子进程中指定适当数量的线程。这可以通过在子进程中使用`torch.set_num_threads(int)`函数为每个进程设置线程数来实现。 -假设机器上有N个虚拟CPU，并且将生成M个进程，每个进程使用的最大`num_threads`值将为`floor(N/M)`。为了避免在mnist_hogwild示例中出现CPU过度订阅，需要对[示例存储库](https://github.com/pytorch/examples/tree/main/mnist_hogwild)中的`train.py`文件进行以下更改。 +假设机器上有 N 个虚拟 CPU，并且将生成 M 个进程，每个进程使用的最大`num_threads`值将为`floor(N/M)`。为了避免在 mnist_hogwild 示例中出现 CPU 过度订阅，需要对[示例存储库](https://github.com/pytorch/examples/tree/main/mnist_hogwild)中的`train.py`文件进行以下更改。 ```py def train(rank, args, model, device, dataset, dataloader_kwargs): @@ -123,4 +123,4 @@ def train(rank, args, model, device, dataset, dataloader_kwargs): train_epoch(epoch, args, model, device, train_loader, optimizer) ``` -使用`torch.set_num_threads(floor(N/M))`为每个进程设置`num_thread`。其中，将N替换为可用的虚拟CPU数量，将M替换为选择的进程数量。适当的`num_thread`值将根据手头的具体任务而变化。然而，作为一般准则，`num_thread`的最大值应为`floor(N/M)`，以避免CPU过度订阅。在[mnist_hogwild](https://github.com/pytorch/examples/tree/main/mnist_hogwild)训练示例中，在避免CPU过度订阅后，您可以实现30倍的性能提升。 +使用`torch.set_num_threads(floor(N/M))`为每个进程设置`num_thread`。其中，将 N 替换为可用的虚拟 CPU 数量，将 M 替换为选择的进程数量。适当的`num_thread`值将根据手头的具体任务而变化。然而，作为一般准则，`num_thread`的最大值应为`floor(N/M)`，以避免 CPU 过度订阅。在[mnist_hogwild](https://github.com/pytorch/examples/tree/main/mnist_hogwild)训练示例中，在避免 CPU 过度订阅后，您可以实现 30 倍的性能提升。 diff --git a/totrans/doc22_023.md b/totrans/doc22_023.md index 3a6823a4..f8427347 100644 --- a/totrans/doc22_023.md +++ b/totrans/doc22_023.md @@ -1,12 +1,12 @@ # 数值精度 -> 原文：[https://pytorch.org/docs/stable/notes/numerical_accuracy.html](https://pytorch.org/docs/stable/notes/numerical_accuracy.html) +> 原文：[`pytorch.org/docs/stable/notes/numerical_accuracy.html`](https://pytorch.org/docs/stable/notes/numerical_accuracy.html) -在现代计算机中，浮点数使用IEEE 754标准表示。有关浮点运算和IEEE 754标准的更多详细信息，请参见[浮点运算](https://en.wikipedia.org/wiki/Floating-point_arithmetic)。特别要注意的是，浮点提供有限的精度（单精度浮点数约为7位小数，双精度浮点数约为16位小数），浮点加法和乘法不是结合的，因此操作的顺序会影响结果。因此，PyTorch不能保证对于数学上相同的浮点计算产生按位相同的结果。同样，即使在控制随机源后，PyTorch发布、单个提交或不同平台之间也不能保证按位相同的结果。特别是，即使输入按位相同，CPU和GPU的结果也可能不同。 +在现代计算机中，浮点数使用 IEEE 754 标准表示。有关浮点运算和 IEEE 754 标准的更多详细信息，请参见[浮点运算](https://en.wikipedia.org/wiki/Floating-point_arithmetic)。特别要注意的是，浮点提供有限的精度（单精度浮点数约为 7 位小数，双精度浮点数约为 16 位小数），浮点加法和乘法不是结合的，因此操作的顺序会影响结果。因此，PyTorch 不能保证对于数学上相同的浮点计算产生按位相同的结果。同样，即使在控制随机源后，PyTorch 发布、单个提交或不同平台之间也不能保证按位相同的结果。特别是，即使输入按位相同，CPU 和 GPU 的结果也可能不同。 ## 批处理计算或切片计算[](#batched-computations-or-slice-computations "跳转到此标题") -PyTorch中的许多操作支持批处理计算，其中对输入批次的元素执行相同的操作。一个例子是[`torch.mm()`](../generated/torch.mm.html#torch.mm "torch.mm")和[`torch.bmm()`](../generated/torch.bmm.html#torch.bmm "torch.bmm")。可以将批处理计算实现为对批处理元素的循环，并对各个批处理元素应用必要的数学操作，出于效率原因，我们没有这样做，通常对整个批次进行计算。在这种情况下，我们调用的数学库和PyTorch内部操作的实现可能与非批处理计算产生略有不同的结果。特别是，设`A`和`B`为适合批处理矩阵乘法的三维张量。那么`(A@B)[0]`（批处理结果的第一个元素）不能保证与`A[0]@B[0]`（输入批次的第一个元素的矩阵乘积）按位相同，尽管在数学上它是相同的计算。 +PyTorch 中的许多操作支持批处理计算，其中对输入批次的元素执行相同的操作。一个例子是`torch.mm()`和`torch.bmm()`。可以将批处理计算实现为对批处理元素的循环，并对各个批处理元素应用必要的数学操作，出于效率原因，我们没有这样做，通常对整个批次进行计算。在这种情况下，我们调用的数学库和 PyTorch 内部操作的实现可能与非批处理计算产生略有不同的结果。特别是，设`A`和`B`为适合批处理矩阵乘法的三维张量。那么`(A@B)[0]`（批处理结果的第一个元素）不能保证与`A[0]@B[0]`（输入批次的第一个元素的矩阵乘积）按位相同，尽管在数学上它是相同的计算。 类似地，对张量切片应用的操作不能保证产生与对完整张量应用相同操作的结果切片相同。例如，设`A`为一个二维张量。`A.sum(-1)[0]`不能保证与`A[:,0].sum()`按位相等。 @@ -27,47 +27,47 @@ a.double().norm() # produces tensor(1.4142e+20, dtype=torch.float64), representa `torch.linalg` 使用的外部库（后端）在输入具有非有限值（如`inf`或`NaN`）时不提供其行为的任何保证。因此，PyTorch 也不提供。这些操作可能返回一个带有非有限值的张量，或引发异常，甚至导致段错误。 -在调用这些函数之前考虑使用[`torch.isfinite()`](../generated/torch.isfinite.html#torch.isfinite "torch.isfinite")来检测这种情况。 +在调用这些函数之前考虑使用`torch.isfinite()`来检测这种情况。 -### linalg中的极端值 +### linalg 中的极端值 -`torch.linalg` 中的函数比其他PyTorch函数具有更多的[极端值](#extremal-values)。 +`torch.linalg` 中的函数比其他 PyTorch 函数具有更多的极端值。 -[求解器](../linalg.html#linalg-solvers)和[逆矩阵](../linalg.html#linalg-inverses)假设输入矩阵`A`是可逆的。如果它接近不可逆（例如，如果它具有非常小的奇异值），那么这些算法可能会悄悄返回不正确的结果。这些矩阵被称为[病态矩阵](https://nhigham.com/2020/03/19/what-is-a-condition-number/)。如果提供了病态输入，这些函数的结果可能会因在不同设备上使用相同输入或通过关键字`driver`使用不同后端而有所不同。 +求解器和逆矩阵假设输入矩阵`A`是可逆的。如果它接近不可逆（例如，如果它具有非常小的奇异值），那么这些算法可能会悄悄返回不正确的结果。这些矩阵被称为[病态矩阵](https://nhigham.com/2020/03/19/what-is-a-condition-number/)。如果提供了病态输入，这些函数的结果可能会因在不同设备上使用相同输入或通过关键字`driver`使用不同后端而有所不同。 像`svd`、`eig`和`eigh`这样的谱操作在它们的输入具有接近的奇异值时也可能返回不正确的结果（它们的梯度可能是无穷大的）。这是因为用于计算这些分解的算法在这些输入上很难收敛。 -以`float64`（默认情况下NumPy所做的）运行计算通常有所帮助，但并不总是解决所有问题。通过[`torch.linalg.svdvals()`](../generated/torch.linalg.svdvals.html#torch.linalg.svdvals "torch.linalg.svdvals")分析输入的频谱或通过[`torch.linalg.cond()`](../generated/torch.linalg.cond.html#torch.linalg.cond "torch.linalg.cond")分析它们的条件数可能有助于检测这些问题。 +以`float64`（默认情况下 NumPy 所做的）运行计算通常有所帮助，但并不总是解决所有问题。通过`torch.linalg.svdvals()`分析输入的频谱或通过`torch.linalg.cond()`分析它们的条件数可能有助于检测这些问题。 -## Nvidia Ampere（以及之后）设备上的TensorFloat-32（TF32）[](#tensorfloat-32-tf32-on-nvidia-ampere-and-later-devices "跳转到此标题的永久链接") +## Nvidia Ampere（以及之后）设备上的 TensorFloat-32（TF32）[](#tensorfloat-32-tf32-on-nvidia-ampere-and-later-devices "跳转到此标题的永久链接") -在Ampere（以及之后）的Nvidia GPU上，PyTorch可以使用TensorFloat32（TF32）来加速数学密集型操作，特别是矩阵乘法和卷积。当使用TF32张量核心执行操作时，只读取输入尾数的前10位。这可能会降低精度并产生令人惊讶的结果（例如，将矩阵乘以单位矩阵可能会产生与输入不同的结果）。默认情况下，TF32张量核心在矩阵乘法中被禁用，并在卷积中启用，尽管大多数神经网络工作负载在使用TF32时具有与fp32相同的收敛行为。如果您的网络不需要完整的float32精度，我们建议通过`torch.backends.cuda.matmul.allow_tf32 = True`启用TF32张量核心进行矩阵乘法。如果您的网络在矩阵乘法和卷积中都需要完整的float32精度，则可以通过`torch.backends.cudnn.allow_tf32 = False`禁用卷积的TF32张量核心。 +在 Ampere（以及之后）的 Nvidia GPU 上，PyTorch 可以使用 TensorFloat32（TF32）来加速数学密集型操作，特别是矩阵乘法和卷积。当使用 TF32 张量核心执行操作时，只读取输入尾数的前 10 位。这可能会降低精度并产生令人惊讶的结果（例如，将矩阵乘以单位矩阵可能会产生与输入不同的结果）。默认情况下，TF32 张量核心在矩阵乘法中被禁用，并在卷积中启用，尽管大多数神经网络工作负载在使用 TF32 时具有与 fp32 相同的收敛行为。如果您的网络不需要完整的 float32 精度，我们建议通过`torch.backends.cuda.matmul.allow_tf32 = True`启用 TF32 张量核心进行矩阵乘法。如果您的网络在矩阵乘法和卷积中都需要完整的 float32 精度，则可以通过`torch.backends.cudnn.allow_tf32 = False`禁用卷积的 TF32 张量核心。 -有关更多信息，请参阅[TensorFloat32](cuda.html#tf32-on-ampere)。 +有关更多信息，请参阅 TensorFloat32。 -## FP16和BF16 GEMM的降低精度[](#reduced-precision-reduction-for-fp16-and-bf16-gemms "跳转到此标题的永久链接") +## FP16 和 BF16 GEMM 的降低精度[](#reduced-precision-reduction-for-fp16-and-bf16-gemms "跳转到此标题的永久链接") -半精度GEMM操作通常使用单精度进行中间累积（降低）以提高数值精度和对溢出的抵抗力。为了性能，某些GPU架构，特别是较新的架构，允许将中间累积结果截断为降低精度（例如，半精度）。从模型收敛的角度来看，这种变化通常是良性的，尽管它可能导致意外的结果（例如，当最终结果应该在半精度中表示时出现`inf`值）。如果降低精度的降低造成问题，可以通过`torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction = False`关闭。 +半精度 GEMM 操作通常使用单精度进行中间累积（降低）以提高数值精度和对溢出的抵抗力。为了性能，某些 GPU 架构，特别是较新的架构，允许将中间累积结果截断为降低精度（例如，半精度）。从模型收敛的角度来看，这种变化通常是良性的，尽管它可能导致意外的结果（例如，当最终结果应该在半精度中表示时出现`inf`值）。如果降低精度的降低造成问题，可以通过`torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction = False`关闭。 -BF16 GEMM操作也有类似的标志，默认情况下是打开的。如果BF16降低精度造成问题，可以通过`torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction = False`关闭。 +BF16 GEMM 操作也有类似的标志，默认情况下是打开的。如果 BF16 降低精度造成问题，可以通过`torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction = False`关闭。 -有关更多信息，请参阅[allow_fp16_reduced_precision_reduction](cuda.html#fp16reducedprecision)和[allow_bf16_reduced_precision_reduction](cuda.html#bf16reducedprecision) +有关更多信息，请参阅 allow_fp16_reduced_precision_reduction 和 allow_bf16_reduced_precision_reduction -## 在AMD Instinct MI200设备上降低精度的FP16和BF16 GEMMs和卷积[](#reduced-precision-fp16-and-bf16-gemms-and-convolutions-on-amd-instinct-mi200-devices "跳转到此标题的永久链接") +## 在 AMD Instinct MI200 设备上降低精度的 FP16 和 BF16 GEMMs 和卷积[](#reduced-precision-fp16-and-bf16-gemms-and-convolutions-on-amd-instinct-mi200-devices "跳转到此标题的永久链接") -在AMD Instinct MI200 GPU上，FP16和BF16 V_DOT2和MFMA矩阵指令会将输入和输出的非规范化值刷新为零。FP32和FP64 MFMA矩阵指令不会将输入和输出的非规范化值刷新为零。受影响的指令仅由rocBLAS（GEMM）和MIOpen（卷积）内核使用；所有其他PyTorch操作不会遇到这种行为。所有其他支持的AMD GPU不会遇到这种行为。 +在 AMD Instinct MI200 GPU 上，FP16 和 BF16 V_DOT2 和 MFMA 矩阵指令会将输入和输出的非规范化值刷新为零。FP32 和 FP64 MFMA 矩阵指令不会将输入和输出的非规范化值刷新为零。受影响的指令仅由 rocBLAS（GEMM）和 MIOpen（卷积）内核使用；所有其他 PyTorch 操作不会遇到这种行为。所有其他支持的 AMD GPU 不会遇到这种行为。 -rocBLAS和MIOpen为受影响的FP16操作提供了替代实现。不提供BF16操作的替代实现；BF16数字的动态范围比FP16数字大，不太可能遇到非规范化值。对于FP16替代实现，FP16输入值被转换为中间BF16值，然后在累积FP32操作后转换回FP16输出。通过这种方式，输入和输出类型保持不变。 +rocBLAS 和 MIOpen 为受影响的 FP16 操作提供了替代实现。不提供 BF16 操作的替代实现；BF16 数字的动态范围比 FP16 数字大，不太可能遇到非规范化值。对于 FP16 替代实现，FP16 输入值被转换为中间 BF16 值，然后在累积 FP32 操作后转换回 FP16 输出。通过这种方式，输入和输出类型保持不变。 -在使用FP16精度训练时，一些模型可能无法收敛，因为FP16 denorms被刷新为零。在训练的反向传播过程中，梯度计算过程中更频繁地出现非规范化值。PyTorch默认会在反向传播过程中使用rocBLAS和MIOpen的替代实现。可以使用环境变量ROCBLAS_INTERNAL_FP16_ALT_IMPL和MIOPEN_DEBUG_CONVOLUTION_ATTRIB_FP16_ALT_IMPL来覆盖默认行为。这些环境变量的行为如下： +在使用 FP16 精度训练时，一些模型可能无法收敛，因为 FP16 denorms 被刷新为零。在训练的反向传播过程中，梯度计算过程中更频繁地出现非规范化值。PyTorch 默认会在反向传播过程中使用 rocBLAS 和 MIOpen 的替代实现。可以使用环境变量 ROCBLAS_INTERNAL_FP16_ALT_IMPL 和 MIOPEN_DEBUG_CONVOLUTION_ATTRIB_FP16_ALT_IMPL 来覆盖默认行为。这些环境变量的行为如下： | | 前向 | 反向 | | --- | --- | --- | | 环境取消设置 | 原始 | 替代 | -| 环境设置为1 | 替代 | 替代 | -| 环境设置为0 | 原始 | 原始 | +| 环境设置为 1 | 替代 | 替代 | +| 环境设置为 0 | 原始 | 原始 | -以下是可能使用rocBLAS的操作列表： +以下是可能使用 rocBLAS 的操作列表： + torch.addbmm @@ -87,7 +87,7 @@ rocBLAS和MIOpen为受影响的FP16操作提供了替代实现。不提供BF16 + torch.sparse.addmm -+ 以下是torch._C._ConvBackend实现列表： ++ 以下是 torch._C._ConvBackend 实现列表： + slowNd @@ -97,11 +97,11 @@ rocBLAS和MIOpen为受影响的FP16操作提供了替代实现。不提供BF16 + slowNd_dilated_transposed -以下是可能使用MIOpen的操作列表： +以下是可能使用 MIOpen 的操作列表： + torch.nn.Conv[Transpose]Nd -+ 以下是torch._C._ConvBackend实现列表： ++ 以下是 torch._C._ConvBackend 实现列表： + ConvBackend::Miopen diff --git a/totrans/doc22_024.md b/totrans/doc22_024.md index f0c2a780..8f742195 100644 --- a/totrans/doc22_024.md +++ b/totrans/doc22_024.md @@ -1,10 +1,10 @@ # 可复制性 -> 原文：[https://pytorch.org/docs/stable/notes/randomness.html](https://pytorch.org/docs/stable/notes/randomness.html) +> 原文：[`pytorch.org/docs/stable/notes/randomness.html`](https://pytorch.org/docs/stable/notes/randomness.html) -在PyTorch发布、单个提交或不同平台之间不能保证完全可复制的结果。此外，即使使用相同的种子，在CPU和GPU执行之间的结果也可能无法复制。 +在 PyTorch 发布、单个提交或不同平台之间不能保证完全可复制的结果。此外，即使使用相同的种子，在 CPU 和 GPU 执行之间的结果也可能无法复制。 -然而，您可以采取一些步骤来限制特定平台、设备和PyTorch发布的不确定行为源的数量。首先，您可以控制可能导致应用程序多次执行时行为不同的随机性源。其次，您可以配置PyTorch以避免对某些操作使用非确定性算法，以便对这些操作进行多次调用时，给定相同的输入，将产生相同的结果。 +然而，您可以采取一些步骤来限制特定平台、设备和 PyTorch 发布的不确定行为源的数量。首先，您可以控制可能导致应用程序多次执行时行为不同的随机性源。其次，您可以配置 PyTorch 以避免对某些操作使用非确定性算法，以便对这些操作进行多次调用时，给定相同的输入，将产生相同的结果。 警告 @@ -12,22 +12,22 @@ ## 控制随机性源[](#controlling-sources-of-randomness "Permalink to this heading") -### PyTorch随机数生成器[](#pytorch-random-number-generator "Permalink to this heading") +### PyTorch 随机数生成器[](#pytorch-random-number-generator "Permalink to this heading") -您可以使用[`torch.manual_seed()`](../generated/torch.manual_seed.html#torch.manual_seed "torch.manual_seed")为所有设备（CPU和CUDA）设置RNG的种子： +您可以使用`torch.manual_seed()`为所有设备（CPU 和 CUDA）设置 RNG 的种子： ```py import torch torch.manual_seed(0) ``` -一些PyTorch操作可能在内部使用随机数。例如，[`torch.svd_lowrank()`](../generated/torch.svd_lowrank.html#torch.svd_lowrank "torch.svd_lowrank")就是这样。因此，连续多次使用相同的输入参数调用它可能会产生不同的结果。然而，只要在应用程序开头将[`torch.manual_seed()`](../generated/torch.manual_seed.html#torch.manual_seed "torch.manual_seed")设置为常量，并且已经消除了所有其他不确定性源，每次在相同环境中运行应用程序时都会生成相同系列的随机数。 +一些 PyTorch 操作可能在内部使用随机数。例如，`torch.svd_lowrank()`就是这样。因此，连续多次使用相同的输入参数调用它可能会产生不同的结果。然而，只要在应用程序开头将`torch.manual_seed()`设置为常量，并且已经消除了所有其他不确定性源，每次在相同环境中运行应用程序时都会生成相同系列的随机数。 -通过在连续调用之间将[`torch.manual_seed()`](../generated/torch.manual_seed.html#torch.manual_seed "torch.manual_seed")设置为相同的值，也可以从使用随机数的操作中获得相同的结果。 +通过在连续调用之间将`torch.manual_seed()`设置为相同的值，也可以从使用随机数的操作中获得相同的结果。 ### Python -对于自定义操作符，您可能还需要设置python种子： +对于自定义操作符，您可能还需要设置 python 种子： ```py import random @@ -36,22 +36,22 @@ random.seed(0) ### 其他库中的随机数生成器[](#random-number-generators-in-other-libraries "Permalink to this heading") -如果您或您正在使用的任何库依赖于NumPy，您可以使用以下方法为全局NumPy RNG设置种子： +如果您或您正在使用的任何库依赖于 NumPy，您可以使用以下方法为全局 NumPy RNG 设置种子： ```py import numpy as np np.random.seed(0) ``` -然而，一些应用程序和库可能使用NumPy随机生成器对象，而不是全局RNG ([https://numpy.org/doc/stable/reference/random/generator.html](https://numpy.org/doc/stable/reference/random/generator.html))，这些对象也需要一致地设置种子。 +然而，一些应用程序和库可能使用 NumPy 随机生成器对象，而不是全局 RNG ([`numpy.org/doc/stable/reference/random/generator.html`](https://numpy.org/doc/stable/reference/random/generator.html))，这些对象也需要一致地设置种子。 如果您正在使用任何其他使用随机数生成器的库，请参考这些库的文档，看看如何为它们设置一致的种子。 -### CUDA卷积基准测试[](#cuda-convolution-benchmarking "Permalink to this heading") +### CUDA 卷积基准测试[](#cuda-convolution-benchmarking "Permalink to this heading") -由CUDA卷积操作使用的cuDNN库可能是应用程序多次执行中的不确定性源。当使用新的大小参数集调用cuDNN卷积时，一个可选功能可以运行多个卷积算法，并对它们进行基准测试以找到最快的算法。然后，在接下来的过程中，将始终使用最快的算法来处理相应的大小参数集。由于基准测试噪声和不同的硬件，基准测试可能会在后续运行中选择不同的算法，即使在同一台机器上也是如此。 +由 CUDA 卷积操作使用的 cuDNN 库可能是应用程序多次执行中的不确定性源。当使用新的大小参数集调用 cuDNN 卷积时，一个可选功能可以运行多个卷积算法，并对它们进行基准测试以找到最快的算法。然后，在接下来的过程中，将始终使用最快的算法来处理相应的大小参数集。由于基准测试噪声和不同的硬件，基准测试可能会在后续运行中选择不同的算法，即使在同一台机器上也是如此。 -通过使用`torch.backends.cudnn.benchmark = False`禁用基准测试功能，可以使cuDNN确定性地选择算法，可能会以降低性能为代价。 +通过使用`torch.backends.cudnn.benchmark = False`禁用基准测试功能，可以使 cuDNN 确定性地选择算法，可能会以降低性能为代价。 然而，如果您不需要在应用程序的多次执行之间实现可重现性，则启用基准测试功能可能会提高性能，方法是使用`torch.backends.cudnn.benchmark = True`。 @@ -59,11 +59,11 @@ np.random.seed(0) ## 避免非确定性算法[](#avoiding-nondeterministic-algorithms "跳转到此标题") -[`torch.use_deterministic_algorithms()`](../generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms "torch.use_deterministic_algorithms")允许您配置PyTorch使用确定性算法，而不是非确定性算法（如果有的话），并且如果已知某个操作是非确定性的（且没有确定性替代方案），则会引发错误。 +`torch.use_deterministic_algorithms()`允许您配置 PyTorch 使用确定性算法，而不是非确定性算法（如果有的话），并且如果已知某个操作是非确定性的（且没有确定性替代方案），则会引发错误。 -请查看[`torch.use_deterministic_algorithms()`](../generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms "torch.use_deterministic_algorithms")文档，获取受影响操作的完整列表。如果某个操作未按照文档正确执行，或者您需要一个没有确定性实现的操作的确定性实现，请提交一个问题：[https://github.com/pytorch/pytorch/issues?q=label:%22module:%20determinism%22](https://github.com/pytorch/pytorch/issues?q=label:%22module:%20determinism%22) +请查看`torch.use_deterministic_algorithms()`文档，获取受影响操作的完整列表。如果某个操作未按照文档正确执行，或者您需要一个没有确定性实现的操作的确定性实现，请提交一个问题：[`github.com/pytorch/pytorch/issues?q=label:%22module:%20determinism%22`](https://github.com/pytorch/pytorch/issues?q=label:%22module:%20determinism%22) -例如，运行[`torch.Tensor.index_add_()`](../generated/torch.Tensor.index_add_.html#torch.Tensor.index_add_ "torch.Tensor.index_add_")的非确定性CUDA实现将引发错误： +例如，运行`torch.Tensor.index_add_()`的非确定性 CUDA 实现将引发错误： ```py >>> import torch @@ -75,7 +75,7 @@ RuntimeError: index_add_cuda_ does not have a deterministic implementation, but 'torch.use_deterministic_algorithms(True)'. ... ``` -当使用稀疏-稠密CUDA张量调用[`torch.bmm()`](../generated/torch.bmm.html#torch.bmm "torch.bmm")时，通常会使用一个非确定性算法，但当打开确定性标志时，将使用其备用确定性实现： +当使用稀疏-稠密 CUDA 张量调用`torch.bmm()`时，通常会使用一个非确定性算法，但当打开确定性标志时，将使用其备用确定性实现： ```py >>> import torch @@ -87,25 +87,25 @@ tensor([[[ 1.1900, -2.3409], [ 0.0333, -1.1444]]], device='cuda:0') ``` -此外，如果您正在使用CUDA张量，并且CUDA版本为10.2或更高，则应根据CUDA文档设置环境变量CUBLAS_WORKSPACE_CONFIG：[https://docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility](https://docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility) +此外，如果您正在使用 CUDA 张量，并且 CUDA 版本为 10.2 或更高，则应根据 CUDA 文档设置环境变量 CUBLAS_WORKSPACE_CONFIG：[`docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility`](https://docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility) -### CUDA卷积确定性性[](#cuda-convolution-determinism "跳转到此标题") +### CUDA 卷积确定性性[](#cuda-convolution-determinism "跳转到此标题") -虽然禁用CUDA卷积基准测试（如上所述）确保CUDA每次运行应用程序时选择相同的算法，但该算法本身可能是非确定性的，除非设置`torch.use_deterministic_algorithms(True)`或`torch.backends.cudnn.deterministic = True`。后者仅控制此行为，不像[`torch.use_deterministic_algorithms()`](../generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms "torch.use_deterministic_algorithms")会使其他PyTorch操作也表现出确定性。 +虽然禁用 CUDA 卷积基准测试（如上所述）确保 CUDA 每次运行应用程序时选择相同的算法，但该算法本身可能是非确定性的，除非设置`torch.use_deterministic_algorithms(True)`或`torch.backends.cudnn.deterministic = True`。后者仅控制此行为，不像`torch.use_deterministic_algorithms()`会使其他 PyTorch 操作也表现出确定性。 -### CUDA RNN和LSTM +### CUDA RNN 和 LSTM -在某些版本的CUDA中，RNN和LSTM网络可能具有非确定性行为。有关详细信息和解决方法，请参阅[`torch.nn.RNN()`](../generated/torch.nn.RNN.html#torch.nn.RNN "torch.nn.RNN")和[`torch.nn.LSTM()`](../generated/torch.nn.LSTM.html#torch.nn.LSTM "torch.nn.LSTM")。 +在某些版本的 CUDA 中，RNN 和 LSTM 网络可能具有非确定性行为。有关详细信息和解决方法，请参阅`torch.nn.RNN()`和`torch.nn.LSTM()`。 ### 填充未初始化内存[](#filling-uninitialized-memory "跳转到此标题") -像[`torch.empty()`](../generated/torch.empty.html#torch.empty "torch.empty")和[`torch.Tensor.resize_()`](../generated/torch.Tensor.resize_.html#torch.Tensor.resize_ "torch.Tensor.resize_")这样的操作可能返回具有未初始化内存的张量，其中包含未定义的值。如果需要确定性，将这样的张量用作另一个操作的输入是无效的，因为输出将是不确定的。但实际上没有任何东西可以阻止运行这种无效代码。因此，为了安全起见，默认情况下将[`torch.utils.deterministic.fill_uninitialized_memory`](../deterministic.html#torch.utils.deterministic.fill_uninitialized_memory "torch.utils.deterministic.fill_uninitialized_memory")设置为`True`，如果设置了`torch.use_deterministic_algorithms(True)`，则会使用已知值填充未初始化的内存。这将防止这种非确定性行为的可能性。 +像`torch.empty()`和`torch.Tensor.resize_()`这样的操作可能返回具有未初始化内存的张量，其中包含未定义的值。如果需要确定性，将这样的张量用作另一个操作的输入是无效的，因为输出将是不确定的。但实际上没有任何东西可以阻止运行这种无效代码。因此，为了安全起见，默认情况下将`torch.utils.deterministic.fill_uninitialized_memory`设置为`True`，如果设置了`torch.use_deterministic_algorithms(True)`，则会使用已知值填充未初始化的内存。这将防止这种非确定性行为的可能性。 然而，填充未初始化内存对性能有害。因此，如果您的程序有效且不将未初始化内存用作操作的输入，则可以关闭此设置以获得更好的性能。 ## DataLoader -DataLoader将根据[多进程数据加载中的随机性](../data.html#data-loading-randomness)算法重新播种工作进程。使用`worker_init_fn()`和生成器来保持可重现性： +DataLoader 将根据多进程数据加载中的随机性算法重新播种工作进程。使用`worker_init_fn()`和生成器来保持可重现性： ```py def seed_worker(worker_id): diff --git a/totrans/doc22_025.md b/totrans/doc22_025.md index 1a1e68d5..240143e5 100644 --- a/totrans/doc22_025.md +++ b/totrans/doc22_025.md @@ -1,32 +1,32 @@ # 序列化语义 -> 原文：[https://pytorch.org/docs/stable/notes/serialization.html](https://pytorch.org/docs/stable/notes/serialization.html) +> 原文：[`pytorch.org/docs/stable/notes/serialization.html`](https://pytorch.org/docs/stable/notes/serialization.html) -本说明描述了如何在Python中保存和加载PyTorch张量和模块状态，以及如何序列化Python模块，以便它们可以在C++中加载。 +本说明描述了如何在 Python 中保存和加载 PyTorch 张量和模块状态，以及如何序列化 Python 模块，以便它们可以在 C++中加载。 目录 -+ [序列化语义](#serialization-semantics) ++ 序列化语义 - + [保存和加载张量](#saving-and-loading-tensors) + + 保存和加载张量 - + [保存和加载张量保留视图](#saving-and-loading-tensors-preserves-views) + + 保存和加载张量保留视图 - + [保存和加载torch.nn.Modules](#saving-and-loading-torch-nn-modules) + + 保存和加载 torch.nn.Modules - + [序列化torch.nn.Modules并在C++中加载它们](#serializing-torch-nn-modules-and-loading-them-in-c) + + 序列化 torch.nn.Modules 并在 C++中加载它们 - + [在不同PyTorch版本中保存和加载ScriptModules](#saving-and-loading-scriptmodules-across-pytorch-versions) + + 在不同 PyTorch 版本中保存和加载 ScriptModules - + [torch.div执行整数除法](#torch-div-performing-integer-division) + + torch.div 执行整数除法 - + [torch.full总是推断为浮点dtype](#torch-full-always-inferring-a-float-dtype) + + torch.full 总是推断为浮点 dtype - + [实用函数](#utility-functions) + + 实用函数 -## [保存和加载张量](#id3)[](#saving-and-loading-tensors "跳转到此标题") +## 保存和加载张量[](#saving-and-loading-tensors "跳转到此标题") -[`torch.save()`](../generated/torch.save.html#torch.save "torch.save") 和 [`torch.load()`](../generated/torch.load.html#torch.load "torch.load") 让您轻松保存和加载张量： +`torch.save()` 和 `torch.load()` 让您轻松保存和加载张量： ```py >>> t = torch.tensor([1., 2.]) @@ -35,9 +35,9 @@ tensor([1., 2.]) ``` -按照惯例，PyTorch文件通常使用‘.pt’或‘.pth’扩展名编写。 +按照惯例，PyTorch 文件通常使用‘.pt’或‘.pth’扩展名编写。 -[`torch.save()`](../generated/torch.save.html#torch.save "torch.save") 和 [`torch.load()`](../generated/torch.load.html#torch.load "torch.load") 默认使用Python的pickle，因此您也可以将多个张量保存为Python对象的一部分，如元组、列表和字典： +`torch.save()` 和 `torch.load()` 默认使用 Python 的 pickle，因此您也可以将多个张量保存为 Python 对象的一部分，如元组、列表和字典： ```py >>> d = {'a': torch.tensor([1., 2.]), 'b': torch.tensor([3., 4.])} @@ -46,7 +46,7 @@ tensor([1., 2.]) {'a': tensor([1., 2.]), 'b': tensor([3., 4.])} ``` -如果数据结构是可pickle的，那么包含PyTorch张量的自定义数据结构也可以保存。## [保存和加载张量保留视图](#id4)[](#saving-and-loading-tensors-preserves-views "跳转到此标题") +如果数据结构是可 pickle 的，那么包含 PyTorch 张量的自定义数据结构也可以保存。## 保存和加载张量保留视图[](#saving-and-loading-tensors-preserves-views "跳转到此标题") 保存张量保留它们的视图关系： @@ -62,7 +62,7 @@ tensor([ 1, 4, 3, 8, 5, 12, 7, 16, 9]) 在幕后，这些张量共享相同的“存储”。查看[Tensor Views](https://pytorch.org/docs/main/tensor_view.html)了解更多关于视图和存储的信息。 -当PyTorch保存张量时，它会分别保存它们的存储对象和张量元数据。这是一个实现细节，可能会在将来发生变化，但通常可以节省空间，并让PyTorch轻松重建加载的张量之间的视图关系。例如，在上面的代码片段中，只有一个存储被写入到‘tensors.pt’中。 +当 PyTorch 保存张量时，它会分别保存它们的存储对象和张量元数据。这是一个实现细节，可能会在将来发生变化，但通常可以节省空间，并让 PyTorch 轻松重建加载的张量之间的视图关系。例如，在上面的代码片段中，只有一个存储被写入到‘tensors.pt’中。 然而，在某些情况下，保存当前存储对象可能是不必要的，并且会创建过大的文件。在下面的代码片段中，一个比保存的张量大得多的存储被写入到文件中： @@ -75,7 +75,7 @@ tensor([ 1, 4, 3, 8, 5, 12, 7, 16, 9]) 999 ``` -与仅将小张量中的五个值保存到‘small.pt’不同，它与large共享的存储中的999个值被保存和加载。 +与仅将小张量中的五个值保存到‘small.pt’不同，它与 large 共享的存储中的 999 个值被保存和加载。 当保存具有比其存储对象更少元素的张量时，可以通过首先克隆张量来减小保存文件的大小。克隆张量会产生一个新的张量，其中包含张量中的值的新存储对象： @@ -88,11 +88,11 @@ tensor([ 1, 4, 3, 8, 5, 12, 7, 16, 9]) 5 ``` -然而，由于克隆的张量彼此独立，它们没有原始张量的视图关系。如果在保存比其存储对象小的张量时，文件大小和视图关系都很重要，则必须小心构建新张量，以最小化其存储对象的大小，但仍具有所需的视图关系后再保存。## [保存和加载torch.nn.Modules](#id5)[](#saving-and-loading-torch-nn-modules "跳转到此标题") +然而，由于克隆的张量彼此独立，它们没有原始张量的视图关系。如果在保存比其存储对象小的张量时，文件大小和视图关系都很重要，则必须小心构建新张量，以最小化其存储对象的大小，但仍具有所需的视图关系后再保存。## 保存和加载 torch.nn.Modules[](#saving-and-loading-torch-nn-modules "跳转到此标题") 参见：[教程：保存和加载模块](https://pytorch.org/tutorials/beginner/saving_loading_models.html) -在PyTorch中，模块的状态经常使用‘state dict’进行序列化。模块的状态字典包含所有参数和持久缓冲区： +在 PyTorch 中，模块的状态经常使用‘state dict’进行序列化。模块的状态字典包含所有参数和持久缓冲区： ```py >>> bn = torch.nn.BatchNorm1d(3, track_running_stats=True) @@ -113,7 +113,7 @@ OrderedDict([('weight', tensor([1., 1., 1.])), ('num_batches_tracked', tensor(0))]) ``` -为了兼容性的原因，建议不直接保存模块，而是只保存其状态字典。Python模块甚至有一个函数[`load_state_dict()`](../generated/torch.nn.Module.html#torch.nn.Module.load_state_dict "torch.nn.Module.load_state_dict")，可以从状态字典中恢复它们的状态： +为了兼容性的原因，建议不直接保存模块，而是只保存其状态字典。Python 模块甚至有一个函数`load_state_dict()`，可以从状态字典中恢复它们的状态： ```py >>> torch.save(bn.state_dict(), 'bn.pt') @@ -123,7 +123,7 @@ OrderedDict([('weight', tensor([1., 1., 1.])), ``` -请注意，状态字典首先使用[`torch.load()`](../generated/torch.load.html#torch.load "torch.load")从文件中加载，然后使用[`load_state_dict()`](../generated/torch.nn.Module.html#torch.nn.Module.load_state_dict "torch.nn.Module.load_state_dict")恢复状态。 +请注意，状态字典首先使用`torch.load()`从文件中加载，然后使用`load_state_dict()`恢复状态。 即使是自定义模块和包含其他模块的模块也有状态字典，并且可以使用这种模式： @@ -153,15 +153,15 @@ OrderedDict([('l0.weight', tensor([[ 0.1400, 0.4563, -0.0271, -0.4406], >>> new_m = MyModule() >>> new_m.load_state_dict(m_state_dict) -``` ## [序列化torch.nn.Modules并在C++中加载它们](#id6)[](#serializing-torch-nn-modules-and-loading-them-in-c "跳转到此标题") +``` ## 序列化 torch.nn.Modules 并在 C++中加载它们[](#serializing-torch-nn-modules-and-loading-them-in-c "跳转到此标题") -另请参阅：[教程：在C++中加载TorchScript模型](https://pytorch.org/tutorials/advanced/cpp_export.html) +另请参阅：[教程：在 C++中加载 TorchScript 模型](https://pytorch.org/tutorials/advanced/cpp_export.html) -ScriptModules可以被序列化为TorchScript程序，并使用[`torch.jit.load()`](../generated/torch.jit.load.html#torch.jit.load "torch.jit.load")加载。这种序列化编码了所有模块的方法、子模块、参数和属性，并允许在C++中加载序列化的程序（即不需要Python）。 +ScriptModules 可以被序列化为 TorchScript 程序，并使用`torch.jit.load()`加载。这种序列化编码了所有模块的方法、子模块、参数和属性，并允许在 C++中加载序列化的程序（即不需要 Python）。 -[`torch.jit.save()`](../generated/torch.jit.save.html#torch.jit.save "torch.jit.save")和[`torch.save()`](../generated/torch.save.html#torch.save "torch.save")之间的区别可能不是立即清楚的。[`torch.save()`](../generated/torch.save.html#torch.save "torch.save")使用pickle保存Python对象。这对于原型设计、研究和训练特别有用。另一方面，[`torch.jit.save()`](../generated/torch.jit.save.html#torch.jit.save "torch.jit.save")将ScriptModules序列化为可以在Python或C++中加载的格式。这在保存和加载C++模块或在C++中运行在Python中训练的模块时非常有用，这是部署PyTorch模型时的常见做法。 +`torch.jit.save()`和`torch.save()`之间的区别可能不是立即清楚的。`torch.save()`使用 pickle 保存 Python 对象。这对于原型设计、研究和训练特别有用。另一方面，`torch.jit.save()`将 ScriptModules 序列化为可以在 Python 或 C++中加载的格式。这在保存和加载 C++模块或在 C++中运行在 Python 中训练的模块时非常有用，这是部署 PyTorch 模型时的常见做法。 -要在Python中脚本化、序列化和加载模块： +要在 Python 中脚本化、序列化和加载模块： ```py >>> scripted_module = torch.jit.script(MyModule()) @@ -172,7 +172,7 @@ RecursiveScriptModule( original_name=MyModule (l1): RecursiveScriptModule(original_name=Linear) ) ``` -跟踪模块也可以使用[`torch.jit.save()`](../generated/torch.jit.save.html#torch.jit.save "torch.jit.save")保存，但要注意只有跟踪的代码路径被序列化。以下示例演示了这一点： +跟踪模块也可以使用`torch.jit.save()`保存，但要注意只有跟踪的代码路径被序列化。以下示例演示了这一点： ```py # A module with control flow @@ -203,22 +203,22 @@ tensor([[-0.1571], [-0.3793]], grad_fn=) tensor(0) ``` -上述模块有一个if语句，不会被跟踪的输入触发，因此不是跟踪的模块的一部分，也不会与之一起序列化。然而，脚本化模块包含if语句，并与之一起序列化。有关脚本化和跟踪的更多信息，请参阅[TorchScript文档](https://pytorch.org/docs/stable/jit.html)。 +上述模块有一个 if 语句，不会被跟踪的输入触发，因此不是跟踪的模块的一部分，也不会与之一起序列化。然而，脚本化模块包含 if 语句，并与之一起序列化。有关脚本化和跟踪的更多信息，请参阅[TorchScript 文档](https://pytorch.org/docs/stable/jit.html)。 -最后，在C++中加载模块： +最后，在 C++中加载模块： ```py >>> torch::jit::script::Module module; >>> module = torch::jit::load('controlflowmodule_scripted.pt'); ``` -有关如何在C++中使用PyTorch模块的详细信息，请参阅[PyTorch C++ API文档](https://pytorch.org/cppdocs/)。## [在PyTorch版本间保存和加载ScriptModules](#id7)[](#saving-and-loading-scriptmodules-across-pytorch-versions "跳转到此标题") +有关如何在 C++中使用 PyTorch 模块的详细信息，请参阅[PyTorch C++ API 文档](https://pytorch.org/cppdocs/)。## 在 PyTorch 版本间保存和加载 ScriptModules[](#saving-and-loading-scriptmodules-across-pytorch-versions "跳转到此标题") -PyTorch团队建议使用相同版本的PyTorch保存和加载模块。较旧版本的PyTorch可能不支持较新的模块，而较新版本可能已删除或修改了较旧的行为。这些更改在PyTorch的[发布说明](https://github.com/pytorch/pytorch/releases)中有明确描述，依赖已更改功能的模块可能需要更新才能继续正常工作。在有限的情况下，如下所述，PyTorch将保留序列化ScriptModules的历史行为，因此它们不需要更新。 +PyTorch 团队建议使用相同版本的 PyTorch 保存和加载模块。较旧版本的 PyTorch 可能不支持较新的模块，而较新版本可能已删除或修改了较旧的行为。这些更改在 PyTorch 的[发布说明](https://github.com/pytorch/pytorch/releases)中有明确描述，依赖已更改功能的模块可能需要更新才能继续正常工作。在有限的情况下，如下所述，PyTorch 将保留序列化 ScriptModules 的历史行为，因此它们不需要更新。 -### [torch.div执行整数除法](#id8)[](#torch-div-performing-integer-division "跳转到此标题") +### torch.div 执行整数除法[](#torch-div-performing-integer-division "跳转到此标题") -在PyTorch 1.5及更早版本中，当给定两个整数输入时，[`torch.div()`](../generated/torch.div.html#torch.div "torch.div")将执行地板除法： +在 PyTorch 1.5 及更早版本中，当给定两个整数输入时，`torch.div()`将执行地板除法： ```py # PyTorch 1.5 (and earlier) @@ -228,7 +228,7 @@ PyTorch团队建议使用相同版本的PyTorch保存和加载模块。较旧版 tensor(1) ``` -然而，在PyTorch 1.7中，[`torch.div()`](../generated/torch.div.html#torch.div "torch.div")将始终执行其输入的真除法，就像Python 3中的除法一样： +然而，在 PyTorch 1.7 中，`torch.div()`将始终执行其输入的真除法，就像 Python 3 中的除法一样： ```py # PyTorch 1.7 @@ -238,11 +238,11 @@ tensor(1) tensor(1.6667) ``` -[`torch.div()`](../generated/torch.div.html#torch.div "torch.div")的行为在序列化的ScriptModules中得到保留。也就是说，使用PyTorch 1.6之前版本序列化的ScriptModules将继续看到当给定两个整数输入时，[`torch.div()`](../generated/torch.div.html#torch.div "torch.div")执行地板除法，即使在较新版本的PyTorch中加载时也是如此。然而，使用[`torch.div()`](../generated/torch.div.html#torch.div "torch.div")并在PyTorch 1.6及更高版本上序列化的ScriptModules无法在较早版本的PyTorch中加载，因为这些较早版本不理解新的行为。 +`torch.div()`的行为在序列化的 ScriptModules 中得到保留。也就是说，使用 PyTorch 1.6 之前版本序列化的 ScriptModules 将继续看到当给定两个整数输入时，`torch.div()`执行地板除法，即使在较新版本的 PyTorch 中加载时也是如此。然而，使用`torch.div()`并在 PyTorch 1.6 及更高版本上序列化的 ScriptModules 无法在较早版本的 PyTorch 中加载，因为这些较早版本不理解新的行为。 -### [torch.full总是推断浮点数据类型](#id9)[](#torch-full-always-inferring-a-float-dtype "跳转到此标题的永久链接") +### torch.full 总是推断浮点数据类型[](#torch-full-always-inferring-a-float-dtype "跳转到此标题的永久链接") -在PyTorch 1.5及更早版本中，[`torch.full()`](../generated/torch.full.html#torch.full "torch.full")始终返回一个浮点张量，而不管给定的填充值是什么： +在 PyTorch 1.5 及更早版本中，`torch.full()`始终返回一个浮点张量，而不管给定的填充值是什么： ```py # PyTorch 1.5 and earlier @@ -250,7 +250,7 @@ tensor(1.6667) tensor([1., 1., 1.]) # ...but float tensor! ``` -然而，在PyTorch 1.7中，[`torch.full()`](../generated/torch.full.html#torch.full "torch.full")将从填充值推断返回的张量的数据类型： +然而，在 PyTorch 1.7 中，`torch.full()`将从填充值推断返回的张量的数据类型： ```py # PyTorch 1.7 @@ -267,7 +267,7 @@ tensor([1., 1., 1.]) tensor([1.+1.j, 1.+1.j, 1.+1.j]) ``` -[`torch.full()`](../generated/torch.full.html#torch.full "torch.full")的行为在序列化的ScriptModules中得到保留。也就是说，使用PyTorch 1.6之前版本序列化的ScriptModules将继续看到torch.full默认返回浮点张量，即使给定布尔或整数填充值。然而，使用[`torch.full()`](../generated/torch.full.html#torch.full "torch.full")并在PyTorch 1.6及更高版本上序列化的ScriptModules无法在较早版本的PyTorch中加载，因为这些较早版本不理解新的行为。## [实用函数](#id10)[](#utility-functions "跳转到此标题的永久链接") +`torch.full()`的行为在序列化的 ScriptModules 中得到保留。也就是说，使用 PyTorch 1.6 之前版本序列化的 ScriptModules 将继续看到 torch.full 默认返回浮点张量，即使给定布尔或整数填充值。然而，使用`torch.full()`并在 PyTorch 1.6 及更高版本上序列化的 ScriptModules 无法在较早版本的 PyTorch 中加载，因为这些较早版本不理解新的行为。## 实用函数[](#utility-functions "跳转到此标题的永久链接") 以下实用函数与序列化相关： @@ -275,7 +275,7 @@ tensor([1.+1.j, 1.+1.j, 1.+1.j]) torch.serialization.register_package(priority, tagger, deserializer)¶ ``` -为标记和反序列化存储对象注册可调用对象，并附带优先级。标记在保存时将设备与存储对象关联，而在加载时反序列化将存储对象移动到适当的设备上。`tagger`和`deserializer`按照它们的`priority`给出的顺序运行，直到一个标记器/反序列化器返回一个不是None的值。 +为标记和反序列化存储对象注册可调用对象，并附带优先级。标记在保存时将设备与存储对象关联，而在加载时反序列化将存储对象移动到适当的设备上。`tagger`和`deserializer`按照它们的`priority`给出的顺序运行，直到一个标记器/反序列化器返回一个不是 None 的值。 要覆盖全局注册表中设备的反序列化行为，可以注册一个优先级高于现有标记器的标记器。 @@ -283,11 +283,11 @@ torch.serialization.register_package(priority, tagger, deserializer)¶ 参数 -+ **priority**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12)")）– 指示与标记器和反序列化器相关联的优先级，其中较低的值表示较高的优先级。 ++ **priority**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12)")）– 指示与标记器和反序列化器相关联的优先级，其中较低的值表示较高的优先级。 -+ **tagger**（[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在Python v3.12)")*[**[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12)")*[**Storage**,* [*TypedStorage*](../storage.html#torch.TypedStorage "torch.storage.TypedStorage")*,* [*UntypedStorage*](../storage.html#torch.UntypedStorage "torch.storage.UntypedStorage")*]**]**,* [*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")*]**]*) – 接受存储对象并返回其标记设备的可调用对象，返回字符串或None。 ++ **tagger**（[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在 Python v3.12)")*[**[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12)")***Storage**,* [*TypedStorage**,* *UntypedStorage**]**]**,* [*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")*]**]*) – 接受存储对象并返回其标记设备的可调用对象，返回字符串或 None。 -+ deserializer（Callable）[Union[Storage, TypedStorage, UntypedStorage], str] [Optional[Union[Storage, TypedStorage, UntypedStorage]]] - 接受存储对象和设备字符串并返回适当设备上的存储对象或None的可调用函数。 ++ deserializer（Callable）[Union[Storage, TypedStorage, UntypedStorage], str] [Optional[Union[Storage, TypedStorage, UntypedStorage]]] - 接受存储对象和设备字符串并返回适当设备上的存储对象或 None 的可调用函数。 返回 diff --git a/totrans/doc22_026.md b/totrans/doc22_026.md index aa2bea28..5c8e3bdc 100644 --- a/totrans/doc22_026.md +++ b/totrans/doc22_026.md @@ -1,6 +1,6 @@ # Windows 常见问题 -> 原文：[https://pytorch.org/docs/stable/notes/windows.html](https://pytorch.org/docs/stable/notes/windows.html) +> 原文：[`pytorch.org/docs/stable/notes/windows.html`](https://pytorch.org/docs/stable/notes/windows.html) ## 从源代码构建 @@ -176,7 +176,7 @@ ForkingPickler(file, protocol).dump(obj) BrokenPipeError: [Errno 32] Broken pipe ``` -当子进程在父进程完成发送数据之前结束时，就会出现这个问题。您的代码可能有问题。您可以通过将 [`DataLoader`](../data.html#torch.utils.data.DataLoader "torch.utils.data.DataLoader") 的 `num_worker` 减少到零来调试您的代码，看看问题是否仍然存在。 +当子进程在父进程完成发送数据之前结束时，就会出现这个问题。您的代码可能有问题。您可以通过将 `DataLoader` 的 `num_worker` 减少到零来调试您的代码，看看问题是否仍然存在。 ### 多进程错误“驱动程序关闭”[](#multiprocessing-error-driver-shut-down "跳转到此标题的永久链接") @@ -196,6 +196,6 @@ THCudaCheck FAIL file=torch\csrc\generic\StorageSharing.cpp line=252 error=63 : 它们不支持 Windows。例如，在 CUDA 张量上进行多进程操作是不可能成功的，有两种替代方案。 -1\. 不要使用 `multiprocessing`。将 [`DataLoader`](../data.html#torch.utils.data.DataLoader "torch.utils.data.DataLoader") 的 `num_worker` 设置为零。 +1\. 不要使用 `multiprocessing`。将 `DataLoader` 的 `num_worker` 设置为零。 2. 共享 CPU 张量。确保您的自定义 `DataSet` 返回 CPU 张量。 diff --git a/totrans/doc22_028.md b/totrans/doc22_028.md index 049931eb..a056ce06 100644 --- a/totrans/doc22_028.md +++ b/totrans/doc22_028.md @@ -1,47 +1,47 @@ # C++ -> 原文：[https://pytorch.org/docs/stable/cpp_index.html](https://pytorch.org/docs/stable/cpp_index.html) +> 原文：[`pytorch.org/docs/stable/cpp_index.html`](https://pytorch.org/docs/stable/cpp_index.html) 注意 -如果您正在寻找PyTorch C++ API文档，请直接前往[此处](https://pytorch.org/cppdocs/)。 +如果您正在寻找 PyTorch C++ API 文档，请直接前往[此处](https://pytorch.org/cppdocs/)。 -PyTorch提供了几个用于处理C++的功能，最好根据您的需求选择其中之一。在高层次上，以下支持可用： +PyTorch 提供了几个用于处理 C++的功能，最好根据您的需求选择其中之一。在高层次上，以下支持可用： ## TorchScript C++ API -[TorchScript](https://pytorch.org/docs/stable/jit.html)允许将在Python中定义的PyTorch模型序列化，然后在C++中加载和运行，通过编译或跟踪其执行来捕获模型代码。您可以在[在C++中加载TorchScript模型](https://pytorch.org/tutorials/advanced/cpp_export.html)教程中了解更多信息。这意味着您可以尽可能在Python中定义模型，但随后通过TorchScript导出它们，以在生产或嵌入式环境中进行无Python执行。TorchScript C++ API用于与这些模型和TorchScript执行引擎进行交互，包括： +[TorchScript](https://pytorch.org/docs/stable/jit.html)允许将在 Python 中定义的 PyTorch 模型序列化，然后在 C++中加载和运行，通过编译或跟踪其执行来捕获模型代码。您可以在[在 C++中加载 TorchScript 模型](https://pytorch.org/tutorials/advanced/cpp_export.html)教程中了解更多信息。这意味着您可以尽可能在 Python 中定义模型，但随后通过 TorchScript 导出它们，以在生产或嵌入式环境中进行无 Python 执行。TorchScript C++ API 用于与这些模型和 TorchScript 执行引擎进行交互，包括： -+ 加载从Python保存的序列化TorchScript模型 ++ 加载从 Python 保存的序列化 TorchScript 模型 + 如果需要，进行简单的模型修改（例如，提取子模块） -+ 使用C++ Tensor API构建输入并进行预处理 ++ 使用 C++ Tensor API 构建输入并进行预处理 -## 使用C++扩展扩展PyTorch和TorchScript[](#extending-pytorch-and-torchscript-with-c-extensions "跳转到此标题的永久链接") +## 使用 C++扩展扩展 PyTorch 和 TorchScript[](#extending-pytorch-and-torchscript-with-c-extensions "跳转到此标题的永久链接") -TorchScript可以通过自定义运算符和自定义类增强用户提供的代码。一旦在TorchScript中注册了这些运算符和类，这些运算符和类可以在Python中运行的TorchScript代码中被调用，或者作为序列化的TorchScript模型的一部分在C++中被调用。[使用自定义C++运算符扩展TorchScript](https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html)教程介绍了如何将TorchScript与OpenCV进行接口。除了使用自定义运算符包装函数调用外，C++类和结构体还可以通过类似于pybind11的接口绑定到TorchScript中，这在[使用自定义C++类扩展TorchScript](https://pytorch.org/tutorials/advanced/torch_script_custom_classes.html)教程中有解释。 +TorchScript 可以通过自定义运算符和自定义类增强用户提供的代码。一旦在 TorchScript 中注册了这些运算符和类，这些运算符和类可以在 Python 中运行的 TorchScript 代码中被调用，或者作为序列化的 TorchScript 模型的一部分在 C++中被调用。[使用自定义 C++运算符扩展 TorchScript](https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html)教程介绍了如何将 TorchScript 与 OpenCV 进行接口。除了使用自定义运算符包装函数调用外，C++类和结构体还可以通过类似于 pybind11 的接口绑定到 TorchScript 中，这在[使用自定义 C++类扩展 TorchScript](https://pytorch.org/tutorials/advanced/torch_script_custom_classes.html)教程中有解释。 -## 在C++中的Tensor和Autograd +## 在 C++中的 Tensor 和 Autograd -PyTorch Python API中的大多数张量和自动求导操作也可在C++ API中使用。包括： +PyTorch Python API 中的大多数张量和自动求导操作也可在 C++ API 中使用。包括： -+ `torch::Tensor`方法，如`add` / `reshape` / `clone`。有关可用方法的完整列表，请参阅：[https://pytorch.org/cppdocs/api/classat_1_1_tensor.html](https://pytorch.org/cppdocs/api/classat_1_1_tensor.html) ++ `torch::Tensor`方法，如`add` / `reshape` / `clone`。有关可用方法的完整列表，请参阅：[`pytorch.org/cppdocs/api/classat_1_1_tensor.html`](https://pytorch.org/cppdocs/api/classat_1_1_tensor.html) -+ C++张量索引API，看起来和行为与Python API相同。有关其用法的详细信息，请参阅：[https://pytorch.org/cppdocs/notes/tensor_indexing.html](https://pytorch.org/cppdocs/notes/tensor_indexing.html) ++ C++张量索引 API，看起来和行为与 Python API 相同。有关其用法的详细信息，请参阅：[`pytorch.org/cppdocs/notes/tensor_indexing.html`](https://pytorch.org/cppdocs/notes/tensor_indexing.html) -+ 在C++前端构建动态神经网络至关重要的张量自动求导API和`torch::autograd`包。有关更多详细信息，请参阅：[https://pytorch.org/tutorials/advanced/cpp_autograd.html](https://pytorch.org/tutorials/advanced/cpp_autograd.html) ++ 在 C++前端构建动态神经网络至关重要的张量自动求导 API 和`torch::autograd`包。有关更多详细信息，请参阅：[`pytorch.org/tutorials/advanced/cpp_autograd.html`](https://pytorch.org/tutorials/advanced/cpp_autograd.html) -## 在C++中编写模型 +## 在 C++中编写模型 -“在TorchScript中编写，使用C++进行推断”的工作流程要求在TorchScript中进行模型编写。但是，可能存在必须在C++中编写模型的情况（例如，在不希望使用Python组件的工作流程中）。为了满足这种用例，我们提供了在C++中完全编写和训练神经网络模型的完整功能，其中包括`torch::nn` / `torch::nn::functional` / `torch::optim`等熟悉的组件，这些组件与Python API非常相似。 +“在 TorchScript 中编写，使用 C++进行推断”的工作流程要求在 TorchScript 中进行模型编写。但是，可能存在必须在 C++中编写模型的情况（例如，在不希望使用 Python 组件的工作流程中）。为了满足这种用例，我们提供了在 C++中完全编写和训练神经网络模型的完整功能，其中包括`torch::nn` / `torch::nn::functional` / `torch::optim`等熟悉的组件，这些组件与 Python API 非常相似。 -+ 有关PyTorch C++模型编写和训练API的概述，请参阅：[https://pytorch.org/cppdocs/frontend.html](https://pytorch.org/cppdocs/frontend.html) ++ 有关 PyTorch C++模型编写和训练 API 的概述，请参阅：[`pytorch.org/cppdocs/frontend.html`](https://pytorch.org/cppdocs/frontend.html) -+ 有关如何使用API的详细教程，请参阅：[https://pytorch.org/tutorials/advanced/cpp_frontend.html](https://pytorch.org/tutorials/advanced/cpp_frontend.html) ++ 有关如何使用 API 的详细教程，请参阅：[`pytorch.org/tutorials/advanced/cpp_frontend.html`](https://pytorch.org/tutorials/advanced/cpp_frontend.html) -+ 有关诸如`torch::nn` / `torch::nn::functional` / `torch::optim`等组件的文档，请访问：[https://pytorch.org/cppdocs/api/library_root.html](https://pytorch.org/cppdocs/api/library_root.html) ++ 有关诸如`torch::nn` / `torch::nn::functional` / `torch::optim`等组件的文档，请访问：[`pytorch.org/cppdocs/api/library_root.html`](https://pytorch.org/cppdocs/api/library_root.html) ## C++包装 -有关如何安装和链接libtorch（包含所有上述C++ API的库）的指导，请参阅：[https://pytorch.org/cppdocs/installing.html](https://pytorch.org/cppdocs/installing.html)。请注意，在Linux上提供了两种类型的libtorch二进制文件：一种是使用GCC pre-cxx11 ABI编译的，另一种是使用GCC cxx11 ABI编译的，您应该根据系统使用的GCC ABI进行选择。 +有关如何安装和链接 libtorch（包含所有上述 C++ API 的库）的指导，请参阅：[`pytorch.org/cppdocs/installing.html`](https://pytorch.org/cppdocs/installing.html)。请注意，在 Linux 上提供了两种类型的 libtorch 二进制文件：一种是使用 GCC pre-cxx11 ABI 编译的，另一种是使用 GCC cxx11 ABI 编译的，您应该根据系统使用的 GCC ABI 进行选择。 diff --git a/totrans/doc22_029.md b/totrans/doc22_029.md index 9c90ca89..51b387e7 100644 --- a/totrans/doc22_029.md +++ b/totrans/doc22_029.md @@ -1,5 +1,5 @@ # torch::deploy 已经迁移到 pytorch/multipy -> 原文：[https://pytorch.org/docs/stable/deploy.html](https://pytorch.org/docs/stable/deploy.html) +> 原文：[`pytorch.org/docs/stable/deploy.html`](https://pytorch.org/docs/stable/deploy.html) -`torch::deploy` 已经迁移到了它的新家 [https://github.com/pytorch/multipy](https://github.com/pytorch/multipy)。 +`torch::deploy` 已经迁移到了它的新家 [`github.com/pytorch/multipy`](https://github.com/pytorch/multipy)。 diff --git a/totrans/doc22_031.md b/totrans/doc22_031.md index 4691696c..f8db9872 100644 --- a/totrans/doc22_031.md +++ b/totrans/doc22_031.md @@ -1,191 +1,191 @@ # torch -> 原文：[https://pytorch.org/docs/stable/torch.html](https://pytorch.org/docs/stable/torch.html) +> 原文：[`pytorch.org/docs/stable/torch.html`](https://pytorch.org/docs/stable/torch.html) -torch包含用于多维张量的数据结构，并定义了这些张量上的数学操作。此外，它还提供了许多用于高效序列化张量和任意类型的工具，以及其他有用的实用程序。 +torch 包含用于多维张量的数据结构，并定义了这些张量上的数学操作。此外，它还提供了许多用于高效序列化张量和任意类型的工具，以及其他有用的实用程序。 -它有一个CUDA对应项，可以让您在具有计算能力>= 3.0的NVIDIA GPU上运行张量计算。 +它有一个 CUDA 对应项，可以让您在具有计算能力>= 3.0 的 NVIDIA GPU 上运行张量计算。 ## 张量 -| [`is_tensor`](generated/torch.is_tensor.html#torch.is_tensor "torch.is_tensor") | 如果obj是PyTorch张量，则返回True。 | +| `is_tensor` | 如果 obj 是 PyTorch 张量，则返回 True。 | | --- | --- | -| [`is_storage`](generated/torch.is_storage.html#torch.is_storage "torch.is_storage") | 如果obj是PyTorch存储对象，则返回True。 | -| [`is_complex`](generated/torch.is_complex.html#torch.is_complex "torch.is_complex") | 如果`input`的数据类型是复数数据类型，即`torch.complex64`和`torch.complex128`之一，则返回True。 | -| [`is_conj`](generated/torch.is_conj.html#torch.is_conj "torch.is_conj") | 如果`input`是一个共轭张量，即其共轭位设置为True，则返回True。 | -| [`is_floating_point`](generated/torch.is_floating_point.html#torch.is_floating_point "torch.is_floating_point") | 如果`input`的数据类型是浮点数据类型，即`torch.float64`、`torch.float32`、`torch.float16`和`torch.bfloat16`之一，则返回True。 | -| [`is_nonzero`](generated/torch.is_nonzero.html#torch.is_nonzero "torch.is_nonzero") | 如果`input`是一个经过类型转换后不等于零的单个元素张量，则返回True。 | -| [`set_default_dtype`](generated/torch.set_default_dtype.html#torch.set_default_dtype "torch.set_default_dtype") | 将默认的浮点dtype设置为`d`。 | -| [`get_default_dtype`](generated/torch.get_default_dtype.html#torch.get_default_dtype "torch.get_default_dtype") | 获取当前默认的浮点[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")。 | -| [`set_default_device`](generated/torch.set_default_device.html#torch.set_default_device "torch.set_default_device") | 将默认的`torch.Tensor`分配到`device`上。 | -| [`set_default_tensor_type`](generated/torch.set_default_tensor_type.html#torch.set_default_tensor_type "torch.set_default_tensor_type") | 将默认的`torch.Tensor`类型设置为浮点张量类型`t`。 | -| [`numel`](generated/torch.numel.html#torch.numel "torch.numel") | 返回`input`张量中的总元素数。 | -| [`set_printoptions`](generated/torch.set_printoptions.html#torch.set_printoptions "torch.set_printoptions") | 设置打印选项。 | -| [`set_flush_denormal`](generated/torch.set_flush_denormal.html#torch.set_flush_denormal "torch.set_flush_denormal") | 禁用CPU上的非规格化浮点数。 | +| `is_storage` | 如果 obj 是 PyTorch 存储对象，则返回 True。 | +| `is_complex` | 如果`input`的数据类型是复数数据类型，即`torch.complex64`和`torch.complex128`之一，则返回 True。 | +| `is_conj` | 如果`input`是一个共轭张量，即其共轭位设置为 True，则返回 True。 | +| `is_floating_point` | 如果`input`的数据类型是浮点数据类型，即`torch.float64`、`torch.float32`、`torch.float16`和`torch.bfloat16`之一，则返回 True。 | +| `is_nonzero` | 如果`input`是一个经过类型转换后不等于零的单个元素张量，则返回 True。 | +| `set_default_dtype` | 将默认的浮点 dtype 设置为`d`。 | +| `get_default_dtype` | 获取当前默认的浮点`torch.dtype`。 | +| `set_default_device` | 将默认的`torch.Tensor`分配到`device`上。 | +| `set_default_tensor_type` | 将默认的`torch.Tensor`类型设置为浮点张量类型`t`。 | +| `numel` | 返回`input`张量中的总元素数。 | +| `set_printoptions` | 设置打印选项。 | +| `set_flush_denormal` | 禁用 CPU 上的非规格化浮点数。 | ### 创建操作 注意 -随机抽样创建操作列在[随机抽样](#random-sampling)下，包括：[`torch.rand()`](generated/torch.rand.html#torch.rand "torch.rand") [`torch.rand_like()`](generated/torch.rand_like.html#torch.rand_like "torch.rand_like") [`torch.randn()`](generated/torch.randn.html#torch.randn "torch.randn") [`torch.randn_like()`](generated/torch.randn_like.html#torch.randn_like "torch.randn_like") [`torch.randint()`](generated/torch.randint.html#torch.randint "torch.randint") [`torch.randint_like()`](generated/torch.randint_like.html#torch.randint_like "torch.randint_like") [`torch.randperm()`](generated/torch.randperm.html#torch.randperm "torch.randperm") 您还可以使用[`torch.empty()`](generated/torch.empty.html#torch.empty "torch.empty")与[原地随机抽样](#inplace-random-sampling)方法一起创建从更广泛的分布中抽样值的[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")。 +随机抽样创建操作列在随机抽样下，包括：`torch.rand()` `torch.rand_like()` `torch.randn()` `torch.randn_like()` `torch.randint()` `torch.randint_like()` `torch.randperm()` 您还可以使用`torch.empty()`与原地随机抽样方法一起创建从更广泛的分布中抽样值的`torch.Tensor`。 -| [`tensor`](generated/torch.tensor.html#torch.tensor "torch.tensor") | 通过复制`data`构建一个没有自动求导历史的张量（也称为“叶子张量”，参见[自动求导机制](notes/autograd.html)）。 | +| `tensor` | 通过复制`data`构建一个没有自动求导历史的张量（也称为“叶子张量”，参见自动求导机制）。 | | --- | --- | -| [`sparse_coo_tensor`](generated/torch.sparse_coo_tensor.html#torch.sparse_coo_tensor "torch.sparse_coo_tensor") | 使用给定的`indices`构建一个COO（坐标）格式的稀疏张量。 | -| [`sparse_csr_tensor`](generated/torch.sparse_csr_tensor.html#torch.sparse_csr_tensor "torch.sparse_csr_tensor") | 使用给定的`crow_indices`和`col_indices`构建一个CSR（压缩稀疏行）格式的稀疏张量。 | -| [`sparse_csc_tensor`](generated/torch.sparse_csc_tensor.html#torch.sparse_csc_tensor "torch.sparse_csc_tensor") | 使用给定的`ccol_indices`和`row_indices`构建一个CSC（压缩稀疏列）格式的稀疏张量。 | -| [`sparse_bsr_tensor`](generated/torch.sparse_bsr_tensor.html#torch.sparse_bsr_tensor "torch.sparse_bsr_tensor") | 使用给定的`crow_indices`和`col_indices`构建一个BSR（块压缩稀疏行）格式的稀疏张量。 | -| [`sparse_bsc_tensor`](generated/torch.sparse_bsc_tensor.html#torch.sparse_bsc_tensor "torch.sparse_bsc_tensor") | 使用给定的`ccol_indices`和`row_indices`构建一个BSC（块压缩稀疏列）格式的稀疏张量。 | -| [`asarray`](generated/torch.asarray.html#torch.asarray "torch.asarray") | 将`obj`转换为张量。 | -| [`as_tensor`](generated/torch.as_tensor.html#torch.as_tensor "torch.as_tensor") | 将`data`转换为张量，如果可能的话共享数据并保留自动求导历史。 | -| [`as_strided`](generated/torch.as_strided.html#torch.as_strided "torch.as_strided") | 使用指定的`size`、`stride`和`storage_offset`创建一个现有torch.Tensor `input`的视图。 | -| [`from_file`](generated/torch.from_file.html#torch.from_file "torch.from_file") | 创建一个由内存映射文件支持的CPU张量。 | -| [`from_numpy`](generated/torch.from_numpy.html#torch.from_numpy "torch.from_numpy") | 从一个[`numpy.ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray)创建一个[`Tensor`](tensors.html#torch.Tensor)。 | -| [`from_dlpack`](generated/torch.from_dlpack.html#torch.from_dlpack "torch.from_dlpack") | 将来自外部库的张量转换为`torch.Tensor`。 | -| [`frombuffer`](generated/torch.frombuffer.html#torch.frombuffer "torch.frombuffer") | 从实现Python缓冲区协议的对象创建一个1维张量。 | -| [`zeros`](generated/torch.zeros.html#torch.zeros "torch.zeros") | 返回一个填充了标量值0且形状由可变参数`size`定义的张量。 | -| [`zeros_like`](generated/torch.zeros_like.html#torch.zeros_like "torch.zeros_like") | 返回一个与`input`相同大小且填充了标量值0的张量。 | -| [`ones`](generated/torch.ones.html#torch.ones "torch.ones") | 返回一个填充了标量值1且形状由可变参数`size`定义的张量。 | -| [`ones_like`](generated/torch.ones_like.html#torch.ones_like "torch.ones_like") | 返回一个与`input`相同大小且填充了标量值1的张量。 | -| [`arange`](generated/torch.arange.html#torch.arange "torch.arange") | 返回一个大小为$\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil$的一维张量，其值来自区间`[start, end)`，以`step`为公差从`start`开始。 | -| [`range`](生成/torch.range.html#torch.range "torch.range") | 返回一个大小为$\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor + 1$的一维张量，其值从`start`到`end`，步长为`step`。 | -| [`linspace`](生成/torch.linspace.html#torch.linspace "torch.linspace") | 创建一个大小为`steps`的一维张量，其值从`start`到`end`均匀间隔。 | -| [`logspace`](生成/torch.logspace.html#torch.logspace "torch.logspace") | 创建一个大小为`steps`的一维张量，其值在对数刻度上从${{\text{{base}}}}^{{\text{{start}}}}$basestart到${{\text{{base}}}}^{{\text{{end}}}}$baseend均匀间隔。 | -| [`eye`](生成/torch.eye.html#torch.eye "torch.eye") | 返回一个对角线为1，其他位置为0的二维张量。 | -| [`empty`](生成/torch.empty.html#torch.empty "torch.empty") | 返回一个填充未初始化数据的张量。 | -| [`empty_like`](生成/torch.empty_like.html#torch.empty_like "torch.empty_like") | 返回一个与`input`大小相同的未初始化张量。 | -| [`empty_strided`](生成/torch.empty_strided.html#torch.empty_strided "torch.empty_strided") | 创建一个指定`size`和`stride`的张量，并填充未定义数据。 | -| [`full`](生成/torch.full.html#torch.full "torch.full") | 创建一个大小为`size`且填充为`fill_value`的张量。 | -| [`full_like`](生成/torch.full_like.html#torch.full_like "torch.full_like") | 返回一个与`input`大小相同且填充为`fill_value`的张量。 | -| [`quantize_per_tensor`](生成/torch.quantize_per_tensor.html#torch.quantize_per_tensor "torch.quantize_per_tensor") | 将浮点张量转换为具有给定比例和零点的量化张量。 | -| [`quantize_per_channel`](生成/torch.quantize_per_channel.html#torch.quantize_per_channel "torch.quantize_per_channel") | 将浮点张量转换为具有给定比例和零点的按通道量化张量。 | -| [`dequantize`](生成/torch.dequantize.html#torch.dequantize "torch.dequantize") | 通过去量化一个量化张量返回一个fp32张量。 | -| [`complex`](生成/torch.complex.html#torch.complex "torch.complex") | 构造一个复数张量，其实部等于[`real`](生成/torch.real.html#torch.real "torch.real")，虚部等于[`imag`](生成/torch.imag.html#torch.imag "torch.imag")。 | -| [`polar`](生成/torch.polar.html#torch.polar "torch.polar") | 构造一个复数张量，其元素是对应于绝对值[`abs`](生成/torch.abs.html#torch.abs "torch.abs")和角度[`angle`](生成/torch.angle.html#torch.angle "torch.angle")的极坐标。 | - -| [`heaviside`](生成/torch.heaviside.html#torch.heaviside "torch.heaviside") | 计算`input`中每个元素的Heaviside阶跃函数。 | ### 索引、切片、连接、变异操作[](#indexing-slicing-joining-mutating-ops "跳转到此标题的永久链接") - -| [`adjoint`](生成/torch.adjoint.html#torch.adjoint "torch.adjoint") | 返回一个共轭并且最后两个维度转置的张量视图。 | +| `sparse_coo_tensor` | 使用给定的`indices`构建一个 COO（坐标）格式的稀疏张量。 | +| `sparse_csr_tensor` | 使用给定的`crow_indices`和`col_indices`构建一个 CSR（压缩稀疏行）格式的稀疏张量。 | +| `sparse_csc_tensor` | 使用给定的`ccol_indices`和`row_indices`构建一个 CSC（压缩稀疏列）格式的稀疏张量。 | +| `sparse_bsr_tensor` | 使用给定的`crow_indices`和`col_indices`构建一个 BSR（块压缩稀疏行）格式的稀疏张量。 | +| `sparse_bsc_tensor` | 使用给定的`ccol_indices`和`row_indices`构建一个 BSC（块压缩稀疏列）格式的稀疏张量。 | +| `asarray` | 将`obj`转换为张量。 | +| `as_tensor` | 将`data`转换为张量，如果可能的话共享数据并保留自动求导历史。 | +| `as_strided` | 使用指定的`size`、`stride`和`storage_offset`创建一个现有 torch.Tensor `input`的视图。 | +| `from_file` | 创建一个由内存映射文件支持的 CPU 张量。 | +| `from_numpy` | 从一个[`numpy.ndarray`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray)创建一个`Tensor`。 | +| `from_dlpack` | 将来自外部库的张量转换为`torch.Tensor`。 | +| `frombuffer` | 从实现 Python 缓冲区协议的对象创建一个 1 维张量。 | +| `zeros` | 返回一个填充了标量值 0 且形状由可变参数`size`定义的张量。 | +| `zeros_like` | 返回一个与`input`相同大小且填充了标量值 0 的张量。 | +| `ones` | 返回一个填充了标量值 1 且形状由可变参数`size`定义的张量。 | +| `ones_like` | 返回一个与`input`相同大小且填充了标量值 1 的张量。 | +| `arange` | 返回一个大小为$\left\lceil \frac{\text{end} - \text{start}}{\text{step}} \right\rceil$的一维张量，其值来自区间`start, end)`，以`step`为公差从`start`开始。 | +| [`range` | 返回一个大小为$\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor + 1$的一维张量，其值从`start`到`end`，步长为`step`。 | +| `linspace` | 创建一个大小为`steps`的一维张量，其值从`start`到`end`均匀间隔。 | +| `logspace` | 创建一个大小为`steps`的一维张量，其值在对数刻度上从${{\text{{base}}}}^{{\text{{start}}}}$basestart 到${{\text{{base}}}}^{{\text{{end}}}}$baseend 均匀间隔。 | +| `eye` | 返回一个对角线为 1，其他位置为 0 的二维张量。 | +| `empty` | 返回一个填充未初始化数据的张量。 | +| `empty_like` | 返回一个与`input`大小相同的未初始化张量。 | +| `empty_strided` | 创建一个指定`size`和`stride`的张量，并填充未定义数据。 | +| `full` | 创建一个大小为`size`且填充为`fill_value`的张量。 | +| `full_like` | 返回一个与`input`大小相同且填充为`fill_value`的张量。 | +| `quantize_per_tensor` | 将浮点张量转换为具有给定比例和零点的量化张量。 | +| `quantize_per_channel` | 将浮点张量转换为具有给定比例和零点的按通道量化张量。 | +| `dequantize` | 通过去量化一个量化张量返回一个 fp32 张量。 | +| `complex` | 构造一个复数张量，其实部等于`real`，虚部等于`imag`。 | +| `polar` | 构造一个复数张量，其元素是对应于绝对值`abs`和角度`angle`的极坐标。 | + +| `heaviside` | 计算`input`中每个元素的 Heaviside 阶跃函数。 | ### 索引、切片、连接、变异操作[](#indexing-slicing-joining-mutating-ops "跳转到此标题的永久链接") + +| `adjoint` | 返回一个共轭并且最后两个维度转置的张量视图。 | | --- | --- | -| [`argwhere`](生成/torch.argwhere.html#torch.argwhere "torch.argwhere") | 返回一个包含`input`所有非零元素索引的张量。 | -| [`cat`](生成/torch.cat.html#torch.cat "torch.cat") | 在给定维度上连接给定序列`seq`的张量。 | -| [`concat`](生成/torch.concat.html#torch.concat "torch.concat") | [`torch.cat()`](生成/torch.cat.html#torch.cat "torch.cat")的别名。 | -| [`concatenate`](生成/torch.concatenate.html#torch.concatenate "torch.concatenate") | [`torch.cat()`](生成/torch.cat.html#torch.cat "torch.cat")的别名。 | -| [`conj`](生成/torch.conj.html#torch.conj "torch.conj") | 返回一个具有翻转共轭位的`input`视图。 | -| [`chunk`](generated/torch.chunk.html#torch.chunk "torch.chunk") | 尝试将张量分割成指定数量的块。 | -| [`dsplit`](generated/torch.dsplit.html#torch.dsplit "torch.dsplit") | 根据`indices_or_sections`，将具有三个或更多维度的`input`张量沿深度方向分割成多个张量。 | -| [`column_stack`](generated/torch.column_stack.html#torch.column_stack "torch.column_stack") | 通过水平堆叠`tensors`在`tensors`中创建一个新的张量。 | -| [`dstack`](generated/torch.dstack.html#torch.dstack "torch.dstack") | 深度顺序堆叠张量（沿第三轴）。 | -| [`gather`](generated/torch.gather.html#torch.gather "torch.gather") | 沿着由dim指定的轴收集值。 | -| [`hsplit`](generated/torch.hsplit.html#torch.hsplit "torch.hsplit") | 根据`indices_or_sections`，将具有一个或多个维度的`input`张量水平分割成多个张量。 | -| [`hstack`](generated/torch.hstack.html#torch.hstack "torch.hstack") | 水平顺序堆叠张量（按列）。 | -| [`index_add`](generated/torch.index_add.html#torch.index_add "torch.index_add") | 有关函数描述，请参阅[`index_add_()`](generated/torch.Tensor.index_add_.html#torch.Tensor.index_add_ "torch.Tensor.index_add_")。 | -| [`index_copy`](generated/torch.index_copy.html#torch.index_copy "torch.index_copy") | 有关函数描述，请参阅[`index_add_()`](generated/torch.Tensor.index_add_.html#torch.Tensor.index_add_ "torch.Tensor.index_add_")。 | -| [`index_reduce`](generated/torch.index_reduce.html#torch.index_reduce "torch.index_reduce") | 有关函数描述，请参阅[`index_reduce_()`](generated/torch.Tensor.index_reduce_.html#torch.Tensor.index_reduce_ "torch.Tensor.index_reduce_")。 | -| [`index_select`](generated/torch.index_select.html#torch.index_select "torch.index_select") | 返回一个新的张量，沿着维度`dim`使用`index`中的条目对`input`张量进行索引，其中`index`是一个LongTensor。 | -| [`masked_select`](generated/torch.masked_select.html#torch.masked_select "torch.masked_select") | 返回一个新的1-D张量，根据布尔掩码`mask`（BoolTensor）对`input`张量进行索引。 | -| [`movedim`](generated/torch.movedim.html#torch.movedim "torch.movedim") | 将`input`张量的维度移动到`source`中的位置到`destination`中的位置。 | -| [`moveaxis`](generated/torch.moveaxis.html#torch.moveaxis "torch.moveaxis") | [`torch.movedim()`](generated/torch.movedim.html#torch.movedim "torch.movedim")的别名。 | -| [`narrow`](generated/torch.narrow.html#torch.narrow "torch.narrow") | 返回一个缩小版本的`input`张量的新张量。 | -| [`narrow_copy`](generated/torch.narrow_copy.html#torch.narrow_copy "torch.narrow_copy") | 与[`Tensor.narrow()`](generated/torch.Tensor.narrow.html#torch.Tensor.narrow "torch.Tensor.narrow")相同，除了这里返回的是副本而不是共享存储。 | -| [`nonzero`](generated/torch.nonzero.html#torch.nonzero "torch.nonzero") | | -| [`permute`](generated/torch.permute.html#torch.permute "torch.permute") | 返回原始张量`input`的维度重新排列视图。 | -| [`reshape`](generated/torch.reshape.html#torch.reshape "torch.reshape") | 返回一个与`input`具有相同数据和元素数量的张量，但具有指定的形状。 | -| [`row_stack`](generated/torch.row_stack.html#torch.row_stack "torch.row_stack") | [`torch.vstack()`](generated/torch.vstack.html#torch.vstack "torch.vstack")的别名。 | -| [`select`](generated/torch.select.html#torch.select "torch.select") | 在给定索引处沿所选维度切片`input`张量。 | -| [`scatter`](generated/torch.scatter.html#torch.scatter "torch.scatter") | [`torch.Tensor.scatter_()`](generated/torch.Tensor.scatter_.html#torch.Tensor.scatter_ "torch.Tensor.scatter_")的就地版本 | -| [`diagonal_scatter`](generated/torch.diagonal_scatter.html#torch.diagonal_scatter "torch.diagonal_scatter") | 将`src`张量的值嵌入到`input`的对角线元素中，相对于`dim1`和`dim2`。 | -| [`select_scatter`](generated/torch.select_scatter.html#torch.select_scatter "torch.select_scatter") | 将`src`张量的值嵌入到给定索引的`input`中。 | -| [`slice_scatter`](generated/torch.slice_scatter.html#torch.slice_scatter "torch.slice_scatter") | 将`src`张量的值嵌入到给定维度的`input`中。 | -| [`scatter_add`](generated/torch.scatter_add.html#torch.scatter_add "torch.scatter_add") | [`torch.Tensor.scatter_add_()`](generated/torch.Tensor.scatter_add_.html#torch.Tensor.scatter_add_ "torch.Tensor.scatter_add_")的就地版本。 | -| [`scatter_reduce`](generated/torch.scatter_reduce.html#torch.scatter_reduce "torch.scatter_reduce") | [`torch.Tensor.scatter_reduce_()`](generated/torch.Tensor.scatter_reduce_.html#torch.Tensor.scatter_reduce_ "torch.Tensor.scatter_reduce_")的就地版本。 | -| [`split`](generated/torch.split.html#torch.split "torch.split") | 将张量分割成多个块。 | -| [`squeeze`](generated/torch.squeeze.html#torch.squeeze "torch.squeeze") | 返回一个去除`input`中所有指定大小为1的维度的张量。 | -| [`stack`](generated/torch.stack.html#torch.stack "torch.stack") | 沿着新维度连接一系列张量。 | -| [`swapaxes`](generated/torch.swapaxes.html#torch.swapaxes "torch.swapaxes") | [`torch.transpose()`](generated/torch.transpose.html#torch.transpose "torch.transpose")的别名。 | -| [`swapdims`](generated/torch.swapdims.html#torch.swapdims "torch.swapdims") | [`torch.transpose()`](generated/torch.transpose.html#torch.transpose "torch.transpose")的别名。 | -| [`t`](generated/torch.t.html#torch.t "torch.t") | 期望`input`是 <= 2-D 张量，并转置维度0和1。 | -| [`take`](generated/torch.take.html#torch.take "torch.take") | 返回一个包含`input`在给定索引处的元素的新张量。 | -| [`take_along_dim`](generated/torch.take_along_dim.html#torch.take_along_dim "torch.take_along_dim") | 在给定`dim`上沿着`indices`的一维索引从`input`中选择值。 | -| [`tensor_split`](generated/torch.tensor_split.html#torch.tensor_split "torch.tensor_split") | 将张量沿着维度`dim`根据`indices_or_sections`指定的索引或分段数拆分为多个子张量，所有这些子张量都是`input`的视图。 | -| [`tile`](generated/torch.tile.html#torch.tile "torch.tile") | 通过重复`input`的元素构造张量。 | -| [`transpose`](generated/torch.transpose.html#torch.transpose "torch.transpose") | 返回`input`的转置版本的张量。 | -| [`unbind`](generated/torch.unbind.html#torch.unbind "torch.unbind") | 移除张量的一个维度。 | -| [`unravel_index`](generated/torch.unravel_index.html#torch.unravel_index "torch.unravel_index") | 将扁平索引的张量转换为索引到指定形状的任意张量的坐标张量元组。 | -| [`unsqueeze`](generated/torch.unsqueeze.html#torch.unsqueeze "torch.unsqueeze") | 在指定位置插入一个大小为一的维度，返回一个新的张量。 | -| [`vsplit`](generated/torch.vsplit.html#torch.vsplit "torch.vsplit") | 根据`indices_or_sections`将具有两个或更多维度的`input`张量垂直拆分为多个张量。 | -| [`vstack`](generated/torch.vstack.html#torch.vstack "torch.vstack") | 按行将张量依次堆叠起来。 | - -| [`where`](generated/torch.where.html#torch.where "torch.where") | 根据`condition`从`input`或`other`中选择元素并返回张量。 | - -| [`Generator`](generated/torch.Generator.html#torch.Generator "torch.Generator") | 创建并返回一个生成器对象，该对象管理产生伪随机数的算法的状态。 | ## 随机抽样[](#random-sampling "Permalink to this heading") - -| [`seed`](generated/torch.seed.html#torch.seed "torch.seed") | 将生成随机数的种子设置为非确定性随机数。 | +| `argwhere` | 返回一个包含`input`所有非零元素索引的张量。 | +| `cat` | 在给定维度上连接给定序列`seq`的张量。 | +| `concat` | `torch.cat()`的别名。 | +| `concatenate` | `torch.cat()`的别名。 | +| `conj` | 返回一个具有翻转共轭位的`input`视图。 | +| `chunk` | 尝试将张量分割成指定数量的块。 | +| `dsplit` | 根据`indices_or_sections`，将具有三个或更多维度的`input`张量沿深度方向分割成多个张量。 | +| `column_stack` | 通过水平堆叠`tensors`在`tensors`中创建一个新的张量。 | +| `dstack` | 深度顺序堆叠张量（沿第三轴）。 | +| `gather` | 沿着由 dim 指定的轴收集值。 | +| `hsplit` | 根据`indices_or_sections`，将具有一个或多个维度的`input`张量水平分割成多个张量。 | +| `hstack` | 水平顺序堆叠张量（按列）。 | +| `index_add` | 有关函数描述，请参阅`index_add_()`。 | +| `index_copy` | 有关函数描述，请参阅`index_add_()`。 | +| `index_reduce` | 有关函数描述，请参阅`index_reduce_()`。 | +| `index_select` | 返回一个新的张量，沿着维度`dim`使用`index`中的条目对`input`张量进行索引，其中`index`是一个 LongTensor。 | +| `masked_select` | 返回一个新的 1-D 张量，根据布尔掩码`mask`（BoolTensor）对`input`张量进行索引。 | +| `movedim` | 将`input`张量的维度移动到`source`中的位置到`destination`中的位置。 | +| `moveaxis` | `torch.movedim()`的别名。 | +| `narrow` | 返回一个缩小版本的`input`张量的新张量。 | +| `narrow_copy` | 与`Tensor.narrow()`相同，除了这里返回的是副本而不是共享存储。 | +| `nonzero` | | +| `permute` | 返回原始张量`input`的维度重新排列视图。 | +| `reshape` | 返回一个与`input`具有相同数据和元素数量的张量，但具有指定的形状。 | +| `row_stack` | `torch.vstack()`的别名。 | +| `select` | 在给定索引处沿所选维度切片`input`张量。 | +| `scatter` | `torch.Tensor.scatter_()`的就地版本 | +| `diagonal_scatter` | 将`src`张量的值嵌入到`input`的对角线元素中，相对于`dim1`和`dim2`。 | +| `select_scatter` | 将`src`张量的值嵌入到给定索引的`input`中。 | +| `slice_scatter` | 将`src`张量的值嵌入到给定维度的`input`中。 | +| `scatter_add` | `torch.Tensor.scatter_add_()`的就地版本。 | +| `scatter_reduce` | `torch.Tensor.scatter_reduce_()`的就地版本。 | +| `split` | 将张量分割成多个块。 | +| `squeeze` | 返回一个去除`input`中所有指定大小为 1 的维度的张量。 | +| `stack` | 沿着新维度连接一系列张量。 | +| `swapaxes` | `torch.transpose()`的别名。 | +| `swapdims` | `torch.transpose()`的别名。 | +| `t` | 期望`input`是 <= 2-D 张量，并转置维度 0 和 1。 | +| `take` | 返回一个包含`input`在给定索引处的元素的新张量。 | +| `take_along_dim` | 在给定`dim`上沿着`indices`的一维索引从`input`中选择值。 | +| `tensor_split` | 将张量沿着维度`dim`根据`indices_or_sections`指定的索引或分段数拆分为多个子张量，所有这些子张量都是`input`的视图。 | +| `tile` | 通过重复`input`的元素构造张量。 | +| `transpose` | 返回`input`的转置版本的张量。 | +| `unbind` | 移除张量的一个维度。 | +| `unravel_index` | 将扁平索引的张量转换为索引到指定形状的任意张量的坐标张量元组。 | +| `unsqueeze` | 在指定位置插入一个大小为一的维度，返回一个新的张量。 | +| `vsplit` | 根据`indices_or_sections`将具有两个或更多维度的`input`张量垂直拆分为多个张量。 | +| `vstack` | 按行将张量依次堆叠起来。 | + +| `where` | 根据`condition`从`input`或`other`中选择元素并返回张量。 | + +| `Generator` | 创建并返回一个生成器对象，该对象管理产生伪随机数的算法的状态。 | ## 随机抽样[](#random-sampling "Permalink to this heading") + +| `seed` | 将生成随机数的种子设置为非确定性随机数。 | | --- | --- | -| [`manual_seed`](generated/torch.manual_seed.html#torch.manual_seed "torch.manual_seed") | 设置生成随机数的种子。 | -| [`initial_seed`](generated/torch.initial_seed.html#torch.initial_seed "torch.initial_seed") | 将生成随机数的初始种子作为Python长整型返回。 | -| [`get_rng_state`](generated/torch.get_rng_state.html#torch.get_rng_state "torch.get_rng_state") | 将随机数生成器状态作为torch.ByteTensor返回。 | -| [`set_rng_state`](generated/torch.set_rng_state.html#torch.set_rng_state "torch.set_rng_state") | 设置随机数生成器状态。 | +| `manual_seed` | 设置生成随机数的种子。 | +| `initial_seed` | 将生成随机数的初始种子作为 Python 长整型返回。 | +| `get_rng_state` | 将随机数生成器状态作为 torch.ByteTensor 返回。 | +| `set_rng_state` | 设置随机数生成器状态。 | ```py torch.default_generator Returns the default CPU torch.Generator¶ ``` -| [`bernoulli`](generated/torch.bernoulli.html#torch.bernoulli "torch.bernoulli") | 从伯努利分布中抽取二进制随机数（0或1）。 | +| `bernoulli` | 从伯努利分布中抽取二进制随机数（0 或 1）。 | | --- | --- | -| [`multinomial`](generated/torch.multinomial.html#torch.multinomial "torch.multinomial") | 返回一个张量，其中每行包含从多项式（更严格的定义是多变量，有关更多细节，请参考torch.distributions.multinomial.Multinomial）概率分布中抽样的`num_samples`个索引，这些概率分布位于张量`input`相应行中。 | -| [`normal`](generated/torch.normal.html#torch.normal "torch.normal") | 返回从具有给定均值和标准差的单独正态分布中抽取的随机数的张量。 | -| [`poisson`](generated/torch.poisson.html#torch.poisson "torch.poisson") | 返回与`input`相同大小的张量，其中每个元素从泊松分布中抽样，速率参数由`input`中相应元素给出。 | -| [`rand`](generated/torch.rand.html#torch.rand "torch.rand") | 返回一个填充有来自区间$[0, 1)$的均匀分布的随机数的张量。 | -| [`rand_like`](generated/torch.rand_like.html#torch.rand_like "torch.rand_like") | 返回与`input`相同大小的张量，其中填充有来自区间$[0, 1)$的均匀分布的随机数。 | -| [`randint`](generated/torch.randint.html#torch.randint "torch.randint") | 返回一个填充有在`low`（包含）和`high`（不包含）之间均匀生成的随机整数的张量。 | -| [`randint_like`](generated/torch.randint_like.html#torch.randint_like "torch.randint_like") | 返回与张量`input`形状相同的张量，其中填充有在`low`（包含）和`high`（不包含）之间均匀生成的随机整数。 | -| [`randn`](generated/torch.randn.html#torch.randn "torch.randn") | 返回一个填充有来自均值为0，方差为1（也称为标准正态分布）的随机数的张量。 | -| [`randn_like`](generated/torch.randn_like.html#torch.randn_like "torch.randn_like") | 返回与`input`相同大小的张量，其中填充有来自均值为0，方差为1的正态分布的随机数。 | -| [`randperm`](generated/torch.randperm.html#torch.randperm "torch.randperm") | 返回从`0`到`n - 1`的整数的随机排列。 | +| `multinomial` | 返回一个张量，其中每行包含从多项式（更严格的定义是多变量，有关更多细节，请参考 torch.distributions.multinomial.Multinomial）概率分布中抽样的`num_samples`个索引，这些概率分布位于张量`input`相应行中。 | +| `normal` | 返回从具有给定均值和标准差的单独正态分布中抽取的随机数的张量。 | +| `poisson` | 返回与`input`相同大小的张量，其中每个元素从泊松分布中抽样，速率参数由`input`中相应元素给出。 | +| `rand` | 返回一个填充有来自区间$0, 1)$的均匀分布的随机数的张量。 | +| [`rand_like` | 返回与`input`相同大小的张量，其中填充有来自区间$0, 1)$的均匀分布的随机数。 | +| [`randint` | 返回一个填充有在`low`（包含）和`high`（不包含）之间均匀生成的随机整数的张量。 | +| `randint_like` | 返回与张量`input`形状相同的张量，其中填充有在`low`（包含）和`high`（不包含）之间均匀生成的随机整数。 | +| `randn` | 返回一个填充有来自均值为 0，方差为 1（也称为标准正态分布）的随机数的张量。 | +| `randn_like` | 返回与`input`相同大小的张量，其中填充有来自均值为 0，方差为 1 的正态分布的随机数。 | +| `randperm` | 返回从`0`到`n - 1`的整数的随机排列。 | ### 就地随机抽样[](#in-place-random-sampling "Permalink to this heading") 还有一些在张量上定义的就地随机抽样函数。点击查看它们的文档： -+ [`torch.Tensor.bernoulli_()`](generated/torch.Tensor.bernoulli_.html#torch.Tensor.bernoulli_ "torch.Tensor.bernoulli_") - [`torch.bernoulli()`](generated/torch.bernoulli.html#torch.bernoulli "torch.bernoulli")的就地版本 ++ `torch.Tensor.bernoulli_()` - `torch.bernoulli()`的就地版本 -+ [`torch.Tensor.cauchy_()`](generated/torch.Tensor.cauchy_.html#torch.Tensor.cauchy_ "torch.Tensor.cauchy_") - 从柯西分布中抽取的数字 ++ `torch.Tensor.cauchy_()` - 从柯西分布中抽取的数字 -+ [`torch.Tensor.exponential_()`](generated/torch.Tensor.exponential_.html#torch.Tensor.exponential_ "torch.Tensor.exponential_") - 从指数分布中抽取的数字 ++ `torch.Tensor.exponential_()` - 从指数分布中抽取的数字 -+ [`torch.Tensor.geometric_()`](generated/torch.Tensor.geometric_.html#torch.Tensor.geometric_ "torch.Tensor.geometric_") - 从几何分布中抽取的元素 ++ `torch.Tensor.geometric_()` - 从几何分布中抽取的元素 -+ [`torch.Tensor.log_normal_()`](generated/torch.Tensor.log_normal_.html#torch.Tensor.log_normal_ "torch.Tensor.log_normal_") - 从对数正态分布中抽样 ++ `torch.Tensor.log_normal_()` - 从对数正态分布中抽样 -+ [`torch.Tensor.normal_()`](generated/torch.Tensor.normal_.html#torch.Tensor.normal_ "torch.Tensor.normal_") - [`torch.normal()`](generated/torch.normal.html#torch.normal "torch.normal") 的原地版本 ++ `torch.Tensor.normal_()` - `torch.normal()` 的原地版本 -+ [`torch.Tensor.random_()`](generated/torch.Tensor.random_.html#torch.Tensor.random_ "torch.Tensor.random_") - 从离散均匀分布中抽取的数字 ++ `torch.Tensor.random_()` - 从离散均匀分布中抽取的数字 -+ [`torch.Tensor.uniform_()`](generated/torch.Tensor.uniform_.html#torch.Tensor.uniform_ "torch.Tensor.uniform_") - 从连续均匀分布中抽取的数字 ++ `torch.Tensor.uniform_()` - 从连续均匀分布中抽取的数字 ### 准随机抽样 -| [`quasirandom.SobolEngine`](generated/torch.quasirandom.SobolEngine.html#torch.quasirandom.SobolEngine "torch.quasirandom.SobolEngine") | [`torch.quasirandom.SobolEngine`](generated/torch.quasirandom.SobolEngine.html#torch.quasirandom.SobolEngine "torch.quasirandom.SobolEngine") 是用于生成（混淆）Sobol 序列的引擎。 | +| `quasirandom.SobolEngine` | `torch.quasirandom.SobolEngine` 是用于生成（混淆）Sobol 序列的引擎。 | | --- | --- | ## 序列化 -| [`save`](generated/torch.save.html#torch.save "torch.save") | 将对象保存到磁盘文件中。 | +| `save` | 将对象保存到磁盘文件中。 | | --- | --- | -| [`load`](generated/torch.load.html#torch.load "torch.load") | 从文件中加载使用 [`torch.save()`](generated/torch.save.html#torch.save "torch.save") 保存的对象。 | +| `load` | 从文件中加载使用 `torch.save()` 保存的对象。 | ## 并行性 -| [`get_num_threads`](generated/torch.get_num_threads.html#torch.get_num_threads "torch.get_num_threads") | 返回用于并行化 CPU 操作的线程数 | +| `get_num_threads` | 返回用于并行化 CPU 操作的线程数 | | --- | --- | -| [`set_num_threads`](generated/torch.set_num_threads.html#torch.set_num_threads "torch.set_num_threads") | 设置在 CPU 上用于内部并行性的线程数。 | -| [`get_num_interop_threads`](generated/torch.get_num_interop_threads.html#torch.get_num_interop_threads "torch.get_num_interop_threads") | 返回在 CPU 上用于互操作并行性的线程数（例如 | -| [`set_num_interop_threads`](generated/torch.set_num_interop_threads.html#torch.set_num_interop_threads "torch.set_num_interop_threads") | 设置用于互操作并行性的线程数（例如 | +| `set_num_threads` | 设置在 CPU 上用于内部并行性的线程数。 | +| `get_num_interop_threads` | 返回在 CPU 上用于互操作并行性的线程数（例如 | +| `set_num_interop_threads` | 设置用于互操作并行性的线程数（例如 | ## 本地禁用梯度计算[](#locally-disabling-gradient-computation "Permalink to this heading") -上下文管理器 [`torch.no_grad()`](generated/torch.no_grad.html#torch.no_grad "torch.no_grad")、[`torch.enable_grad()`](generated/torch.enable_grad.html#torch.enable_grad "torch.enable_grad") 和 [`torch.set_grad_enabled()`](generated/torch.set_grad_enabled.html#torch.set_grad_enabled "torch.set_grad_enabled") 对于本地禁用和启用梯度计算非常有用。有关它们的使用详情，请参阅[本地禁用梯度计算](autograd.html#locally-disable-grad)。这些上下文管理器是线程局部的，因此如果使用 `threading` 模块等将工作发送到另一个线程，则它们将无法工作。 +上下文管理器 `torch.no_grad()`、`torch.enable_grad()` 和 `torch.set_grad_enabled()` 对于本地禁用和启用梯度计算非常有用。有关它们的使用详情，请参阅本地禁用梯度计算。这些上下文管理器是线程局部的，因此如果使用 `threading` 模块等将工作发送到另一个线程，则它们将无法工作。 示例： @@ -213,321 +213,321 @@ True False ``` -| [`no_grad`](generated/torch.no_grad.html#torch.no_grad "torch.no_grad") | 禁用梯度计算的上下文管理器。 | +| `no_grad` | 禁用梯度计算的上下文管理器。 | | --- | --- | -| [`enable_grad`](generated/torch.enable_grad.html#torch.enable_grad "torch.enable_grad") | 启用梯度计算的上下文管理器。 | -| [`set_grad_enabled`](generated/torch.set_grad_enabled.html#torch.set_grad_enabled "torch.set_grad_enabled") | 上下文管理器，用于打开或关闭梯度计算。 | -| [`is_grad_enabled`](generated/torch.is_grad_enabled.html#torch.is_grad_enabled "torch.is_grad_enabled") | 如果当前启用梯度模式，则返回True。 | -| [`inference_mode`](generated/torch.inference_mode.html#torch.inference_mode "torch.inference_mode") | 启用或禁用推理模式的上下文管理器。 | -| [`is_inference_mode_enabled`](generated/torch.is_inference_mode_enabled.html#torch.is_inference_mode_enabled "torch.is_inference_mode_enabled") | 如果当前启用推理模式，则返回True。 | +| `enable_grad` | 启用梯度计算的上下文管理器。 | +| `set_grad_enabled` | 上下文管理器，用于打开或关闭梯度计算。 | +| `is_grad_enabled` | 如果当前启用梯度模式，则返回 True。 | +| `inference_mode` | 启用或禁用推理模式的上下文管理器。 | +| `is_inference_mode_enabled` | 如果当前启用推理模式，则返回 True。 | ## Math operations ### Pointwise Ops -| [`abs`](generated/torch.abs.html#torch.abs "torch.abs") | 计算`input`中每个元素的绝对值。 | +| `abs` | 计算`input`中每个元素的绝对值。 | | --- | --- | -| [`absolute`](generated/torch.absolute.html#torch.absolute "torch.absolute") | [`torch.abs()`](generated/torch.abs.html#torch.abs "torch.abs")的别名。 | -| [`acos`](generated/torch.acos.html#torch.acos "torch.acos") | 计算`input`中每个元素的反余弦值。 | -| [`arccos`](generated/torch.arccos.html#torch.arccos "torch.arccos") | [`torch.acos()`](generated/torch.acos.html#torch.acos "torch.acos")的别名。 | -| [`acosh`](generated/torch.acosh.html#torch.acosh "torch.acosh") | 返回一个新的张量，其中包含`input`元素的反双曲余弦值。 | -| [`arccosh`](generated/torch.arccosh.html#torch.arccosh "torch.arccosh") | [`torch.acosh()`](generated/torch.acosh.html#torch.acosh "torch.acosh")的别名。 | -| [`add`](generated/torch.add.html#torch.add "torch.add") | 将`other`按`alpha`缩放后加到`input`中。 | -| [`addcdiv`](generated/torch.addcdiv.html#torch.addcdiv "torch.addcdiv") | 对`tensor1`和`tensor2`进行逐元素除法，将结果乘以标量`value`并加到`input`中。 | -| [`addcmul`](generated/torch.addcmul.html#torch.addcmul "torch.addcmul") | 对`tensor1`和`tensor2`进行逐元素相乘，将结果乘以标量`value`并加到`input`中。 | -| [`angle`](generated/torch.angle.html#torch.angle "torch.angle") | 计算给定`input`张量的逐元素角度（弧度）。 | -| [`asin`](generated/torch.asin.html#torch.asin "torch.asin") | 返回一个新的张量，其中包含`input`元素的反正弦值。 | -| [`arcsin`](generated/torch.arcsin.html#torch.arcsin "torch.arcsin") | [`torch.asin()`](generated/torch.asin.html#torch.asin "torch.asin")的别名。 | -| [`asinh`](generated/torch.asinh.html#torch.asinh "torch.asinh") | 返回一个新的张量，其中包含`input`元素的反双曲正弦值。 | -| [`arcsinh`](generated/torch.arcsinh.html#torch.arcsinh "torch.arcsinh") | [`torch.asinh()`](generated/torch.asinh.html#torch.asinh "torch.asinh")的别名。 | -| [`atan`](generated/torch.atan.html#torch.atan "torch.atan") | 返回一个新的张量，其中包含`input`元素的反正切值。 | -| [`arctan`](generated/torch.arctan.html#torch.arctan "torch.arctan") | [`torch.atan()`](generated/torch.atan.html#torch.atan "torch.atan")的别名。 | -| [`atanh`](generated/torch.atanh.html#torch.atanh "torch.atanh") | 返回一个新的张量，其中包含`input`元素的反双曲正切值。 | -| [`arctanh`](generated/torch.arctanh.html#torch.arctanh "torch.arctanh") | [`torch.atanh()`](generated/torch.atanh.html#torch.atanh "torch.atanh")的别名。 | -| [`atan2`](generated/torch.atan2.html#torch.atan2 "torch.atan2") | 考虑象限的`inputi​/otheri​`的逐元素反正切。 | -| [`arctan2`](generated/torch.arctan2.html#torch.arctan2 "torch.arctan2") | [`torch.atan2()`](generated/torch.atan2.html#torch.atan2 "torch.atan2")的别名。 | -| [`bitwise_not`](generated/torch.bitwise_not.html#torch.bitwise_not "torch.bitwise_not") | 计算给定输入张量的按位非。 | -| [`bitwise_and`](generated/torch.bitwise_and.html#torch.bitwise_and "torch.bitwise_and") | 计算`input`和`other`的按位与。 | -| [`bitwise_or`](generated/torch.bitwise_or.html#torch.bitwise_or "torch.bitwise_or") | 计算`input`和`other`的按位或。 | -| [`bitwise_xor`](generated/torch.bitwise_xor.html#torch.bitwise_xor "torch.bitwise_xor") | 计算`input`和`other`的按位异或。 | -| [`bitwise_left_shift`](generated/torch.bitwise_left_shift.html#torch.bitwise_left_shift "torch.bitwise_left_shift") | 计算`input`按`other`位的左算术移位。 | -| [`bitwise_right_shift`](generated/torch.bitwise_right_shift.html#torch.bitwise_right_shift "torch.bitwise_right_shift") | 计算`input`按`other`位的右算术移位。 | -| [`ceil`](generated/torch.ceil.html#torch.ceil "torch.ceil") | 返回一个新的张量，其中包含`input`元素的上限，即大于或等于每个元素的最小整数。 | -| [`clamp`](generated/torch.clamp.html#torch.clamp "torch.clamp") | 将`input`中的所有元素夹紧到范围[`min`](generated/torch.min.html#torch.min "torch.min"), [`max`](generated/torch.max.html#torch.max "torch.max")内。 | -| [`clip`](generated/torch.clip.html#torch.clip "torch.clip") | [`torch.clamp()`](generated/torch.clamp.html#torch.clamp "torch.clamp")的别名。 | -| [`conj_physical`](generated/torch.conj_physical.html#torch.conj_physical "torch.conj_physical") | 计算给定`input`张量的逐元素共轭。 | -| [`copysign`](generated/torch.copysign.html#torch.copysign "torch.copysign") | 创建一个新的浮点张量，其大小为`input`，符号为`other`，逐元素。 | -| [`cos`](generated/torch.cos.html#torch.cos "torch.cos") | 返回一个新的张量，其中包含`input`元素的余弦值。 | -| [`cosh`](generated/torch.cosh.html#torch.cosh "torch.cosh") | 返回一个新的张量，其中包含`input`元素的双曲余弦值。 | -| [`deg2rad`](generated/torch.deg2rad.html#torch.deg2rad "torch.deg2rad") | 返回一个新的张量，其中包含`input`中每个元素从角度转换为弧度。 | -| [`div`](generated/torch.div.html#torch.div "torch.div") | 将输入`input`的每个元素除以相应的`other`元素。 | -| [`divide`](generated/torch.divide.html#torch.divide "torch.divide") | [`torch.div()`](generated/torch.div.html#torch.div "torch.div")的别名。 | -| [`digamma`](generated/torch.digamma.html#torch.digamma "torch.digamma") | [`torch.special.digamma()`](special.html#torch.special.digamma "torch.special.digamma")的别名。 | -| [`erf`](generated/torch.erf.html#torch.erf "torch.erf") | [`torch.special.erf()`](special.html#torch.special.erf "torch.special.erf")的别名。 | -| [`erfc`](generated/torch.erfc.html#torch.erfc "torch.erfc") | [`torch.special.erfc()`](special.html#torch.special.erfc "torch.special.erfc")的别名。 | -| [`erfinv`](generated/torch.erfinv.html#torch.erfinv "torch.erfinv") | [`torch.special.erfinv()`](special.html#torch.special.erfinv "torch.special.erfinv")的别名。 | -| [`exp`](generated/torch.exp.html#torch.exp "torch.exp") | 返回一个新的张量，其中包含输入张量`input`元素的指数。 | -| [`exp2`](generated/torch.exp2.html#torch.exp2 "torch.exp2") | [`torch.special.exp2()`](special.html#torch.special.exp2 "torch.special.exp2")的别名。 | -| [`expm1`](generated/torch.expm1.html#torch.expm1 "torch.expm1") | [`torch.special.expm1()`](special.html#torch.special.expm1 "torch.special.expm1")的别名。 | -| [`fake_quantize_per_channel_affine`](generated/torch.fake_quantize_per_channel_affine.html#torch.fake_quantize_per_channel_affine "torch.fake_quantize_per_channel_affine") | 返回一个新的张量，其中包含使用`scale`、`zero_point`、`quant_min`和`quant_max`对`input`进行每通道伪量化的数据，跨通道由`axis`指定。 | -| [`fake_quantize_per_tensor_affine`](generated/torch.fake_quantize_per_tensor_affine.html#torch.fake_quantize_per_tensor_affine "torch.fake_quantize_per_tensor_affine") | 使用 `scale`、`zero_point`、`quant_min` 和 `quant_max` 对 `input` 中的数据进行伪量化，并返回一个新的张量。 | -| [`fix`](generated/torch.fix.html#torch.fix "torch.fix") | [`torch.trunc()`](generated/torch.trunc.html#torch.trunc "torch.trunc") 的别名 | -| [`float_power`](generated/torch.float_power.html#torch.float_power "torch.float_power") | 以双精度计算，对 `input` 的每个元素进行 `exponent` 次幂运算。 | -| [`floor`](generated/torch.floor.html#torch.floor "torch.floor") | 返回一个新的张量，其元素为 `input` 的下取整，即小于或等于每个元素的最大整数。 | -| [`floor_divide`](generated/torch.floor_divide.html#torch.floor_divide "torch.floor_divide") | | -| [`fmod`](generated/torch.fmod.html#torch.fmod "torch.fmod") | 对每个元素应用 C++ 的 [std::fmod](https://en.cppreference.com/w/cpp/numeric/math/fmod)。 | -| [`frac`](generated/torch.frac.html#torch.frac "torch.frac") | 计算 `input` 中每个元素的小数部分。 | -| [`frexp`](generated/torch.frexp.html#torch.frexp "torch.frexp") | 将 `input` 分解为尾数和指数张量，使得 $\text{input} = \text{mantissa} \times 2^{\text{exponent}}$。 | -| [`gradient`](generated/torch.gradient.html#torch.gradient "torch.gradient") | 使用 [二阶中心差分方法](https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf) 在一个或多个维度上估计函数 $g : \mathbb{R}^n \rightarrow \mathbb{R}$g:Rn→R 的梯度，并在边界处使用一阶或二阶估计。 | -| [`imag`](generated/torch.imag.html#torch.imag "torch.imag") | 返回一个包含 `self` 张量的虚部的新张量。 | -| [`ldexp`](generated/torch.ldexp.html#torch.ldexp "torch.ldexp") | 将 `input` 乘以 2 ** `other`。 | -| [`lerp`](generated/torch.lerp.html#torch.lerp "torch.lerp") | 根据标量或张量 `weight` 对两个张量 `start`（由 `input` 给出）和 `end` 进行线性插值，并返回结果张量 `out`。 | -| [`lgamma`](generated/torch.lgamma.html#torch.lgamma "torch.lgamma") | 计算 `input` 上伽玛函数绝对值的自然对数。 | -| [`log`](generated/torch.log.html#torch.log "torch.log") | 返回一个新的张量，其元素为 `input` 的自然对数。 | -| [`log10`](generated/torch.log10.html#torch.log10 "torch.log10") | 返回一个新的张量，其元素为 `input` 的以 10 为底的对数。 | -| [`log1p`](generated/torch.log1p.html#torch.log1p "torch.log1p") | 返回一个新的张量，其元素为 (1 + `input`) 的自然对数。 | -| [`log2`](generated/torch.log2.html#torch.log2 "torch.log2") | 返回一个新的张量，其元素为 `input` 的以 2 为底的对数。 | -| [`logaddexp`](generated/torch.logaddexp.html#torch.logaddexp "torch.logaddexp") | 对输入的指数求和的对数。 | -| [`logaddexp2`](generated/torch.logaddexp2.html#torch.logaddexp2 "torch.logaddexp2") | 以 2 为底对输入的指数求和的对数。 | -| [`logical_and`](generated/torch.logical_and.html#torch.logical_and "torch.logical_and") | 计算给定输入张量的逐元素逻辑与。 | -| [`logical_not`](generated/torch.logical_not.html#torch.logical_not "torch.logical_not") | 计算给定输入张量的逐元素逻辑非。 | -| [`logical_or`](generated/torch.logical_or.html#torch.logical_or "torch.logical_or") | 计算给定输入张量的逐元素逻辑或。 | -| [`logical_xor`](generated/torch.logical_xor.html#torch.logical_xor "torch.logical_xor") | 计算给定输入张量的逐元素逻辑异或。 | -| [`logit`](生成/torch.logit.html#torch.logit "torch.logit") | [`torch.special.logit()`](special.html#torch.special.logit "torch.special.logit") 的别名。 | -| [`hypot`](生成/torch.hypot.html#torch.hypot "torch.hypot") | 给定直角三角形的两条直角边，返回其斜边。 | -| [`i0`](生成/torch.i0.html#torch.i0 "torch.i0") | [`torch.special.i0()`](special.html#torch.special.i0 "torch.special.i0") 的别名。 | -| [`igamma`](生成/torch.igamma.html#torch.igamma "torch.igamma") | [`torch.special.gammainc()`](special.html#torch.special.gammainc "torch.special.gammainc") 的别名。 | -| [`igammac`](生成/torch.igammac.html#torch.igammac "torch.igammac") | [`torch.special.gammaincc()`](special.html#torch.special.gammaincc "torch.special.gammaincc") 的别名。 | -| [`mul`](生成/torch.mul.html#torch.mul "torch.mul") | 将 `input` 乘以 `other`。 | -| [`multiply`](生成/torch.multiply.html#torch.multiply "torch.multiply") | [`torch.mul()`](生成/torch.mul.html#torch.mul "torch.mul") 的别名。 | -| [`mvlgamma`](生成/torch.mvlgamma.html#torch.mvlgamma "torch.mvlgamma") | [`torch.special.multigammaln()`](special.html#torch.special.multigammaln "torch.special.multigammaln") 的别名。 | -| [`nan_to_num`](生成/torch.nan_to_num.html#torch.nan_to_num "torch.nan_to_num") | 用 `nan`、`posinf` 和 `neginf` 指定的值替换 `input` 中的 `NaN`、正无穷大和负无穷大值。 | -| [`neg`](生成/torch.neg.html#torch.neg "torch.neg") | 返回一个新的张量，其元素为 `input` 的负数。 | -| [`negative`](生成/torch.negative.html#torch.negative "torch.negative") | [`torch.neg()`](生成/torch.neg.html#torch.neg "torch.neg") 的别名。 | -| [`nextafter`](生成/torch.nextafter.html#torch.nextafter "torch.nextafter") | 返回 `input` 向 `other` 方向的下一个浮点值，逐元素进行。 | -| [`polygamma`](生成/torch.polygamma.html#torch.polygamma "torch.polygamma") | [`torch.special.polygamma()`](special.html#torch.special.polygamma "torch.special.polygamma") 的别名。 | -| [`positive`](生成/torch.positive.html#torch.positive "torch.positive") | 返回 `input`。 | -| [`pow`](生成/torch.pow.html#torch.pow "torch.pow") | 对 `input` 中的每个元素进行 `exponent` 次幂运算，并返回结果张量。 | -| [`quantized_batch_norm`](生成/torch.quantized_batch_norm.html#torch.quantized_batch_norm "torch.quantized_batch_norm") | 对4D（NCHW）量化张量应用批量归一化。 | -| [`quantized_max_pool1d`](生成/torch.quantized_max_pool1d.html#torch.quantized_max_pool1d "torch.quantized_max_pool1d") | 对由多个输入平面组成的输入量化张量应用1D最大池化。 | -| [`quantized_max_pool2d`](生成/torch.quantized_max_pool2d.html#torch.quantized_max_pool2d "torch.quantized_max_pool2d") | 对由多个输入平面组成的输入量化张量应用2D最大池化。 | -| [`rad2deg`](生成/torch.rad2deg.html#torch.rad2deg "torch.rad2deg") | 返回一个新的张量，其中 `input` 的每个元素从弧度转换为度。 | -| [`real`](生成/torch.real.html#torch.real "torch.real") | 返回一个包含 `self` 张量的实数值的新张量。 | -| [`reciprocal`](生成/torch.reciprocal.html#torch.reciprocal "torch.reciprocal") | 返回一个新的张量，其元素为 `input` 的倒数。 | -| [`remainder`](生成/torch.remainder.html#torch.remainder "torch.remainder") | 计算逐元素的[Python取模运算](https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations)。 | -| [`round`](生成/torch.round.html#torch.round "torch.round") | 将 `input` 的元素四舍五入到最接近的整数。 | -| [`rsqrt`](生成/torch.rsqrt.html#torch.rsqrt "torch.rsqrt") | 返回一个新的张量，其元素为 `input` 的平方根的倒数。 | -| [`sigmoid`](generated/torch.sigmoid.html#torch.sigmoid "torch.sigmoid") | [`torch.special.expit()`](special.html#torch.special.expit "torch.special.expit")的别名。 | -| [`sign`](generated/torch.sign.html#torch.sign "torch.sign") | 返回具有`input`元素的符号的新张量。 | -| [`sgn`](generated/torch.sgn.html#torch.sgn "torch.sgn") | 这个函数是对复数张量的torch.sign()的扩展。 | -| [`signbit`](generated/torch.signbit.html#torch.signbit "torch.signbit") | 检查`input`的每个元素是否设置了符号位。 | -| [`sin`](generated/torch.sin.html#torch.sin "torch.sin") | 返回具有`input`元素的正弦的新张量。 | -| [`sinc`](generated/torch.sinc.html#torch.sinc "torch.sinc") | [`torch.special.sinc()`](special.html#torch.special.sinc "torch.special.sinc")的别名。 | -| [`sinh`](generated/torch.sinh.html#torch.sinh "torch.sinh") | 返回具有`input`元素的双曲正弦的新张量。 | -| [`softmax`](generated/torch.softmax.html#torch.softmax "torch.softmax") | [`torch.nn.functional.softmax()`](generated/torch.nn.functional.softmax.html#torch.nn.functional.softmax "torch.nn.functional.softmax")的别名。 | -| [`sqrt`](generated/torch.sqrt.html#torch.sqrt "torch.sqrt") | 返回具有`input`元素的平方根的新张量。 | -| [`square`](generated/torch.square.html#torch.square "torch.square") | 返回具有`input`元素的平方的新张量。 | -| [`sub`](generated/torch.sub.html#torch.sub "torch.sub") | 从`input`中减去经过`alpha`缩放的`other`。 | -| [`subtract`](generated/torch.subtract.html#torch.subtract "torch.subtract") | [`torch.sub()`](generated/torch.sub.html#torch.sub "torch.sub")的别名。 | -| [`tan`](generated/torch.tan.html#torch.tan "torch.tan") | 返回具有`input`元素的正切的新张量。 | -| [`tanh`](generated/torch.tanh.html#torch.tanh "torch.tanh") | 返回具有`input`元素的双曲正切的新张量。 | -| [`true_divide`](generated/torch.true_divide.html#torch.true_divide "torch.true_divide") | 使用`rounding_mode=None`的[`torch.div()`](generated/torch.div.html#torch.div "torch.div")的别名。 | -| [`trunc`](generated/torch.trunc.html#torch.trunc "torch.trunc") | 返回具有`input`元素的截断整数值的新张量。 | -| [`xlogy`](generated/torch.xlogy.html#torch.xlogy "torch.xlogy") | [`torch.special.xlogy()`](special.html#torch.special.xlogy "torch.special.xlogy")的别名。 | +| `absolute` | `torch.abs()`的别名。 | +| `acos` | 计算`input`中每个元素的反余弦值。 | +| `arccos` | `torch.acos()`的别名。 | +| `acosh` | 返回一个新的张量，其中包含`input`元素的反双曲余弦值。 | +| `arccosh` | `torch.acosh()`的别名。 | +| `add` | 将`other`按`alpha`缩放后加到`input`中。 | +| `addcdiv` | 对`tensor1`和`tensor2`进行逐元素除法，将结果乘以标量`value`并加到`input`中。 | +| `addcmul` | 对`tensor1`和`tensor2`进行逐元素相乘，将结果乘以标量`value`并加到`input`中。 | +| `angle` | 计算给定`input`张量的逐元素角度（弧度）。 | +| `asin` | 返回一个新的张量，其中包含`input`元素的反正弦值。 | +| `arcsin` | `torch.asin()`的别名。 | +| `asinh` | 返回一个新的张量，其中包含`input`元素的反双曲正弦值。 | +| `arcsinh` | `torch.asinh()`的别名。 | +| `atan` | 返回一个新的张量，其中包含`input`元素的反正切值。 | +| `arctan` | `torch.atan()`的别名。 | +| `atanh` | 返回一个新的张量，其中包含`input`元素的反双曲正切值。 | +| `arctanh` | `torch.atanh()`的别名。 | +| `atan2` | 考虑象限的`inputi​/otheri​`的逐元素反正切。 | +| `arctan2` | `torch.atan2()`的别名。 | +| `bitwise_not` | 计算给定输入张量的按位非。 | +| `bitwise_and` | 计算`input`和`other`的按位与。 | +| `bitwise_or` | 计算`input`和`other`的按位或。 | +| `bitwise_xor` | 计算`input`和`other`的按位异或。 | +| `bitwise_left_shift` | 计算`input`按`other`位的左算术移位。 | +| `bitwise_right_shift` | 计算`input`按`other`位的右算术移位。 | +| `ceil` | 返回一个新的张量，其中包含`input`元素的上限，即大于或等于每个元素的最小整数。 | +| `clamp` | 将`input`中的所有元素夹紧到范围`min`, `max`内。 | +| `clip` | `torch.clamp()`的别名。 | +| `conj_physical` | 计算给定`input`张量的逐元素共轭。 | +| `copysign` | 创建一个新的浮点张量，其大小为`input`，符号为`other`，逐元素。 | +| `cos` | 返回一个新的张量，其中包含`input`元素的余弦值。 | +| `cosh` | 返回一个新的张量，其中包含`input`元素的双曲余弦值。 | +| `deg2rad` | 返回一个新的张量，其中包含`input`中每个元素从角度转换为弧度。 | +| `div` | 将输入`input`的每个元素除以相应的`other`元素。 | +| `divide` | `torch.div()`的别名。 | +| `digamma` | `torch.special.digamma()`的别名。 | +| `erf` | `torch.special.erf()`的别名。 | +| `erfc` | `torch.special.erfc()`的别名。 | +| `erfinv` | `torch.special.erfinv()`的别名。 | +| `exp` | 返回一个新的张量，其中包含输入张量`input`元素的指数。 | +| `exp2` | `torch.special.exp2()`的别名。 | +| `expm1` | `torch.special.expm1()`的别名。 | +| `fake_quantize_per_channel_affine` | 返回一个新的张量，其中包含使用`scale`、`zero_point`、`quant_min`和`quant_max`对`input`进行每通道伪量化的数据，跨通道由`axis`指定。 | +| `fake_quantize_per_tensor_affine` | 使用 `scale`、`zero_point`、`quant_min` 和 `quant_max` 对 `input` 中的数据进行伪量化，并返回一个新的张量。 | +| `fix` | `torch.trunc()` 的别名 | +| `float_power` | 以双精度计算，对 `input` 的每个元素进行 `exponent` 次幂运算。 | +| `floor` | 返回一个新的张量，其元素为 `input` 的下取整，即小于或等于每个元素的最大整数。 | +| `floor_divide` | | +| `fmod` | 对每个元素应用 C++ 的 [std::fmod](https://en.cppreference.com/w/cpp/numeric/math/fmod)。 | +| `frac` | 计算 `input` 中每个元素的小数部分。 | +| `frexp` | 将 `input` 分解为尾数和指数张量，使得 $\text{input} = \text{mantissa} \times 2^{\text{exponent}}$。 | +| `gradient` | 使用 [二阶中心差分方法](https://www.ams.org/journals/mcom/1988-51-184/S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf) 在一个或多个维度上估计函数 $g : \mathbb{R}^n \rightarrow \mathbb{R}$g:Rn→R 的梯度，并在边界处使用一阶或二阶估计。 | +| `imag` | 返回一个包含 `self` 张量的虚部的新张量。 | +| `ldexp` | 将 `input` 乘以 2 ** `other`。 | +| `lerp` | 根据标量或张量 `weight` 对两个张量 `start`（由 `input` 给出）和 `end` 进行线性插值，并返回结果张量 `out`。 | +| `lgamma` | 计算 `input` 上伽玛函数绝对值的自然对数。 | +| `log` | 返回一个新的张量，其元素为 `input` 的自然对数。 | +| `log10` | 返回一个新的张量，其元素为 `input` 的以 10 为底的对数。 | +| `log1p` | 返回一个新的张量，其元素为 (1 + `input`) 的自然对数。 | +| `log2` | 返回一个新的张量，其元素为 `input` 的以 2 为底的对数。 | +| `logaddexp` | 对输入的指数求和的对数。 | +| `logaddexp2` | 以 2 为底对输入的指数求和的对数。 | +| `logical_and` | 计算给定输入张量的逐元素逻辑与。 | +| `logical_not` | 计算给定输入张量的逐元素逻辑非。 | +| `logical_or` | 计算给定输入张量的逐元素逻辑或。 | +| `logical_xor` | 计算给定输入张量的逐元素逻辑异或。 | +| `logit` | `torch.special.logit()` 的别名。 | +| `hypot` | 给定直角三角形的两条直角边，返回其斜边。 | +| `i0` | `torch.special.i0()` 的别名。 | +| `igamma` | `torch.special.gammainc()` 的别名。 | +| `igammac` | `torch.special.gammaincc()` 的别名。 | +| `mul` | 将 `input` 乘以 `other`。 | +| `multiply` | `torch.mul()` 的别名。 | +| `mvlgamma` | `torch.special.multigammaln()` 的别名。 | +| `nan_to_num` | 用 `nan`、`posinf` 和 `neginf` 指定的值替换 `input` 中的 `NaN`、正无穷大和负无穷大值。 | +| `neg` | 返回一个新的张量，其元素为 `input` 的负数。 | +| `negative` | `torch.neg()` 的别名。 | +| `nextafter` | 返回 `input` 向 `other` 方向的下一个浮点值，逐元素进行。 | +| `polygamma` | `torch.special.polygamma()` 的别名。 | +| `positive` | 返回 `input`。 | +| `pow` | 对 `input` 中的每个元素进行 `exponent` 次幂运算，并返回结果张量。 | +| `quantized_batch_norm` | 对 4D（NCHW）量化张量应用批量归一化。 | +| `quantized_max_pool1d` | 对由多个输入平面组成的输入量化张量应用 1D 最大池化。 | +| `quantized_max_pool2d` | 对由多个输入平面组成的输入量化张量应用 2D 最大池化。 | +| `rad2deg` | 返回一个新的张量，其中 `input` 的每个元素从弧度转换为度。 | +| `real` | 返回一个包含 `self` 张量的实数值的新张量。 | +| `reciprocal` | 返回一个新的张量，其元素为 `input` 的倒数。 | +| `remainder` | 计算逐元素的[Python 取模运算](https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations)。 | +| `round` | 将 `input` 的元素四舍五入到最接近的整数。 | +| `rsqrt` | 返回一个新的张量，其元素为 `input` 的平方根的倒数。 | +| `sigmoid` | `torch.special.expit()`的别名。 | +| `sign` | 返回具有`input`元素的符号的新张量。 | +| `sgn` | 这个函数是对复数张量的 torch.sign()的扩展。 | +| `signbit` | 检查`input`的每个元素是否设置了符号位。 | +| `sin` | 返回具有`input`元素的正弦的新张量。 | +| `sinc` | `torch.special.sinc()`的别名。 | +| `sinh` | 返回具有`input`元素的双曲正弦的新张量。 | +| `softmax` | `torch.nn.functional.softmax()`的别名。 | +| `sqrt` | 返回具有`input`元素的平方根的新张量。 | +| `square` | 返回具有`input`元素的平方的新张量。 | +| `sub` | 从`input`中减去经过`alpha`缩放的`other`。 | +| `subtract` | `torch.sub()`的别名。 | +| `tan` | 返回具有`input`元素的正切的新张量。 | +| `tanh` | 返回具有`input`元素的双曲正切的新张量。 | +| `true_divide` | 使用`rounding_mode=None`的`torch.div()`的别名。 | +| `trunc` | 返回具有`input`元素的截断整数值的新张量。 | +| `xlogy` | `torch.special.xlogy()`的别名。 | ### Reduction Ops -| [`argmax`](generated/torch.argmax.html#torch.argmax "torch.argmax") | 返回`input`张量中所有元素的最大值的索引。 | +| `argmax` | 返回`input`张量中所有元素的最大值的索引。 | | --- | --- | -| [`argmin`](generated/torch.argmin.html#torch.argmin "torch.argmin") | 返回扁平张量或沿着维度的最小值的索引。 | -| [`amax`](generated/torch.amax.html#torch.amax "torch.amax") | 返回给定维度`dim`中`input`张量每个切片的最大值。 | -| [`amin`](generated/torch.amin.html#torch.amin "torch.amin") | 返回给定维度`dim`中`input`张量每个切片的最小值。 | -| [`aminmax`](generated/torch.aminmax.html#torch.aminmax "torch.aminmax") | 计算`input`张量的最小值和最大值。 | -| [`all`](generated/torch.all.html#torch.all "torch.all") | 检查`input`中是否所有元素评估为True。 | -| [`any`](generated/torch.any.html#torch.any "torch.any") | 检查`input`中是否有任何元素评估为True。 | -| [`max`](generated/torch.max.html#torch.max "torch.max") | 返回`input`张量中所有元素的最大值。 | -| [`min`](generated/torch.min.html#torch.min "torch.min") | 返回`input`张量中所有元素的最小值。 | -| [`dist`](generated/torch.dist.html#torch.dist "torch.dist") | 返回(`input` - `other`)的p-范数 | -| [`logsumexp`](生成/torch.logsumexp.html#torch.logsumexp "torch.logsumexp") | 返回`input`张量每行在给定维度`dim`上的对数求和指数。 | -| [`mean`](生成/torch.mean.html#torch.mean "torch.mean") | 返回`input`张量中所有元素的均值。 | -| [`nanmean`](生成/torch.nanmean.html#torch.nanmean "torch.nanmean") | 计算指定维度上所有非NaN元素的均值。 | -| [`median`](生成/torch.median.html#torch.median "torch.median") | 返回`input`中值的中位数。 | -| [`nanmedian`](生成/torch.nanmedian.html#torch.nanmedian "torch.nanmedian") | 返回`input`中值的中位数，忽略`NaN`值。 | -| [`mode`](生成/torch.mode.html#torch.mode "torch.mode") | 返回一个命名元组`(values, indices)`，其中`values`是`input`张量每行在给定维度`dim`上的众数值，即在该行中出现最频繁的值，`indices`是找到的每个众数值的索引位置。 | -| [`norm`](生成/torch.norm.html#torch.norm "torch.norm") | 返回给定张量的矩阵范数或向量范数。 | -| [`nansum`](生成/torch.nansum.html#torch.nansum "torch.nansum") | 返回所有元素的和，将非数值（NaN）视为零。 | -| [`prod`](生成/torch.prod.html#torch.prod "torch.prod") | 返回`input`张量中所有元素的乘积。 | -| [`quantile`](生成/torch.quantile.html#torch.quantile "torch.quantile") | 计算`input`张量每行沿维度`dim`的q分位数。 | -| [`nanquantile`](生成/torch.nanquantile.html#torch.nanquantile "torch.nanquantile") | 这是[`torch.quantile()`](生成/torch.quantile.html#torch.quantile "torch.quantile")的一个变体，"忽略" `NaN` 值，计算`input`中的分位数`q`，就好像`input`中不存在`NaN`值一样。 | -| [`std`](生成/torch.std.html#torch.std "torch.std") | 计算由`dim`指定的维度上的标准差。 | -| [`std_mean`](生成/torch.std_mean.html#torch.std_mean "torch.std_mean") | 计算由`dim`指定的维度上的标准差和均值。 | -| [`sum`](生成/torch.sum.html#torch.sum "torch.sum") | 返回`input`张量中所有元素的和。 | -| [`unique`](生成/torch.unique.html#torch.unique "torch.unique") | 返回输入张量的唯一元素。 | -| [`unique_consecutive`](生成/torch.unique_consecutive.html#torch.unique_consecutive "torch.unique_consecutive") | 消除每个连续等价元素组中除第一个元素之外的所有元素。 | -| [`var`](生成/torch.var.html#torch.var "torch.var") | 计算由`dim`指定的维度上的方差。 | -| [`var_mean`](生成/torch.var_mean.html#torch.var_mean "torch.var_mean") | 计算由`dim`指定的维度上的方差和均值。 | -| [`count_nonzero`](生成/torch.count_nonzero.html#torch.count_nonzero "torch.count_nonzero") | 计算张量`input`沿给定`dim`中的非零值的数量。 | +| `argmin` | 返回扁平张量或沿着维度的最小值的索引。 | +| `amax` | 返回给定维度`dim`中`input`张量每个切片的最大值。 | +| `amin` | 返回给定维度`dim`中`input`张量每个切片的最小值。 | +| `aminmax` | 计算`input`张量的最小值和最大值。 | +| `all` | 检查`input`中是否所有元素评估为 True。 | +| `any` | 检查`input`中是否有任何元素评估为 True。 | +| `max` | 返回`input`张量中所有元素的最大值。 | +| `min` | 返回`input`张量中所有元素的最小值。 | +| `dist` | 返回(`input` - `other`)的 p-范数 | +| `logsumexp` | 返回`input`张量每行在给定维度`dim`上的对数求和指数。 | +| `mean` | 返回`input`张量中所有元素的均值。 | +| `nanmean` | 计算指定维度上所有非 NaN 元素的均值。 | +| `median` | 返回`input`中值的中位数。 | +| `nanmedian` | 返回`input`中值的中位数，忽略`NaN`值。 | +| `mode` | 返回一个命名元组`(values, indices)`，其中`values`是`input`张量每行在给定维度`dim`上的众数值，即在该行中出现最频繁的值，`indices`是找到的每个众数值的索引位置。 | +| `norm` | 返回给定张量的矩阵范数或向量范数。 | +| `nansum` | 返回所有元素的和，将非数值（NaN）视为零。 | +| `prod` | 返回`input`张量中所有元素的乘积。 | +| `quantile` | 计算`input`张量每行沿维度`dim`的 q 分位数。 | +| `nanquantile` | 这是`torch.quantile()`的一个变体，"忽略" `NaN` 值，计算`input`中的分位数`q`，就好像`input`中不存在`NaN`值一样。 | +| `std` | 计算由`dim`指定的维度上的标准差。 | +| `std_mean` | 计算由`dim`指定的维度上的标准差和均值。 | +| `sum` | 返回`input`张量中所有元素的和。 | +| `unique` | 返回输入张量的唯一元素。 | +| `unique_consecutive` | 消除每个连续等价元素组中除第一个元素之外的所有元素。 | +| `var` | 计算由`dim`指定的维度上的方差。 | +| `var_mean` | 计算由`dim`指定的维度上的方差和均值。 | +| `count_nonzero` | 计算张量`input`沿给定`dim`中的非零值的数量。 | ### Comparison Ops -| [`allclose`](生成/torch.allclose.html#torch.allclose "torch.allclose") | 此函数检查`input`和`other`是否满足条件： | +| `allclose` | 此函数检查`input`和`other`是否满足条件： | | --- | --- | -| [`argsort`](生成/torch.argsort.html#torch.argsort "torch.argsort") | 返回按值升序沿给定维度对张量进行排序的索引。 | -| [`eq`](生成/torch.eq.html#torch.eq "torch.eq") | 计算逐元素相等 | -| [`equal`](生成/torch.equal.html#torch.equal "torch.equal") | 如果两个张量具有相同的大小和元素，则为`True`，否则为`False`。 | -| [`ge`](生成/torch.ge.html#torch.ge "torch.ge") | 计算$\text{input} \geq \text{other}$逐元素。 | -| [`greater_equal`](generated/torch.greater_equal.html#torch.greater_equal "torch.greater_equal") | [`torch.ge()`](generated/torch.ge.html#torch.ge "torch.ge") 的别名。 | -| [`gt`](generated/torch.gt.html#torch.gt "torch.gt") | 计算 $\text{input} > \text{other}$input>other 逐元素。 | -| [`greater`](generated/torch.greater.html#torch.greater "torch.greater") | [`torch.gt()`](generated/torch.gt.html#torch.gt "torch.gt") 的别名。 | -| [`isclose`](generated/torch.isclose.html#torch.isclose "torch.isclose") | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否与 `other` 的对应元素“接近”。 | -| [`isfinite`](generated/torch.isfinite.html#torch.isfinite "torch.isfinite") | 返回一个新张量，其中的布尔元素表示每个元素是否为有限数。 | -| [`isin`](generated/torch.isin.html#torch.isin "torch.isin") | 检查 `elements` 的每个元素是否在 `test_elements` 中。 | -| [`isinf`](generated/torch.isinf.html#torch.isinf "torch.isinf") | 检查 `input` 的每个元素是否为无穷大（正无穷大或负无穷大）。 | -| [`isposinf`](generated/torch.isposinf.html#torch.isposinf "torch.isposinf") | 检查 `input` 的每个元素是否为正无穷大。 | -| [`isneginf`](generated/torch.isneginf.html#torch.isneginf "torch.isneginf") | 检查 `input` 的每个元素是否为负无穷大。 | -| [`isnan`](generated/torch.isnan.html#torch.isnan "torch.isnan") | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否为 NaN。 | -| [`isreal`](generated/torch.isreal.html#torch.isreal "torch.isreal") | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否为实数或非实数。 | -| [`kthvalue`](generated/torch.kthvalue.html#torch.kthvalue "torch.kthvalue") | 返回一个命名元组 `(values, indices)`，其中 `values` 是 `input` 张量在给定维度 `dim` 中每行的第 `k` 小元素。 | -| [`le`](generated/torch.le.html#torch.le "torch.le") | 计算 $\text{input} \leq \text{other}$input≤other 逐元素。 | -| [`less_equal`](generated/torch.less_equal.html#torch.less_equal "torch.less_equal") | [`torch.le()`](generated/torch.le.html#torch.le "torch.le") 的别名。 | -| [`lt`](generated/torch.lt.html#torch.lt "torch.lt") | 计算 $\text{input} < \text{other}$input \text{other}$input>other 逐元素。 | +| `greater` | `torch.gt()` 的别名。 | +| `isclose` | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否与 `other` 的对应元素“接近”。 | +| `isfinite` | 返回一个新张量，其中的布尔元素表示每个元素是否为有限数。 | +| `isin` | 检查 `elements` 的每个元素是否在 `test_elements` 中。 | +| `isinf` | 检查 `input` 的每个元素是否为无穷大（正无穷大或负无穷大）。 | +| `isposinf` | 检查 `input` 的每个元素是否为正无穷大。 | +| `isneginf` | 检查 `input` 的每个元素是否为负无穷大。 | +| `isnan` | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否为 NaN。 | +| `isreal` | 返回一个新张量，其中的布尔元素表示 `input` 的每个元素是否为实数或非实数。 | +| `kthvalue` | 返回一个命名元组 `(values, indices)`，其中 `values` 是 `input` 张量在给定维度 `dim` 中每行的第 `k` 小元素。 | +| `le` | 计算 $\text{input} \leq \text{other}$input≤other 逐元素。 | +| `less_equal` | `torch.le()` 的别名。 | +| `lt` | 计算 $\text{input} < \text{other}$input 原文：[https://pytorch.org/docs/stable/nn.html](https://pytorch.org/docs/stable/nn.html) +> 原文：[`pytorch.org/docs/stable/nn.html`](https://pytorch.org/docs/stable/nn.html) 这些是图的基本构建块： torch.nn -+ [容器](#containers) ++ 容器 -+ [卷积层](#convolution-layers) ++ 卷积层 -+ [池化层](#pooling-layers) ++ 池化层 -+ [填充层](#padding-layers) ++ 填充层 -+ [非线性激活（加权和，非线性）](#non-linear-activations-weighted-sum-nonlinearity) ++ 非线性激活（加权和，非线性） -+ [非线性激活（其他）](#non-linear-activations-other) ++ 非线性激活（其他） -+ [归一化层](#normalization-layers) ++ 归一化层 -+ [循环层](#recurrent-layers) ++ 循环层 -+ [变换器层](#transformer-layers) ++ 变换器层 -+ [线性层](#linear-layers) ++ 线性层 -+ [丢弃层](#dropout-layers) ++ 丢弃层 -+ [稀疏层](#sparse-layers) ++ 稀疏层 -+ [距离函数](#distance-functions) ++ 距离函数 -+ [损失函数](#loss-functions) ++ 损失函数 -+ [视觉层](#vision-layers) ++ 视觉层 -+ [洗牌层](#shuffle-layers) ++ 洗牌层 -+ [DataParallel 层（多GPU，分布式）](#module-torch.nn.parallel) ++ DataParallel 层（多 GPU，分布式） -+ [实用工具](#module-torch.nn.utils) ++ 实用工具 -+ [量化函数](#quantized-functions) ++ 量化函数 -+ [延迟模块初始化](#lazy-modules-initialization) ++ 延迟模块初始化 -| [`Parameter`](generated/torch.nn.parameter.Parameter.html#torch.nn.parameter.Parameter "torch.nn.parameter.Parameter") | 一种被视为模块参数的张量。 | +| `Parameter` | 一种被视为模块参数的张量。 | | --- | --- | -| [`UninitializedParameter`](generated/torch.nn.parameter.UninitializedParameter.html#torch.nn.parameter.UninitializedParameter "torch.nn.parameter.UninitializedParameter") | 一个未初始化的参数。 | -| [`UninitializedBuffer`](generated/torch.nn.parameter.UninitializedBuffer.html#torch.nn.parameter.UninitializedBuffer "torch.nn.parameter.UninitializedBuffer") | 一个未初始化的缓冲区。 | +| `UninitializedParameter` | 一个未初始化的参数。 | +| `UninitializedBuffer` | 一个未初始化的缓冲区。 | -## [容器](#id1) +## 容器 -| [`Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module") | 所有神经网络模块的基类。 | +| `Module` | 所有神经网络模块的基类。 | | --- | --- | -| [`Sequential`](generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential") | 一个顺序容器。 | -| [`ModuleList`](generated/torch.nn.ModuleList.html#torch.nn.ModuleList "torch.nn.ModuleList") | 在列表中保存子模块。 | -| [`ModuleDict`](generated/torch.nn.ModuleDict.html#torch.nn.ModuleDict "torch.nn.ModuleDict") | 在字典中保存子模块。 | -| [`ParameterList`](generated/torch.nn.ParameterList.html#torch.nn.ParameterList "torch.nn.ParameterList") | 在列表中保存参数。 | -| [`ParameterDict`](generated/torch.nn.ParameterDict.html#torch.nn.ParameterDict "torch.nn.ParameterDict") | 在字典中保存参数。 | +| `Sequential` | 一个顺序容器。 | +| `ModuleList` | 在列表中保存子模块。 | +| `ModuleDict` | 在字典中保存子模块。 | +| `ParameterList` | 在列表中保存参数。 | +| `ParameterDict` | 在字典中保存参数。 | 模块的全局钩子 -| [`register_module_forward_pre_hook`](generated/torch.nn.modules.module.register_module_forward_pre_hook.html#torch.nn.modules.module.register_module_forward_pre_hook "torch.nn.modules.module.register_module_forward_pre_hook") | 注册一个对所有模块通用的前向预钩子。 | +| `register_module_forward_pre_hook` | 注册一个对所有模块通用的前向预钩子。 | | --- | --- | -| [`register_module_forward_hook`](generated/torch.nn.modules.module.register_module_forward_hook.html#torch.nn.modules.module.register_module_forward_hook "torch.nn.modules.module.register_module_forward_hook") | 为所有模块注册一个全局前向钩子。 | -| [`register_module_backward_hook`](generated/torch.nn.modules.module.register_module_backward_hook.html#torch.nn.modules.module.register_module_backward_hook "torch.nn.modules.module.register_module_backward_hook") | 注册一个对所有模块通用的反向钩子。 | -| [`register_module_full_backward_pre_hook`](generated/torch.nn.modules.module.register_module_full_backward_pre_hook.html#torch.nn.modules.module.register_module_full_backward_pre_hook "torch.nn.modules.module.register_module_full_backward_pre_hook") | 注册一个对所有模块通用的反向预钩子。 | -| [`register_module_full_backward_hook`](generated/torch.nn.modules.module.register_module_full_backward_hook.html#torch.nn.modules.module.register_module_full_backward_hook "torch.nn.modules.module.register_module_full_backward_hook") | 注册一个对所有模块通用的反向钩子。 | -| [`register_module_buffer_registration_hook`](generated/torch.nn.modules.module.register_module_buffer_registration_hook.html#torch.nn.modules.module.register_module_buffer_registration_hook "torch.nn.modules.module.register_module_buffer_registration_hook") | 注册一个适用于所有模块的缓冲区注册钩子。 | -| [`register_module_module_registration_hook`](generated/torch.nn.modules.module.register_module_module_registration_hook.html#torch.nn.modules.module.register_module_module_registration_hook "torch.nn.modules.module.register_module_module_registration_hook") | 注册一个适用于所有模块的模块注册钩子。 | -| [`register_module_parameter_registration_hook`](generated/torch.nn.modules.module.register_module_parameter_registration_hook.html#torch.nn.modules.module.register_module_parameter_registration_hook "torch.nn.modules.module.register_module_parameter_registration_hook") | 注册一个适用于所有模块的参数注册钩子。 | +| `register_module_forward_hook` | 为所有模块注册一个全局前向钩子。 | +| `register_module_backward_hook` | 注册一个对所有模块通用的反向钩子。 | +| `register_module_full_backward_pre_hook` | 注册一个对所有模块通用的反向预钩子。 | +| `register_module_full_backward_hook` | 注册一个对所有模块通用的反向钩子。 | +| `register_module_buffer_registration_hook` | 注册一个适用于所有模块的缓冲区注册钩子。 | +| `register_module_module_registration_hook` | 注册一个适用于所有模块的模块注册钩子。 | +| `register_module_parameter_registration_hook` | 注册一个适用于所有模块的参数注册钩子。 | -## [卷积层](#id1) +## 卷积层 -| [`nn.Conv1d`](generated/torch.nn.Conv1d.html#torch.nn.Conv1d "torch.nn.Conv1d") | 对由多个输入平面组成的输入信号应用1D卷积。 | +| `nn.Conv1d` | 对由多个输入平面组成的输入信号应用 1D 卷积。 | | --- | --- | -| [`nn.Conv2d`](generated/torch.nn.Conv2d.html#torch.nn.Conv2d "torch.nn.Conv2d") | 对由多个输入平面组成的输入信号应用2D卷积。 | -| [`nn.Conv3d`](generated/torch.nn.Conv3d.html#torch.nn.Conv3d "torch.nn.Conv3d") | 对由多个输入平面组成的输入信号应用3D卷积。 | -| [`nn.ConvTranspose1d`](generated/torch.nn.ConvTranspose1d.html#torch.nn.ConvTranspose1d "torch.nn.ConvTranspose1d") | 对由多个输入平面组成的输入图像应用1D转置卷积运算符。 | -| [`nn.ConvTranspose2d`](generated/torch.nn.ConvTranspose2d.html#torch.nn.ConvTranspose2d "torch.nn.ConvTranspose2d") | 对由多个输入平面组成的输入图像应用2D转置卷积运算符。 | -| [`nn.ConvTranspose3d`](generated/torch.nn.ConvTranspose3d.html#torch.nn.ConvTranspose3d "torch.nn.ConvTranspose3d") | 对由多个输入平面组成的输入图像应用3D转置卷积运算符。 | -| [`nn.LazyConv1d`](generated/torch.nn.LazyConv1d.html#torch.nn.LazyConv1d "torch.nn.LazyConv1d") | 一个带有`in_channels`参数延迟初始化的[`torch.nn.Conv1d`](generated/torch.nn.Conv1d.html#torch.nn.Conv1d "torch.nn.Conv1d")模块。 | -| [`nn.LazyConv2d`](generated/torch.nn.LazyConv2d.html#torch.nn.LazyConv2d "torch.nn.LazyConv2d") | 一个带有`in_channels`参数延迟初始化的[`torch.nn.Conv2d`](generated/torch.nn.Conv2d.html#torch.nn.Conv2d "torch.nn.Conv2d")模块。 | -| [`nn.LazyConv3d`](generated/torch.nn.LazyConv3d.html#torch.nn.LazyConv3d "torch.nn.LazyConv3d") | 一个带有`in_channels`参数延迟初始化的[`torch.nn.Conv3d`](generated/torch.nn.Conv3d.html#torch.nn.Conv3d "torch.nn.Conv3d")模块。 | -| [`nn.LazyConvTranspose1d`](generated/torch.nn.LazyConvTranspose1d.html#torch.nn.LazyConvTranspose1d "torch.nn.LazyConvTranspose1d") | 一个带有`in_channels`参数延迟初始化的[`torch.nn.ConvTranspose1d`](generated/torch.nn.ConvTranspose1d.html#torch.nn.ConvTranspose1d "torch.nn.ConvTranspose1d")模块。 | -| [`nn.LazyConvTranspose2d`](generated/torch.nn.LazyConvTranspose2d.html#torch.nn.LazyConvTranspose2d "torch.nn.LazyConvTranspose2d") | 一个带有`in_channels`参数延迟初始化的[`torch.nn.ConvTranspose2d`](generated/torch.nn.ConvTranspose2d.html#torch.nn.ConvTranspose2d "torch.nn.ConvTranspose2d")模块。 | -| [`nn.LazyConvTranspose3d`](generated/torch.nn.LazyConvTranspose3d.html#torch.nn.LazyConvTranspose3d "torch.nn.LazyConvTranspose3d") | 一个带有`in_channels`参数延迟初始化的[`torch.nn.ConvTranspose3d`](generated/torch.nn.ConvTranspose3d.html#torch.nn.ConvTranspose3d "torch.nn.ConvTranspose3d")模块。 | -| [`nn.Unfold`](generated/torch.nn.Unfold.html#torch.nn.Unfold "torch.nn.Unfold") | 从批量输入张量中提取滑动局部块。 | -| [`nn.Fold`](generated/torch.nn.Fold.html#torch.nn.Fold "torch.nn.Fold") | 将一组滑动局部块组合成一个大的包含张量。 | - -## [池化层](#id1) - -| [`nn.MaxPool1d`](generated/torch.nn.MaxPool1d.html#torch.nn.MaxPool1d "torch.nn.MaxPool1d") | 对由多个输入平面组成的输入信号应用1D最大池化。 | +| `nn.Conv2d` | 对由多个输入平面组成的输入信号应用 2D 卷积。 | +| `nn.Conv3d` | 对由多个输入平面组成的输入信号应用 3D 卷积。 | +| `nn.ConvTranspose1d` | 对由多个输入平面组成的输入图像应用 1D 转置卷积运算符。 | +| `nn.ConvTranspose2d` | 对由多个输入平面组成的输入图像应用 2D 转置卷积运算符。 | +| `nn.ConvTranspose3d` | 对由多个输入平面组成的输入图像应用 3D 转置卷积运算符。 | +| `nn.LazyConv1d` | 一个带有`in_channels`参数延迟初始化的`torch.nn.Conv1d`模块。 | +| `nn.LazyConv2d` | 一个带有`in_channels`参数延迟初始化的`torch.nn.Conv2d`模块。 | +| `nn.LazyConv3d` | 一个带有`in_channels`参数延迟初始化的`torch.nn.Conv3d`模块。 | +| `nn.LazyConvTranspose1d` | 一个带有`in_channels`参数延迟初始化的`torch.nn.ConvTranspose1d`模块。 | +| `nn.LazyConvTranspose2d` | 一个带有`in_channels`参数延迟初始化的`torch.nn.ConvTranspose2d`模块。 | +| `nn.LazyConvTranspose3d` | 一个带有`in_channels`参数延迟初始化的`torch.nn.ConvTranspose3d`模块。 | +| `nn.Unfold` | 从批量输入张量中提取滑动局部块。 | +| `nn.Fold` | 将一组滑动局部块组合成一个大的包含张量。 | + +## 池化层 + +| `nn.MaxPool1d` | 对由多个输入平面组成的输入信号应用 1D 最大池化。 | | --- | --- | -| [`nn.MaxPool2d`](generated/torch.nn.MaxPool2d.html#torch.nn.MaxPool2d "torch.nn.MaxPool2d") | 对由多个输入平面组成的输入信号应用2D最大池化。 | -| [`nn.MaxPool3d`](generated/torch.nn.MaxPool3d.html#torch.nn.MaxPool3d "torch.nn.MaxPool3d") | 对由多个输入平面组成的输入信号应用3D最大池化。 | -| [`nn.MaxUnpool1d`](generated/torch.nn.MaxUnpool1d.html#torch.nn.MaxUnpool1d "torch.nn.MaxUnpool1d") | 计算`MaxPool1d`的部分逆操作。 | -| [`nn.MaxUnpool2d`](generated/torch.nn.MaxUnpool2d.html#torch.nn.MaxUnpool2d "torch.nn.MaxUnpool2d") | 计算`MaxPool2d`的部分逆操作。 | -| [`nn.MaxUnpool3d`](generated/torch.nn.MaxUnpool3d.html#torch.nn.MaxUnpool3d "torch.nn.MaxUnpool3d") | 计算`MaxPool3d`的部分逆操作。 | -| [`nn.AvgPool1d`](generated/torch.nn.AvgPool1d.html#torch.nn.AvgPool1d "torch.nn.AvgPool1d") | 对由多个输入平面组成的输入信号应用1D平均池化。 | -| [`nn.AvgPool2d`](generated/torch.nn.AvgPool2d.html#torch.nn.AvgPool2d "torch.nn.AvgPool2d") | 对由多个输入平面组成的输入信号应用2D平均池化。 | -| [`nn.AvgPool3d`](generated/torch.nn.AvgPool3d.html#torch.nn.AvgPool3d "torch.nn.AvgPool3d") | 对由多个输入平面组成的输入信号应用3D平均池化。 | -| [`nn.FractionalMaxPool2d`](generated/torch.nn.FractionalMaxPool2d.html#torch.nn.FractionalMaxPool2d "torch.nn.FractionalMaxPool2d") | 对由多个输入平面组成的输入信号应用2D分数最大池化。 | -| [`nn.FractionalMaxPool3d`](generated/torch.nn.FractionalMaxPool3d.html#torch.nn.FractionalMaxPool3d "torch.nn.FractionalMaxPool3d") | 对由多个输入平面组成的输入信号应用3D分数最大池化。 | -| [`nn.LPPool1d`](generated/torch.nn.LPPool1d.html#torch.nn.LPPool1d "torch.nn.LPPool1d") | 对由多个输入平面组成的输入信号应用1D幂平均池化。 | -| [`nn.LPPool2d`](generated/torch.nn.LPPool2d.html#torch.nn.LPPool2d "torch.nn.LPPool2d") | 对由多个输入平面组成的输入信号应用2D幂平均池化。 | -| [`nn.AdaptiveMaxPool1d`](generated/torch.nn.AdaptiveMaxPool1d.html#torch.nn.AdaptiveMaxPool1d "torch.nn.AdaptiveMaxPool1d") | 对由多个输入平面组成的输入信号应用1D自适应最大池化。 | -| [`nn.AdaptiveMaxPool2d`](generated/torch.nn.AdaptiveMaxPool2d.html#torch.nn.AdaptiveMaxPool2d "torch.nn.AdaptiveMaxPool2d") | 对由多个输入平面组成的输入信号应用2D自适应最大池化。 | -| [`nn.AdaptiveMaxPool3d`](generated/torch.nn.AdaptiveMaxPool3d.html#torch.nn.AdaptiveMaxPool3d "torch.nn.AdaptiveMaxPool3d") | 对由多个输入平面组成的输入信号应用3D自适应最大池化。 | -| [`nn.AdaptiveAvgPool1d`](generated/torch.nn.AdaptiveAvgPool1d.html#torch.nn.AdaptiveAvgPool1d "torch.nn.AdaptiveAvgPool1d") | 对由多个输入平面组成的输入信号应用1D自适应平均池化。 | -| [`nn.AdaptiveAvgPool2d`](generated/torch.nn.AdaptiveAvgPool2d.html#torch.nn.AdaptiveAvgPool2d "torch.nn.AdaptiveAvgPool2d") | 对由多个输入平面组成的输入信号应用2D自适应平均池化。 | -| [`nn.AdaptiveAvgPool3d`](generated/torch.nn.AdaptiveAvgPool3d.html#torch.nn.AdaptiveAvgPool3d "torch.nn.AdaptiveAvgPool3d") | 对由多个输入平面组成的输入信号应用3D自适应平均池化。 | - -## [填充层](#id1) - -| [`nn.ReflectionPad1d`](generated/torch.nn.ReflectionPad1d.html#torch.nn.ReflectionPad1d "torch.nn.ReflectionPad1d") | 使用输入边界的反射来填充输入张量。 | +| `nn.MaxPool2d` | 对由多个输入平面组成的输入信号应用 2D 最大池化。 | +| `nn.MaxPool3d` | 对由多个输入平面组成的输入信号应用 3D 最大池化。 | +| `nn.MaxUnpool1d` | 计算`MaxPool1d`的部分逆操作。 | +| `nn.MaxUnpool2d` | 计算`MaxPool2d`的部分逆操作。 | +| `nn.MaxUnpool3d` | 计算`MaxPool3d`的部分逆操作。 | +| `nn.AvgPool1d` | 对由多个输入平面组成的输入信号应用 1D 平均池化。 | +| `nn.AvgPool2d` | 对由多个输入平面组成的输入信号应用 2D 平均池化。 | +| `nn.AvgPool3d` | 对由多个输入平面组成的输入信号应用 3D 平均池化。 | +| `nn.FractionalMaxPool2d` | 对由多个输入平面组成的输入信号应用 2D 分数最大池化。 | +| `nn.FractionalMaxPool3d` | 对由多个输入平面组成的输入信号应用 3D 分数最大池化。 | +| `nn.LPPool1d` | 对由多个输入平面组成的输入信号应用 1D 幂平均池化。 | +| `nn.LPPool2d` | 对由多个输入平面组成的输入信号应用 2D 幂平均池化。 | +| `nn.AdaptiveMaxPool1d` | 对由多个输入平面组成的输入信号应用 1D 自适应最大池化。 | +| `nn.AdaptiveMaxPool2d` | 对由多个输入平面组成的输入信号应用 2D 自适应最大池化。 | +| `nn.AdaptiveMaxPool3d` | 对由多个输入平面组成的输入信号应用 3D 自适应最大池化。 | +| `nn.AdaptiveAvgPool1d` | 对由多个输入平面组成的输入信号应用 1D 自适应平均池化。 | +| `nn.AdaptiveAvgPool2d` | 对由多个输入平面组成的输入信号应用 2D 自适应平均池化。 | +| `nn.AdaptiveAvgPool3d` | 对由多个输入平面组成的输入信号应用 3D 自适应平均池化。 | + +## 填充层 + +| `nn.ReflectionPad1d` | 使用输入边界的反射来填充输入张量。 | | --- | --- | -| [`nn.ReflectionPad2d`](generated/torch.nn.ReflectionPad2d.html#torch.nn.ReflectionPad2d "torch.nn.ReflectionPad2d") | 使用输入边界的反射来填充输入张量。 | -| [`nn.ReflectionPad3d`](generated/torch.nn.ReflectionPad3d.html#torch.nn.ReflectionPad3d "torch.nn.ReflectionPad3d") | 使用输入边界的反射来填充输入张量。 | -| [`nn.ReplicationPad1d`](generated/torch.nn.ReplicationPad1d.html#torch.nn.ReplicationPad1d "torch.nn.ReplicationPad1d") | 使用输入边界的复制来填充输入张量。 | -| [`nn.ReplicationPad2d`](generated/torch.nn.ReplicationPad2d.html#torch.nn.ReplicationPad2d "torch.nn.ReplicationPad2d") | 使用输入边界的复制来填充输入张量。 | -| [`nn.ReplicationPad3d`](generated/torch.nn.ReplicationPad3d.html#torch.nn.ReplicationPad3d "torch.nn.ReplicationPad3d") | 使用输入边界的复制来填充输入张量。 | -| [`nn.ZeroPad1d`](generated/torch.nn.ZeroPad1d.html#torch.nn.ZeroPad1d "torch.nn.ZeroPad1d") | 使用零值填充输入张量的边界。 | -| [`nn.ZeroPad2d`](generated/torch.nn.ZeroPad2d.html#torch.nn.ZeroPad2d "torch.nn.ZeroPad2d") | 使用零值填充输入张量的边界。 | -| [`nn.ZeroPad3d`](generated/torch.nn.ZeroPad3d.html#torch.nn.ZeroPad3d "torch.nn.ZeroPad3d") | 使用零值填充输入张量的边界。 | -| [`nn.ConstantPad1d`](generated/torch.nn.ConstantPad1d.html#torch.nn.ConstantPad1d "torch.nn.ConstantPad1d") | 使用常数值填充输入张量的边界。 | -| [`nn.ConstantPad2d`](generated/torch.nn.ConstantPad2d.html#torch.nn.ConstantPad2d "torch.nn.ConstantPad2d") | 使用常数值填充输入张量的边界。 | -| [`nn.ConstantPad3d`](generated/torch.nn.ConstantPad3d.html#torch.nn.ConstantPad3d "torch.nn.ConstantPad3d") | 使用常数值填充输入张量的边界。 | - -## [非线性激活函数（加权和，非线性）](#id1)[](#non-linear-activations-weighted-sum-nonlinearity "跳转到此标题") - -| [`nn.ELU`](generated/torch.nn.ELU.html#torch.nn.ELU "torch.nn.ELU") | 对每个元素应用指数线性单元（ELU）函数，如论文中所述：[通过指数线性单元（ELUs）实现快速准确的深度网络学习](https://arxiv.org/abs/1511.07289)。 | +| `nn.ReflectionPad2d` | 使用输入边界的反射来填充输入张量。 | +| `nn.ReflectionPad3d` | 使用输入边界的反射来填充输入张量。 | +| `nn.ReplicationPad1d` | 使用输入边界的复制来填充输入张量。 | +| `nn.ReplicationPad2d` | 使用输入边界的复制来填充输入张量。 | +| `nn.ReplicationPad3d` | 使用输入边界的复制来填充输入张量。 | +| `nn.ZeroPad1d` | 使用零值填充输入张量的边界。 | +| `nn.ZeroPad2d` | 使用零值填充输入张量的边界。 | +| `nn.ZeroPad3d` | 使用零值填充输入张量的边界。 | +| `nn.ConstantPad1d` | 使用常数值填充输入张量的边界。 | +| `nn.ConstantPad2d` | 使用常数值填充输入张量的边界。 | +| `nn.ConstantPad3d` | 使用常数值填充输入张量的边界。 | + +## 非线性激活函数（加权和，非线性）[](#non-linear-activations-weighted-sum-nonlinearity "跳转到此标题") + +| `nn.ELU` | 对每个元素应用指数线性单元（ELU）函数，如论文中所述：[通过指数线性单元（ELUs）实现快速准确的深度网络学习](https://arxiv.org/abs/1511.07289)。 | | --- | --- | -| [`nn.Hardshrink`](generated/torch.nn.Hardshrink.html#torch.nn.Hardshrink "torch.nn.Hardshrink") | 对每个元素应用硬收缩（Hardshrink）函数。 | -| [`nn.Hardsigmoid`](generated/torch.nn.Hardsigmoid.html#torch.nn.Hardsigmoid "torch.nn.Hardsigmoid") | 对每个元素应用硬Sigmoid函数。 | -| [`nn.Hardtanh`](generated/torch.nn.Hardtanh.html#torch.nn.Hardtanh "torch.nn.Hardtanh") | 对每个元素应用HardTanh函数。 | -| [`nn.Hardswish`](generated/torch.nn.Hardswish.html#torch.nn.Hardswish "torch.nn.Hardswish") | 对每个元素应用Hardswish函数，如论文中所述：[搜索MobileNetV3](https://arxiv.org/abs/1905.02244)。 | -| [`nn.LeakyReLU`](generated/torch.nn.LeakyReLU.html#torch.nn.LeakyReLU "torch.nn.LeakyReLU") | 应用逐元素函数： | -| [`nn.LogSigmoid`](generated/torch.nn.LogSigmoid.html#torch.nn.LogSigmoid "torch.nn.LogSigmoid") | 应用逐元素函数： | -| [`nn.MultiheadAttention`](generated/torch.nn.MultiheadAttention.html#torch.nn.MultiheadAttention "torch.nn.MultiheadAttention") | 允许模型同时关注来自不同表示子空间的信息，如论文中所述：[注意力机制是你所需要的一切](https://arxiv.org/abs/1706.03762)。 | -| [`nn.PReLU`](generated/torch.nn.PReLU.html#torch.nn.PReLU "torch.nn.PReLU") | 应用逐元素函数： | -| [`nn.ReLU`](generated/torch.nn.ReLU.html#torch.nn.ReLU "torch.nn.ReLU") | 逐元素应用修正线性单元函数： | -| [`nn.ReLU6`](generated/torch.nn.ReLU6.html#torch.nn.ReLU6 "torch.nn.ReLU6") | 应用逐元素函数： | -| [`nn.RReLU`](generated/torch.nn.RReLU.html#torch.nn.RReLU "torch.nn.RReLU") | 应用随机泄漏修正线性单元函数，逐元素地，如论文中所述： | -| [`nn.SELU`](generated/torch.nn.SELU.html#torch.nn.SELU "torch.nn.SELU") | 逐元素应用，如： | -| [`nn.CELU`](generated/torch.nn.CELU.html#torch.nn.CELU "torch.nn.CELU") | 应用逐元素函数： | -| [`nn.GELU`](generated/torch.nn.GELU.html#torch.nn.GELU "torch.nn.GELU") | 应用高斯误差线性单元函数： | -| [`nn.Sigmoid`](generated/torch.nn.Sigmoid.html#torch.nn.Sigmoid "torch.nn.Sigmoid") | 应用逐元素函数： | -| [`nn.SiLU`](generated/torch.nn.SiLU.html#torch.nn.SiLU "torch.nn.SiLU") | 应用Sigmoid线性单元（SiLU）函数，逐元素。 | -| [`nn.Mish`](generated/torch.nn.Mish.html#torch.nn.Mish "torch.nn.Mish") | 应用Mish函数，逐元素。 | -| [`nn.Softplus`](generated/torch.nn.Softplus.html#torch.nn.Softplus "torch.nn.Softplus") | 逐元素应用Softplus函数$\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))$。 | -| [`nn.Softshrink`](generated/torch.nn.Softshrink.html#torch.nn.Softshrink "torch.nn.Softshrink") | 应用软阈值函数，逐元素： | -| [`nn.Softsign`](generated/torch.nn.Softsign.html#torch.nn.Softsign "torch.nn.Softsign") | 应用逐元素函数： | -| [`nn.Tanh`](generated/torch.nn.Tanh.html#torch.nn.Tanh "torch.nn.Tanh") | 逐元素应用双曲正切（Tanh）函数。 | -| [`nn.Tanhshrink`](generated/torch.nn.Tanhshrink.html#torch.nn.Tanhshrink "torch.nn.Tanhshrink") | 应用逐元素函数： | -| [`nn.Threshold`](generated/torch.nn.Threshold.html#torch.nn.Threshold "torch.nn.Threshold") | 对输入张量的每个元素进行阈值处理。 | -| [`nn.GLU`](generated/torch.nn.GLU.html#torch.nn.GLU "torch.nn.GLU") | 应用门控线性单元函数${GLU}(a, b)= a \otimes \sigma(b)$，其中$a$是输入矩阵的前一半，$b$是后一半。 | - -## [非线性激活函数（其他）](#id1) - -| [`nn.Softmin`](generated/torch.nn.Softmin.html#torch.nn.Softmin "torch.nn.Softmin") | 对n维输入张量应用Softmin函数，重新缩放它们，使得n维输出张量的元素位于范围[0, 1]并总和为1。 | +| `nn.Hardshrink` | 对每个元素应用硬收缩（Hardshrink）函数。 | +| `nn.Hardsigmoid` | 对每个元素应用硬 Sigmoid 函数。 | +| `nn.Hardtanh` | 对每个元素应用 HardTanh 函数。 | +| `nn.Hardswish` | 对每个元素应用 Hardswish 函数，如论文中所述：[搜索 MobileNetV3](https://arxiv.org/abs/1905.02244)。 | +| `nn.LeakyReLU` | 应用逐元素函数： | +| `nn.LogSigmoid` | 应用逐元素函数： | +| `nn.MultiheadAttention` | 允许模型同时关注来自不同表示子空间的信息，如论文中所述：[注意力机制是你所需要的一切](https://arxiv.org/abs/1706.03762)。 | +| `nn.PReLU` | 应用逐元素函数： | +| `nn.ReLU` | 逐元素应用修正线性单元函数： | +| `nn.ReLU6` | 应用逐元素函数： | +| `nn.RReLU` | 应用随机泄漏修正线性单元函数，逐元素地，如论文中所述： | +| `nn.SELU` | 逐元素应用，如： | +| `nn.CELU` | 应用逐元素函数： | +| `nn.GELU` | 应用高斯误差线性单元函数： | +| `nn.Sigmoid` | 应用逐元素函数： | +| `nn.SiLU` | 应用 Sigmoid 线性单元（SiLU）函数，逐元素。 | +| `nn.Mish` | 应用 Mish 函数，逐元素。 | +| `nn.Softplus` | 逐元素应用 Softplus 函数$\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))$。 | +| `nn.Softshrink` | 应用软阈值函数，逐元素： | +| `nn.Softsign` | 应用逐元素函数： | +| `nn.Tanh` | 逐元素应用双曲正切（Tanh）函数。 | +| `nn.Tanhshrink` | 应用逐元素函数： | +| `nn.Threshold` | 对输入张量的每个元素进行阈值处理。 | +| `nn.GLU` | 应用门控线性单元函数${GLU}(a, b)= a \otimes \sigma(b)$，其中$a$是输入矩阵的前一半，$b$是后一半。 | + +## 非线性激活函数（其他） + +| `nn.Softmin` | 对 n 维输入张量应用 Softmin 函数，重新缩放它们，使得 n 维输出张量的元素位于范围[0, 1]并总和为 1。 | | --- | --- | -| [`nn.Softmax`](generated/torch.nn.Softmax.html#torch.nn.Softmax "torch.nn.Softmax") | 对n维输入张量应用Softmax函数，重新缩放它们，使得n维输出张量的元素位于范围[0,1]并总和为1。 | -| [`nn.Softmax2d`](generated/torch.nn.Softmax2d.html#torch.nn.Softmax2d "torch.nn.Softmax2d") | 对每个空间位置的特征应用SoftMax。 | -| [`nn.LogSoftmax`](generated/torch.nn.LogSoftmax.html#torch.nn.LogSoftmax "torch.nn.LogSoftmax") | 对n维输入张量应用$\log(\text{Softmax}(x))$函数。 | -| [`nn.AdaptiveLogSoftmaxWithLoss`](generated/torch.nn.AdaptiveLogSoftmaxWithLoss.html#torch.nn.AdaptiveLogSoftmaxWithLoss "torch.nn.AdaptiveLogSoftmaxWithLoss") | 高效的softmax近似。 | +| `nn.Softmax` | 对 n 维输入张量应用 Softmax 函数，重新缩放它们，使得 n 维输出张量的元素位于范围[0,1]并总和为 1。 | +| `nn.Softmax2d` | 对每个空间位置的特征应用 SoftMax。 | +| `nn.LogSoftmax` | 对 n 维输入张量应用$\log(\text{Softmax}(x))$函数。 | +| `nn.AdaptiveLogSoftmaxWithLoss` | 高效的 softmax 近似。 | -## [归一化层](#id1) +## 归一化层 -| [`nn.BatchNorm1d`](generated/torch.nn.BatchNorm1d.html#torch.nn.BatchNorm1d "torch.nn.BatchNorm1d") | 对2D或3D输入应用批量归一化，如论文[Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167)中描述。 | +| `nn.BatchNorm1d` | 对 2D 或 3D 输入应用批量归一化，如论文[Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167)中描述。 | | --- | --- | -| [`nn.BatchNorm2d`](generated/torch.nn.BatchNorm2d.html#torch.nn.BatchNorm2d "torch.nn.BatchNorm2d") | 对 4D 输入（带有额外通道维度的 2D 输入的小批量）应用批归一化，如论文 [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167) 中所述。 | -| [`nn.BatchNorm3d`](generated/torch.nn.BatchNorm3d.html#torch.nn.BatchNorm3d "torch.nn.BatchNorm3d") | 对 5D 输入（带有额外通道维度的 3D 输入的小批量）应用批归一化，如论文 [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167) 中所述。 | -| [`nn.LazyBatchNorm1d`](generated/torch.nn.LazyBatchNorm1d.html#torch.nn.LazyBatchNorm1d "torch.nn.LazyBatchNorm1d") | 具有延迟初始化的 `num_features` 参数的 [`torch.nn.BatchNorm1d`](generated/torch.nn.BatchNorm1d.html#torch.nn.BatchNorm1d "torch.nn.BatchNorm1d") 模块，该参数从 `input.size(1)` 推断而来。 | -| [`nn.LazyBatchNorm2d`](generated/torch.nn.LazyBatchNorm2d.html#torch.nn.LazyBatchNorm2d "torch.nn.LazyBatchNorm2d") | 具有延迟初始化的 `num_features` 参数的 [`torch.nn.BatchNorm2d`](generated/torch.nn.BatchNorm2d.html#torch.nn.BatchNorm2d "torch.nn.BatchNorm2d") 模块，该参数从 `input.size(1)` 推断而来。 | -| [`nn.LazyBatchNorm3d`](generated/torch.nn.LazyBatchNorm3d.html#torch.nn.LazyBatchNorm3d "torch.nn.LazyBatchNorm3d") | 具有延迟初始化的 `num_features` 参数的 [`torch.nn.BatchNorm3d`](generated/torch.nn.BatchNorm3d.html#torch.nn.BatchNorm3d "torch.nn.BatchNorm3d") 模块，该参数从 `input.size(1)` 推断而来。 | -| [`nn.GroupNorm`](generated/torch.nn.GroupNorm.html#torch.nn.GroupNorm "torch.nn.GroupNorm") | 对输入的一个小批量应用组归一化。 | -| [`nn.SyncBatchNorm`](generated/torch.nn.SyncBatchNorm.html#torch.nn.SyncBatchNorm "torch.nn.SyncBatchNorm") | 对 N 维输入（带有额外通道维度的小批量 [N-2]D 输入）应用批归一化，如论文 [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167) 中所述。 | -| [`nn.InstanceNorm1d`](generated/torch.nn.InstanceNorm1d.html#torch.nn.InstanceNorm1d "torch.nn.InstanceNorm1d") | 应用实例归一化。 | -| [`nn.InstanceNorm2d`](generated/torch.nn.InstanceNorm2d.html#torch.nn.InstanceNorm2d "torch.nn.InstanceNorm2d") | 应用实例归一化。 | -| [`nn.InstanceNorm3d`](generated/torch.nn.InstanceNorm3d.html#torch.nn.InstanceNorm3d "torch.nn.InstanceNorm3d") | 应用实例归一化。 | -| [`nn.LazyInstanceNorm1d`](generated/torch.nn.LazyInstanceNorm1d.html#torch.nn.LazyInstanceNorm1d "torch.nn.LazyInstanceNorm1d") | 具有延迟初始化的 `num_features` 参数的 [`torch.nn.InstanceNorm1d`](generated/torch.nn.InstanceNorm1d.html#torch.nn.InstanceNorm1d "torch.nn.InstanceNorm1d") 模块。 | -| [`nn.LazyInstanceNorm2d`](generated/torch.nn.LazyInstanceNorm2d.html#torch.nn.LazyInstanceNorm2d "torch.nn.LazyInstanceNorm2d") | 具有延迟初始化的 `num_features` 参数的 [`torch.nn.InstanceNorm2d`](generated/torch.nn.InstanceNorm2d.html#torch.nn.InstanceNorm2d "torch.nn.InstanceNorm2d") 模块。 | -| [`nn.LazyInstanceNorm3d`](generated/torch.nn.LazyInstanceNorm3d.html#torch.nn.LazyInstanceNorm3d "torch.nn.LazyInstanceNorm3d") | 具有 `num_features` 参数的延迟初始化的 [`torch.nn.InstanceNorm3d`](generated/torch.nn.InstanceNorm3d.html#torch.nn.InstanceNorm3d "torch.nn.InstanceNorm3d") 模块。 | -| [`nn.LayerNorm`](generated/torch.nn.LayerNorm.html#torch.nn.LayerNorm "torch.nn.LayerNorm") | 对输入的一个小批量应用层归一化。 | -| [`nn.LocalResponseNorm`](generated/torch.nn.LocalResponseNorm.html#torch.nn.LocalResponseNorm "torch.nn.LocalResponseNorm") | 对输入信号应用局部响应归一化。 | - -## [Recurrent Layers](#id1) - -| [`nn.RNNBase`](generated/torch.nn.RNNBase.html#torch.nn.RNNBase "torch.nn.RNNBase") | RNN 模块（RNN、LSTM、GRU）的基类。 | +| `nn.BatchNorm2d` | 对 4D 输入（带有额外通道维度的 2D 输入的小批量）应用批归一化，如论文 [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167) 中所述。 | +| `nn.BatchNorm3d` | 对 5D 输入（带有额外通道维度的 3D 输入的小批量）应用批归一化，如论文 [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167) 中所述。 | +| `nn.LazyBatchNorm1d` | 具有延迟初始化的 `num_features` 参数的 `torch.nn.BatchNorm1d` 模块，该参数从 `input.size(1)` 推断而来。 | +| `nn.LazyBatchNorm2d` | 具有延迟初始化的 `num_features` 参数的 `torch.nn.BatchNorm2d` 模块，该参数从 `input.size(1)` 推断而来。 | +| `nn.LazyBatchNorm3d` | 具有延迟初始化的 `num_features` 参数的 `torch.nn.BatchNorm3d` 模块，该参数从 `input.size(1)` 推断而来。 | +| `nn.GroupNorm` | 对输入的一个小批量应用组归一化。 | +| `nn.SyncBatchNorm` | 对 N 维输入（带有额外通道维度的小批量 [N-2]D 输入）应用批归一化，如论文 [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/abs/1502.03167) 中所述。 | +| `nn.InstanceNorm1d` | 应用实例归一化。 | +| `nn.InstanceNorm2d` | 应用实例归一化。 | +| `nn.InstanceNorm3d` | 应用实例归一化。 | +| `nn.LazyInstanceNorm1d` | 具有延迟初始化的 `num_features` 参数的 `torch.nn.InstanceNorm1d` 模块。 | +| `nn.LazyInstanceNorm2d` | 具有延迟初始化的 `num_features` 参数的 `torch.nn.InstanceNorm2d` 模块。 | +| `nn.LazyInstanceNorm3d` | 具有 `num_features` 参数的延迟初始化的 `torch.nn.InstanceNorm3d` 模块。 | +| `nn.LayerNorm` | 对输入的一个小批量应用层归一化。 | +| `nn.LocalResponseNorm` | 对输入信号应用局部响应归一化。 | + +## Recurrent Layers + +| `nn.RNNBase` | RNN 模块（RNN、LSTM、GRU）的基类。 | | --- | --- | -| [`nn.RNN`](generated/torch.nn.RNN.html#torch.nn.RNN "torch.nn.RNN") | 对输入序列应用多层 Elman RNN，使用 $\tanh$ 或 $\text{ReLU}$ 非线性。 | -| [`nn.LSTM`](generated/torch.nn.LSTM.html#torch.nn.LSTM "torch.nn.LSTM") | 对输入序列应用多层长短期记忆（LSTM）RNN。 | -| [`nn.GRU`](generated/torch.nn.GRU.html#torch.nn.GRU "torch.nn.GRU") | 对输入序列应用多层门控循环单元（GRU）RNN。 | -| [`nn.RNNCell`](generated/torch.nn.RNNCell.html#torch.nn.RNNCell "torch.nn.RNNCell") | 一个具有 tanh 或 ReLU 非线性的 Elman RNN 单元。 | -| [`nn.LSTMCell`](generated/torch.nn.LSTMCell.html#torch.nn.LSTMCell "torch.nn.LSTMCell") | 长短期记忆（LSTM）单元。 | -| [`nn.GRUCell`](generated/torch.nn.GRUCell.html#torch.nn.GRUCell "torch.nn.GRUCell") | 门控循环单元（GRU）单元。 | +| `nn.RNN` | 对输入序列应用多层 Elman RNN，使用 $\tanh$ 或 $\text{ReLU}$ 非线性。 | +| `nn.LSTM` | 对输入序列应用多层长短期记忆（LSTM）RNN。 | +| `nn.GRU` | 对输入序列应用多层门控循环单元（GRU）RNN。 | +| `nn.RNNCell` | 一个具有 tanh 或 ReLU 非线性的 Elman RNN 单元。 | +| `nn.LSTMCell` | 长短期记忆（LSTM）单元。 | +| `nn.GRUCell` | 门控循环单元（GRU）单元。 | -## [Transformer Layers](#id1) +## Transformer Layers -| [`nn.Transformer`](generated/torch.nn.Transformer.html#torch.nn.Transformer "torch.nn.Transformer") | 一个 transformer 模型。 | +| `nn.Transformer` | 一个 transformer 模型。 | | --- | --- | -| [`nn.TransformerEncoder`](generated/torch.nn.TransformerEncoder.html#torch.nn.TransformerEncoder "torch.nn.TransformerEncoder") | TransformerEncoder 是 N 个编码器层的堆叠。 | -| [`nn.TransformerDecoder`](generated/torch.nn.TransformerDecoder.html#torch.nn.TransformerDecoder "torch.nn.TransformerDecoder") | TransformerDecoder 是 N 个解码器层的堆叠。 | -| [`nn.TransformerEncoderLayer`](generated/torch.nn.TransformerEncoderLayer.html#torch.nn.TransformerEncoderLayer "torch.nn.TransformerEncoderLayer") | TransformerEncoderLayer 由 self-attn 和前馈网络组成。 | -| [`nn.TransformerDecoderLayer`](generated/torch.nn.TransformerDecoderLayer.html#torch.nn.TransformerDecoderLayer "torch.nn.TransformerDecoderLayer") | TransformerDecoderLayer 由 self-attn、multi-head-attn 和前馈网络组成。 | +| `nn.TransformerEncoder` | TransformerEncoder 是 N 个编码器层的堆叠。 | +| `nn.TransformerDecoder` | TransformerDecoder 是 N 个解码器层的堆叠。 | +| `nn.TransformerEncoderLayer` | TransformerEncoderLayer 由 self-attn 和前馈网络组成。 | +| `nn.TransformerDecoderLayer` | TransformerDecoderLayer 由 self-attn、multi-head-attn 和前馈网络组成。 | -## [Linear Layers](#id1) +## Linear Layers -| [`nn.Identity`](generated/torch.nn.Identity.html#torch.nn.Identity "torch.nn.Identity") | 一个占位符身份运算符，不受参数影响。 | +| `nn.Identity` | 一个占位符身份运算符，不受参数影响。 | | --- | --- | -| [`nn.Linear`](generated/torch.nn.Linear.html#torch.nn.Linear "torch.nn.Linear") | 对传入数据应用线性变换：$y = xA^T + b$。 | -| [`nn.Bilinear`](generated/torch.nn.Bilinear.html#torch.nn.Bilinear "torch.nn.Bilinear") | 对传入数据应用双线性变换：$y = x_1^T A x_2 + b$。 | -| [`nn.LazyLinear`](generated/torch.nn.LazyLinear.html#torch.nn.LazyLinear "torch.nn.LazyLinear") | 一个 [`torch.nn.Linear`](generated/torch.nn.Linear.html#torch.nn.Linear "torch.nn.Linear") 模块，其中的 in_features 是推断出来的。 | +| `nn.Linear` | 对传入数据应用线性变换：$y = xA^T + b$。 | +| `nn.Bilinear` | 对传入数据应用双线性变换：$y = x_1^T A x_2 + b$。 | +| `nn.LazyLinear` | 一个 `torch.nn.Linear` 模块，其中的 in_features 是推断出来的。 | -## [Dropout Layers](#id1) +## Dropout Layers -| [`nn.Dropout`](generated/torch.nn.Dropout.html#torch.nn.Dropout "torch.nn.Dropout") | 在训练期间，以概率 `p` 随机将输入张量的一些元素置零。 | +| `nn.Dropout` | 在训练期间，以概率 `p` 随机将输入张量的一些元素置零。 | | --- | --- | -| [`nn.Dropout1d`](generated/torch.nn.Dropout1d.html#torch.nn.Dropout1d "torch.nn.Dropout1d") | 随机将整个通道置零。 | -| [`nn.Dropout2d`](generated/torch.nn.Dropout2d.html#torch.nn.Dropout2d "torch.nn.Dropout2d") | 随机将整个通道置零。 | -| [`nn.Dropout3d`](generated/torch.nn.Dropout3d.html#torch.nn.Dropout3d "torch.nn.Dropout3d") | 随机将整个通道置零。 | -| [`nn.AlphaDropout`](generated/torch.nn.AlphaDropout.html#torch.nn.AlphaDropout "torch.nn.AlphaDropout") | 对输入应用 Alpha Dropout。 | -| [`nn.FeatureAlphaDropout`](generated/torch.nn.FeatureAlphaDropout.html#torch.nn.FeatureAlphaDropout "torch.nn.FeatureAlphaDropout") | 随机屏蔽整个通道。 | +| `nn.Dropout1d` | 随机将整个通道置零。 | +| `nn.Dropout2d` | 随机将整个通道置零。 | +| `nn.Dropout3d` | 随机将整个通道置零。 | +| `nn.AlphaDropout` | 对输入应用 Alpha Dropout。 | +| `nn.FeatureAlphaDropout` | 随机屏蔽整个通道。 | -## [Sparse Layers](#id1) +## Sparse Layers -| [`nn.Embedding`](generated/torch.nn.Embedding.html#torch.nn.Embedding "torch.nn.Embedding") | 存储固定字典和大小的嵌入的简单查找表。 | +| `nn.Embedding` | 存储固定字典和大小的嵌入的简单查找表。 | | --- | --- | -| [`nn.EmbeddingBag`](generated/torch.nn.EmbeddingBag.html#torch.nn.EmbeddingBag "torch.nn.EmbeddingBag") | 计算嵌入“bags”的和或均值，而不实例化中间嵌入。 | +| `nn.EmbeddingBag` | 计算嵌入“bags”的和或均值，而不实例化中间嵌入。 | -## [距离函数](#id1) +## 距离函数 -| [`nn.CosineSimilarity`](generated/torch.nn.CosineSimilarity.html#torch.nn.CosineSimilarity "torch.nn.CosineSimilarity") | 返回 $x_1$ 和 $x_2$ 之间的余弦相似度，沿着维度计算。 | +| `nn.CosineSimilarity` | 返回 $x_1$ 和 $x_2$ 之间的余弦相似度，沿着维度计算。 | | --- | --- | -| [`nn.PairwiseDistance`](generated/torch.nn.PairwiseDistance.html#torch.nn.PairwiseDistance "torch.nn.PairwiseDistance") | 计算输入向量之间的成对距离，或输入矩阵的列之间的距离。 | +| `nn.PairwiseDistance` | 计算输入向量之间的成对距离，或输入矩阵的列之间的距离。 | -## [损失函数](#id1) +## 损失函数 -| [`nn.L1Loss`](generated/torch.nn.L1Loss.html#torch.nn.L1Loss "torch.nn.L1Loss") | 创建一个标准，衡量输入 $x$ 和目标 $y$ 中每个元素的平均绝对误差（MAE）。 | +| `nn.L1Loss` | 创建一个标准，衡量输入 $x$ 和目标 $y$ 中每个元素的平均绝对误差（MAE）。 | | --- | --- | -| [`nn.MSELoss`](generated/torch.nn.MSELoss.html#torch.nn.MSELoss "torch.nn.MSELoss") | 创建一个标准，衡量输入 $x$ 和目标 $y$ 中每个元素的均方误差（平方L2范数）。 | -| [`nn.CrossEntropyLoss`](generated/torch.nn.CrossEntropyLoss.html#torch.nn.CrossEntropyLoss "torch.nn.CrossEntropyLoss") | 此标准计算输入logits和目标之间的交叉熵损失。 | -| [`nn.CTCLoss`](generated/torch.nn.CTCLoss.html#torch.nn.CTCLoss "torch.nn.CTCLoss") | 连接主义时间分类损失。 | -| [`nn.NLLLoss`](generated/torch.nn.NLLLoss.html#torch.nn.NLLLoss "torch.nn.NLLLoss") | 负对数似然损失。 | -| [`nn.PoissonNLLLoss`](generated/torch.nn.PoissonNLLLoss.html#torch.nn.PoissonNLLLoss "torch.nn.PoissonNLLLoss") | 具有泊松分布目标的负对数似然损失。 | -| [`nn.GaussianNLLLoss`](generated/torch.nn.GaussianNLLLoss.html#torch.nn.GaussianNLLLoss "torch.nn.GaussianNLLLoss") | 高斯负对数似然损失。 | -| [`nn.KLDivLoss`](generated/torch.nn.KLDivLoss.html#torch.nn.KLDivLoss "torch.nn.KLDivLoss") | Kullback-Leibler 散度损失。 | -| [`nn.BCELoss`](generated/torch.nn.BCELoss.html#torch.nn.BCELoss "torch.nn.BCELoss") | 创建一个衡量目标和输入概率之间的二元交叉熵的标准： | -| [`nn.BCEWithLogitsLoss`](generated/torch.nn.BCEWithLogitsLoss.html#torch.nn.BCEWithLogitsLoss "torch.nn.BCEWithLogitsLoss") | 此损失将 Sigmoid 层和 BCELoss 结合在一个单一类中。 | -| [`nn.MarginRankingLoss`](generated/torch.nn.MarginRankingLoss.html#torch.nn.MarginRankingLoss "torch.nn.MarginRankingLoss") | 创建一个标准，衡量给定输入 $x1$、$x2$，两个1D mini-batch或0D张量，以及标签1D mini-batch或0D张量 $y$（包含1或-1）的损失。 | -| [`nn.HingeEmbeddingLoss`](generated/torch.nn.HingeEmbeddingLoss.html#torch.nn.HingeEmbeddingLoss "torch.nn.HingeEmbeddingLoss") | 给定输入张量 $x$ 和标签张量 $y$（包含1或-1），衡量损失。 | -| [`nn.MultiLabelMarginLoss`](generated/torch.nn.MultiLabelMarginLoss.html#torch.nn.MultiLabelMarginLoss "torch.nn.MultiLabelMarginLoss") | 创建一个标准，优化输入 $x$（一个2D mini-batch张量）和输出 $y$（目标类别索引的2D张量）之间的多类多分类铰链损失（基于边缘的损失）。 | -| [`nn.HuberLoss`](generated/torch.nn.HuberLoss.html#torch.nn.HuberLoss "torch.nn.HuberLoss") | 创建一个标准，如果绝对逐元素误差低于 delta，则使用平方项，否则使用 delta-scaled L1 项。 | -| [`nn.SmoothL1Loss`](generated/torch.nn.SmoothL1Loss.html#torch.nn.SmoothL1Loss "torch.nn.SmoothL1Loss") | 创建一个标准，如果绝对逐元素误差低于 beta，则使用平方项，否则使用L1项。 | -| [`nn.SoftMarginLoss`](generated/torch.nn.SoftMarginLoss.html#torch.nn.SoftMarginLoss "torch.nn.SoftMarginLoss") | 创建一个标准，优化输入张量$x$和目标张量$y$（包含1或-1）之间的两类分类逻辑损失。 | -| [`nn.MultiLabelSoftMarginLoss`](generated/torch.nn.MultiLabelSoftMarginLoss.html#torch.nn.MultiLabelSoftMarginLoss "torch.nn.MultiLabelSoftMarginLoss") | 创建一个标准，基于最大熵，优化输入$x$和大小为$(N, C)$的目标$y$的多标签一对所有损失。 | -| [`nn.CosineEmbeddingLoss`](generated/torch.nn.CosineEmbeddingLoss.html#torch.nn.CosineEmbeddingLoss "torch.nn.CosineEmbeddingLoss") | 创建一个标准，根据输入张量$x_1$、$x_2$和一个值为1或-1的张量标签$y$来测量损失。 | -| [`nn.MultiMarginLoss`](generated/torch.nn.MultiMarginLoss.html#torch.nn.MultiMarginLoss "torch.nn.MultiMarginLoss") | 创建一个标准，优化输入$x$(一个2D小批量张量)和输出$y$(一个目标类别索引的1D张量，$0 \leq y \leq \text{x.size}(1)-1$)之间的多类分类铰链损失（基于边缘的损失）： | -| [`nn.TripletMarginLoss`](generated/torch.nn.TripletMarginLoss.html#torch.nn.TripletMarginLoss "torch.nn.TripletMarginLoss") | 创建一个标准，根据大于$0$的边距值，测量给定输入张量$x_1$、$x_2$、$x_3$的三元组损失。 | -| [`nn.TripletMarginWithDistanceLoss`](generated/torch.nn.TripletMarginWithDistanceLoss.html#torch.nn.TripletMarginWithDistanceLoss "torch.nn.TripletMarginWithDistanceLoss") | 创建一个标准，根据输入张量$a$、$p$、$n$（分别表示锚点、正例和负例）和用于计算锚点和正例之间关系（“正距离”）以及锚点和负例之间关系（“负距离”）的非负实值函数（“距离函数”）。 | - -## [视觉层](#id1) - -| [`nn.PixelShuffle`](generated/torch.nn.PixelShuffle.html#torch.nn.PixelShuffle "torch.nn.PixelShuffle") | 根据放大因子重新排列张量中的元素。 | +| `nn.MSELoss` | 创建一个标准，衡量输入 $x$ 和目标 $y$ 中每个元素的均方误差（平方 L2 范数）。 | +| `nn.CrossEntropyLoss` | 此标准计算输入 logits 和目标之间的交叉熵损失。 | +| `nn.CTCLoss` | 连接主义时间分类损失。 | +| `nn.NLLLoss` | 负对数似然损失。 | +| `nn.PoissonNLLLoss` | 具有泊松分布目标的负对数似然损失。 | +| `nn.GaussianNLLLoss` | 高斯负对数似然损失。 | +| `nn.KLDivLoss` | Kullback-Leibler 散度损失。 | +| `nn.BCELoss` | 创建一个衡量目标和输入概率之间的二元交叉熵的标准： | +| `nn.BCEWithLogitsLoss` | 此损失将 Sigmoid 层和 BCELoss 结合在一个单一类中。 | +| `nn.MarginRankingLoss` | 创建一个标准，衡量给定输入 $x1$、$x2$，两个 1D mini-batch 或 0D 张量，以及标签 1D mini-batch 或 0D 张量 $y$（包含 1 或-1）的损失。 | +| `nn.HingeEmbeddingLoss` | 给定输入张量 $x$ 和标签张量 $y$（包含 1 或-1），衡量损失。 | +| `nn.MultiLabelMarginLoss` | 创建一个标准，优化输入 $x$（一个 2D mini-batch 张量）和输出 $y$（目标类别索引的 2D 张量）之间的多类多分类铰链损失（基于边缘的损失）。 | +| `nn.HuberLoss` | 创建一个标准，如果绝对逐元素误差低于 delta，则使用平方项，否则使用 delta-scaled L1 项。 | +| `nn.SmoothL1Loss` | 创建一个标准，如果绝对逐元素误差低于 beta，则使用平方项，否则使用 L1 项。 | +| `nn.SoftMarginLoss` | 创建一个标准，优化输入张量$x$和目标张量$y$（包含 1 或-1）之间的两类分类逻辑损失。 | +| `nn.MultiLabelSoftMarginLoss` | 创建一个标准，基于最大熵，优化输入$x$和大小为$(N, C)$的目标$y$的多标签一对所有损失。 | +| `nn.CosineEmbeddingLoss` | 创建一个标准，根据输入张量$x_1$、$x_2$和一个值为 1 或-1 的张量标签$y$来测量损失。 | +| `nn.MultiMarginLoss` | 创建一个标准，优化输入$x$(一个 2D 小批量张量)和输出$y$(一个目标类别索引的 1D 张量，$0 \leq y \leq \text{x.size}(1)-1$)之间的多类分类铰链损失（基于边缘的损失）： | +| `nn.TripletMarginLoss` | 创建一个标准，根据大于$0$的边距值，测量给定输入张量$x_1$、$x_2$、$x_3$的三元组损失。 | +| `nn.TripletMarginWithDistanceLoss` | 创建一个标准，根据输入张量$a$、$p$、$n$（分别表示锚点、正例和负例）和用于计算锚点和正例之间关系（“正距离”）以及锚点和负例之间关系（“负距离”）的非负实值函数（“距离函数”）。 | + +## 视觉层 + +| `nn.PixelShuffle` | 根据放大因子重新排列张量中的元素。 | | --- | --- | -| [`nn.PixelUnshuffle`](generated/torch.nn.PixelUnshuffle.html#torch.nn.PixelUnshuffle "torch.nn.PixelUnshuffle") | 反转PixelShuffle操作。 | -| [`nn.Upsample`](generated/torch.nn.Upsample.html#torch.nn.Upsample "torch.nn.Upsample") | 上采样给定的多通道1D（时间）、2D（空间）或3D（体积）数据。 | -| [`nn.UpsamplingNearest2d`](generated/torch.nn.UpsamplingNearest2d.html#torch.nn.UpsamplingNearest2d "torch.nn.UpsamplingNearest2d") | 对由多个输入通道组成的输入信号应用2D最近邻上采样。 | -| [`nn.UpsamplingBilinear2d`](generated/torch.nn.UpsamplingBilinear2d.html#torch.nn.UpsamplingBilinear2d "torch.nn.UpsamplingBilinear2d") | 对由多个输入通道组成的输入信号应用2D双线性上采样。 | +| `nn.PixelUnshuffle` | 反转 PixelShuffle 操作。 | +| `nn.Upsample` | 上采样给定的多通道 1D（时间）、2D（空间）或 3D（体积）数据。 | +| `nn.UpsamplingNearest2d` | 对由多个输入通道组成的输入信号应用 2D 最近邻上采样。 | +| `nn.UpsamplingBilinear2d` | 对由多个输入通道组成的输入信号应用 2D 双线性上采样。 | -## [洗牌层](#id1) +## 洗牌层 -| [`nn.ChannelShuffle`](generated/torch.nn.ChannelShuffle.html#torch.nn.ChannelShuffle "torch.nn.ChannelShuffle") | 分割并重新排列张量中的通道。 | +| `nn.ChannelShuffle` | 分割并重新排列张量中的通道。 | | --- | --- | -## [数据并行层（多GPU，分布式）](#id1)[](#module-torch.nn.parallel "跳转到此标题的永久链接") +## 数据并行层（多 GPU，分布式）[](#module-torch.nn.parallel "跳转到此标题的永久链接") -| [`nn.DataParallel`](generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel") | 在模块级别实现数据并行。 | +| `nn.DataParallel` | 在模块级别实现数据并行。 | | --- | --- | -| [`nn.parallel.DistributedDataParallel`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel") | 在模块级别基于`torch.distributed`实现分布式数据并行。 | ## [实用工具](#id1)[](#module-torch.nn.utils "跳转到此标题的永久链接") +| `nn.parallel.DistributedDataParallel` | 在模块级别基于`torch.distributed`实现分布式数据并行。 | ## 实用工具[](#module-torch.nn.utils "跳转到此标题的永久链接") 来自`torch.nn.utils`模块： 用于裁剪参数梯度的实用函数。 -| [`clip_grad_norm_`](generated/torch.nn.utils.clip_grad_norm_.html#torch.nn.utils.clip_grad_norm_ "torch.nn.utils.clip_grad_norm_") | 对参数的可迭代对象剪裁梯度范数。 | +| `clip_grad_norm_` | 对参数的可迭代对象剪裁梯度范数。 | | --- | --- | -| [`clip_grad_norm`](generated/torch.nn.utils.clip_grad_norm.html#torch.nn.utils.clip_grad_norm "torch.nn.utils.clip_grad_norm") | 对参数的可迭代对象剪裁梯度范数。 | -| [`clip_grad_value_`](generated/torch.nn.utils.clip_grad_value_.html#torch.nn.utils.clip_grad_value_ "torch.nn.utils.clip_grad_value_") | 将参数的梯度剪裁到指定值。 | +| `clip_grad_norm` | 对参数的可迭代对象剪裁梯度范数。 | +| `clip_grad_value_` | 将参数的梯度剪裁到指定值。 | 将模块参数展平和展开为单个向量的实用函数。 -| [`parameters_to_vector`](generated/torch.nn.utils.parameters_to_vector.html#torch.nn.utils.parameters_to_vector "torch.nn.utils.parameters_to_vector") | 将参数的可迭代对象展平为单个向量。 | +| `parameters_to_vector` | 将参数的可迭代对象展平为单个向量。 | | --- | --- | -| [`vector_to_parameters`](generated/torch.nn.utils.vector_to_parameters.html#torch.nn.utils.vector_to_parameters "torch.nn.utils.vector_to_parameters") | 将向量的切片复制到参数的可迭代对象中。 | +| `vector_to_parameters` | 将向量的切片复制到参数的可迭代对象中。 | -用于融合带有BatchNorm模块的模块的实用函数。 +用于融合带有 BatchNorm 模块的模块的实用函数。 -| [`fuse_conv_bn_eval`](generated/torch.nn.utils.fuse_conv_bn_eval.html#torch.nn.utils.fuse_conv_bn_eval "torch.nn.utils.fuse_conv_bn_eval") | 将卷积模块和BatchNorm模块融合为单个新的卷积模块。 | +| `fuse_conv_bn_eval` | 将卷积模块和 BatchNorm 模块融合为单个新的卷积模块。 | | --- | --- | -| [`fuse_conv_bn_weights`](generated/torch.nn.utils.fuse_conv_bn_weights.html#torch.nn.utils.fuse_conv_bn_weights "torch.nn.utils.fuse_conv_bn_weights") | 将卷积模块参数和BatchNorm模块参数融合为新的卷积模块参数。 | -| [`fuse_linear_bn_eval`](generated/torch.nn.utils.fuse_linear_bn_eval.html#torch.nn.utils.fuse_linear_bn_eval "torch.nn.utils.fuse_linear_bn_eval") | 将线性模块和BatchNorm模块融合为单个新的线性模块。 | -| [`fuse_linear_bn_weights`](generated/torch.nn.utils.fuse_linear_bn_weights.html#torch.nn.utils.fuse_linear_bn_weights "torch.nn.utils.fuse_linear_bn_weights") | 将线性模块参数和BatchNorm模块参数融合为新的线性模块参数。 | +| `fuse_conv_bn_weights` | 将卷积模块参数和 BatchNorm 模块参数融合为新的卷积模块参数。 | +| `fuse_linear_bn_eval` | 将线性模块和 BatchNorm 模块融合为单个新的线性模块。 | +| `fuse_linear_bn_weights` | 将线性模块参数和 BatchNorm 模块参数融合为新的线性模块参数。 | 用于转换模块参数内存格式的实用函数。 -| [`convert_conv2d_weight_memory_format`](generated/torch.nn.utils.convert_conv2d_weight_memory_format.html#torch.nn.utils.convert_conv2d_weight_memory_format "torch.nn.utils.convert_conv2d_weight_memory_format") | 将`nn.Conv2d.weight`的`memory_format`转换为`memory_format`。 | +| `convert_conv2d_weight_memory_format` | 将`nn.Conv2d.weight`的`memory_format`转换为`memory_format`。 | | --- | --- | 应用和移除模块参数中的权重归一化的实用函数。 -| [`weight_norm`](#module-torch.nn.utils.weight_norm "torch.nn.utils.weight_norm") | 对给定模块中的参数应用权重归一化。 | +| `weight_norm` | 对给定模块中的参数应用权重归一化。 | | --- | --- | -| [`remove_weight_norm`](generated/torch.nn.utils.remove_weight_norm.html#torch.nn.utils.remove_weight_norm "torch.nn.utils.remove_weight_norm") | 从模块中移除权重归一化重新参数化。 | -| [`spectral_norm`](#module-torch.nn.utils.spectral_norm "torch.nn.utils.spectral_norm") | 对给定模块中的参数应用谱归一化。 | -| [`remove_spectral_norm`](generated/torch.nn.utils.remove_spectral_norm.html#torch.nn.utils.remove_spectral_norm "torch.nn.utils.remove_spectral_norm") | 从模块中移除谱归一化重新参数化。 | +| `remove_weight_norm` | 从模块中移除权重归一化重新参数化。 | +| `spectral_norm` | 对给定模块中的参数应用谱归一化。 | +| `remove_spectral_norm` | 从模块中移除谱归一化重新参数化。 | 用于初始化模块参数的实用函数。 -| [`skip_init`](generated/torch.nn.utils.skip_init.html#torch.nn.utils.skip_init "torch.nn.utils.skip_init") | 给定模块类对象和参数/关键字参数，实例化模块而不初始化参数/缓冲区。 | +| `skip_init` | 给定模块类对象和参数/关键字参数，实例化模块而不初始化参数/缓冲区。 | | --- | --- | 用于修剪模块参数的实用类和函数。 -| [`prune.BasePruningMethod`](generated/torch.nn.utils.prune.BasePruningMethod.html#torch.nn.utils.prune.BasePruningMethod "torch.nn.utils.prune.BasePruningMethod") | 用于创建新修剪技术的抽象基类。 | +| `prune.BasePruningMethod` | 用于创建新修剪技术的抽象基类。 | | --- | --- | -| [`prune.PruningContainer`](generated/torch.nn.utils.prune.PruningContainer.html#torch.nn.utils.prune.PruningContainer "torch.nn.utils.prune.PruningContainer") | 包含一系列迭代剪枝方法的容器。 | -| [`prune.Identity`](generated/torch.nn.utils.prune.Identity.html#torch.nn.utils.prune.Identity "torch.nn.utils.prune.Identity") | 不剪枝任何单元，但生成具有全为1的掩码的剪枝参数化的实用剪枝方法。 | -| [`prune.RandomUnstructured`](generated/torch.nn.utils.prune.RandomUnstructured.html#torch.nn.utils.prune.RandomUnstructured "torch.nn.utils.prune.RandomUnstructured") | 随机剪枝张量中的（当前未剪枝）单元。 | -| [`prune.L1Unstructured`](generated/torch.nn.utils.prune.L1Unstructured.html#torch.nn.utils.prune.L1Unstructured "torch.nn.utils.prune.L1Unstructured") | 通过将具有最低 L1-范数的单元置零来剪枝张量中的（当前未剪枝）单元。 | -| [`prune.RandomStructured`](generated/torch.nn.utils.prune.RandomStructured.html#torch.nn.utils.prune.RandomStructured "torch.nn.utils.prune.RandomStructured") | 随机剪枝张量中的整个（当前未剪枝）通道。 | -| [`prune.LnStructured`](generated/torch.nn.utils.prune.LnStructured.html#torch.nn.utils.prune.LnStructured "torch.nn.utils.prune.LnStructured") | 基于它们的 L`n`-范数剪枝张量中整个（当前未剪枝）通道。 | -| [`prune.CustomFromMask`](generated/torch.nn.utils.prune.CustomFromMask.html#torch.nn.utils.prune.CustomFromMask "torch.nn.utils.prune.CustomFromMask") | | -| [`prune.identity`](generated/torch.nn.utils.prune.identity.html#torch.nn.utils.prune.identity "torch.nn.utils.prune.identity") | 应用剪枝重新参数化，而不剪枝任何单元。 | -| [`prune.random_unstructured`](generated/torch.nn.utils.prune.random_unstructured.html#torch.nn.utils.prune.random_unstructured "torch.nn.utils.prune.random_unstructured") | 通过移除随机（当前未剪枝）单元来剪枝张量。 | -| [`prune.l1_unstructured`](generated/torch.nn.utils.prune.l1_unstructured.html#torch.nn.utils.prune.l1_unstructured "torch.nn.utils.prune.l1_unstructured") | 通过移除具有最低 L1-范数的单元来剪枝张量。 | -| [`prune.random_structured`](generated/torch.nn.utils.prune.random_structured.html#torch.nn.utils.prune.random_structured "torch.nn.utils.prune.random_structured") | 通过沿指定维度移除随机通道来剪枝张量。 | -| [`prune.ln_structured`](generated/torch.nn.utils.prune.ln_structured.html#torch.nn.utils.prune.ln_structured "torch.nn.utils.prune.ln_structured") | 通过沿指定维度移除具有最低 L`n`-范数的通道来剪枝张量。 | -| [`prune.global_unstructured`](generated/torch.nn.utils.prune.global_unstructured.html#torch.nn.utils.prune.global_unstructured "torch.nn.utils.prune.global_unstructured") | 通过应用指定的 `pruning_method` 全局剪枝与 `parameters` 中所有参数对应的张量。 | -| [`prune.custom_from_mask`](generated/torch.nn.utils.prune.custom_from_mask.html#torch.nn.utils.prune.custom_from_mask "torch.nn.utils.prune.custom_from_mask") | 通过应用 `mask` 中的预先计算的掩码来剪枝与 `module` 中名为 `name` 的参数对应的张量。 | -| [`prune.remove`](generated/torch.nn.utils.prune.remove.html#torch.nn.utils.prune.remove "torch.nn.utils.prune.remove") | 从模块中移除剪枝重新参数化，并从前向钩子中移除剪枝方法。 | -| [`prune.is_pruned`](generated/torch.nn.utils.prune.is_pruned.html#torch.nn.utils.prune.is_pruned "torch.nn.utils.prune.is_pruned") | 通过查找剪枝预钩子来检查模块是否被剪枝。 | +| `prune.PruningContainer` | 包含一系列迭代剪枝方法的容器。 | +| `prune.Identity` | 不剪枝任何单元，但生成具有全为 1 的掩码的剪枝参数化的实用剪枝方法。 | +| `prune.RandomUnstructured` | 随机剪枝张量中的（当前未剪枝）单元。 | +| `prune.L1Unstructured` | 通过将具有最低 L1-范数的单元置零来剪枝张量中的（当前未剪枝）单元。 | +| `prune.RandomStructured` | 随机剪枝张量中的整个（当前未剪枝）通道。 | +| `prune.LnStructured` | 基于它们的 L`n`-范数剪枝张量中整个（当前未剪枝）通道。 | +| `prune.CustomFromMask` | | +| `prune.identity` | 应用剪枝重新参数化，而不剪枝任何单元。 | +| `prune.random_unstructured` | 通过移除随机（当前未剪枝）单元来剪枝张量。 | +| `prune.l1_unstructured` | 通过移除具有最低 L1-范数的单元来剪枝张量。 | +| `prune.random_structured` | 通过沿指定维度移除随机通道来剪枝张量。 | +| `prune.ln_structured` | 通过沿指定维度移除具有最低 L`n`-范数的通道来剪枝张量。 | +| `prune.global_unstructured` | 通过应用指定的 `pruning_method` 全局剪枝与 `parameters` 中所有参数对应的张量。 | +| `prune.custom_from_mask` | 通过应用 `mask` 中的预先计算的掩码来剪枝与 `module` 中名为 `name` 的参数对应的张量。 | +| `prune.remove` | 从模块中移除剪枝重新参数化，并从前向钩子中移除剪枝方法。 | +| `prune.is_pruned` | 通过查找剪枝预钩子来检查模块是否被剪枝。 | 使用 `torch.nn.utils.parameterize.register_parametrization()` 中的新参数化功能实现的参数化。 -| [`parametrizations.orthogonal`](generated/torch.nn.utils.parametrizations.orthogonal.html#torch.nn.utils.parametrizations.orthogonal "torch.nn.utils.parametrizations.orthogonal") | 对矩阵或一批矩阵应用正交或酉参数化。 | +| `parametrizations.orthogonal` | 对矩阵或一批矩阵应用正交或酉参数化。 | | --- | --- | -| [`parametrizations.weight_norm`](generated/torch.nn.utils.parametrizations.weight_norm.html#torch.nn.utils.parametrizations.weight_norm "torch.nn.utils.parametrizations.weight_norm") | 将权重归一化应用于给定模块中的参数。 | -| [`parametrizations.spectral_norm`](generated/torch.nn.utils.parametrizations.spectral_norm.html#torch.nn.utils.parametrizations.spectral_norm "torch.nn.utils.parametrizations.spectral_norm") | 对给定模块中的参数应用谱归一化。 | +| `parametrizations.weight_norm` | 将权重归一化应用于给定模块中的参数。 | +| `parametrizations.spectral_norm` | 对给定模块中的参数应用谱归一化。 | 用于在现有模块上对张量进行参数化的实用函数。请注意，这些函数可用于对给定的参数或缓冲区进行参数化，给定特定函数从输入空间映射到参数化空间。它们不是将对象转换为参数的参数化。有关如何实现自己的参数化的更多信息，请参阅[参数化教程](https://pytorch.org/tutorials/intermediate/parametrizations.html)。 -| [`parametrize.register_parametrization`](generated/torch.nn.utils.parametrize.register_parametrization.html#torch.nn.utils.parametrize.register_parametrization "torch.nn.utils.parametrize.register_parametrization") | 在模块中的张量上注册参数化。 | +| `parametrize.register_parametrization` | 在模块中的张量上注册参数化。 | | --- | --- | -| [`parametrize.remove_parametrizations`](generated/torch.nn.utils.parametrize.remove_parametrizations.html#torch.nn.utils.parametrize.remove_parametrizations "torch.nn.utils.parametrize.remove_parametrizations") | 在模块中的张量上移除参数化。 | -| [`parametrize.cached`](generated/torch.nn.utils.parametrize.cached.html#torch.nn.utils.parametrize.cached "torch.nn.utils.parametrize.cached") | 启用与`register_parametrization()`注册的参数化中的缓存系统的上下文管理器。 | -| [`parametrize.is_parametrized`](generated/torch.nn.utils.parametrize.is_parametrized.html#torch.nn.utils.parametrize.is_parametrized "torch.nn.utils.parametrize.is_parametrized") | 确定模块是否具有参数化。 | -| [`parametrize.ParametrizationList`](generated/torch.nn.utils.parametrize.ParametrizationList.html#torch.nn.utils.parametrize.ParametrizationList "torch.nn.utils.parametrize.ParametrizationList") | 一个顺序容器，保存和管理参数化[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")的原始参数或缓冲区。 | +| `parametrize.remove_parametrizations` | 在模块中的张量上移除参数化。 | +| `parametrize.cached` | 启用与`register_parametrization()`注册的参数化中的缓存系统的上下文管理器。 | +| `parametrize.is_parametrized` | 确定模块是否具有参数化。 | +| `parametrize.ParametrizationList` | 一个顺序容器，保存和管理参数化`torch.nn.Module`的原始参数或缓冲区。 | 以无状态方式调用给定模块的实用函数。 -| [`stateless.functional_call`](generated/torch.nn.utils.stateless.functional_call.html#torch.nn.utils.stateless.functional_call "torch.nn.utils.stateless.functional_call") | 通过用提供的参数替换模块的参数和缓冲区来对模块执行功能调用。 | +| `stateless.functional_call` | 通过用提供的参数替换模块的参数和缓冲区来对模块执行功能调用。 | | --- | --- | 其他模块中的实用函数 -| [`nn.utils.rnn.PackedSequence`](generated/torch.nn.utils.rnn.PackedSequence.html#torch.nn.utils.rnn.PackedSequence "torch.nn.utils.rnn.PackedSequence") | 包含打包序列的数据和`batch_sizes`列表。 | +| `nn.utils.rnn.PackedSequence` | 包含打包序列的数据和`batch_sizes`列表。 | | --- | --- | -| [`nn.utils.rnn.pack_padded_sequence`](generated/torch.nn.utils.rnn.pack_padded_sequence.html#torch.nn.utils.rnn.pack_padded_sequence "torch.nn.utils.rnn.pack_padded_sequence") | 将包含变长填充序列的张量打包。 | -| [`nn.utils.rnn.pad_packed_sequence`](generated/torch.nn.utils.rnn.pad_packed_sequence.html#torch.nn.utils.rnn.pad_packed_sequence "torch.nn.utils.rnn.pad_packed_sequence") | 填充变长序列的打包批次。 | -| [`nn.utils.rnn.pad_sequence`](generated/torch.nn.utils.rnn.pad_sequence.html#torch.nn.utils.rnn.pad_sequence "torch.nn.utils.rnn.pad_sequence") | 使用`padding_value`填充变长张量列表。 | -| [`nn.utils.rnn.pack_sequence`](generated/torch.nn.utils.rnn.pack_sequence.html#torch.nn.utils.rnn.pack_sequence "torch.nn.utils.rnn.pack_sequence") | 打包长度可变的张量列表。 | -| [`nn.utils.rnn.unpack_sequence`](generated/torch.nn.utils.rnn.unpack_sequence.html#torch.nn.utils.rnn.unpack_sequence "torch.nn.utils.rnn.unpack_sequence") | 将PackedSequence解包成长度可变的张量列表。 | -| [`nn.utils.rnn.unpad_sequence`](generated/torch.nn.utils.rnn.unpad_sequence.html#torch.nn.utils.rnn.unpad_sequence "torch.nn.utils.rnn.unpad_sequence") | 将填充的张量解除填充为长度可变的张量列表。 | -| [`nn.Flatten`](generated/torch.nn.Flatten.html#torch.nn.Flatten "torch.nn.Flatten") | 将连续的维度范围展平为张量。 | -| [`nn.Unflatten`](generated/torch.nn.Unflatten.html#torch.nn.Unflatten "torch.nn.Unflatten") | 将张量展平，将其扩展为所需的形状。 | +| `nn.utils.rnn.pack_padded_sequence` | 将包含变长填充序列的张量打包。 | +| `nn.utils.rnn.pad_packed_sequence` | 填充变长序列的打包批次。 | +| `nn.utils.rnn.pad_sequence` | 使用`padding_value`填充变长张量列表。 | +| `nn.utils.rnn.pack_sequence` | 打包长度可变的张量列表。 | +| `nn.utils.rnn.unpack_sequence` | 将 PackedSequence 解包成长度可变的张量列表。 | +| `nn.utils.rnn.unpad_sequence` | 将填充的张量解除填充为长度可变的张量列表。 | +| `nn.Flatten` | 将连续的维度范围展平为张量。 | +| `nn.Unflatten` | 将张量展平，将其扩展为所需的形状。 | -## [量化函数](#id1) +## 量化函数 -量化是指在比浮点精度更低的比特宽度上执行计算和存储张量的技术。PyTorch支持每个张量和每个通道的非对称线性量化。要了解如何在PyTorch中使用量化函数，请参阅[量化](quantization.html#quantization-doc)文档。 +量化是指在比浮点精度更低的比特宽度上执行计算和存储张量的技术。PyTorch 支持每个张量和每个通道的非对称线性量化。要了解如何在 PyTorch 中使用量化函数，请参阅量化文档。 -## [延迟模块初始化](#id1)[](#lazy-modules-initialization "跳转到此标题") +## 延迟模块初始化[](#lazy-modules-initialization "跳转到此标题") -| [`nn.modules.lazy.LazyModuleMixin`](generated/torch.nn.modules.lazy.LazyModuleMixin.html#torch.nn.modules.lazy.LazyModuleMixin "torch.nn.modules.lazy.LazyModuleMixin") | 用于延迟初始化参数的模块混合，也称为“延迟模块”。 | +| `nn.modules.lazy.LazyModuleMixin` | 用于延迟初始化参数的模块混合，也称为“延迟模块”。 | | --- | --- | diff --git a/totrans/doc22_033.md b/totrans/doc22_033.md index 4b0339b6..0fe62f79 100644 --- a/totrans/doc22_033.md +++ b/totrans/doc22_033.md @@ -1,162 +1,162 @@ # torch.nn.functional -> 原文：[https://pytorch.org/docs/stable/nn.functional.html](https://pytorch.org/docs/stable/nn.functional.html) +> 原文：[`pytorch.org/docs/stable/nn.functional.html`](https://pytorch.org/docs/stable/nn.functional.html) ## 卷积函数 -| [`conv1d`](generated/torch.nn.functional.conv1d.html#torch.nn.functional.conv1d "torch.nn.functional.conv1d") | 对由多个输入平面组成的输入信号应用1D卷积。 | +| `conv1d` | 对由多个输入平面组成的输入信号应用 1D 卷积。 | | --- | --- | -| [`conv2d`](generated/torch.nn.functional.conv2d.html#torch.nn.functional.conv2d "torch.nn.functional.conv2d") | 对由多个输入平面组成的输入图像应用2D卷积。 | -| [`conv3d`](generated/torch.nn.functional.conv3d.html#torch.nn.functional.conv3d "torch.nn.functional.conv3d") | 对由多个输入平面组成的输入图像应用3D卷积。 | -| [`conv_transpose1d`](generated/torch.nn.functional.conv_transpose1d.html#torch.nn.functional.conv_transpose1d "torch.nn.functional.conv_transpose1d") | 对由多个输入平面组成的输入信号应用1D转置卷积运算，有时也称为“反卷积”。 | -| [`conv_transpose2d`](generated/torch.nn.functional.conv_transpose2d.html#torch.nn.functional.conv_transpose2d "torch.nn.functional.conv_transpose2d") | 对由多个输入平面组成的输入图像应用2D转置卷积运算，有时也称为“反卷积”。 | -| [`conv_transpose3d`](generated/torch.nn.functional.conv_transpose3d.html#torch.nn.functional.conv_transpose3d "torch.nn.functional.conv_transpose3d") | 对由多个输入平面组成的输入图像应用3D转置卷积运算，有时也称为“反卷积” | -| [`unfold`](generated/torch.nn.functional.unfold.html#torch.nn.functional.unfold "torch.nn.functional.unfold") | 从批量输入张量中提取滑动的局部块。 | -| [`fold`](generated/torch.nn.functional.fold.html#torch.nn.functional.fold "torch.nn.functional.fold") | 将滑动的局部块数组合并成一个包含大张量。 | +| `conv2d` | 对由多个输入平面组成的输入图像应用 2D 卷积。 | +| `conv3d` | 对由多个输入平面组成的输入图像应用 3D 卷积。 | +| `conv_transpose1d` | 对由多个输入平面组成的输入信号应用 1D 转置卷积运算，有时也称为“反卷积”。 | +| `conv_transpose2d` | 对由多个输入平面组成的输入图像应用 2D 转置卷积运算，有时也称为“反卷积”。 | +| `conv_transpose3d` | 对由多个输入平面组成的输入图像应用 3D 转置卷积运算，有时也称为“反卷积” | +| `unfold` | 从批量输入张量中提取滑动的局部块。 | +| `fold` | 将滑动的局部块数组合并成一个包含大张量。 | ## 池化函数 -| [`avg_pool1d`](generated/torch.nn.functional.avg_pool1d.html#torch.nn.functional.avg_pool1d "torch.nn.functional.avg_pool1d") | 对由多个输入平面组成的输入信号应用1D平均池化。 | +| `avg_pool1d` | 对由多个输入平面组成的输入信号应用 1D 平均池化。 | | --- | --- | -| [`avg_pool2d`](generated/torch.nn.functional.avg_pool2d.html#torch.nn.functional.avg_pool2d "torch.nn.functional.avg_pool2d") | 通过步长$sH \times sW$在$kH \times kW$区域内应用2D平均池化操作。 | -| [`avg_pool3d`](generated/torch.nn.functional.avg_pool3d.html#torch.nn.functional.avg_pool3d "torch.nn.functional.avg_pool3d") | 通过步长$sT \times sH \times sW$在$kT \times kH \times kW$区域内应用3D平均池化操作。 | -| [`max_pool1d`](generated/torch.nn.functional.max_pool1d.html#torch.nn.functional.max_pool1d "torch.nn.functional.max_pool1d") | 对由多个输入平面组成的输入信号应用1D最大池化。 | -| [`max_pool2d`](generated/torch.nn.functional.max_pool2d.html#torch.nn.functional.max_pool2d "torch.nn.functional.max_pool2d") | 对由多个输入平面组成的输入信号应用2D最大池化。 | -| [`max_pool3d`](generated/torch.nn.functional.max_pool3d.html#torch.nn.functional.max_pool3d "torch.nn.functional.max_pool3d") | 对由多个输入平面组成的输入信号应用3D最大池化。 | -| [`max_unpool1d`](generated/torch.nn.functional.max_unpool1d.html#torch.nn.functional.max_unpool1d "torch.nn.functional.max_unpool1d") | 计算`MaxPool1d`的部分逆。 | -| [`max_unpool2d`](generated/torch.nn.functional.max_unpool2d.html#torch.nn.functional.max_unpool2d "torch.nn.functional.max_unpool2d") | 计算`MaxPool2d`的部分逆。 | -| [`max_unpool3d`](generated/torch.nn.functional.max_unpool3d.html#torch.nn.functional.max_unpool3d "torch.nn.functional.max_unpool3d") | 计算`MaxPool3d`的部分逆。 | -| [`lp_pool1d`](生成/torch.nn.functional.lp_pool1d.html#torch.nn.functional.lp_pool1d "torch.nn.functional.lp_pool1d") | 对由多个输入平面组成的输入信号应用1D幂平均池化。 | -| [`lp_pool2d`](生成/torch.nn.functional.lp_pool2d.html#torch.nn.functional.lp_pool2d "torch.nn.functional.lp_pool2d") | 对由多个输入平面组成的输入信号应用2D幂平均池化。 | -| [`adaptive_max_pool1d`](生成/torch.nn.functional.adaptive_max_pool1d.html#torch.nn.functional.adaptive_max_pool1d "torch.nn.functional.adaptive_max_pool1d") | 对由多个输入平面组成的输入信号应用1D自适应最大池化。 | -| [`adaptive_max_pool2d`](生成/torch.nn.functional.adaptive_max_pool2d.html#torch.nn.functional.adaptive_max_pool2d "torch.nn.functional.adaptive_max_pool2d") | 对由多个输入平面组成的输入信号应用2D自适应最大池化。 | -| [`adaptive_max_pool3d`](生成/torch.nn.functional.adaptive_max_pool3d.html#torch.nn.functional.adaptive_max_pool3d "torch.nn.functional.adaptive_max_pool3d") | 对由多个输入平面组成的输入信号应用3D自适应最大池化。 | -| [`adaptive_avg_pool1d`](生成/torch.nn.functional.adaptive_avg_pool1d.html#torch.nn.functional.adaptive_avg_pool1d "torch.nn.functional.adaptive_avg_pool1d") | 对由多个输入平面组成的输入信号应用1D自适应平均池化。 | -| [`adaptive_avg_pool2d`](生成/torch.nn.functional.adaptive_avg_pool2d.html#torch.nn.functional.adaptive_avg_pool2d "torch.nn.functional.adaptive_avg_pool2d") | 对由多个输入平面组成的输入信号应用2D自适应平均池化。 | -| [`adaptive_avg_pool3d`](生成/torch.nn.functional.adaptive_avg_pool3d.html#torch.nn.functional.adaptive_avg_pool3d "torch.nn.functional.adaptive_avg_pool3d") | 对由多个输入平面组成的输入信号应用3D自适应平均池化。 | -| [`fractional_max_pool2d`](生成/torch.nn.functional.fractional_max_pool2d.html#torch.nn.functional.fractional_max_pool2d "torch.nn.functional.fractional_max_pool2d") | 对由多个输入平面组成的输入信号应用2D分数最大池化。 | -| [`fractional_max_pool3d`](生成/torch.nn.functional.fractional_max_pool3d.html#torch.nn.functional.fractional_max_pool3d "torch.nn.functional.fractional_max_pool3d") | 对由多个输入平面组成的输入信号应用3D分数最大池化。 | +| `avg_pool2d` | 通过步长$sH \times sW$在$kH \times kW$区域内应用 2D 平均池化操作。 | +| `avg_pool3d` | 通过步长$sT \times sH \times sW$在$kT \times kH \times kW$区域内应用 3D 平均池化操作。 | +| `max_pool1d` | 对由多个输入平面组成的输入信号应用 1D 最大池化。 | +| `max_pool2d` | 对由多个输入平面组成的输入信号应用 2D 最大池化。 | +| `max_pool3d` | 对由多个输入平面组成的输入信号应用 3D 最大池化。 | +| `max_unpool1d` | 计算`MaxPool1d`的部分逆。 | +| `max_unpool2d` | 计算`MaxPool2d`的部分逆。 | +| `max_unpool3d` | 计算`MaxPool3d`的部分逆。 | +| `lp_pool1d` | 对由多个输入平面组成的输入信号应用 1D 幂平均池化。 | +| `lp_pool2d` | 对由多个输入平面组成的输入信号应用 2D 幂平均池化。 | +| `adaptive_max_pool1d` | 对由多个输入平面组成的输入信号应用 1D 自适应最大池化。 | +| `adaptive_max_pool2d` | 对由多个输入平面组成的输入信号应用 2D 自适应最大池化。 | +| `adaptive_max_pool3d` | 对由多个输入平面组成的输入信号应用 3D 自适应最大池化。 | +| `adaptive_avg_pool1d` | 对由多个输入平面组成的输入信号应用 1D 自适应平均池化。 | +| `adaptive_avg_pool2d` | 对由多个输入平面组成的输入信号应用 2D 自适应平均池化。 | +| `adaptive_avg_pool3d` | 对由多个输入平面组成的输入信号应用 3D 自适应平均池化。 | +| `fractional_max_pool2d` | 对由多个输入平面组成的输入信号应用 2D 分数最大池化。 | +| `fractional_max_pool3d` | 对由多个输入平面组成的输入信号应用 3D 分数最大池化。 | ## 注意力机制 -| [`scaled_dot_product_attention`](生成/torch.nn.functional.scaled_dot_product_attention.html#torch.nn.functional.scaled_dot_product_attention "torch.nn.functional.scaled_dot_product_attention") | 在查询、键和值张量上计算缩放点积注意力，如果传递了可选的注意力掩码，则应用dropout，如果指定了大于0.0的概率。 | +| `scaled_dot_product_attention` | 在查询、键和值张量上计算缩放点积注意力，如果传递了可选的注意力掩码，则应用 dropout，如果指定了大于 0.0 的概率。 | | --- | --- | ## 非线性激活函数[](#non-linear-activation-functions "跳转到此标题") -| [`threshold`](生成/torch.nn.functional.threshold.html#torch.nn.functional.threshold "torch.nn.functional.threshold") | 对输入张量的每个元素应用阈值。 | +| `threshold` | 对输入张量的每个元素应用阈值。 | | --- | --- | -| [`threshold_`](生成/torch.nn.functional.threshold_.html#torch.nn.functional.threshold_ "torch.nn.functional.threshold_") | [`threshold()`](生成/torch.nn.functional.threshold.html#torch.nn.functional.threshold "torch.nn.functional.threshold")的原地版本。 | -| [`relu`](生成/torch.nn.functional.relu.html#torch.nn.functional.relu "torch.nn.functional.relu") | 逐元素应用修正线性单元函数。 | -| [`relu_`](生成/torch.nn.functional.relu_.html#torch.nn.functional.relu_ "torch.nn.functional.relu_") | [`relu()`](生成/torch.nn.functional.relu.html#torch.nn.functional.relu "torch.nn.functional.relu")的原地版本。 | -| [`hardtanh`](generated/torch.nn.functional.hardtanh.html#torch.nn.functional.hardtanh "torch.nn.functional.hardtanh") | 逐元素应用HardTanh函数。 | -| [`hardtanh_`](generated/torch.nn.functional.hardtanh_.html#torch.nn.functional.hardtanh_ "torch.nn.functional.hardtanh_") | [`hardtanh()`](generated/torch.nn.functional.hardtanh.html#torch.nn.functional.hardtanh "torch.nn.functional.hardtanh")的原地版本。 | -| [`hardswish`](generated/torch.nn.functional.hardswish.html#torch.nn.functional.hardswish "torch.nn.functional.hardswish") | 应用硬swish函数，逐元素。 | -| [`relu6`](generated/torch.nn.functional.relu6.html#torch.nn.functional.relu6 "torch.nn.functional.relu6") | 应用逐元素函数 $\text{ReLU6}(x) = \min(\max(0,x), 6)$。 | -| [`elu`](generated/torch.nn.functional.elu.html#torch.nn.functional.elu "torch.nn.functional.elu") | 逐元素应用指数线性单元（ELU）函数。 | -| [`elu_`](generated/torch.nn.functional.elu_.html#torch.nn.functional.elu_ "torch.nn.functional.elu_") | [`elu()`](generated/torch.nn.functional.elu.html#torch.nn.functional.elu "torch.nn.functional.elu")的原地版本。 | -| [`selu`](generated/torch.nn.functional.selu.html#torch.nn.functional.selu "torch.nn.functional.selu") | 逐元素应用，$\text{SELU}(x) = scale * (\max(0,x) + \min(0, \alpha * (\exp(x) - 1)))$，其中 $\alpha=1.6732632423543772848170429916717$ 和 $scale=1.0507009873554804934193349852946$。 | -| [`celu`](generated/torch.nn.functional.celu.html#torch.nn.functional.celu "torch.nn.functional.celu") | 逐元素应用，$\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))$。 | -| [`leaky_relu`](generated/torch.nn.functional.leaky_relu.html#torch.nn.functional.leaky_relu "torch.nn.functional.leaky_relu") | 逐元素应用，$\text{LeakyReLU}(x) = \max(0, x) + \text{negative\_slope} * \min(0, x)$。 | -| [`leaky_relu_`](generated/torch.nn.functional.leaky_relu_.html#torch.nn.functional.leaky_relu_ "torch.nn.functional.leaky_relu_") | [`leaky_relu()`](generated/torch.nn.functional.leaky_relu.html#torch.nn.functional.leaky_relu "torch.nn.functional.leaky_relu")的原地版本。 | -| [`prelu`](generated/torch.nn.functional.prelu.html#torch.nn.functional.prelu "torch.nn.functional.prelu") | 逐元素应用函数 $\text{PReLU}(x) = \max(0,x) + \text{weight} * \min(0,x)$，其中weight是可学习参数。 | -| [`rrelu`](generated/torch.nn.functional.rrelu.html#torch.nn.functional.rrelu "torch.nn.functional.rrelu") | 随机泄漏的ReLU。 | -| [`rrelu_`](generated/torch.nn.functional.rrelu_.html#torch.nn.functional.rrelu_ "torch.nn.functional.rrelu_") | [`rrelu()`](generated/torch.nn.functional.rrelu.html#torch.nn.functional.rrelu "torch.nn.functional.rrelu")的原地版本。 | -| [`glu`](generated/torch.nn.functional.glu.html#torch.nn.functional.glu "torch.nn.functional.glu") | 门控线性单元。 | -| [`gelu`](generated/torch.nn.functional.gelu.html#torch.nn.functional.gelu "torch.nn.functional.gelu") | 当近似参数为'none'时，逐元素应用函数 $\text{GELU}(x) = x * \Phi(x)$。 | -| [`logsigmoid`](generated/torch.nn.functional.logsigmoid.html#torch.nn.functional.logsigmoid "torch.nn.functional.logsigmoid") | 逐元素应用 $\text{LogSigmoid}(x_i) = \log \left(\frac{1}{1 + \exp(-x_i)}\right)$。 | -| [`hardshrink`](generated/torch.nn.functional.hardshrink.html#torch.nn.functional.hardshrink "torch.nn.functional.hardshrink") | 逐元素应用硬收缩函数。 | -| [`tanhshrink`](generated/torch.nn.functional.tanhshrink.html#torch.nn.functional.tanhshrink "torch.nn.functional.tanhshrink") | 应用函数$\text{Tanhshrink}(x) = x - \text{Tanh}(x)$ | -| [`softsign`](generated/torch.nn.functional.softsign.html#torch.nn.functional.softsign "torch.nn.functional.softsign") | 对每个元素应用函数$\text{SoftSign}(x) = \frac{x}{1 + | x | }$ | -| [`softplus`](generated/torch.nn.functional.softplus.html#torch.nn.functional.softplus "torch.nn.functional.softplus") | 对每个元素应用函数$\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))$ | -| [`softmin`](generated/torch.nn.functional.softmin.html#torch.nn.functional.softmin "torch.nn.functional.softmin") | 应用softmin函数。 | -| [`softmax`](generated/torch.nn.functional.softmax.html#torch.nn.functional.softmax "torch.nn.functional.softmax") | 应用softmax函数。 | -| [`softshrink`](generated/torch.nn.functional.softshrink.html#torch.nn.functional.softshrink "torch.nn.functional.softshrink") | 对每个元素应用软收缩函数。 | -| [`gumbel_softmax`](generated/torch.nn.functional.gumbel_softmax.html#torch.nn.functional.gumbel_softmax "torch.nn.functional.gumbel_softmax") | 从Gumbel-Softmax分布中采样，并可选择离散化。 | -| [`log_softmax`](generated/torch.nn.functional.log_softmax.html#torch.nn.functional.log_softmax "torch.nn.functional.log_softmax") | 应用softmax后再取对数。 | -| [`tanh`](generated/torch.nn.functional.tanh.html#torch.nn.functional.tanh "torch.nn.functional.tanh") | 对每个元素应用$\text{Tanh}(x) = \tanh(x) = \frac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}$ | -| [`sigmoid`](generated/torch.nn.functional.sigmoid.html#torch.nn.functional.sigmoid "torch.nn.functional.sigmoid") | 对每个元素应用函数$\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}$ | -| [`hardsigmoid`](generated/torch.nn.functional.hardsigmoid.html#torch.nn.functional.hardsigmoid "torch.nn.functional.hardsigmoid") | 对每个元素应用Hardsigmoid函数。 | -| [`silu`](generated/torch.nn.functional.silu.html#torch.nn.functional.silu "torch.nn.functional.silu") | 对每个元素应用Sigmoid线性单元（SiLU）函数。 | -| [`mish`](generated/torch.nn.functional.mish.html#torch.nn.functional.mish "torch.nn.functional.mish") | 对每个元素应用Mish函数。 | -| [`batch_norm`](generated/torch.nn.functional.batch_norm.html#torch.nn.functional.batch_norm "torch.nn.functional.batch_norm") | 对数据批次中的每个通道应用批次归一化。 | -| [`group_norm`](generated/torch.nn.functional.group_norm.html#torch.nn.functional.group_norm "torch.nn.functional.group_norm") | 对最后若干维度应用组归一化。 | -| [`instance_norm`](generated/torch.nn.functional.instance_norm.html#torch.nn.functional.instance_norm "torch.nn.functional.instance_norm") | 对每个数据样本中的每个通道独立应用实例归一化。 | -| [`layer_norm`](generated/torch.nn.functional.layer_norm.html#torch.nn.functional.layer_norm "torch.nn.functional.layer_norm") | 对最后若干维度应用层归一化。 | -| [`local_response_norm`](generated/torch.nn.functional.local_response_norm.html#torch.nn.functional.local_response_norm "torch.nn.functional.local_response_norm") | 对输入信号应用局部响应归一化。 | -| [`normalize`](generated/torch.nn.functional.normalize.html#torch.nn.functional.normalize "torch.nn.functional.normalize") | 在指定维度上对输入进行$L_p$规范化。 | +| `threshold_` | `threshold()`的原地版本。 | +| `relu` | 逐元素应用修正线性单元函数。 | +| `relu_` | `relu()`的原地版本。 | +| `hardtanh` | 逐元素应用 HardTanh 函数。 | +| `hardtanh_` | `hardtanh()`的原地版本。 | +| `hardswish` | 应用硬 swish 函数，逐元素。 | +| `relu6` | 应用逐元素函数 $\text{ReLU6}(x) = \min(\max(0,x), 6)$。 | +| `elu` | 逐元素应用指数线性单元（ELU）函数。 | +| `elu_` | `elu()`的原地版本。 | +| `selu` | 逐元素应用，$\text{SELU}(x) = scale * (\max(0,x) + \min(0, \alpha * (\exp(x) - 1)))$，其中 $\alpha=1.6732632423543772848170429916717$ 和 $scale=1.0507009873554804934193349852946$。 | +| `celu` | 逐元素应用，$\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))$。 | +| `leaky_relu` | 逐元素应用，$\text{LeakyReLU}(x) = \max(0, x) + \text{negative\_slope} * \min(0, x)$。 | +| `leaky_relu_` | `leaky_relu()`的原地版本。 | +| `prelu` | 逐元素应用函数 $\text{PReLU}(x) = \max(0,x) + \text{weight} * \min(0,x)$，其中 weight 是可学习参数。 | +| `rrelu` | 随机泄漏的 ReLU。 | +| `rrelu_` | `rrelu()`的原地版本。 | +| `glu` | 门控线性单元。 | +| `gelu` | 当近似参数为'none'时，逐元素应用函数 $\text{GELU}(x) = x * \Phi(x)$。 | +| `logsigmoid` | 逐元素应用 $\text{LogSigmoid}(x_i) = \log \left(\frac{1}{1 + \exp(-x_i)}\right)$。 | +| `hardshrink` | 逐元素应用硬收缩函数。 | +| `tanhshrink` | 应用函数$\text{Tanhshrink}(x) = x - \text{Tanh}(x)$ | +| `softsign` | 对每个元素应用函数$\text{SoftSign}(x) = \frac{x}{1 + | x | }$ | +| `softplus` | 对每个元素应用函数$\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))$ | +| `softmin` | 应用 softmin 函数。 | +| `softmax` | 应用 softmax 函数。 | +| `softshrink` | 对每个元素应用软收缩函数。 | +| `gumbel_softmax` | 从 Gumbel-Softmax 分布中采样，并可选择离散化。 | +| `log_softmax` | 应用 softmax 后再取对数。 | +| `tanh` | 对每个元素应用$\text{Tanh}(x) = \tanh(x) = \frac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}$ | +| `sigmoid` | 对每个元素应用函数$\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}$ | +| `hardsigmoid` | 对每个元素应用 Hardsigmoid 函数。 | +| `silu` | 对每个元素应用 Sigmoid 线性单元（SiLU）函数。 | +| `mish` | 对每个元素应用 Mish 函数。 | +| `batch_norm` | 对数据批次中的每个通道应用批次归一化。 | +| `group_norm` | 对最后若干维度应用组归一化。 | +| `instance_norm` | 对每个数据样本中的每个通道独立应用实例归一化。 | +| `layer_norm` | 对最后若干维度应用层归一化。 | +| `local_response_norm` | 对输入信号应用局部响应归一化。 | +| `normalize` | 在指定维度上对输入进行$L_p$规范化。 | ## 线性函数 -| [`linear`](生成/torch.nn.functional.linear.html#torch.nn.functional.linear "torch.nn.functional.linear") | 对传入数据应用线性变换：$y = xA^T + b$y=xAT+b。 | +| `linear` | 对传入数据应用线性变换：$y = xA^T + b$y=xAT+b。 | | --- | --- | -| [`bilinear`](生成/torch.nn.functional.bilinear.html#torch.nn.functional.bilinear "torch.nn.functional.bilinear") | 对传入数据应用双线性变换：$y = x_1^T A x_2 + b$y=x1T​Ax2​+b | +| `bilinear` | 对传入数据应用双线性变换：$y = x_1^T A x_2 + b$y=x1T​Ax2​+b | -## Dropout函数 +## Dropout 函数 -| [`dropout`](生成/torch.nn.functional.dropout.html#torch.nn.functional.dropout "torch.nn.functional.dropout") | 在训练期间，以概率`p`随机将输入张量的一些元素置零。 | +| `dropout` | 在训练期间，以概率`p`随机将输入张量的一些元素置零。 | | --- | --- | -| [`alpha_dropout`](生成/torch.nn.functional.alpha_dropout.html#torch.nn.functional.alpha_dropout "torch.nn.functional.alpha_dropout") | 对输入应用alpha dropout。 | -| [`feature_alpha_dropout`](生成/torch.nn.functional.feature_alpha_dropout.html#torch.nn.functional.feature_alpha_dropout "torch.nn.functional.feature_alpha_dropout") | 随机屏蔽整个通道（通道是一个特征图）。 | -| [`dropout1d`](生成/torch.nn.functional.dropout1d.html#torch.nn.functional.dropout1d "torch.nn.functional.dropout1d") | 随机将整个通道置零（通道是一个1D特征图）。 | -| [`dropout2d`](生成/torch.nn.functional.dropout2d.html#torch.nn.functional.dropout2d "torch.nn.functional.dropout2d") | 随机将整个通道置零（通道是一个2D特征图）。 | -| [`dropout3d`](生成/torch.nn.functional.dropout3d.html#torch.nn.functional.dropout3d "torch.nn.functional.dropout3d") | 随机将整个通道置零（通道是一个3D特征图）。 | +| `alpha_dropout` | 对输入应用 alpha dropout。 | +| `feature_alpha_dropout` | 随机屏蔽整个通道（通道是一个特征图）。 | +| `dropout1d` | 随机将整个通道置零（通道是一个 1D 特征图）。 | +| `dropout2d` | 随机将整个通道置零（通道是一个 2D 特征图）。 | +| `dropout3d` | 随机将整个通道置零（通道是一个 3D 特征图）。 | ## 稀疏函数 -| [`embedding`](生成/torch.nn.functional.embedding.html#torch.nn.functional.embedding "torch.nn.functional.embedding") | 生成一个简单的查找表，在固定字典和大小中查找嵌入。 | +| `embedding` | 生成一个简单的查找表，在固定字典和大小中查找嵌入。 | | --- | --- | -| [`embedding_bag`](生成/torch.nn.functional.embedding_bag.html#torch.nn.functional.embedding_bag "torch.nn.functional.embedding_bag") | 计算嵌入包的总和、平均值或最大值。 | -| [`one_hot`](生成/torch.nn.functional.one_hot.html#torch.nn.functional.one_hot "torch.nn.functional.one_hot") | 接受形状为`(*)`的LongTensor索引值，并返回形状为`(*, num_classes)`的张量，除了最后一维的索引与输入张量的相应值匹配的地方为1外，其他地方都为零。 | +| `embedding_bag` | 计算嵌入包的总和、平均值或最大值。 | +| `one_hot` | 接受形状为`(*)`的 LongTensor 索引值，并返回形状为`(*, num_classes)`的张量，除了最后一维的索引与输入张量的相应值匹配的地方为 1 外，其他地方都为零。 | ## 距离函数 -| [`pairwise_distance`](生成/torch.nn.functional.pairwise_distance.html#torch.nn.functional.pairwise_distance "torch.nn.functional.pairwise_distance") | 详细信息请参见[`torch.nn.PairwiseDistance`](生成/torch.nn.PairwiseDistance.html#torch.nn.PairwiseDistance "torch.nn.PairwiseDistance") | +| `pairwise_distance` | 详细信息请参见`torch.nn.PairwiseDistance` | | --- | --- | -| [`cosine_similarity`](生成/torch.nn.functional.cosine_similarity.html#torch.nn.functional.cosine_similarity "torch.nn.functional.cosine_similarity") | 返回沿着维度计算的`x1`和`x2`之间的余弦相似度。 | -| [`pdist`](生成/torch.nn.functional.pdist.html#torch.nn.functional.pdist "torch.nn.functional.pdist") | 计算输入中每对行向量之间的p-范数距离。 | +| `cosine_similarity` | 返回沿着维度计算的`x1`和`x2`之间的余弦相似度。 | +| `pdist` | 计算输入中每对行向量之间的 p-范数距离。 | ## 损失函数 -| [`binary_cross_entropy`](生成/torch.nn.functional.binary_cross_entropy.html#torch.nn.functional.binary_cross_entropy "torch.nn.functional.binary_cross_entropy") | 计算目标和输入概率之间的二元交叉熵。 | +| `binary_cross_entropy` | 计算目标和输入概率之间的二元交叉熵。 | | --- | --- | -| [`binary_cross_entropy_with_logits`](生成/torch.nn.functional.binary_cross_entropy_with_logits.html#torch.nn.functional.binary_cross_entropy_with_logits "torch.nn.functional.binary_cross_entropy_with_logits") | 计算目标和输入logits之间的二元交叉熵。 | -| [`poisson_nll_loss`](生成/torch.nn.functional.poisson_nll_loss.html#torch.nn.functional.poisson_nll_loss "torch.nn.functional.poisson_nll_loss") | 泊松负对数似然损失。 | -| [`cosine_embedding_loss`](generated/torch.nn.functional.cosine_embedding_loss.html#torch.nn.functional.cosine_embedding_loss "torch.nn.functional.cosine_embedding_loss") | 详细信息请参阅[`CosineEmbeddingLoss`](generated/torch.nn.CosineEmbeddingLoss.html#torch.nn.CosineEmbeddingLoss "torch.nn.CosineEmbeddingLoss")。 | -| [`cross_entropy`](generated/torch.nn.functional.cross_entropy.html#torch.nn.functional.cross_entropy "torch.nn.functional.cross_entropy") | 计算输入logits和目标之间的交叉熵损失。 | -| [`ctc_loss`](generated/torch.nn.functional.ctc_loss.html#torch.nn.functional.ctc_loss "torch.nn.functional.ctc_loss") | 应用连接主义时间分类损失。 | -| [`gaussian_nll_loss`](generated/torch.nn.functional.gaussian_nll_loss.html#torch.nn.functional.gaussian_nll_loss "torch.nn.functional.gaussian_nll_loss") | 高斯负对数似然损失。 | -| [`hinge_embedding_loss`](generated/torch.nn.functional.hinge_embedding_loss.html#torch.nn.functional.hinge_embedding_loss "torch.nn.functional.hinge_embedding_loss") | 详细信息请参阅[`HingeEmbeddingLoss`](generated/torch.nn.HingeEmbeddingLoss.html#torch.nn.HingeEmbeddingLoss "torch.nn.HingeEmbeddingLoss")。 | -| [`kl_div`](generated/torch.nn.functional.kl_div.html#torch.nn.functional.kl_div "torch.nn.functional.kl_div") | 计算KL散度损失。 | -| [`l1_loss`](generated/torch.nn.functional.l1_loss.html#torch.nn.functional.l1_loss "torch.nn.functional.l1_loss") | 计算元素间绝对值差的均值。 | -| [`mse_loss`](generated/torch.nn.functional.mse_loss.html#torch.nn.functional.mse_loss "torch.nn.functional.mse_loss") | 计算元素间均方误差。 | -| [`margin_ranking_loss`](generated/torch.nn.functional.margin_ranking_loss.html#torch.nn.functional.margin_ranking_loss "torch.nn.functional.margin_ranking_loss") | 详细信息请参阅[`MarginRankingLoss`](generated/torch.nn.MarginRankingLoss.html#torch.nn.MarginRankingLoss "torch.nn.MarginRankingLoss")。 | -| [`multilabel_margin_loss`](generated/torch.nn.functional.multilabel_margin_loss.html#torch.nn.functional.multilabel_margin_loss "torch.nn.functional.multilabel_margin_loss") | 详细信息请参阅[`MultiLabelMarginLoss`](generated/torch.nn.MultiLabelMarginLoss.html#torch.nn.MultiLabelMarginLoss "torch.nn.MultiLabelMarginLoss")。 | -| [`multilabel_soft_margin_loss`](generated/torch.nn.functional.multilabel_soft_margin_loss.html#torch.nn.functional.multilabel_soft_margin_loss "torch.nn.functional.multilabel_soft_margin_loss") | 详细信息请参阅[`MultiLabelSoftMarginLoss`](generated/torch.nn.MultiLabelSoftMarginLoss.html#torch.nn.MultiLabelSoftMarginLoss "torch.nn.MultiLabelSoftMarginLoss")。 | -| [`multi_margin_loss`](generated/torch.nn.functional.multi_margin_loss.html#torch.nn.functional.multi_margin_loss "torch.nn.functional.multi_margin_loss") | 详细信息请参阅[`MultiMarginLoss`](generated/torch.nn.MultiMarginLoss.html#torch.nn.MultiMarginLoss "torch.nn.MultiMarginLoss")。 | -| [`nll_loss`](generated/torch.nn.functional.nll_loss.html#torch.nn.functional.nll_loss "torch.nn.functional.nll_loss") | 计算负对数似然损失。 | -| [`huber_loss`](generated/torch.nn.functional.huber_loss.html#torch.nn.functional.huber_loss "torch.nn.functional.huber_loss") | 计算Huber损失。 | -| [`smooth_l1_loss`](generated/torch.nn.functional.smooth_l1_loss.html#torch.nn.functional.smooth_l1_loss "torch.nn.functional.smooth_l1_loss") | 计算平滑L1损失。 | -| [`soft_margin_loss`](generated/torch.nn.functional.soft_margin_loss.html#torch.nn.functional.soft_margin_loss "torch.nn.functional.soft_margin_loss") | 详细信息请参阅[`SoftMarginLoss`](generated/torch.nn.SoftMarginLoss.html#torch.nn.SoftMarginLoss "torch.nn.SoftMarginLoss")。 | -| [`triplet_margin_loss`](generated/torch.nn.functional.triplet_margin_loss.html#torch.nn.functional.triplet_margin_loss "torch.nn.functional.triplet_margin_loss") | 计算给定输入张量之间的三元组损失，边距大于0。 | -| [`triplet_margin_with_distance_loss`](generated/torch.nn.functional.triplet_margin_with_distance_loss.html#torch.nn.functional.triplet_margin_with_distance_loss "torch.nn.functional.triplet_margin_with_distance_loss") | 使用自定义距离函数计算输入张量的三元组边距损失。 | +| `binary_cross_entropy_with_logits` | 计算目标和输入 logits 之间的二元交叉熵。 | +| `poisson_nll_loss` | 泊松负对数似然损失。 | +| `cosine_embedding_loss` | 详细信息请参阅`CosineEmbeddingLoss`。 | +| `cross_entropy` | 计算输入 logits 和目标之间的交叉熵损失。 | +| `ctc_loss` | 应用连接主义时间分类损失。 | +| `gaussian_nll_loss` | 高斯负对数似然损失。 | +| `hinge_embedding_loss` | 详细信息请参阅`HingeEmbeddingLoss`。 | +| `kl_div` | 计算 KL 散度损失。 | +| `l1_loss` | 计算元素间绝对值差的均值。 | +| `mse_loss` | 计算元素间均方误差。 | +| `margin_ranking_loss` | 详细信息请参阅`MarginRankingLoss`。 | +| `multilabel_margin_loss` | 详细信息请参阅`MultiLabelMarginLoss`。 | +| `multilabel_soft_margin_loss` | 详细信息请参阅`MultiLabelSoftMarginLoss`。 | +| `multi_margin_loss` | 详细信息请参阅`MultiMarginLoss`。 | +| `nll_loss` | 计算负对数似然损失。 | +| `huber_loss` | 计算 Huber 损失。 | +| `smooth_l1_loss` | 计算平滑 L1 损失。 | +| `soft_margin_loss` | 详细信息请参阅`SoftMarginLoss`。 | +| `triplet_margin_loss` | 计算给定输入张量之间的三元组损失，边距大于 0。 | +| `triplet_margin_with_distance_loss` | 使用自定义距离函数计算输入张量的三元组边距损失。 | ## Vision functions -| [`pixel_shuffle`](generated/torch.nn.functional.pixel_shuffle.html#torch.nn.functional.pixel_shuffle "torch.nn.functional.pixel_shuffle") | 将形状为$(*, C \times r^2, H, W)$(∗,C×r2,H,W)的张量重新排列为形状为$(*, C, H \times r, W \times r)$(∗,C,H×r,W×r)的张量，其中r是`upscale_factor`。 | +| `pixel_shuffle` | 将形状为$(*, C \times r², H, W)$(∗,C×r2,H,W)的张量重新排列为形状为$(*, C, H \times r, W \times r)$(∗,C,H×r,W×r)的张量，其中 r 是`upscale_factor`。 | | --- | --- | -| [`pixel_unshuffle`](generated/torch.nn.functional.pixel_unshuffle.html#torch.nn.functional.pixel_unshuffle "torch.nn.functional.pixel_unshuffle") | 通过将形状为$(*, C, H \times r, W \times r)$(∗,C,H×r,W×r)的张量重新排列为形状为$(*, C \times r^2, H, W)$(∗,C×r2,H,W)的张量，其中r是`downscale_factor`，来反转[`PixelShuffle`](generated/torch.nn.PixelShuffle.html#torch.nn.PixelShuffle "torch.nn.PixelShuffle")操作。 | -| [`pad`](generated/torch.nn.functional.pad.html#torch.nn.functional.pad "torch.nn.functional.pad") | 填充张量。 | -| [`interpolate`](generated/torch.nn.functional.interpolate.html#torch.nn.functional.interpolate "torch.nn.functional.interpolate") | 对输入进行下采样/上采样。 | -| [`upsample`](generated/torch.nn.functional.upsample.html#torch.nn.functional.upsample "torch.nn.functional.upsample") | 上采样输入。 | -| [`upsample_nearest`](generated/torch.nn.functional.upsample_nearest.html#torch.nn.functional.upsample_nearest "torch.nn.functional.upsample_nearest") | 使用最近邻像素值对输入进行上采样。 | -| [`upsample_bilinear`](generated/torch.nn.functional.upsample_bilinear.html#torch.nn.functional.upsample_bilinear "torch.nn.functional.upsample_bilinear") | 使用双线性上采样对输入进行上采样。 | -| [`grid_sample`](generated/torch.nn.functional.grid_sample.html#torch.nn.functional.grid_sample "torch.nn.functional.grid_sample") | 计算网格采样。 | -| [`affine_grid`](generated/torch.nn.functional.affine_grid.html#torch.nn.functional.affine_grid "torch.nn.functional.affine_grid") | 给定一批仿射矩阵`theta`，生成2D或3D流场（采样网格）。 | +| `pixel_unshuffle` | 通过将形状为$(*, C, H \times r, W \times r)$(∗,C,H×r,W×r)的张量重新排列为形状为$(*, C \times r², H, W)$(∗,C×r2,H,W)的张量，其中 r 是`downscale_factor`，来反转`PixelShuffle`操作。 | +| `pad` | 填充张量。 | +| `interpolate` | 对输入进行下采样/上采样。 | +| `upsample` | 上采样输入。 | +| `upsample_nearest` | 使用最近邻像素值对输入进行上采样。 | +| `upsample_bilinear` | 使用双线性上采样对输入进行上采样。 | +| `grid_sample` | 计算网格采样。 | +| `affine_grid` | 给定一批仿射矩阵`theta`，生成 2D 或 3D 流场（采样网格）。 | ## DataParallel functions (multi-GPU, distributed)[](#dataparallel-functions-multi-gpu-distributed "Permalink to this heading") ### data_parallel -| `torch.nn.parallel.data_parallel` | 在给定的device_ids上并行评估模块(input)。 | +| `torch.nn.parallel.data_parallel` | 在给定的 device_ids 上并行评估模块(input)。 | | --- | --- | diff --git a/totrans/doc22_034.md b/totrans/doc22_034.md index 16917595..54dcbe00 100644 --- a/totrans/doc22_034.md +++ b/totrans/doc22_034.md @@ -1,50 +1,50 @@ # torch.Tensor -> 原文：[https://pytorch.org/docs/stable/tensors.html](https://pytorch.org/docs/stable/tensors.html) +> 原文：[`pytorch.org/docs/stable/tensors.html`](https://pytorch.org/docs/stable/tensors.html) -[`torch.Tensor`](#torch.Tensor "torch.Tensor") 是包含单一数据类型元素的多维矩阵。 +`torch.Tensor` 是包含单一数据类型元素的多维矩阵。 ## 数据类型 -Torch定义了10种张量类型，包括CPU和GPU变体，如下所示： +Torch 定义了 10 种张量类型，包括 CPU 和 GPU 变体，如下所示： -| 数据类型 | dtype | CPU张量 | GPU张量 | +| 数据类型 | dtype | CPU 张量 | GPU 张量 | | --- | --- | --- | --- | -| 32位浮点数 | `torch.float32` 或 `torch.float` | `torch.FloatTensor` | `torch.cuda.FloatTensor` | -| 64位浮点数 | `torch.float64` 或 `torch.double` | `torch.DoubleTensor` | `torch.cuda.DoubleTensor` | -| 16位浮点数 [1](#id4) | `torch.float16` 或 `torch.half` | `torch.HalfTensor` | `torch.cuda.HalfTensor` | -| 16位浮点数 [2](#id5) | `torch.bfloat16` | `torch.BFloat16Tensor` | `torch.cuda.BFloat16Tensor` | -| 32位复数 | `torch.complex32` 或 `torch.chalf` | | | -| 64位复数 | `torch.complex64` 或 `torch.cfloat` | | | -| 128位复数 | `torch.complex128` 或 `torch.cdouble` | | | -| 8位整数（无符号） | `torch.uint8` | `torch.ByteTensor` | `torch.cuda.ByteTensor` | -| 8位整数（有符号） | `torch.int8` | `torch.CharTensor` | `torch.cuda.CharTensor` | -| 16位整数（有符号） | `torch.int16` 或 `torch.short` | `torch.ShortTensor` | `torch.cuda.ShortTensor` | -| 32位整数（有符号） | `torch.int32` 或 `torch.int` | `torch.IntTensor` | `torch.cuda.IntTensor` | -| 64位整数（有符号） | `torch.int64` 或 `torch.long` | `torch.LongTensor` | `torch.cuda.LongTensor` | +| 32 位浮点数 | `torch.float32` 或 `torch.float` | `torch.FloatTensor` | `torch.cuda.FloatTensor` | +| 64 位浮点数 | `torch.float64` 或 `torch.double` | `torch.DoubleTensor` | `torch.cuda.DoubleTensor` | +| 16 位浮点数 1 | `torch.float16` 或 `torch.half` | `torch.HalfTensor` | `torch.cuda.HalfTensor` | +| 16 位浮点数 2 | `torch.bfloat16` | `torch.BFloat16Tensor` | `torch.cuda.BFloat16Tensor` | +| 32 位复数 | `torch.complex32` 或 `torch.chalf` | | | +| 64 位复数 | `torch.complex64` 或 `torch.cfloat` | | | +| 128 位复数 | `torch.complex128` 或 `torch.cdouble` | | | +| 8 位整数（无符号） | `torch.uint8` | `torch.ByteTensor` | `torch.cuda.ByteTensor` | +| 8 位整数（有符号） | `torch.int8` | `torch.CharTensor` | `torch.cuda.CharTensor` | +| 16 位整数（有符号） | `torch.int16` 或 `torch.short` | `torch.ShortTensor` | `torch.cuda.ShortTensor` | +| 32 位整数（有符号） | `torch.int32` 或 `torch.int` | `torch.IntTensor` | `torch.cuda.IntTensor` | +| 64 位整数（有符号） | `torch.int64` 或 `torch.long` | `torch.LongTensor` | `torch.cuda.LongTensor` | | 布尔值 | `torch.bool` | `torch.BoolTensor` | `torch.cuda.BoolTensor` | -| 量化的8位整数（无符号） | `torch.quint8` | `torch.ByteTensor` | / | -| 量化的8位整数（有符号） | `torch.qint8` | `torch.CharTensor` | / | -| 量化的32位整数（有符号） | `torch.qint32` | `torch.IntTensor` | / | -| 量化的4位整数（无符号）[3](#id6) | `torch.quint4x2` | `torch.ByteTensor` | / | +| 量化的 8 位整数（无符号） | `torch.quint8` | `torch.ByteTensor` | / | +| 量化的 8 位整数（有符号） | `torch.qint8` | `torch.CharTensor` | / | +| 量化的 32 位整数（有符号） | `torch.qint32` | `torch.IntTensor` | / | +| 量化的 4 位整数（无符号）3 | `torch.quint4x2` | `torch.ByteTensor` | / | -[1](#id1) +1 -有时被称为binary16：使用1个符号位，5个指数位和10个有效位。当精度重要时很有用，但会牺牲范围。 +有时被称为 binary16：使用 1 个符号位，5 个指数位和 10 个有效位。当精度重要时很有用，但会牺牲范围。 -[2](#id2) +2 -有时被称为Brain Floating Point：使用1个符号位，8个指数位和7个有效位。当范围重要时很有用，因为它具有与`float32`相同数量的指数位。 +有时被称为 Brain Floating Point：使用 1 个符号位，8 个指数位和 7 个有效位。当范围重要时很有用，因为它具有与`float32`相同数量的指数位。 -[3](#id3) +3 -量化的4位整数存储为8位有符号整数。目前仅在EmbeddingBag运算符中支持。 +量化的 4 位整数存储为 8 位有符号整数。目前仅在 EmbeddingBag 运算符中支持。 -[`torch.Tensor`](#torch.Tensor "torch.Tensor") 是默认张量类型（`torch.FloatTensor`）的别名。 +`torch.Tensor` 是默认张量类型（`torch.FloatTensor`）的别名。 ## 初始化和基本操作[](#initializing-and-basic-operations "跳转到此标题的永久链接") -可以使用[`torch.tensor()`](generated/torch.tensor.html#torch.tensor "torch.tensor")构造来自Python [`list`](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)") 或序列的张量： +可以使用`torch.tensor()`构造来自 Python [`list`](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)") 或序列的张量： ```py >>> torch.tensor([[1., -1.], [1., -1.]]) @@ -57,9 +57,9 @@ tensor([[ 1, 2, 3], 警告 -[`torch.tensor()`](generated/torch.tensor.html#torch.tensor "torch.tensor") 总是复制`data`。如果您有一个张量`data`，只想改变其`requires_grad`标志，请使用[`requires_grad_()`](generated/torch.Tensor.requires_grad_.html#torch.Tensor.requires_grad_ "torch.Tensor.requires_grad_")或[`detach()`](generated/torch.Tensor.detach.html#torch.Tensor.detach "torch.Tensor.detach")来避免复制。如果您有一个numpy数组并想避免复制，请使用[`torch.as_tensor()`](generated/torch.as_tensor.html#torch.as_tensor "torch.as_tensor")。 +`torch.tensor()` 总是复制`data`。如果您有一个张量`data`，只想改变其`requires_grad`标志，请使用`requires_grad_()`或`detach()`来避免复制。如果您有一个 numpy 数组并想避免复制，请使用`torch.as_tensor()`。 -通过将[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")和/或[`torch.device`](tensor_attributes.html#torch.device "torch.device")传递给构造函数或张量创建操作，可以构造特定数据类型的张量： +通过将`torch.dtype`和/或`torch.device`传递给构造函数或张量创建操作，可以构造特定数据类型的张量： ```py >>> torch.zeros([2, 4], dtype=torch.int32) @@ -71,9 +71,9 @@ tensor([[ 1.0000, 1.0000, 1.0000, 1.0000], [ 1.0000, 1.0000, 1.0000, 1.0000]], dtype=torch.float64, device='cuda:0') ``` -有关构建张量的更多信息，请参阅[Creation Ops](torch.html#tensor-creation-ops) +有关构建张量的更多信息，请参阅 Creation Ops -可以使用Python的索引和切片表示法访问和修改张量的内容： +可以使用 Python 的索引和切片表示法访问和修改张量的内容： ```py >>> x = torch.tensor([[1, 2, 3], [4, 5, 6]]) @@ -85,7 +85,7 @@ tensor([[ 1, 8, 3], [ 4, 5, 6]]) ``` -使用 [`torch.Tensor.item()`](generated/torch.Tensor.item.html#torch.Tensor.item "torch.Tensor.item") 从包含单个值的张量中获取一个Python数字： +使用 `torch.Tensor.item()` 从包含单个值的张量中获取一个 Python 数字： ```py >>> x = torch.tensor([[1]]) @@ -100,9 +100,9 @@ tensor(2.5000) 2.5 ``` -有关索引的更多信息，请参见 [Indexing, Slicing, Joining, Mutating Ops](torch.html#indexing-slicing-joining)。 +有关索引的更多信息，请参见 Indexing, Slicing, Joining, Mutating Ops。 -可以创建一个带有 `requires_grad=True` 的张量，以便 [`torch.autograd`](autograd.html#module-torch.autograd "torch.autograd") 记录对它们的操作以进行自动微分。 +可以创建一个带有 `requires_grad=True` 的张量，以便 `torch.autograd` 记录对它们的操作以进行自动微分。 ```py >>> x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True) @@ -117,11 +117,11 @@ tensor([[ 2.0000, -2.0000], 注意 -有关张量视图的更多信息，请参见 [Tensor Views](tensor_view.html#tensor-view-doc)。 +有关张量视图的更多信息，请参见 Tensor Views。 注意 -有关 [`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")、[`torch.device`](tensor_attributes.html#torch.device "torch.device") 和 [`torch.layout`](tensor_attributes.html#torch.layout "torch.layout") 属性的更多信息，请参见 [`torch.Tensor`](#torch.Tensor "torch.Tensor") 的 [Tensor Attributes](tensor_attributes.html#tensor-attributes-doc)。 +有关 `torch.dtype`、`torch.device` 和 `torch.layout` 属性的更多信息，请参见 `torch.Tensor` 的 Tensor Attributes。 注意 @@ -129,11 +129,11 @@ tensor([[ 2.0000, -2.0000], 注意 -要更改现有张量的 [`torch.device`](tensor_attributes.html#torch.device "torch.device") 和/或 [`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")，请考虑在张量上使用 [`to()`](generated/torch.Tensor.to.html#torch.Tensor.to "torch.Tensor.to") 方法。 +要更改现有张量的 `torch.device` 和/或 `torch.dtype`，请考虑在张量上使用 `to()` 方法。 警告 -当前的 [`torch.Tensor`](#torch.Tensor "torch.Tensor") 实现引入了内存开销，因此在具有许多小张量的应用程序中可能导致意外高的内存使用量。如果这是您的情况，请考虑使用一个大结构。 +当前的 `torch.Tensor` 实现引入了内存开销，因此在具有许多小张量的应用程序中可能导致意外高的内存使用量。如果这是您的情况，请考虑使用一个大结构。 ## 张量类参考 @@ -143,11 +143,11 @@ class torch.Tensor¶ 有几种主要方法可以创建张量，取决于您的用例。 -+ 要使用预先存在的数据创建张量，请使用 [`torch.tensor()`](generated/torch.tensor.html#torch.tensor "torch.tensor")。 ++ 要使用预先存在的数据创建张量，请使用 `torch.tensor()`。 -+ 要创建特定大小的张量，请使用 `torch.*` 张量创建操作（参见 [Creation Ops](torch.html#tensor-creation-ops)）。 ++ 要创建特定大小的张量，请使用 `torch.*` 张量创建操作（参见 Creation Ops）。 -+ 要创建一个与另一个张量相同大小（和相似类型）的张量，请使用 `torch.*_like` 张量创建操作（参见 [Creation Ops](torch.html#tensor-creation-ops)）。 ++ 要创建一个与另一个张量相同大小（和相似类型）的张量，请使用 `torch.*_like` 张量创建操作（参见 Creation Ops）。 + 要创建一个与另一个张量相似类型但不同大小的张量，请使用 `tensor.new_*` 创建操作。 @@ -161,19 +161,19 @@ Tensor.T¶ 警告 -在维度不为2的张量上使用 [`Tensor.T()`](#torch.Tensor.T "torch.Tensor.T") 来颠倒它们的形状已被弃用，并且在将来的版本中会引发错误。考虑使用 [`mT`](#torch.Tensor.mT "torch.Tensor.mT") 来转置矩阵批次或者使用 x.permute(*torch.arange(x.ndim - 1, -1, -1)) 来颠倒张量的维度。 +在维度不为 2 的张量上使用 `Tensor.T()` 来颠倒它们的形状已被弃用，并且在将来的版本中会引发错误。考虑使用 `mT` 来转置矩阵批次或者使用 x.permute(*torch.arange(x.ndim - 1, -1, -1)) 来颠倒张量的维度。 ```py Tensor.H¶ ``` -返回一个共轭和转置的矩阵（2-D张量）视图。 +返回一个共轭和转置的矩阵（2-D 张量）视图。 对于复杂矩阵，`x.H` 等同于 `x.transpose(0, 1).conj()`，对于实矩阵，`x.H` 等同于 `x.transpose(0, 1)`。 另请参阅 -[`mH`](#torch.Tensor.mH "torch.Tensor.mH")：也适用于矩阵批次的属性。 +`mH`：也适用于矩阵批次的属性。 ```py Tensor.mT¶ @@ -187,538 +187,538 @@ Tensor.mT¶ Tensor.mH¶ ``` -访问此属性等同于调用 [`adjoint()`](generated/torch.adjoint.html#torch.adjoint "torch.adjoint")。 +访问此属性等同于调用 `adjoint()`。 -| [`Tensor.new_tensor`](generated/torch.Tensor.new_tensor.html#torch.Tensor.new_tensor "torch.Tensor.new_tensor") | 返回一个以 `data` 为张量数据的新张量。 | +| `Tensor.new_tensor` | 返回一个以 `data` 为张量数据的新张量。 | | --- | --- | -| [`Tensor.new_full`](generated/torch.Tensor.new_full.html#torch.Tensor.new_full "torch.Tensor.new_full") | 返回一个大小为`size`且填充为`fill_value`的张量。 | -| [`Tensor.new_empty`](generated/torch.Tensor.new_empty.html#torch.Tensor.new_empty "torch.Tensor.new_empty") | 返回一个大小为`size`且填充为未初始化数据的张量。 | -| [`Tensor.new_ones`](generated/torch.Tensor.new_ones.html#torch.Tensor.new_ones "torch.Tensor.new_ones") | 返回一个大小为`size`且填充为`1`的张量。 | -| [`Tensor.new_zeros`](generated/torch.Tensor.new_zeros.html#torch.Tensor.new_zeros "torch.Tensor.new_zeros") | 返回一个大小为`size`且填充为`0`的张量。 | -| [`Tensor.is_cuda`](generated/torch.Tensor.is_cuda.html#torch.Tensor.is_cuda "torch.Tensor.is_cuda") | 如果张量存储在GPU上，则为`True`，否则为`False`。 | -| [`Tensor.is_quantized`](generated/torch.Tensor.is_quantized.html#torch.Tensor.is_quantized "torch.Tensor.is_quantized") | 如果张量是量化的，则为`True`，否则为`False`。 | -| [`Tensor.is_meta`](generated/torch.Tensor.is_meta.html#torch.Tensor.is_meta "torch.Tensor.is_meta") | 如果张量是元张量，则为`True`，否则为`False`。 | -| [`Tensor.device`](generated/torch.Tensor.device.html#torch.Tensor.device "torch.Tensor.device") | 此张量所在的[`torch.device`](tensor_attributes.html#torch.device "torch.device")。 | -| [`Tensor.grad`](generated/torch.Tensor.grad.html#torch.Tensor.grad "torch.Tensor.grad") | 默认情况下，此属性为`None`，第一次调用`backward()`计算`self`的梯度时会变成一个张量。 | -| [`Tensor.ndim`](generated/torch.Tensor.ndim.html#torch.Tensor.ndim "torch.Tensor.ndim") | [`dim()`](generated/torch.Tensor.dim.html#torch.Tensor.dim "torch.Tensor.dim")的别名 | -| [`Tensor.real`](generated/torch.Tensor.real.html#torch.Tensor.real "torch.Tensor.real") | 返回一个包含复值输入张量`self`的实部值的新张量。 | -| [`Tensor.imag`](generated/torch.Tensor.imag.html#torch.Tensor.imag "torch.Tensor.imag") | 返回一个包含`self`张量的虚部值的新张量。 | -| [`Tensor.nbytes`](generated/torch.Tensor.nbytes.html#torch.Tensor.nbytes "torch.Tensor.nbytes") | 如果张量不使用稀疏存储布局，则返回张量元素“视图”消耗的字节数。 | -| [`Tensor.itemsize`](generated/torch.Tensor.itemsize.html#torch.Tensor.itemsize "torch.Tensor.itemsize") | [`element_size()`](generated/torch.Tensor.element_size.html#torch.Tensor.element_size "torch.Tensor.element_size")的别名 | -| [`Tensor.abs`](generated/torch.Tensor.abs.html#torch.Tensor.abs "torch.Tensor.abs") | 参见[`torch.abs()`](generated/torch.abs.html#torch.abs "torch.abs") | -| [`Tensor.abs_`](generated/torch.Tensor.abs_.html#torch.Tensor.abs_ "torch.Tensor.abs_") | [`abs()`](generated/torch.Tensor.abs.html#torch.Tensor.abs "torch.Tensor.abs")的原地版本 | -| [`Tensor.absolute`](generated/torch.Tensor.absolute.html#torch.Tensor.absolute "torch.Tensor.absolute") | [`abs()`](generated/torch.abs.html#torch.abs "torch.abs")的别名 | -| [`Tensor.absolute_`](generated/torch.Tensor.absolute_.html#torch.Tensor.absolute_ "torch.Tensor.absolute_") | [`absolute()`](generated/torch.Tensor.absolute.html#torch.Tensor.absolute "torch.Tensor.absolute")的原地版本，别名为`abs_()` | -| [`Tensor.acos`](generated/torch.Tensor.acos.html#torch.Tensor.acos "torch.Tensor.acos") | 参见[`torch.acos()`](generated/torch.acos.html#torch.acos "torch.acos") | -| [`Tensor.acos_`](generated/torch.Tensor.acos_.html#torch.Tensor.acos_ "torch.Tensor.acos_") | [`acos()`](generated/torch.Tensor.acos.html#torch.Tensor.acos "torch.Tensor.acos")的原地版本 | -| [`Tensor.arccos`](generated/torch.Tensor.arccos.html#torch.Tensor.arccos "torch.Tensor.arccos") | 参见[`torch.arccos()`](generated/torch.arccos.html#torch.arccos "torch.arccos") | -| [`Tensor.arccos_`](generated/torch.Tensor.arccos_.html#torch.Tensor.arccos_ "torch.Tensor.arccos_") | [`arccos()`](generated/torch.Tensor.arccos.html#torch.Tensor.arccos "torch.Tensor.arccos") 的原地版本 | -| [`Tensor.add`](generated/torch.Tensor.add.html#torch.Tensor.add "torch.Tensor.add") | 将标量或张量添加到 `self` 张量中。 | -| [`Tensor.add_`](generated/torch.Tensor.add_.html#torch.Tensor.add_ "torch.Tensor.add_") | [`add()`](generated/torch.Tensor.add.html#torch.Tensor.add "torch.Tensor.add") 的原地版本 | -| [`Tensor.addbmm`](generated/torch.Tensor.addbmm.html#torch.Tensor.addbmm "torch.Tensor.addbmm") | 查看 [`torch.addbmm()`](generated/torch.addbmm.html#torch.addbmm "torch.addbmm") | -| [`Tensor.addbmm_`](generated/torch.Tensor.addbmm_.html#torch.Tensor.addbmm_ "torch.Tensor.addbmm_") | [`addbmm()`](generated/torch.Tensor.addbmm.html#torch.Tensor.addbmm "torch.Tensor.addbmm") 的原地版本 | -| [`Tensor.addcdiv`](generated/torch.Tensor.addcdiv.html#torch.Tensor.addcdiv "torch.Tensor.addcdiv") | 查看 [`torch.addcdiv()`](generated/torch.addcdiv.html#torch.addcdiv "torch.addcdiv") | -| [`Tensor.addcdiv_`](generated/torch.Tensor.addcdiv_.html#torch.Tensor.addcdiv_ "torch.Tensor.addcdiv_") | [`addcdiv()`](generated/torch.Tensor.addcdiv.html#torch.Tensor.addcdiv "torch.Tensor.addcdiv") 的原地版本 | -| [`Tensor.addcmul`](generated/torch.Tensor.addcmul.html#torch.Tensor.addcmul "torch.Tensor.addcmul") | 查看 [`torch.addcmul()`](generated/torch.addcmul.html#torch.addcmul "torch.addcmul") | -| [`Tensor.addcmul_`](generated/torch.Tensor.addcmul_.html#torch.Tensor.addcmul_ "torch.Tensor.addcmul_") | [`addcmul()`](generated/torch.Tensor.addcmul.html#torch.Tensor.addcmul "torch.Tensor.addcmul") 的原地版本 | -| [`Tensor.addmm`](generated/torch.Tensor.addmm.html#torch.Tensor.addmm "torch.Tensor.addmm") | 查看 [`torch.addmm()`](generated/torch.addmm.html#torch.addmm "torch.addmm") | -| [`Tensor.addmm_`](generated/torch.Tensor.addmm_.html#torch.Tensor.addmm_ "torch.Tensor.addmm_") | [`addmm()`](generated/torch.Tensor.addmm.html#torch.Tensor.addmm "torch.Tensor.addmm") 的原地版本 | -| [`Tensor.sspaddmm`](generated/torch.Tensor.sspaddmm.html#torch.Tensor.sspaddmm "torch.Tensor.sspaddmm") | 查看 [`torch.sspaddmm()`](generated/torch.sspaddmm.html#torch.sspaddmm "torch.sspaddmm") | -| [`Tensor.addmv`](generated/torch.Tensor.addmv.html#torch.Tensor.addmv "torch.Tensor.addmv") | 查看 [`torch.addmv()`](generated/torch.addmv.html#torch.addmv "torch.addmv") | -| [`Tensor.addmv_`](generated/torch.Tensor.addmv_.html#torch.Tensor.addmv_ "torch.Tensor.addmv_") | [`addmv()`](generated/torch.Tensor.addmv.html#torch.Tensor.addmv "torch.Tensor.addmv") 的原地版本 | -| [`Tensor.addr`](generated/torch.Tensor.addr.html#torch.Tensor.addr "torch.Tensor.addr") | 查看 [`torch.addr()`](generated/torch.addr.html#torch.addr "torch.addr") | -| [`Tensor.addr_`](generated/torch.Tensor.addr_.html#torch.Tensor.addr_ "torch.Tensor.addr_") | [`addr()`](generated/torch.Tensor.addr.html#torch.Tensor.addr "torch.Tensor.addr") 的原地版本 | -| [`Tensor.adjoint`](generated/torch.Tensor.adjoint.html#torch.Tensor.adjoint "torch.Tensor.adjoint") | [`adjoint()`](generated/torch.adjoint.html#torch.adjoint "torch.adjoint") 的别名 | -| [`Tensor.allclose`](generated/torch.Tensor.allclose.html#torch.Tensor.allclose "torch.Tensor.allclose") | 查看 [`torch.allclose()`](generated/torch.allclose.html#torch.allclose "torch.allclose") | -| [`Tensor.amax`](generated/torch.Tensor.amax.html#torch.Tensor.amax "torch.Tensor.amax") | 查看 [`torch.amax()`](generated/torch.amax.html#torch.amax "torch.amax") | -| [`Tensor.amin`](generated/torch.Tensor.amin.html#torch.Tensor.amin "torch.Tensor.amin") | 查看 [`torch.amin()`](generated/torch.amin.html#torch.amin "torch.amin") | -| [`Tensor.aminmax`](generated/torch.Tensor.aminmax.html#torch.Tensor.aminmax "torch.Tensor.aminmax") | 参见 [`torch.aminmax()`](generated/torch.aminmax.html#torch.aminmax "torch.aminmax") | -| [`Tensor.angle`](generated/torch.Tensor.angle.html#torch.Tensor.angle "torch.Tensor.angle") | 参见 [`torch.angle()`](generated/torch.angle.html#torch.angle "torch.angle") | -| [`Tensor.apply_`](generated/torch.Tensor.apply_.html#torch.Tensor.apply_ "torch.Tensor.apply_") | 将函数 `callable` 应用于张量中的每个元素，用 `callable` 返回的值替换每个元素。 | -| [`Tensor.argmax`](generated/torch.Tensor.argmax.html#torch.Tensor.argmax "torch.Tensor.argmax") | 参见 [`torch.argmax()`](generated/torch.argmax.html#torch.argmax "torch.argmax") | -| [`Tensor.argmin`](generated/torch.Tensor.argmin.html#torch.Tensor.argmin "torch.Tensor.argmin") | 参见 [`torch.argmin()`](generated/torch.argmin.html#torch.argmin "torch.argmin") | -| [`Tensor.argsort`](generated/torch.Tensor.argsort.html#torch.Tensor.argsort "torch.Tensor.argsort") | 参见 [`torch.argsort()`](generated/torch.argsort.html#torch.argsort "torch.argsort") | -| [`Tensor.argwhere`](generated/torch.Tensor.argwhere.html#torch.Tensor.argwhere "torch.Tensor.argwhere") | 参见 [`torch.argwhere()`](generated/torch.argwhere.html#torch.argwhere "torch.argwhere") | -| [`Tensor.asin`](generated/torch.Tensor.asin.html#torch.Tensor.asin "torch.Tensor.asin") | 参见 [`torch.asin()`](generated/torch.asin.html#torch.asin "torch.asin") | -| [`Tensor.asin_`](generated/torch.Tensor.asin_.html#torch.Tensor.asin_ "torch.Tensor.asin_") | [`asin()`](generated/torch.Tensor.asin.html#torch.Tensor.asin "torch.Tensor.asin") 的原地版本 | -| [`Tensor.arcsin`](generated/torch.Tensor.arcsin.html#torch.Tensor.arcsin "torch.Tensor.arcsin") | 参见 [`torch.arcsin()`](generated/torch.arcsin.html#torch.arcsin "torch.arcsin") | -| [`Tensor.arcsin_`](generated/torch.Tensor.arcsin_.html#torch.Tensor.arcsin_ "torch.Tensor.arcsin_") | [`arcsin()`](generated/torch.Tensor.arcsin.html#torch.Tensor.arcsin "torch.Tensor.arcsin") 的原地版本 | -| [`Tensor.as_strided`](generated/torch.Tensor.as_strided.html#torch.Tensor.as_strided "torch.Tensor.as_strided") | 参见 [`torch.as_strided()`](generated/torch.as_strided.html#torch.as_strided "torch.as_strided") | -| [`Tensor.atan`](generated/torch.Tensor.atan.html#torch.Tensor.atan "torch.Tensor.atan") | 参见 [`torch.atan()`](generated/torch.atan.html#torch.atan "torch.atan") | -| [`Tensor.atan_`](generated/torch.Tensor.atan_.html#torch.Tensor.atan_ "torch.Tensor.atan_") | [`atan()`](generated/torch.Tensor.atan.html#torch.Tensor.atan "torch.Tensor.atan") 的原地版本 | -| [`Tensor.arctan`](generated/torch.Tensor.arctan.html#torch.Tensor.arctan "torch.Tensor.arctan") | 参见 [`torch.arctan()`](generated/torch.arctan.html#torch.arctan "torch.arctan") | -| [`Tensor.arctan_`](generated/torch.Tensor.arctan_.html#torch.Tensor.arctan_ "torch.Tensor.arctan_") | [`arctan()`](generated/torch.Tensor.arctan.html#torch.Tensor.arctan "torch.Tensor.arctan") 的原地版本 | -| [`Tensor.atan2`](generated/torch.Tensor.atan2.html#torch.Tensor.atan2 "torch.Tensor.atan2") | 参见 [`torch.atan2()`](generated/torch.atan2.html#torch.atan2 "torch.atan2") | -| [`Tensor.atan2_`](generated/torch.Tensor.atan2_.html#torch.Tensor.atan2_ "torch.Tensor.atan2_") | [`atan2()`](generated/torch.Tensor.atan2.html#torch.Tensor.atan2 "torch.Tensor.atan2") 的原地版本 | -| [`Tensor.arctan2`](generated/torch.Tensor.arctan2.html#torch.Tensor.arctan2 "torch.Tensor.arctan2") | 参见 [`torch.arctan2()`](generated/torch.arctan2.html#torch.arctan2 "torch.arctan2") | -| [`Tensor.arctan2_`](generated/torch.Tensor.arctan2_.html#torch.Tensor.arctan2_ "torch.Tensor.arctan2_") | atan2_(other) -> Tensor | -| [`Tensor.all`](generated/torch.Tensor.all.html#torch.Tensor.all "torch.Tensor.all") | 参见 [`torch.all()`](generated/torch.all.html#torch.all "torch.all") | -| [`Tensor.any`](generated/torch.Tensor.any.html#torch.Tensor.any "torch.Tensor.any") | 查看 [`torch.any()`](generated/torch.any.html#torch.any "torch.any") | -| [`Tensor.backward`](generated/torch.Tensor.backward.html#torch.Tensor.backward "torch.Tensor.backward") | 计算当前张量相对于图中叶子节点的梯度。 | -| [`Tensor.baddbmm`](generated/torch.Tensor.baddbmm.html#torch.Tensor.baddbmm "torch.Tensor.baddbmm") | 查看 [`torch.baddbmm()`](generated/torch.baddbmm.html#torch.baddbmm "torch.baddbmm") | -| [`Tensor.baddbmm_`](generated/torch.Tensor.baddbmm_.html#torch.Tensor.baddbmm_ "torch.Tensor.baddbmm_") | [`baddbmm()`](generated/torch.Tensor.baddbmm.html#torch.Tensor.baddbmm "torch.Tensor.baddbmm") 的原地版本 | -| [`Tensor.bernoulli`](generated/torch.Tensor.bernoulli.html#torch.Tensor.bernoulli "torch.Tensor.bernoulli") | 返回一个结果张量，其中每个 $\texttt{result[i]}$ 从 $\text{Bernoulli}(\texttt{self[i]})$ 独立采样。 | -| [`Tensor.bernoulli_`](generated/torch.Tensor.bernoulli_.html#torch.Tensor.bernoulli_ "torch.Tensor.bernoulli_") | 用来自 $\text{Bernoulli}(\texttt{p})$ 的独立样本填充 `self` 的每个位置。 | -| [`Tensor.bfloat16`](generated/torch.Tensor.bfloat16.html#torch.Tensor.bfloat16 "torch.Tensor.bfloat16") | `self.bfloat16()` 等同于 `self.to(torch.bfloat16)`。 | -| [`Tensor.bincount`](generated/torch.Tensor.bincount.html#torch.Tensor.bincount "torch.Tensor.bincount") | 查看 [`torch.bincount()`](generated/torch.bincount.html#torch.bincount "torch.bincount") | -| [`Tensor.bitwise_not`](generated/torch.Tensor.bitwise_not.html#torch.Tensor.bitwise_not "torch.Tensor.bitwise_not") | 查看 [`torch.bitwise_not()`](generated/torch.bitwise_not.html#torch.bitwise_not "torch.bitwise_not") | -| [`Tensor.bitwise_not_`](generated/torch.Tensor.bitwise_not_.html#torch.Tensor.bitwise_not_ "torch.Tensor.bitwise_not_") | [`bitwise_not()`](generated/torch.Tensor.bitwise_not.html#torch.Tensor.bitwise_not "torch.Tensor.bitwise_not") 的原地版本 | -| [`Tensor.bitwise_and`](generated/torch.Tensor.bitwise_and.html#torch.Tensor.bitwise_and "torch.Tensor.bitwise_and") | 查看 [`torch.bitwise_and()`](generated/torch.bitwise_and.html#torch.bitwise_and "torch.bitwise_and") | -| [`Tensor.bitwise_and_`](generated/torch.Tensor.bitwise_and_.html#torch.Tensor.bitwise_and_ "torch.Tensor.bitwise_and_") | [`bitwise_and()`](generated/torch.Tensor.bitwise_and.html#torch.Tensor.bitwise_and "torch.Tensor.bitwise_and") 的原地版本 | -| [`Tensor.bitwise_or`](generated/torch.Tensor.bitwise_or.html#torch.Tensor.bitwise_or "torch.Tensor.bitwise_or") | 查看 [`torch.bitwise_or()`](generated/torch.bitwise_or.html#torch.bitwise_or "torch.bitwise_or") | -| [`Tensor.bitwise_or_`](generated/torch.Tensor.bitwise_or_.html#torch.Tensor.bitwise_or_ "torch.Tensor.bitwise_or_") | [`bitwise_or()`](generated/torch.Tensor.bitwise_or.html#torch.Tensor.bitwise_or "torch.Tensor.bitwise_or") 的原地版本 | -| [`Tensor.bitwise_xor`](generated/torch.Tensor.bitwise_xor.html#torch.Tensor.bitwise_xor "torch.Tensor.bitwise_xor") | 查看 [`torch.bitwise_xor()`](generated/torch.bitwise_xor.html#torch.bitwise_xor "torch.bitwise_xor") | -| [`Tensor.bitwise_xor_`](generated/torch.Tensor.bitwise_xor_.html#torch.Tensor.bitwise_xor_ "torch.Tensor.bitwise_xor_") | [`bitwise_xor()`](generated/torch.Tensor.bitwise_xor.html#torch.Tensor.bitwise_xor "torch.Tensor.bitwise_xor") 的原地版本 | -| [`Tensor.bitwise_left_shift`](generated/torch.Tensor.bitwise_left_shift.html#torch.Tensor.bitwise_left_shift "torch.Tensor.bitwise_left_shift") | 查看 [`torch.bitwise_left_shift()`](generated/torch.bitwise_left_shift.html#torch.bitwise_left_shift "torch.bitwise_left_shift") | -| [`Tensor.bitwise_left_shift_`](generated/torch.Tensor.bitwise_left_shift_.html#torch.Tensor.bitwise_left_shift_ "torch.Tensor.bitwise_left_shift_") | [`bitwise_left_shift()`](generated/torch.Tensor.bitwise_left_shift.html#torch.Tensor.bitwise_left_shift "torch.Tensor.bitwise_left_shift") 的原地版本 | -| [`Tensor.bitwise_right_shift`](generated/torch.Tensor.bitwise_right_shift.html#torch.Tensor.bitwise_right_shift "torch.Tensor.bitwise_right_shift") | 参见 [`torch.bitwise_right_shift()`](generated/torch.bitwise_right_shift.html#torch.bitwise_right_shift "torch.bitwise_right_shift") | -| [`Tensor.bitwise_right_shift_`](generated/torch.Tensor.bitwise_right_shift_.html#torch.Tensor.bitwise_right_shift_ "torch.Tensor.bitwise_right_shift_") | [`bitwise_right_shift()`](generated/torch.Tensor.bitwise_right_shift.html#torch.Tensor.bitwise_right_shift "torch.Tensor.bitwise_right_shift") 的原地版本 | -| [`Tensor.bmm`](generated/torch.Tensor.bmm.html#torch.Tensor.bmm "torch.Tensor.bmm") | 参见 [`torch.bmm()`](generated/torch.bmm.html#torch.bmm "torch.bmm") | -| [`Tensor.bool`](generated/torch.Tensor.bool.html#torch.Tensor.bool "torch.Tensor.bool") | `self.bool()` 等同于 `self.to(torch.bool)`。 | -| [`Tensor.byte`](generated/torch.Tensor.byte.html#torch.Tensor.byte "torch.Tensor.byte") | `self.byte()` 等同于 `self.to(torch.uint8)`。 | -| [`Tensor.broadcast_to`](generated/torch.Tensor.broadcast_to.html#torch.Tensor.broadcast_to "torch.Tensor.broadcast_to") | 参见 [`torch.broadcast_to()`](generated/torch.broadcast_to.html#torch.broadcast_to "torch.broadcast_to"). | -| [`Tensor.cauchy_`](generated/torch.Tensor.cauchy_.html#torch.Tensor.cauchy_ "torch.Tensor.cauchy_") | 用从 Cauchy 分布中抽取的数字填充张量： | -| [`Tensor.ceil`](generated/torch.Tensor.ceil.html#torch.Tensor.ceil "torch.Tensor.ceil") | 参见 [`torch.ceil()`](generated/torch.ceil.html#torch.ceil "torch.ceil") | -| [`Tensor.ceil_`](generated/torch.Tensor.ceil_.html#torch.Tensor.ceil_ "torch.Tensor.ceil_") | [`ceil()`](generated/torch.Tensor.ceil.html#torch.Tensor.ceil "torch.Tensor.ceil") 的原地版本 | -| [`Tensor.char`](generated/torch.Tensor.char.html#torch.Tensor.char "torch.Tensor.char") | `self.char()` 等同于 `self.to(torch.int8)`。 | -| [`Tensor.cholesky`](generated/torch.Tensor.cholesky.html#torch.Tensor.cholesky "torch.Tensor.cholesky") | 参见 [`torch.cholesky()`](generated/torch.cholesky.html#torch.cholesky "torch.cholesky") | -| [`Tensor.cholesky_inverse`](generated/torch.Tensor.cholesky_inverse.html#torch.Tensor.cholesky_inverse "torch.Tensor.cholesky_inverse") | 参见 [`torch.cholesky_inverse()`](generated/torch.cholesky_inverse.html#torch.cholesky_inverse "torch.cholesky_inverse") | -| [`Tensor.cholesky_solve`](generated/torch.Tensor.cholesky_solve.html#torch.Tensor.cholesky_solve "torch.Tensor.cholesky_solve") | 参见 [`torch.cholesky_solve()`](generated/torch.cholesky_solve.html#torch.cholesky_solve "torch.cholesky_solve") | -| [`Tensor.chunk`](generated/torch.Tensor.chunk.html#torch.Tensor.chunk "torch.Tensor.chunk") | 参见 [`torch.chunk()`](generated/torch.chunk.html#torch.chunk "torch.chunk") | -| [`Tensor.clamp`](generated/torch.Tensor.clamp.html#torch.Tensor.clamp "torch.Tensor.clamp") | 参见 [`torch.clamp()`](generated/torch.clamp.html#torch.clamp "torch.clamp") | -| [`Tensor.clamp_`](generated/torch.Tensor.clamp_.html#torch.Tensor.clamp_ "torch.Tensor.clamp_") | [`clamp()`](generated/torch.Tensor.clamp.html#torch.Tensor.clamp "torch.Tensor.clamp") 的原地版本 | -| [`Tensor.clip`](generated/torch.Tensor.clip.html#torch.Tensor.clip "torch.Tensor.clip") | [`clamp()`](generated/torch.Tensor.clamp.html#torch.Tensor.clamp "torch.Tensor.clamp") 的别名 | -| [`Tensor.clip_`](generated/torch.Tensor.clip_.html#torch.Tensor.clip_ "torch.Tensor.clip_") | [`clamp_()`](generated/torch.Tensor.clamp_.html#torch.Tensor.clamp_ "torch.Tensor.clamp_") 的别名。 | -| [`Tensor.clone`](generated/torch.Tensor.clone.html#torch.Tensor.clone "torch.Tensor.clone") | 查看 [`torch.clone()`](generated/torch.clone.html#torch.clone "torch.clone") | -| [`Tensor.contiguous`](generated/torch.Tensor.contiguous.html#torch.Tensor.contiguous "torch.Tensor.contiguous") | 返回一个包含与 `self` 张量相同数据的内存连续张量 | -| [`Tensor.copy_`](generated/torch.Tensor.copy_.html#torch.Tensor.copy_ "torch.Tensor.copy_") | 将 `src` 中的元素复制到 `self` 张量中并返回 `self` | -| [`Tensor.conj`](generated/torch.Tensor.conj.html#torch.Tensor.conj "torch.Tensor.conj") | 查看 [`torch.conj()`](generated/torch.conj.html#torch.conj "torch.conj") | -| [`Tensor.conj_physical`](generated/torch.Tensor.conj_physical.html#torch.Tensor.conj_physical "torch.Tensor.conj_physical") | 查看 [`torch.conj_physical()`](generated/torch.conj_physical.html#torch.conj_physical "torch.conj_physical") | -| [`Tensor.conj_physical_`](generated/torch.Tensor.conj_physical_.html#torch.Tensor.conj_physical_ "torch.Tensor.conj_physical_") | [`conj_physical()`](generated/torch.Tensor.conj_physical.html#torch.Tensor.conj_physical "torch.Tensor.conj_physical") 的原地版本 | -| [`Tensor.resolve_conj`](generated/torch.Tensor.resolve_conj.html#torch.Tensor.resolve_conj "torch.Tensor.resolve_conj") | 查看 [`torch.resolve_conj()`](generated/torch.resolve_conj.html#torch.resolve_conj "torch.resolve_conj") | -| [`Tensor.resolve_neg`](generated/torch.Tensor.resolve_neg.html#torch.Tensor.resolve_neg "torch.Tensor.resolve_neg") | 查看 [`torch.resolve_neg()`](generated/torch.resolve_neg.html#torch.resolve_neg "torch.resolve_neg") | -| [`Tensor.copysign`](generated/torch.Tensor.copysign.html#torch.Tensor.copysign "torch.Tensor.copysign") | 查看 [`torch.copysign()`](generated/torch.copysign.html#torch.copysign "torch.copysign") | -| [`Tensor.copysign_`](generated/torch.Tensor.copysign_.html#torch.Tensor.copysign_ "torch.Tensor.copysign_") | [`copysign()`](generated/torch.Tensor.copysign.html#torch.Tensor.copysign "torch.Tensor.copysign") 的原地版本 | -| [`Tensor.cos`](generated/torch.Tensor.cos.html#torch.Tensor.cos "torch.Tensor.cos") | 查看 [`torch.cos()`](generated/torch.cos.html#torch.cos "torch.cos") | -| [`Tensor.cos_`](generated/torch.Tensor.cos_.html#torch.Tensor.cos_ "torch.Tensor.cos_") | [`cos()`](generated/torch.Tensor.cos.html#torch.Tensor.cos "torch.Tensor.cos") 的原地版本 | -| [`Tensor.cosh`](generated/torch.Tensor.cosh.html#torch.Tensor.cosh "torch.Tensor.cosh") | 查看 [`torch.cosh()`](generated/torch.cosh.html#torch.cosh "torch.cosh") | -| [`Tensor.cosh_`](generated/torch.Tensor.cosh_.html#torch.Tensor.cosh_ "torch.Tensor.cosh_") | [`cosh()`](generated/torch.Tensor.cosh.html#torch.Tensor.cosh "torch.Tensor.cosh") 的原地版本 | -| [`Tensor.corrcoef`](generated/torch.Tensor.corrcoef.html#torch.Tensor.corrcoef "torch.Tensor.corrcoef") | 查看 [`torch.corrcoef()`](generated/torch.corrcoef.html#torch.corrcoef "torch.corrcoef") | -| [`Tensor.count_nonzero`](generated/torch.Tensor.count_nonzero.html#torch.Tensor.count_nonzero "torch.Tensor.count_nonzero") | 查看 [`torch.count_nonzero()`](generated/torch.count_nonzero.html#torch.count_nonzero "torch.count_nonzero") | -| [`Tensor.cov`](generated/torch.Tensor.cov.html#torch.Tensor.cov "torch.Tensor.cov") | 查看 [`torch.cov()`](generated/torch.cov.html#torch.cov "torch.cov") | -| [`Tensor.acosh`](generated/torch.Tensor.acosh.html#torch.Tensor.acosh "torch.Tensor.acosh") | 查看 [`torch.acosh()`](generated/torch.acosh.html#torch.acosh "torch.acosh") | -| [`Tensor.acosh_`](generated/torch.Tensor.acosh_.html#torch.Tensor.acosh_ "torch.Tensor.acosh_") | [`acosh()`](generated/torch.Tensor.acosh.html#torch.Tensor.acosh "torch.Tensor.acosh") 的原地版本 | -| [`Tensor.arccosh`](generated/torch.Tensor.arccosh.html#torch.Tensor.arccosh "torch.Tensor.arccosh") | acosh() -> Tensor | -| [`Tensor.arccosh_`](generated/torch.Tensor.arccosh_.html#torch.Tensor.arccosh_ "torch.Tensor.arccosh_") | acosh_() -> Tensor | -| [`Tensor.cpu`](generated/torch.Tensor.cpu.html#torch.Tensor.cpu "torch.Tensor.cpu") | 返回此对象在CPU内存中的副本 | -| [`Tensor.cross`](generated/torch.Tensor.cross.html#torch.Tensor.cross "torch.Tensor.cross") | 参见`torch.cross()` | -| [`Tensor.cuda`](generated/torch.Tensor.cuda.html#torch.Tensor.cuda "torch.Tensor.cuda") | 返回此对象在CUDA内存中的副本 | -| [`Tensor.logcumsumexp`](generated/torch.Tensor.logcumsumexp.html#torch.Tensor.logcumsumexp "torch.Tensor.logcumsumexp") | 参见`torch.logcumsumexp()` | -| [`Tensor.cummax`](generated/torch.Tensor.cummax.html#torch.Tensor.cummax "torch.Tensor.cummax") | 参见`torch.cummax()` | -| [`Tensor.cummin`](generated/torch.Tensor.cummin.html#torch.Tensor.cummin "torch.Tensor.cummin") | 参见`torch.cummin()` | -| [`Tensor.cumprod`](generated/torch.Tensor.cumprod.html#torch.Tensor.cumprod "torch.Tensor.cumprod") | 参见`torch.cumprod()` | -| [`Tensor.cumprod_`](generated/torch.Tensor.cumprod_.html#torch.Tensor.cumprod_ "torch.Tensor.cumprod_") | `cumprod()`的原位版本 | -| [`Tensor.cumsum`](generated/torch.Tensor.cumsum.html#torch.Tensor.cumsum "torch.Tensor.cumsum") | 参见`torch.cumsum()` | -| [`Tensor.cumsum_`](generated/torch.Tensor.cumsum_.html#torch.Tensor.cumsum_ "torch.Tensor.cumsum_") | `cumsum()`的原位版本 | -| [`Tensor.chalf`](generated/torch.Tensor.chalf.html#torch.Tensor.chalf "torch.Tensor.chalf") | `self.chalf()`等同于`self.to(torch.complex32)` | -| [`Tensor.cfloat`](generated/torch.Tensor.cfloat.html#torch.Tensor.cfloat "torch.Tensor.cfloat") | `self.cfloat()`等同于`self.to(torch.complex64)` | -| [`Tensor.cdouble`](generated/torch.Tensor.cdouble.html#torch.Tensor.cdouble "torch.Tensor.cdouble") | `self.cdouble()`等同于`self.to(torch.complex128)` | -| [`Tensor.data_ptr`](generated/torch.Tensor.data_ptr.html#torch.Tensor.data_ptr "torch.Tensor.data_ptr") | 返回`self`张量的第一个元素的地址 | -| [`Tensor.deg2rad`](generated/torch.Tensor.deg2rad.html#torch.Tensor.deg2rad "torch.Tensor.deg2rad") | 参见`torch.deg2rad()` | -| [`Tensor.dequantize`](generated/torch.Tensor.dequantize.html#torch.Tensor.dequantize "torch.Tensor.dequantize") | 给定一个量化张量，对其进行去量化并返回去量化的浮点张量 | -| [`Tensor.det`](generated/torch.Tensor.det.html#torch.Tensor.det "torch.Tensor.det") | 参见`torch.det()` | -| [`Tensor.dense_dim`](generated/torch.Tensor.dense_dim.html#torch.Tensor.dense_dim "torch.Tensor.dense_dim") | 返回[稀疏张量](sparse.html#sparse-docs) `self` 中的密集维度数 | -| [`Tensor.detach`](generated/torch.Tensor.detach.html#torch.Tensor.detach "torch.Tensor.detach") | 返回一个从当前图中分离出来的新张量 | -| [`Tensor.detach_`](generated/torch.Tensor.detach_.html#torch.Tensor.detach_ "torch.Tensor.detach_") | 将张量从创建它的图中分离出来，使其成为叶子节点 | -| [`Tensor.diag`](generated/torch.Tensor.diag.html#torch.Tensor.diag "torch.Tensor.diag") | 参见`torch.diag()` | -| [`Tensor.diag_embed`](generated/torch.Tensor.diag_embed.html#torch.Tensor.diag_embed "torch.Tensor.diag_embed") | 查看 [`torch.diag_embed()`](generated/torch.diag_embed.html#torch.diag_embed "torch.diag_embed") | -| [`Tensor.diagflat`](generated/torch.Tensor.diagflat.html#torch.Tensor.diagflat "torch.Tensor.diagflat") | 查看 [`torch.diagflat()`](generated/torch.diagflat.html#torch.diagflat "torch.diagflat") | -| [`Tensor.diagonal`](generated/torch.Tensor.diagonal.html#torch.Tensor.diagonal "torch.Tensor.diagonal") | 查看 [`torch.diagonal()`](generated/torch.diagonal.html#torch.diagonal "torch.diagonal") | -| [`Tensor.diagonal_scatter`](generated/torch.Tensor.diagonal_scatter.html#torch.Tensor.diagonal_scatter "torch.Tensor.diagonal_scatter") | 查看 [`torch.diagonal_scatter()`](generated/torch.diagonal_scatter.html#torch.diagonal_scatter "torch.diagonal_scatter") | -| [`Tensor.fill_diagonal_`](generated/torch.Tensor.fill_diagonal_.html#torch.Tensor.fill_diagonal_ "torch.Tensor.fill_diagonal_") | 填充至少为2维的张量的主对角线。 | -| [`Tensor.fmax`](generated/torch.Tensor.fmax.html#torch.Tensor.fmax "torch.Tensor.fmax") | 查看 [`torch.fmax()`](generated/torch.fmax.html#torch.fmax "torch.fmax") | -| [`Tensor.fmin`](generated/torch.Tensor.fmin.html#torch.Tensor.fmin "torch.Tensor.fmin") | 查看 [`torch.fmin()`](generated/torch.fmin.html#torch.fmin "torch.fmin") | -| [`Tensor.diff`](generated/torch.Tensor.diff.html#torch.Tensor.diff "torch.Tensor.diff") | 查看 [`torch.diff()`](generated/torch.diff.html#torch.diff "torch.diff") | -| [`Tensor.digamma`](generated/torch.Tensor.digamma.html#torch.Tensor.digamma "torch.Tensor.digamma") | 查看 [`torch.digamma()`](generated/torch.digamma.html#torch.digamma "torch.digamma") | -| [`Tensor.digamma_`](generated/torch.Tensor.digamma_.html#torch.Tensor.digamma_ "torch.Tensor.digamma_") | [`digamma()`](generated/torch.Tensor.digamma.html#torch.Tensor.digamma "torch.Tensor.digamma") 的原地版本 | -| [`Tensor.dim`](generated/torch.Tensor.dim.html#torch.Tensor.dim "torch.Tensor.dim") | 返回 `self` 张量的维度数量。 | -| [`Tensor.dim_order`](generated/torch.Tensor.dim_order.html#torch.Tensor.dim_order "torch.Tensor.dim_order") | 返回一个描述 `self` 张量维度顺序或物理布局的整数元组。 | -| [`Tensor.dist`](generated/torch.Tensor.dist.html#torch.Tensor.dist "torch.Tensor.dist") | 查看 [`torch.dist()`](generated/torch.dist.html#torch.dist "torch.dist") | -| [`Tensor.div`](generated/torch.Tensor.div.html#torch.Tensor.div "torch.Tensor.div") | 查看 [`torch.div()`](generated/torch.div.html#torch.div "torch.div") | -| [`Tensor.div_`](generated/torch.Tensor.div_.html#torch.Tensor.div_ "torch.Tensor.div_") | [`div()`](generated/torch.Tensor.div.html#torch.Tensor.div "torch.Tensor.div") 的原地版本 | -| [`Tensor.divide`](generated/torch.Tensor.divide.html#torch.Tensor.divide "torch.Tensor.divide") | 查看 [`torch.divide()`](generated/torch.divide.html#torch.divide "torch.divide") | -| [`Tensor.divide_`](generated/torch.Tensor.divide_.html#torch.Tensor.divide_ "torch.Tensor.divide_") | [`divide()`](generated/torch.Tensor.divide.html#torch.Tensor.divide "torch.Tensor.divide") 的原地版本 | -| [`Tensor.dot`](generated/torch.Tensor.dot.html#torch.Tensor.dot "torch.Tensor.dot") | 查看 [`torch.dot()`](generated/torch.dot.html#torch.dot "torch.dot") | -| [`Tensor.double`](generated/torch.Tensor.double.html#torch.Tensor.double "torch.Tensor.double") | `self.double()` 等同于 `self.to(torch.float64)`。 | -| [`Tensor.dsplit`](generated/torch.Tensor.dsplit.html#torch.Tensor.dsplit "torch.Tensor.dsplit") | 查看 [`torch.dsplit()`](generated/torch.dsplit.html#torch.dsplit "torch.dsplit") | -| [`Tensor.element_size`](generated/torch.Tensor.element_size.html#torch.Tensor.element_size "torch.Tensor.element_size") | 返回单个元素的字节大小。 | -| [`Tensor.eq`](generated/torch.Tensor.eq.html#torch.Tensor.eq "torch.Tensor.eq") | 查看 [`torch.eq()`](generated/torch.eq.html#torch.eq "torch.eq") | -| [`Tensor.eq_`](generated/torch.Tensor.eq_.html#torch.Tensor.eq_ "torch.Tensor.eq_") | [`eq()`](generated/torch.Tensor.eq.html#torch.Tensor.eq "torch.Tensor.eq") 的原地版本 | -| [`Tensor.equal`](generated/torch.Tensor.equal.html#torch.Tensor.equal "torch.Tensor.equal") | 查看 [`torch.equal()`](generated/torch.equal.html#torch.equal "torch.equal") | -| [`Tensor.erf`](generated/torch.Tensor.erf.html#torch.Tensor.erf "torch.Tensor.erf") | 查看 [`torch.erf()`](generated/torch.erf.html#torch.erf "torch.erf") | -| [`Tensor.erf_`](generated/torch.Tensor.erf_.html#torch.Tensor.erf_ "torch.Tensor.erf_") | [`erf()`](generated/torch.Tensor.erf.html#torch.Tensor.erf "torch.Tensor.erf") 的原地版本 | -| [`Tensor.erfc`](generated/torch.Tensor.erfc.html#torch.Tensor.erfc "torch.Tensor.erfc") | 查看 [`torch.erfc()`](generated/torch.erfc.html#torch.erfc "torch.erfc") | -| [`Tensor.erfc_`](generated/torch.Tensor.erfc_.html#torch.Tensor.erfc_ "torch.Tensor.erfc_") | [`erfc()`](generated/torch.Tensor.erfc.html#torch.Tensor.erfc "torch.Tensor.erfc") 的原地版本 | -| [`Tensor.erfinv`](generated/torch.Tensor.erfinv.html#torch.Tensor.erfinv "torch.Tensor.erfinv") | 查看 [`torch.erfinv()`](generated/torch.erfinv.html#torch.erfinv "torch.erfinv") | -| [`Tensor.erfinv_`](generated/torch.Tensor.erfinv_.html#torch.Tensor.erfinv_ "torch.Tensor.erfinv_") | [`erfinv()`](generated/torch.Tensor.erfinv.html#torch.Tensor.erfinv "torch.Tensor.erfinv") 的原地版本 | -| [`Tensor.exp`](generated/torch.Tensor.exp.html#torch.Tensor.exp "torch.Tensor.exp") | 查看 [`torch.exp()`](generated/torch.exp.html#torch.exp "torch.exp") | -| [`Tensor.exp_`](generated/torch.Tensor.exp_.html#torch.Tensor.exp_ "torch.Tensor.exp_") | [`exp()`](generated/torch.Tensor.exp.html#torch.Tensor.exp "torch.Tensor.exp") 的原地版本 | -| [`Tensor.expm1`](generated/torch.Tensor.expm1.html#torch.Tensor.expm1 "torch.Tensor.expm1") | 查看 [`torch.expm1()`](generated/torch.expm1.html#torch.expm1 "torch.expm1") | -| [`Tensor.expm1_`](generated/torch.Tensor.expm1_.html#torch.Tensor.expm1_ "torch.Tensor.expm1_") | [`expm1()`](generated/torch.Tensor.expm1.html#torch.Tensor.expm1 "torch.Tensor.expm1") 的原地版本 | -| [`Tensor.expand`](generated/torch.Tensor.expand.html#torch.Tensor.expand "torch.Tensor.expand") | 返回一个新的视图，将 `self` 张量中的单例维度扩展到更大的大小 | -| [`Tensor.expand_as`](generated/torch.Tensor.expand_as.html#torch.Tensor.expand_as "torch.Tensor.expand_as") | 将此张量扩展到与 `other` 相同的大小 | -| [`Tensor.exponential_`](generated/torch.Tensor.exponential_.html#torch.Tensor.exponential_ "torch.Tensor.exponential_") | 用从概率密度函数中抽取的元素填充 `self` 张量 | -| [`Tensor.fix`](generated/torch.Tensor.fix.html#torch.Tensor.fix "torch.Tensor.fix") | 查看 [`torch.fix()`](generated/torch.fix.html#torch.fix "torch.fix") | -| [`Tensor.fix_`](generated/torch.Tensor.fix_.html#torch.Tensor.fix_ "torch.Tensor.fix_") | [`fix()`](generated/torch.Tensor.fix.html#torch.Tensor.fix "torch.Tensor.fix") 的原地版本 | -| [`Tensor.fill_`](generated/torch.Tensor.fill_.html#torch.Tensor.fill_ "torch.Tensor.fill_") | 用指定值填充 `self` 张量 | -| [`Tensor.flatten`](generated/torch.Tensor.flatten.html#torch.Tensor.flatten "torch.Tensor.flatten") | 查看 [`torch.flatten()`](generated/torch.flatten.html#torch.flatten "torch.flatten") | -| [`Tensor.flip`](generated/torch.Tensor.flip.html#torch.Tensor.flip "torch.Tensor.flip") | 查看 [`torch.flip()`](generated/torch.flip.html#torch.flip "torch.flip") | -| [`Tensor.fliplr`](generated/torch.Tensor.fliplr.html#torch.Tensor.fliplr "torch.Tensor.fliplr") | 查看 [`torch.fliplr()`](generated/torch.fliplr.html#torch.fliplr "torch.fliplr") | -| [`Tensor.flipud`](generated/torch.Tensor.flipud.html#torch.Tensor.flipud "torch.Tensor.flipud") | 查看 [`torch.flipud()`](generated/torch.flipud.html#torch.flipud "torch.flipud") | -| [`Tensor.float`](generated/torch.Tensor.float.html#torch.Tensor.float "torch.Tensor.float") | `self.float()` 等同于 `self.to(torch.float32)` | -| [`Tensor.float_power`](generated/torch.Tensor.float_power.html#torch.Tensor.float_power "torch.Tensor.float_power") | 查看 [`torch.float_power()`](generated/torch.float_power.html#torch.float_power "torch.float_power") | -| [`Tensor.float_power_`](generated/torch.Tensor.float_power_.html#torch.Tensor.float_power_ "torch.Tensor.float_power_") | [`float_power()`](generated/torch.Tensor.float_power.html#torch.Tensor.float_power "torch.Tensor.float_power") 的原地版本 | -| [`Tensor.floor`](generated/torch.Tensor.floor.html#torch.Tensor.floor "torch.Tensor.floor") | 查看 [`torch.floor()`](generated/torch.floor.html#torch.floor "torch.floor") | -| [`Tensor.floor_`](generated/torch.Tensor.floor_.html#torch.Tensor.floor_ "torch.Tensor.floor_") | [`floor()`](generated/torch.Tensor.floor.html#torch.Tensor.floor "torch.Tensor.floor") 的原地版本 | -| [`Tensor.floor_divide`](generated/torch.Tensor.floor_divide.html#torch.Tensor.floor_divide "torch.Tensor.floor_divide") | 查看 [`torch.floor_divide()`](generated/torch.floor_divide.html#torch.floor_divide "torch.floor_divide") | -| [`Tensor.floor_divide_`](generated/torch.Tensor.floor_divide_.html#torch.Tensor.floor_divide_ "torch.Tensor.floor_divide_") | [`floor_divide()`](generated/torch.Tensor.floor_divide.html#torch.Tensor.floor_divide "torch.Tensor.floor_divide") 的原地版本 | -| [`Tensor.fmod`](generated/torch.Tensor.fmod.html#torch.Tensor.fmod "torch.Tensor.fmod") | 查看 [`torch.fmod()`](generated/torch.fmod.html#torch.fmod "torch.fmod") | -| [`Tensor.fmod_`](generated/torch.Tensor.fmod_.html#torch.Tensor.fmod_ "torch.Tensor.fmod_") | [`fmod()`](generated/torch.Tensor.fmod.html#torch.Tensor.fmod "torch.Tensor.fmod") 的原地版本 | -| [`Tensor.frac`](generated/torch.Tensor.frac.html#torch.Tensor.frac "torch.Tensor.frac") | 查看 [`torch.frac()`](generated/torch.frac.html#torch.frac "torch.frac") | -| [`Tensor.frac_`](generated/torch.Tensor.frac_.html#torch.Tensor.frac_ "torch.Tensor.frac_") | [`frac()`](generated/torch.Tensor.frac.html#torch.Tensor.frac "torch.Tensor.frac") 的原地版本 | -| [`Tensor.frexp`](generated/torch.Tensor.frexp.html#torch.Tensor.frexp "torch.Tensor.frexp") | 查看 [`torch.frexp()`](generated/torch.frexp.html#torch.frexp "torch.frexp") | -| [`Tensor.gather`](generated/torch.Tensor.gather.html#torch.Tensor.gather "torch.Tensor.gather") | 查看 [`torch.gather()`](generated/torch.gather.html#torch.gather "torch.gather") | -| [`Tensor.gcd`](generated/torch.Tensor.gcd.html#torch.Tensor.gcd "torch.Tensor.gcd") | 查看 [`torch.gcd()`](generated/torch.gcd.html#torch.gcd "torch.gcd") | -| [`Tensor.gcd_`](generated/torch.Tensor.gcd_.html#torch.Tensor.gcd_ "torch.Tensor.gcd_") | [`gcd()`](generated/torch.Tensor.gcd.html#torch.Tensor.gcd "torch.Tensor.gcd") 的原地版本 | -| [`Tensor.ge`](generated/torch.Tensor.ge.html#torch.Tensor.ge "torch.Tensor.ge") | 查看 [`torch.ge()`](generated/torch.ge.html#torch.ge "torch.ge") | -| [`Tensor.ge_`](generated/torch.Tensor.ge_.html#torch.Tensor.ge_ "torch.Tensor.ge_") | [`ge()`](generated/torch.Tensor.ge.html#torch.Tensor.ge "torch.Tensor.ge") 的原地版本 | -| [`Tensor.greater_equal`](generated/torch.Tensor.greater_equal.html#torch.Tensor.greater_equal "torch.Tensor.greater_equal") | 查看 [`torch.greater_equal()`](generated/torch.greater_equal.html#torch.greater_equal "torch.greater_equal") | -| [`Tensor.greater_equal_`](generated/torch.Tensor.greater_equal_.html#torch.Tensor.greater_equal_ "torch.Tensor.greater_equal_") | [`greater_equal()`](generated/torch.Tensor.greater_equal.html#torch.Tensor.greater_equal "torch.Tensor.greater_equal") 的原地版本 | -| [`Tensor.geometric_`](generated/torch.Tensor.geometric_.html#torch.Tensor.geometric_ "torch.Tensor.geometric_") | 用几何分布中的元素填充 `self` 张量： | -| [`Tensor.geqrf`](generated/torch.Tensor.geqrf.html#torch.Tensor.geqrf "torch.Tensor.geqrf") | 参见 [`torch.geqrf()`](generated/torch.geqrf.html#torch.geqrf "torch.geqrf") | -| [`Tensor.ger`](generated/torch.Tensor.ger.html#torch.Tensor.ger "torch.Tensor.ger") | 参见 [`torch.ger()`](generated/torch.ger.html#torch.ger "torch.ger") | -| [`Tensor.get_device`](generated/torch.Tensor.get_device.html#torch.Tensor.get_device "torch.Tensor.get_device") | 对于 CUDA 张量，此函数返回张量所在 GPU 的设备序数。 | -| [`Tensor.gt`](generated/torch.Tensor.gt.html#torch.Tensor.gt "torch.Tensor.gt") | 参见 [`torch.gt()`](generated/torch.gt.html#torch.gt "torch.gt") | -| [`Tensor.gt_`](generated/torch.Tensor.gt_.html#torch.Tensor.gt_ "torch.Tensor.gt_") | [`gt()`](generated/torch.Tensor.gt.html#torch.Tensor.gt "torch.Tensor.gt") 的原地版本。 | -| [`Tensor.greater`](generated/torch.Tensor.greater.html#torch.Tensor.greater "torch.Tensor.greater") | 参见 [`torch.greater()`](generated/torch.greater.html#torch.greater "torch.greater") | -| [`Tensor.greater_`](generated/torch.Tensor.greater_.html#torch.Tensor.greater_ "torch.Tensor.greater_") | [`greater()`](generated/torch.Tensor.greater.html#torch.Tensor.greater "torch.Tensor.greater") 的原地版本。 | -| [`Tensor.half`](generated/torch.Tensor.half.html#torch.Tensor.half "torch.Tensor.half") | `self.half()` 等同于 `self.to(torch.float16)`。 | -| [`Tensor.hardshrink`](generated/torch.Tensor.hardshrink.html#torch.Tensor.hardshrink "torch.Tensor.hardshrink") | 参见 [`torch.nn.functional.hardshrink()`](generated/torch.nn.functional.hardshrink.html#torch.nn.functional.hardshrink "torch.nn.functional.hardshrink") | -| [`Tensor.heaviside`](generated/torch.Tensor.heaviside.html#torch.Tensor.heaviside "torch.Tensor.heaviside") | 参见 [`torch.heaviside()`](generated/torch.heaviside.html#torch.heaviside "torch.heaviside") | -| [`Tensor.histc`](generated/torch.Tensor.histc.html#torch.Tensor.histc "torch.Tensor.histc") | 参见 [`torch.histc()`](generated/torch.histc.html#torch.histc "torch.histc") | -| [`Tensor.histogram`](generated/torch.Tensor.histogram.html#torch.Tensor.histogram "torch.Tensor.histogram") | 参见 [`torch.histogram()`](generated/torch.histogram.html#torch.histogram "torch.histogram") | -| [`Tensor.hsplit`](generated/torch.Tensor.hsplit.html#torch.Tensor.hsplit "torch.Tensor.hsplit") | 参见 [`torch.hsplit()`](generated/torch.hsplit.html#torch.hsplit "torch.hsplit") | -| [`Tensor.hypot`](generated/torch.Tensor.hypot.html#torch.Tensor.hypot "torch.Tensor.hypot") | 参见 [`torch.hypot()`](generated/torch.hypot.html#torch.hypot "torch.hypot") | -| [`Tensor.hypot_`](generated/torch.Tensor.hypot_.html#torch.Tensor.hypot_ "torch.Tensor.hypot_") | [`hypot()`](generated/torch.Tensor.hypot.html#torch.Tensor.hypot "torch.Tensor.hypot") 的原地版本。 | -| [`Tensor.i0`](generated/torch.Tensor.i0.html#torch.Tensor.i0 "torch.Tensor.i0") | 参见 [`torch.i0()`](generated/torch.i0.html#torch.i0 "torch.i0") | -| [`Tensor.i0_`](generated/torch.Tensor.i0_.html#torch.Tensor.i0_ "torch.Tensor.i0_") | [`i0()`](generated/torch.Tensor.i0.html#torch.Tensor.i0 "torch.Tensor.i0") 的原地版本。 | -| [`Tensor.igamma`](generated/torch.Tensor.igamma.html#torch.Tensor.igamma "torch.Tensor.igamma") | 参见 [`torch.igamma()`](generated/torch.igamma.html#torch.igamma "torch.igamma") | -| [`Tensor.igamma_`](generated/torch.Tensor.igamma_.html#torch.Tensor.igamma_ "torch.Tensor.igamma_") | [`igamma()`](generated/torch.Tensor.igamma.html#torch.Tensor.igamma "torch.Tensor.igamma") 的原地版本。 | -| [`Tensor.igammac`](generated/torch.Tensor.igammac.html#torch.Tensor.igammac "torch.Tensor.igammac") | 参见 [`torch.igammac()`](generated/torch.igammac.html#torch.igammac "torch.igammac") | -| [`Tensor.igammac_`](generated/torch.Tensor.igammac_.html#torch.Tensor.igammac_ "torch.Tensor.igammac_") | [`igammac()`](generated/torch.Tensor.igammac.html#torch.Tensor.igammac "torch.Tensor.igammac")的原地版本。 | -| [`Tensor.index_add_`](generated/torch.Tensor.index_add_.html#torch.Tensor.index_add_ "torch.Tensor.index_add_") | 通过将`alpha`倍的`source`元素累加到`self`张量中，按照`index`中给定的顺序添加到索引中。 | -| [`Tensor.index_add`](generated/torch.Tensor.index_add.html#torch.Tensor.index_add "torch.Tensor.index_add") | [`torch.Tensor.index_add_()`](generated/torch.Tensor.index_add_.html#torch.Tensor.index_add_ "torch.Tensor.index_add_")的非原地版本。 | -| [`Tensor.index_copy_`](generated/torch.Tensor.index_copy_.html#torch.Tensor.index_copy_ "torch.Tensor.index_copy_") | 通过按照`index`中给定的顺序选择的索引，将[`tensor`](generated/torch.tensor.html#torch.tensor "torch.tensor")的元素复制到`self`张量中。 | -| [`Tensor.index_copy`](generated/torch.Tensor.index_copy.html#torch.Tensor.index_copy "torch.Tensor.index_copy") | [`torch.Tensor.index_copy_()`](generated/torch.Tensor.index_copy_.html#torch.Tensor.index_copy_ "torch.Tensor.index_copy_")的非原地版本。 | -| [`Tensor.index_fill_`](generated/torch.Tensor.index_fill_.html#torch.Tensor.index_fill_ "torch.Tensor.index_fill_") | 通过按照`index`中给定的顺序选择的索引，用值`value`填充`self`张量的元素。 | -| [`Tensor.index_fill`](generated/torch.Tensor.index_fill.html#torch.Tensor.index_fill "torch.Tensor.index_fill") | [`torch.Tensor.index_fill_()`](generated/torch.Tensor.index_fill_.html#torch.Tensor.index_fill_ "torch.Tensor.index_fill_")的非原地版本。 | -| [`Tensor.index_put_`](generated/torch.Tensor.index_put_.html#torch.Tensor.index_put_ "torch.Tensor.index_put_") | 使用`indices`中指定的索引（一个张量元组）将张量`values`中的值放入张量`self`中。 | -| [`Tensor.index_put`](generated/torch.Tensor.index_put.html#torch.Tensor.index_put "torch.Tensor.index_put") | [`index_put_()`](generated/torch.Tensor.index_put_.html#torch.Tensor.index_put_ "torch.Tensor.index_put_")的非原地版本。 | -| [`Tensor.index_reduce_`](generated/torch.Tensor.index_reduce_.html#torch.Tensor.index_reduce_ "torch.Tensor.index_reduce_") | 通过使用`reduce`参数给定的减少方式，按照`index`中给定的顺序将`source`元素累加到`self`张量中。 | -| [`Tensor.index_reduce`](generated/torch.Tensor.index_reduce.html#torch.Tensor.index_reduce "torch.Tensor.index_reduce") | | -| [`Tensor.index_select`](generated/torch.Tensor.index_select.html#torch.Tensor.index_select "torch.Tensor.index_select") | 参见[`torch.index_select()`](generated/torch.index_select.html#torch.index_select "torch.index_select") | -| [`Tensor.indices`](generated/torch.Tensor.indices.html#torch.Tensor.indices "torch.Tensor.indices") | 返回[稀疏COO张量](sparse.html#sparse-coo-docs)的索引张量。 | -| [`Tensor.inner`](generated/torch.Tensor.inner.html#torch.Tensor.inner "torch.Tensor.inner") | 参见[`torch.inner()`](generated/torch.inner.html#torch.inner "torch.inner")。 | -| [`Tensor.int`](generated/torch.Tensor.int.html#torch.Tensor.int "torch.Tensor.int") | `self.int()`等同于`self.to(torch.int32)`。 | -| [`Tensor.int_repr`](generated/torch.Tensor.int_repr.html#torch.Tensor.int_repr "torch.Tensor.int_repr") | 给定一个量化张量，`self.int_repr()`返回一个CPU张量，数据类型为uint8_t，存储给定张量的底层uint8_t值。 | -| [`Tensor.inverse`](generated/torch.Tensor.inverse.html#torch.Tensor.inverse "torch.Tensor.inverse") | 参见[`torch.inverse()`](generated/torch.inverse.html#torch.inverse "torch.inverse") | -| [`Tensor.isclose`](generated/torch.Tensor.isclose.html#torch.Tensor.isclose "torch.Tensor.isclose") | 参见[`torch.isclose()`](generated/torch.isclose.html#torch.isclose "torch.isclose") | -| [`Tensor.isfinite`](generated/torch.Tensor.isfinite.html#torch.Tensor.isfinite "torch.Tensor.isfinite") | 参见[`torch.isfinite()`](generated/torch.isfinite.html#torch.isfinite "torch.isfinite") | -| [`Tensor.isinf`](generated/torch.Tensor.isinf.html#torch.Tensor.isinf "torch.Tensor.isinf") | 参见[`torch.isinf()`](generated/torch.isinf.html#torch.isinf "torch.isinf") | -| [`Tensor.isposinf`](generated/torch.Tensor.isposinf.html#torch.Tensor.isposinf "torch.Tensor.isposinf") | 参见[`torch.isposinf()`](generated/torch.isposinf.html#torch.isposinf "torch.isposinf") | -| [`Tensor.isneginf`](generated/torch.Tensor.isneginf.html#torch.Tensor.isneginf "torch.Tensor.isneginf") | 参见[`torch.isneginf()`](generated/torch.isneginf.html#torch.isneginf "torch.isneginf") | -| [`Tensor.isnan`](generated/torch.Tensor.isnan.html#torch.Tensor.isnan "torch.Tensor.isnan") | 参见[`torch.isnan()`](generated/torch.isnan.html#torch.isnan "torch.isnan") | -| [`Tensor.is_contiguous`](generated/torch.Tensor.is_contiguous.html#torch.Tensor.is_contiguous "torch.Tensor.is_contiguous") | 如果`self`张量在内存中按照内存格式指定的顺序是连续的，则返回True。 | -| [`Tensor.is_complex`](generated/torch.Tensor.is_complex.html#torch.Tensor.is_complex "torch.Tensor.is_complex") | 如果`self`的数据类型是复数数据类型，则返回True。 | -| [`Tensor.is_conj`](generated/torch.Tensor.is_conj.html#torch.Tensor.is_conj "torch.Tensor.is_conj") | 如果`self`的共轭位设置为true，则返回True。 | -| [`Tensor.is_floating_point`](generated/torch.Tensor.is_floating_point.html#torch.Tensor.is_floating_point "torch.Tensor.is_floating_point") | 如果`self`的数据类型是浮点数据类型，则返回True。 | -| [`Tensor.is_inference`](generated/torch.Tensor.is_inference.html#torch.Tensor.is_inference "torch.Tensor.is_inference") | 参见`torch.is_inference()` | -| [`Tensor.is_leaf`](generated/torch.Tensor.is_leaf.html#torch.Tensor.is_leaf "torch.Tensor.is_leaf") | 所有`requires_grad`为`False`的张量按照惯例都将是叶张量。 | -| [`Tensor.is_pinned`](generated/torch.Tensor.is_pinned.html#torch.Tensor.is_pinned "torch.Tensor.is_pinned") | 如果此张量驻留在固定内存中，则返回true。 | -| [`Tensor.is_set_to`](generated/torch.Tensor.is_set_to.html#torch.Tensor.is_set_to "torch.Tensor.is_set_to") | 如果两个张量指向完全相同的内存（相同的存储、偏移、大小和步幅），则返回True。 | -| [`Tensor.is_shared`](generated/torch.Tensor.is_shared.html#torch.Tensor.is_shared "torch.Tensor.is_shared") | 检查张量是否在共享内存中。 | -| [`Tensor.is_signed`](generated/torch.Tensor.is_signed.html#torch.Tensor.is_signed "torch.Tensor.is_signed") | 如果`self`的数据类型是有符号数据类型，则返回True。 | -| [`Tensor.is_sparse`](generated/torch.Tensor.is_sparse.html#torch.Tensor.is_sparse "torch.Tensor.is_sparse") | 如果张量使用稀疏COO存储布局，则为`True`，否则为`False`。 | -| [`Tensor.istft`](generated/torch.Tensor.istft.html#torch.Tensor.istft "torch.Tensor.istft") | 参见[`torch.istft()`](generated/torch.istft.html#torch.istft "torch.istft") | -| [`Tensor.isreal`](generated/torch.Tensor.isreal.html#torch.Tensor.isreal "torch.Tensor.isreal") | 参见[`torch.isreal()`](generated/torch.isreal.html#torch.isreal "torch.isreal") | -| [`Tensor.item`](generated/torch.Tensor.item.html#torch.Tensor.item "torch.Tensor.item") | 将此张量的值作为标准Python数字返回。 | -| [`Tensor.kthvalue`](generated/torch.Tensor.kthvalue.html#torch.Tensor.kthvalue "torch.Tensor.kthvalue") | 参见[`torch.kthvalue()`](generated/torch.kthvalue.html#torch.kthvalue "torch.kthvalue") | -| [`Tensor.lcm`](generated/torch.Tensor.lcm.html#torch.Tensor.lcm "torch.Tensor.lcm") | 查看 [`torch.lcm()`](generated/torch.lcm.html#torch.lcm "torch.lcm") | -| [`Tensor.lcm_`](generated/torch.Tensor.lcm_.html#torch.Tensor.lcm_ "torch.Tensor.lcm_") | [`lcm()`](generated/torch.Tensor.lcm.html#torch.Tensor.lcm "torch.Tensor.lcm") 的原地版本。 | -| [`Tensor.ldexp`](generated/torch.Tensor.ldexp.html#torch.Tensor.ldexp "torch.Tensor.ldexp") | 查看 [`torch.ldexp()`](generated/torch.ldexp.html#torch.ldexp "torch.ldexp") | -| [`Tensor.ldexp_`](generated/torch.Tensor.ldexp_.html#torch.Tensor.ldexp_ "torch.Tensor.ldexp_") | [`ldexp()`](generated/torch.Tensor.ldexp.html#torch.Tensor.ldexp "torch.Tensor.ldexp") 的原地版本。 | -| [`Tensor.le`](generated/torch.Tensor.le.html#torch.Tensor.le "torch.Tensor.le") | 查看 [`torch.le()`](generated/torch.le.html#torch.le "torch.le")。 | -| [`Tensor.le_`](generated/torch.Tensor.le_.html#torch.Tensor.le_ "torch.Tensor.le_") | [`le()`](generated/torch.Tensor.le.html#torch.Tensor.le "torch.Tensor.le") 的原地版本。 | -| [`Tensor.less_equal`](generated/torch.Tensor.less_equal.html#torch.Tensor.less_equal "torch.Tensor.less_equal") | 查看 [`torch.less_equal()`](generated/torch.less_equal.html#torch.less_equal "torch.less_equal")。 | -| [`Tensor.less_equal_`](generated/torch.Tensor.less_equal_.html#torch.Tensor.less_equal_ "torch.Tensor.less_equal_") | [`less_equal()`](generated/torch.Tensor.less_equal.html#torch.Tensor.less_equal "torch.Tensor.less_equal") 的原地版本。 | -| [`Tensor.lerp`](generated/torch.Tensor.lerp.html#torch.Tensor.lerp "torch.Tensor.lerp") | 查看 [`torch.lerp()`](generated/torch.lerp.html#torch.lerp "torch.lerp") | -| [`Tensor.lerp_`](generated/torch.Tensor.lerp_.html#torch.Tensor.lerp_ "torch.Tensor.lerp_") | [`lerp()`](generated/torch.Tensor.lerp.html#torch.Tensor.lerp "torch.Tensor.lerp") 的原地版本。 | -| [`Tensor.lgamma`](generated/torch.Tensor.lgamma.html#torch.Tensor.lgamma "torch.Tensor.lgamma") | 查看 [`torch.lgamma()`](generated/torch.lgamma.html#torch.lgamma "torch.lgamma") | -| [`Tensor.lgamma_`](generated/torch.Tensor.lgamma_.html#torch.Tensor.lgamma_ "torch.Tensor.lgamma_") | [`lgamma()`](generated/torch.Tensor.lgamma.html#torch.Tensor.lgamma "torch.Tensor.lgamma") 的原地版本。 | -| [`Tensor.log`](generated/torch.Tensor.log.html#torch.Tensor.log "torch.Tensor.log") | 查看 [`torch.log()`](generated/torch.log.html#torch.log "torch.log") | -| [`Tensor.log_`](generated/torch.Tensor.log_.html#torch.Tensor.log_ "torch.Tensor.log_") | [`log()`](generated/torch.Tensor.log.html#torch.Tensor.log "torch.Tensor.log") 的原地版本。 | -| [`Tensor.logdet`](generated/torch.Tensor.logdet.html#torch.Tensor.logdet "torch.Tensor.logdet") | 查看 [`torch.logdet()`](generated/torch.logdet.html#torch.logdet "torch.logdet") | -| [`Tensor.log10`](generated/torch.Tensor.log10.html#torch.Tensor.log10 "torch.Tensor.log10") | 查看 [`torch.log10()`](generated/torch.log10.html#torch.log10 "torch.log10") | -| [`Tensor.log10_`](generated/torch.Tensor.log10_.html#torch.Tensor.log10_ "torch.Tensor.log10_") | [`log10()`](generated/torch.Tensor.log10.html#torch.Tensor.log10 "torch.Tensor.log10") 的原地版本。 | -| [`Tensor.log1p`](generated/torch.Tensor.log1p.html#torch.Tensor.log1p "torch.Tensor.log1p") | 查看 [`torch.log1p()`](generated/torch.log1p.html#torch.log1p "torch.log1p") | -| [`Tensor.log1p_`](generated/torch.Tensor.log1p_.html#torch.Tensor.log1p_ "torch.Tensor.log1p_") | [`log1p()`](generated/torch.Tensor.log1p.html#torch.Tensor.log1p "torch.Tensor.log1p") 的原地版本。 | -| [`Tensor.log2`](generated/torch.Tensor.log2.html#torch.Tensor.log2 "torch.Tensor.log2") | 查看 [`torch.log2()`](generated/torch.log2.html#torch.log2 "torch.log2") | -| [`Tensor.log2_`](generated/torch.Tensor.log2_.html#torch.Tensor.log2_ "torch.Tensor.log2_") | [`log2()`](generated/torch.Tensor.log2.html#torch.Tensor.log2 "torch.Tensor.log2") 的原地版本。 | -| [`Tensor.log_normal_`](generated/torch.Tensor.log_normal_.html#torch.Tensor.log_normal_ "torch.Tensor.log_normal_") | 使用给定的均值 $\mu$ 和标准差 $\sigma$ 参数化的对数正态分布中的样本填充 `self` 张量 | -| [`Tensor.logaddexp`](generated/torch.Tensor.logaddexp.html#torch.Tensor.logaddexp "torch.Tensor.logaddexp") | 参见 [`torch.logaddexp()`](generated/torch.logaddexp.html#torch.logaddexp "torch.logaddexp") | -| [`Tensor.logaddexp2`](generated/torch.Tensor.logaddexp2.html#torch.Tensor.logaddexp2 "torch.Tensor.logaddexp2") | 参见 [`torch.logaddexp2()`](generated/torch.logaddexp2.html#torch.logaddexp2 "torch.logaddexp2") | -| [`Tensor.logsumexp`](generated/torch.Tensor.logsumexp.html#torch.Tensor.logsumexp "torch.Tensor.logsumexp") | 参见 [`torch.logsumexp()`](generated/torch.logsumexp.html#torch.logsumexp "torch.logsumexp") | -| [`Tensor.logical_and`](generated/torch.Tensor.logical_and.html#torch.Tensor.logical_and "torch.Tensor.logical_and") | 参见 [`torch.logical_and()`](generated/torch.logical_and.html#torch.logical_and "torch.logical_and") | -| [`Tensor.logical_and_`](generated/torch.Tensor.logical_and_.html#torch.Tensor.logical_and_ "torch.Tensor.logical_and_") | [`logical_and()`](generated/torch.Tensor.logical_and.html#torch.Tensor.logical_and "torch.Tensor.logical_and") 的原地版本 | -| [`Tensor.logical_not`](generated/torch.Tensor.logical_not.html#torch.Tensor.logical_not "torch.Tensor.logical_not") | 参见 [`torch.logical_not()`](generated/torch.logical_not.html#torch.logical_not "torch.logical_not") | -| [`Tensor.logical_not_`](generated/torch.Tensor.logical_not_.html#torch.Tensor.logical_not_ "torch.Tensor.logical_not_") | [`logical_not()`](generated/torch.Tensor.logical_not.html#torch.Tensor.logical_not "torch.Tensor.logical_not") 的原地版本 | -| [`Tensor.logical_or`](generated/torch.Tensor.logical_or.html#torch.Tensor.logical_or "torch.Tensor.logical_or") | 参见 [`torch.logical_or()`](generated/torch.logical_or.html#torch.logical_or "torch.logical_or") | -| [`Tensor.logical_or_`](generated/torch.Tensor.logical_or_.html#torch.Tensor.logical_or_ "torch.Tensor.logical_or_") | [`logical_or()`](generated/torch.Tensor.logical_or.html#torch.Tensor.logical_or "torch.Tensor.logical_or") 的原地版本 | -| [`Tensor.logical_xor`](generated/torch.Tensor.logical_xor.html#torch.Tensor.logical_xor "torch.Tensor.logical_xor") | 参见 [`torch.logical_xor()`](generated/torch.logical_xor.html#torch.logical_xor "torch.logical_xor") | -| [`Tensor.logical_xor_`](generated/torch.Tensor.logical_xor_.html#torch.Tensor.logical_xor_ "torch.Tensor.logical_xor_") | [`logical_xor()`](generated/torch.Tensor.logical_xor.html#torch.Tensor.logical_xor "torch.Tensor.logical_xor") 的原地版本 | -| [`Tensor.logit`](generated/torch.Tensor.logit.html#torch.Tensor.logit "torch.Tensor.logit") | 参见 [`torch.logit()`](generated/torch.logit.html#torch.logit "torch.logit") | -| [`Tensor.logit_`](generated/torch.Tensor.logit_.html#torch.Tensor.logit_ "torch.Tensor.logit_") | [`logit()`](generated/torch.Tensor.logit.html#torch.Tensor.logit "torch.Tensor.logit") 的原地版本 | -| [`Tensor.long`](generated/torch.Tensor.long.html#torch.Tensor.long "torch.Tensor.long") | `self.long()` 等同于 `self.to(torch.int64)` | -| [`Tensor.lt`](generated/torch.Tensor.lt.html#torch.Tensor.lt "torch.Tensor.lt") | 参见 [`torch.lt()`](generated/torch.lt.html#torch.lt "torch.lt") | -| [`Tensor.lt_`](generated/torch.Tensor.lt_.html#torch.Tensor.lt_ "torch.Tensor.lt_") | [`lt()`](generated/torch.Tensor.lt.html#torch.Tensor.lt "torch.Tensor.lt") 的原地版本 | -| [`Tensor.less`](generated/torch.Tensor.less.html#torch.Tensor.less "torch.Tensor.less") | lt(other) -> Tensor | -| [`Tensor.less_`](generated/torch.Tensor.less_.html#torch.Tensor.less_ "torch.Tensor.less_") | [`less()`](generated/torch.Tensor.less.html#torch.Tensor.less "torch.Tensor.less") 的原地版本 | -| [`Tensor.lu`](generated/torch.Tensor.lu.html#torch.Tensor.lu "torch.Tensor.lu") | 查看 [`torch.lu()`](generated/torch.lu.html#torch.lu "torch.lu") | -| [`Tensor.lu_solve`](generated/torch.Tensor.lu_solve.html#torch.Tensor.lu_solve "torch.Tensor.lu_solve") | 查看 [`torch.lu_solve()`](generated/torch.lu_solve.html#torch.lu_solve "torch.lu_solve") | -| [`Tensor.as_subclass`](generated/torch.Tensor.as_subclass.html#torch.Tensor.as_subclass "torch.Tensor.as_subclass") | 创建一个具有与`self`相同数据指针的`cls`实例。 | -| [`Tensor.map_`](generated/torch.Tensor.map_.html#torch.Tensor.map_ "torch.Tensor.map_") | 对`self`张量中的每个元素应用`callable`，并将结果存储在`self`张量中。 | -| [`Tensor.masked_scatter_`](generated/torch.Tensor.masked_scatter_.html#torch.Tensor.masked_scatter_ "torch.Tensor.masked_scatter_") | 将`source`中的元素复制到`self`张量中，其中`mask`为True。 | -| [`Tensor.masked_scatter`](generated/torch.Tensor.masked_scatter.html#torch.Tensor.masked_scatter "torch.Tensor.masked_scatter") | [`torch.Tensor.masked_scatter_()`](generated/torch.Tensor.masked_scatter_.html#torch.Tensor.masked_scatter_ "torch.Tensor.masked_scatter_")的非就地版本 | -| [`Tensor.masked_fill_`](generated/torch.Tensor.masked_fill_.html#torch.Tensor.masked_fill_ "torch.Tensor.masked_fill_") | 在`mask`为True的位置，用`value`填充`self`张量的元素。 | -| [`Tensor.masked_fill`](generated/torch.Tensor.masked_fill.html#torch.Tensor.masked_fill "torch.Tensor.masked_fill") | [`torch.Tensor.masked_fill_()`](generated/torch.Tensor.masked_fill_.html#torch.Tensor.masked_fill_ "torch.Tensor.masked_fill_")的非就地版本 | -| [`Tensor.masked_select`](generated/torch.Tensor.masked_select.html#torch.Tensor.masked_select "torch.Tensor.masked_select") | 查看 [`torch.masked_select()`](generated/torch.masked_select.html#torch.masked_select "torch.masked_select") | -| [`Tensor.matmul`](generated/torch.Tensor.matmul.html#torch.Tensor.matmul "torch.Tensor.matmul") | 查看 [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") | -| [`Tensor.matrix_power`](generated/torch.Tensor.matrix_power.html#torch.Tensor.matrix_power "torch.Tensor.matrix_power") | +| `Tensor.new_full` | 返回一个大小为`size`且填充为`fill_value`的张量。 | +| `Tensor.new_empty` | 返回一个大小为`size`且填充为未初始化数据的张量。 | +| `Tensor.new_ones` | 返回一个大小为`size`且填充为`1`的张量。 | +| `Tensor.new_zeros` | 返回一个大小为`size`且填充为`0`的张量。 | +| `Tensor.is_cuda` | 如果张量存储在 GPU 上，则为`True`，否则为`False`。 | +| `Tensor.is_quantized` | 如果张量是量化的，则为`True`，否则为`False`。 | +| `Tensor.is_meta` | 如果张量是元张量，则为`True`，否则为`False`。 | +| `Tensor.device` | 此张量所在的`torch.device`。 | +| `Tensor.grad` | 默认情况下，此属性为`None`，第一次调用`backward()`计算`self`的梯度时会变成一个张量。 | +| `Tensor.ndim` | `dim()`的别名 | +| `Tensor.real` | 返回一个包含复值输入张量`self`的实部值的新张量。 | +| `Tensor.imag` | 返回一个包含`self`张量的虚部值的新张量。 | +| `Tensor.nbytes` | 如果张量不使用稀疏存储布局，则返回张量元素“视图”消耗的字节数。 | +| `Tensor.itemsize` | `element_size()`的别名 | +| `Tensor.abs` | 参见`torch.abs()` | +| `Tensor.abs_` | `abs()`的原地版本 | +| `Tensor.absolute` | `abs()`的别名 | +| `Tensor.absolute_` | `absolute()`的原地版本，别名为`abs_()` | +| `Tensor.acos` | 参见`torch.acos()` | +| `Tensor.acos_` | `acos()`的原地版本 | +| `Tensor.arccos` | 参见`torch.arccos()` | +| `Tensor.arccos_` | `arccos()` 的原地版本 | +| `Tensor.add` | 将标量或张量添加到 `self` 张量中。 | +| `Tensor.add_` | `add()` 的原地版本 | +| `Tensor.addbmm` | 查看 `torch.addbmm()` | +| `Tensor.addbmm_` | `addbmm()` 的原地版本 | +| `Tensor.addcdiv` | 查看 `torch.addcdiv()` | +| `Tensor.addcdiv_` | `addcdiv()` 的原地版本 | +| `Tensor.addcmul` | 查看 `torch.addcmul()` | +| `Tensor.addcmul_` | `addcmul()` 的原地版本 | +| `Tensor.addmm` | 查看 `torch.addmm()` | +| `Tensor.addmm_` | `addmm()` 的原地版本 | +| `Tensor.sspaddmm` | 查看 `torch.sspaddmm()` | +| `Tensor.addmv` | 查看 `torch.addmv()` | +| `Tensor.addmv_` | `addmv()` 的原地版本 | +| `Tensor.addr` | 查看 `torch.addr()` | +| `Tensor.addr_` | `addr()` 的原地版本 | +| `Tensor.adjoint` | `adjoint()` 的别名 | +| `Tensor.allclose` | 查看 `torch.allclose()` | +| `Tensor.amax` | 查看 `torch.amax()` | +| `Tensor.amin` | 查看 `torch.amin()` | +| `Tensor.aminmax` | 参见 `torch.aminmax()` | +| `Tensor.angle` | 参见 `torch.angle()` | +| `Tensor.apply_` | 将函数 `callable` 应用于张量中的每个元素，用 `callable` 返回的值替换每个元素。 | +| `Tensor.argmax` | 参见 `torch.argmax()` | +| `Tensor.argmin` | 参见 `torch.argmin()` | +| `Tensor.argsort` | 参见 `torch.argsort()` | +| `Tensor.argwhere` | 参见 `torch.argwhere()` | +| `Tensor.asin` | 参见 `torch.asin()` | +| `Tensor.asin_` | `asin()` 的原地版本 | +| `Tensor.arcsin` | 参见 `torch.arcsin()` | +| `Tensor.arcsin_` | `arcsin()` 的原地版本 | +| `Tensor.as_strided` | 参见 `torch.as_strided()` | +| `Tensor.atan` | 参见 `torch.atan()` | +| `Tensor.atan_` | `atan()` 的原地版本 | +| `Tensor.arctan` | 参见 `torch.arctan()` | +| `Tensor.arctan_` | `arctan()` 的原地版本 | +| `Tensor.atan2` | 参见 `torch.atan2()` | +| `Tensor.atan2_` | `atan2()` 的原地版本 | +| `Tensor.arctan2` | 参见 `torch.arctan2()` | +| `Tensor.arctan2_` | atan2_(other) -> Tensor | +| `Tensor.all` | 参见 `torch.all()` | +| `Tensor.any` | 查看 `torch.any()` | +| `Tensor.backward` | 计算当前张量相对于图中叶子节点的梯度。 | +| `Tensor.baddbmm` | 查看 `torch.baddbmm()` | +| `Tensor.baddbmm_` | `baddbmm()` 的原地版本 | +| `Tensor.bernoulli` | 返回一个结果张量，其中每个 $\texttt{result[i]}$ 从 $\text{Bernoulli}(\texttt{self[i]})$ 独立采样。 | +| `Tensor.bernoulli_` | 用来自 $\text{Bernoulli}(\texttt{p})$ 的独立样本填充 `self` 的每个位置。 | +| `Tensor.bfloat16` | `self.bfloat16()` 等同于 `self.to(torch.bfloat16)`。 | +| `Tensor.bincount` | 查看 `torch.bincount()` | +| `Tensor.bitwise_not` | 查看 `torch.bitwise_not()` | +| `Tensor.bitwise_not_` | `bitwise_not()` 的原地版本 | +| `Tensor.bitwise_and` | 查看 `torch.bitwise_and()` | +| `Tensor.bitwise_and_` | `bitwise_and()` 的原地版本 | +| `Tensor.bitwise_or` | 查看 `torch.bitwise_or()` | +| `Tensor.bitwise_or_` | `bitwise_or()` 的原地版本 | +| `Tensor.bitwise_xor` | 查看 `torch.bitwise_xor()` | +| `Tensor.bitwise_xor_` | `bitwise_xor()` 的原地版本 | +| `Tensor.bitwise_left_shift` | 查看 `torch.bitwise_left_shift()` | +| `Tensor.bitwise_left_shift_` | `bitwise_left_shift()` 的原地版本 | +| `Tensor.bitwise_right_shift` | 参见 `torch.bitwise_right_shift()` | +| `Tensor.bitwise_right_shift_` | `bitwise_right_shift()` 的原地版本 | +| `Tensor.bmm` | 参见 `torch.bmm()` | +| `Tensor.bool` | `self.bool()` 等同于 `self.to(torch.bool)`。 | +| `Tensor.byte` | `self.byte()` 等同于 `self.to(torch.uint8)`。 | +| `Tensor.broadcast_to` | 参见 `torch.broadcast_to()`. | +| `Tensor.cauchy_` | 用从 Cauchy 分布中抽取的数字填充张量： | +| `Tensor.ceil` | 参见 `torch.ceil()` | +| `Tensor.ceil_` | `ceil()` 的原地版本 | +| `Tensor.char` | `self.char()` 等同于 `self.to(torch.int8)`。 | +| `Tensor.cholesky` | 参见 `torch.cholesky()` | +| `Tensor.cholesky_inverse` | 参见 `torch.cholesky_inverse()` | +| `Tensor.cholesky_solve` | 参见 `torch.cholesky_solve()` | +| `Tensor.chunk` | 参见 `torch.chunk()` | +| `Tensor.clamp` | 参见 `torch.clamp()` | +| `Tensor.clamp_` | `clamp()` 的原地版本 | +| `Tensor.clip` | `clamp()` 的别名 | +| `Tensor.clip_` | `clamp_()` 的别名。 | +| `Tensor.clone` | 查看 `torch.clone()` | +| `Tensor.contiguous` | 返回一个包含与 `self` 张量相同数据的内存连续张量 | +| `Tensor.copy_` | 将 `src` 中的元素复制到 `self` 张量中并返回 `self` | +| `Tensor.conj` | 查看 `torch.conj()` | +| `Tensor.conj_physical` | 查看 `torch.conj_physical()` | +| `Tensor.conj_physical_` | `conj_physical()` 的原地版本 | +| `Tensor.resolve_conj` | 查看 `torch.resolve_conj()` | +| `Tensor.resolve_neg` | 查看 `torch.resolve_neg()` | +| `Tensor.copysign` | 查看 `torch.copysign()` | +| `Tensor.copysign_` | `copysign()` 的原地版本 | +| `Tensor.cos` | 查看 `torch.cos()` | +| `Tensor.cos_` | `cos()` 的原地版本 | +| `Tensor.cosh` | 查看 `torch.cosh()` | +| `Tensor.cosh_` | `cosh()` 的原地版本 | +| `Tensor.corrcoef` | 查看 `torch.corrcoef()` | +| `Tensor.count_nonzero` | 查看 `torch.count_nonzero()` | +| `Tensor.cov` | 查看 `torch.cov()` | +| `Tensor.acosh` | 查看 `torch.acosh()` | +| `Tensor.acosh_` | `acosh()` 的原地版本 | +| `Tensor.arccosh` | acosh() -> Tensor | +| `Tensor.arccosh_` | acosh_() -> Tensor | +| `Tensor.cpu` | 返回此对象在 CPU 内存中的副本 | +| `Tensor.cross` | 参见`torch.cross()` | +| `Tensor.cuda` | 返回此对象在 CUDA 内存中的副本 | +| `Tensor.logcumsumexp` | 参见`torch.logcumsumexp()` | +| `Tensor.cummax` | 参见`torch.cummax()` | +| `Tensor.cummin` | 参见`torch.cummin()` | +| `Tensor.cumprod` | 参见`torch.cumprod()` | +| `Tensor.cumprod_` | `cumprod()`的原位版本 | +| `Tensor.cumsum` | 参见`torch.cumsum()` | +| `Tensor.cumsum_` | `cumsum()`的原位版本 | +| `Tensor.chalf` | `self.chalf()`等同于`self.to(torch.complex32)` | +| `Tensor.cfloat` | `self.cfloat()`等同于`self.to(torch.complex64)` | +| `Tensor.cdouble` | `self.cdouble()`等同于`self.to(torch.complex128)` | +| `Tensor.data_ptr` | 返回`self`张量的第一个元素的地址 | +| `Tensor.deg2rad` | 参见`torch.deg2rad()` | +| `Tensor.dequantize` | 给定一个量化张量，对其进行去量化并返回去量化的浮点张量 | +| `Tensor.det` | 参见`torch.det()` | +| `Tensor.dense_dim` | 返回稀疏张量 `self` 中的密集维度数 | +| `Tensor.detach` | 返回一个从当前图中分离出来的新张量 | +| `Tensor.detach_` | 将张量从创建它的图中分离出来，使其成为叶子节点 | +| `Tensor.diag` | 参见`torch.diag()` | +| `Tensor.diag_embed` | 查看 `torch.diag_embed()` | +| `Tensor.diagflat` | 查看 `torch.diagflat()` | +| `Tensor.diagonal` | 查看 `torch.diagonal()` | +| `Tensor.diagonal_scatter` | 查看 `torch.diagonal_scatter()` | +| `Tensor.fill_diagonal_` | 填充至少为 2 维的张量的主对角线。 | +| `Tensor.fmax` | 查看 `torch.fmax()` | +| `Tensor.fmin` | 查看 `torch.fmin()` | +| `Tensor.diff` | 查看 `torch.diff()` | +| `Tensor.digamma` | 查看 `torch.digamma()` | +| `Tensor.digamma_` | `digamma()` 的原地版本 | +| `Tensor.dim` | 返回 `self` 张量的维度数量。 | +| `Tensor.dim_order` | 返回一个描述 `self` 张量维度顺序或物理布局的整数元组。 | +| `Tensor.dist` | 查看 `torch.dist()` | +| `Tensor.div` | 查看 `torch.div()` | +| `Tensor.div_` | `div()` 的原地版本 | +| `Tensor.divide` | 查看 `torch.divide()` | +| `Tensor.divide_` | `divide()` 的原地版本 | +| `Tensor.dot` | 查看 `torch.dot()` | +| `Tensor.double` | `self.double()` 等同于 `self.to(torch.float64)`。 | +| `Tensor.dsplit` | 查看 `torch.dsplit()` | +| `Tensor.element_size` | 返回单个元素的字节大小。 | +| `Tensor.eq` | 查看 `torch.eq()` | +| `Tensor.eq_` | `eq()` 的原地版本 | +| `Tensor.equal` | 查看 `torch.equal()` | +| `Tensor.erf` | 查看 `torch.erf()` | +| `Tensor.erf_` | `erf()` 的原地版本 | +| `Tensor.erfc` | 查看 `torch.erfc()` | +| `Tensor.erfc_` | `erfc()` 的原地版本 | +| `Tensor.erfinv` | 查看 `torch.erfinv()` | +| `Tensor.erfinv_` | `erfinv()` 的原地版本 | +| `Tensor.exp` | 查看 `torch.exp()` | +| `Tensor.exp_` | `exp()` 的原地版本 | +| `Tensor.expm1` | 查看 `torch.expm1()` | +| `Tensor.expm1_` | `expm1()` 的原地版本 | +| `Tensor.expand` | 返回一个新的视图，将 `self` 张量中的单例维度扩展到更大的大小 | +| `Tensor.expand_as` | 将此张量扩展到与 `other` 相同的大小 | +| `Tensor.exponential_` | 用从概率密度函数中抽取的元素填充 `self` 张量 | +| `Tensor.fix` | 查看 `torch.fix()` | +| `Tensor.fix_` | `fix()` 的原地版本 | +| `Tensor.fill_` | 用指定值填充 `self` 张量 | +| `Tensor.flatten` | 查看 `torch.flatten()` | +| `Tensor.flip` | 查看 `torch.flip()` | +| `Tensor.fliplr` | 查看 `torch.fliplr()` | +| `Tensor.flipud` | 查看 `torch.flipud()` | +| `Tensor.float` | `self.float()` 等同于 `self.to(torch.float32)` | +| `Tensor.float_power` | 查看 `torch.float_power()` | +| `Tensor.float_power_` | `float_power()` 的原地版本 | +| `Tensor.floor` | 查看 `torch.floor()` | +| `Tensor.floor_` | `floor()` 的原地版本 | +| `Tensor.floor_divide` | 查看 `torch.floor_divide()` | +| `Tensor.floor_divide_` | `floor_divide()` 的原地版本 | +| `Tensor.fmod` | 查看 `torch.fmod()` | +| `Tensor.fmod_` | `fmod()` 的原地版本 | +| `Tensor.frac` | 查看 `torch.frac()` | +| `Tensor.frac_` | `frac()` 的原地版本 | +| `Tensor.frexp` | 查看 `torch.frexp()` | +| `Tensor.gather` | 查看 `torch.gather()` | +| `Tensor.gcd` | 查看 `torch.gcd()` | +| `Tensor.gcd_` | `gcd()` 的原地版本 | +| `Tensor.ge` | 查看 `torch.ge()` | +| `Tensor.ge_` | `ge()` 的原地版本 | +| `Tensor.greater_equal` | 查看 `torch.greater_equal()` | +| `Tensor.greater_equal_` | `greater_equal()` 的原地版本 | +| `Tensor.geometric_` | 用几何分布中的元素填充 `self` 张量： | +| `Tensor.geqrf` | 参见 `torch.geqrf()` | +| `Tensor.ger` | 参见 `torch.ger()` | +| `Tensor.get_device` | 对于 CUDA 张量，此函数返回张量所在 GPU 的设备序数。 | +| `Tensor.gt` | 参见 `torch.gt()` | +| `Tensor.gt_` | `gt()` 的原地版本。 | +| `Tensor.greater` | 参见 `torch.greater()` | +| `Tensor.greater_` | `greater()` 的原地版本。 | +| `Tensor.half` | `self.half()` 等同于 `self.to(torch.float16)`。 | +| `Tensor.hardshrink` | 参见 `torch.nn.functional.hardshrink()` | +| `Tensor.heaviside` | 参见 `torch.heaviside()` | +| `Tensor.histc` | 参见 `torch.histc()` | +| `Tensor.histogram` | 参见 `torch.histogram()` | +| `Tensor.hsplit` | 参见 `torch.hsplit()` | +| `Tensor.hypot` | 参见 `torch.hypot()` | +| `Tensor.hypot_` | `hypot()` 的原地版本。 | +| `Tensor.i0` | 参见 `torch.i0()` | +| `Tensor.i0_` | `i0()` 的原地版本。 | +| `Tensor.igamma` | 参见 `torch.igamma()` | +| `Tensor.igamma_` | `igamma()` 的原地版本。 | +| `Tensor.igammac` | 参见 `torch.igammac()` | +| `Tensor.igammac_` | `igammac()`的原地版本。 | +| `Tensor.index_add_` | 通过将`alpha`倍的`source`元素累加到`self`张量中，按照`index`中给定的顺序添加到索引中。 | +| `Tensor.index_add` | `torch.Tensor.index_add_()`的非原地版本。 | +| `Tensor.index_copy_` | 通过按照`index`中给定的顺序选择的索引，将`tensor`的元素复制到`self`张量中。 | +| `Tensor.index_copy` | `torch.Tensor.index_copy_()`的非原地版本。 | +| `Tensor.index_fill_` | 通过按照`index`中给定的顺序选择的索引，用值`value`填充`self`张量的元素。 | +| `Tensor.index_fill` | `torch.Tensor.index_fill_()`的非原地版本。 | +| `Tensor.index_put_` | 使用`indices`中指定的索引（一个张量元组）将张量`values`中的值放入张量`self`中。 | +| `Tensor.index_put` | `index_put_()`的非原地版本。 | +| `Tensor.index_reduce_` | 通过使用`reduce`参数给定的减少方式，按照`index`中给定的顺序将`source`元素累加到`self`张量中。 | +| `Tensor.index_reduce` | | +| `Tensor.index_select` | 参见`torch.index_select()` | +| `Tensor.indices` | 返回稀疏 COO 张量的索引张量。 | +| `Tensor.inner` | 参见`torch.inner()`。 | +| `Tensor.int` | `self.int()`等同于`self.to(torch.int32)`。 | +| `Tensor.int_repr` | 给定一个量化张量，`self.int_repr()`返回一个 CPU 张量，数据类型为 uint8_t，存储给定张量的底层 uint8_t 值。 | +| `Tensor.inverse` | 参见`torch.inverse()` | +| `Tensor.isclose` | 参见`torch.isclose()` | +| `Tensor.isfinite` | 参见`torch.isfinite()` | +| `Tensor.isinf` | 参见`torch.isinf()` | +| `Tensor.isposinf` | 参见`torch.isposinf()` | +| `Tensor.isneginf` | 参见`torch.isneginf()` | +| `Tensor.isnan` | 参见`torch.isnan()` | +| `Tensor.is_contiguous` | 如果`self`张量在内存中按照内存格式指定的顺序是连续的，则返回 True。 | +| `Tensor.is_complex` | 如果`self`的数据类型是复数数据类型，则返回 True。 | +| `Tensor.is_conj` | 如果`self`的共轭位设置为 true，则返回 True。 | +| `Tensor.is_floating_point` | 如果`self`的数据类型是浮点数据类型，则返回 True。 | +| `Tensor.is_inference` | 参见`torch.is_inference()` | +| `Tensor.is_leaf` | 所有`requires_grad`为`False`的张量按照惯例都将是叶张量。 | +| `Tensor.is_pinned` | 如果此张量驻留在固定内存中，则返回 true。 | +| `Tensor.is_set_to` | 如果两个张量指向完全相同的内存（相同的存储、偏移、大小和步幅），则返回 True。 | +| `Tensor.is_shared` | 检查张量是否在共享内存中。 | +| `Tensor.is_signed` | 如果`self`的数据类型是有符号数据类型，则返回 True。 | +| `Tensor.is_sparse` | 如果张量使用稀疏 COO 存储布局，则为`True`，否则为`False`。 | +| `Tensor.istft` | 参见`torch.istft()` | +| `Tensor.isreal` | 参见`torch.isreal()` | +| `Tensor.item` | 将此张量的值作为标准 Python 数字返回。 | +| `Tensor.kthvalue` | 参见`torch.kthvalue()` | +| `Tensor.lcm` | 查看 `torch.lcm()` | +| `Tensor.lcm_` | `lcm()` 的原地版本。 | +| `Tensor.ldexp` | 查看 `torch.ldexp()` | +| `Tensor.ldexp_` | `ldexp()` 的原地版本。 | +| `Tensor.le` | 查看 `torch.le()`。 | +| `Tensor.le_` | `le()` 的原地版本。 | +| `Tensor.less_equal` | 查看 `torch.less_equal()`。 | +| `Tensor.less_equal_` | `less_equal()` 的原地版本。 | +| `Tensor.lerp` | 查看 `torch.lerp()` | +| `Tensor.lerp_` | `lerp()` 的原地版本。 | +| `Tensor.lgamma` | 查看 `torch.lgamma()` | +| `Tensor.lgamma_` | `lgamma()` 的原地版本。 | +| `Tensor.log` | 查看 `torch.log()` | +| `Tensor.log_` | `log()` 的原地版本。 | +| `Tensor.logdet` | 查看 `torch.logdet()` | +| `Tensor.log10` | 查看 `torch.log10()` | +| `Tensor.log10_` | `log10()` 的原地版本。 | +| `Tensor.log1p` | 查看 `torch.log1p()` | +| `Tensor.log1p_` | `log1p()` 的原地版本。 | +| `Tensor.log2` | 查看 `torch.log2()` | +| `Tensor.log2_` | `log2()` 的原地版本。 | +| `Tensor.log_normal_` | 使用给定的均值 $\mu$ 和标准差 $\sigma$ 参数化的对数正态分布中的样本填充 `self` 张量 | +| `Tensor.logaddexp` | 参见 `torch.logaddexp()` | +| `Tensor.logaddexp2` | 参见 `torch.logaddexp2()` | +| `Tensor.logsumexp` | 参见 `torch.logsumexp()` | +| `Tensor.logical_and` | 参见 `torch.logical_and()` | +| `Tensor.logical_and_` | `logical_and()` 的原地版本 | +| `Tensor.logical_not` | 参见 `torch.logical_not()` | +| `Tensor.logical_not_` | `logical_not()` 的原地版本 | +| `Tensor.logical_or` | 参见 `torch.logical_or()` | +| `Tensor.logical_or_` | `logical_or()` 的原地版本 | +| `Tensor.logical_xor` | 参见 `torch.logical_xor()` | +| `Tensor.logical_xor_` | `logical_xor()` 的原地版本 | +| `Tensor.logit` | 参见 `torch.logit()` | +| `Tensor.logit_` | `logit()` 的原地版本 | +| `Tensor.long` | `self.long()` 等同于 `self.to(torch.int64)` | +| `Tensor.lt` | 参见 `torch.lt()` | +| `Tensor.lt_` | `lt()` 的原地版本 | +| `Tensor.less` | lt(other) -> Tensor | +| `Tensor.less_` | `less()` 的原地版本 | +| `Tensor.lu` | 查看 `torch.lu()` | +| `Tensor.lu_solve` | 查看 `torch.lu_solve()` | +| `Tensor.as_subclass` | 创建一个具有与`self`相同数据指针的`cls`实例。 | +| `Tensor.map_` | 对`self`张量中的每个元素应用`callable`，并将结果存储在`self`张量中。 | +| `Tensor.masked_scatter_` | 将`source`中的元素复制到`self`张量中，其中`mask`为 True。 | +| `Tensor.masked_scatter` | `torch.Tensor.masked_scatter_()`的非就地版本 | +| `Tensor.masked_fill_` | 在`mask`为 True 的位置，用`value`填充`self`张量的元素。 | +| `Tensor.masked_fill` | `torch.Tensor.masked_fill_()`的非就地版本 | +| `Tensor.masked_select` | 查看 `torch.masked_select()` | +| `Tensor.matmul` | 查看 `torch.matmul()` | +| `Tensor.matrix_power` | 注意 -[`matrix_power()`](generated/torch.Tensor.matrix_power.html#torch.Tensor.matrix_power "torch.Tensor.matrix_power")已弃用，请使用[`torch.linalg.matrix_power()`](generated/torch.linalg.matrix_power.html#torch.linalg.matrix_power "torch.linalg.matrix_power")代替。 +`matrix_power()`已弃用，请使用`torch.linalg.matrix_power()`代替。 | -| [`Tensor.matrix_exp`](generated/torch.Tensor.matrix_exp.html#torch.Tensor.matrix_exp "torch.Tensor.matrix_exp") | 查看 [`torch.matrix_exp()`](generated/torch.matrix_exp.html#torch.matrix_exp "torch.matrix_exp") | +| `Tensor.matrix_exp` | 查看 `torch.matrix_exp()` | | --- | --- | -| [`Tensor.max`](generated/torch.Tensor.max.html#torch.Tensor.max "torch.Tensor.max") | 查看 [`torch.max()`](generated/torch.max.html#torch.max "torch.max") | -| [`Tensor.maximum`](generated/torch.Tensor.maximum.html#torch.Tensor.maximum "torch.Tensor.maximum") | 查看 [`torch.maximum()`](generated/torch.maximum.html#torch.maximum "torch.maximum") | -| [`Tensor.mean`](generated/torch.Tensor.mean.html#torch.Tensor.mean "torch.Tensor.mean") | 查看 [`torch.mean()`](generated/torch.mean.html#torch.mean "torch.mean") | -| [`Tensor.nanmean`](generated/torch.Tensor.nanmean.html#torch.Tensor.nanmean "torch.Tensor.nanmean") | 查看 [`torch.nanmean()`](generated/torch.nanmean.html#torch.nanmean "torch.nanmean") | -| [`Tensor.median`](generated/torch.Tensor.median.html#torch.Tensor.median "torch.Tensor.median") | 查看 [`torch.median()`](generated/torch.median.html#torch.median "torch.median") | -| [`Tensor.nanmedian`](generated/torch.Tensor.nanmedian.html#torch.Tensor.nanmedian "torch.Tensor.nanmedian") | 查看 [`torch.nanmedian()`](generated/torch.nanmedian.html#torch.nanmedian "torch.nanmedian") | -| [`Tensor.min`](generated/torch.Tensor.min.html#torch.Tensor.min "torch.Tensor.min") | 查看 [`torch.min()`](generated/torch.min.html#torch.min "torch.min") | -| [`Tensor.minimum`](generated/torch.Tensor.minimum.html#torch.Tensor.minimum "torch.Tensor.minimum") | 查看 [`torch.minimum()`](generated/torch.minimum.html#torch.minimum "torch.minimum") | -| [`Tensor.mm`](generated/torch.Tensor.mm.html#torch.Tensor.mm "torch.Tensor.mm") | 查看 [`torch.mm()`](generated/torch.mm.html#torch.mm "torch.mm") | -| [`Tensor.smm`](generated/torch.Tensor.smm.html#torch.Tensor.smm "torch.Tensor.smm") | 查看 [`torch.smm()`](generated/torch.smm.html#torch.smm "torch.smm") | -| [`Tensor.mode`](generated/torch.Tensor.mode.html#torch.Tensor.mode "torch.Tensor.mode") | 查看 [`torch.mode()`](generated/torch.mode.html#torch.mode "torch.mode") | -| [`Tensor.movedim`](generated/torch.Tensor.movedim.html#torch.Tensor.movedim "torch.Tensor.movedim") | 查看 [`torch.movedim()`](generated/torch.movedim.html#torch.movedim "torch.movedim") | -| [`Tensor.moveaxis`](generated/torch.Tensor.moveaxis.html#torch.Tensor.moveaxis "torch.Tensor.moveaxis") | 查看 [`torch.moveaxis()`](generated/torch.moveaxis.html#torch.moveaxis "torch.moveaxis") | -| [`Tensor.msort`](generated/torch.Tensor.msort.html#torch.Tensor.msort "torch.Tensor.msort") | 查看 [`torch.msort()`](generated/torch.msort.html#torch.msort "torch.msort") | -| [`Tensor.mul`](generated/torch.Tensor.mul.html#torch.Tensor.mul "torch.Tensor.mul") | 查看 [`torch.mul()`](generated/torch.mul.html#torch.mul "torch.mul") | -| [`Tensor.mul_`](generated/torch.Tensor.mul_.html#torch.Tensor.mul_ "torch.Tensor.mul_") | [`mul()`](generated/torch.Tensor.mul.html#torch.Tensor.mul "torch.Tensor.mul") 的原地版本 | -| [`Tensor.multiply`](generated/torch.Tensor.multiply.html#torch.Tensor.multiply "torch.Tensor.multiply") | 查看 [`torch.multiply()`](generated/torch.multiply.html#torch.multiply "torch.multiply") | -| [`Tensor.multiply_`](generated/torch.Tensor.multiply_.html#torch.Tensor.multiply_ "torch.Tensor.multiply_") | [`multiply()`](generated/torch.Tensor.multiply.html#torch.Tensor.multiply "torch.Tensor.multiply") 的原地版本 | -| [`Tensor.multinomial`](generated/torch.Tensor.multinomial.html#torch.Tensor.multinomial "torch.Tensor.multinomial") | 查看 [`torch.multinomial()`](generated/torch.multinomial.html#torch.multinomial "torch.multinomial") | -| [`Tensor.mv`](generated/torch.Tensor.mv.html#torch.Tensor.mv "torch.Tensor.mv") | 查看 [`torch.mv()`](generated/torch.mv.html#torch.mv "torch.mv") | -| [`Tensor.mvlgamma`](generated/torch.Tensor.mvlgamma.html#torch.Tensor.mvlgamma "torch.Tensor.mvlgamma") | 查看 [`torch.mvlgamma()`](generated/torch.mvlgamma.html#torch.mvlgamma "torch.mvlgamma") | -| [`Tensor.mvlgamma_`](generated/torch.Tensor.mvlgamma_.html#torch.Tensor.mvlgamma_ "torch.Tensor.mvlgamma_") | [`mvlgamma()`](generated/torch.Tensor.mvlgamma.html#torch.Tensor.mvlgamma "torch.Tensor.mvlgamma") 的原地版本 | -| [`Tensor.nansum`](generated/torch.Tensor.nansum.html#torch.Tensor.nansum "torch.Tensor.nansum") | 查看 [`torch.nansum()`](generated/torch.nansum.html#torch.nansum "torch.nansum") | -| [`Tensor.narrow`](generated/torch.Tensor.narrow.html#torch.Tensor.narrow "torch.Tensor.narrow") | 查看 [`torch.narrow()`](generated/torch.narrow.html#torch.narrow "torch.narrow") | -| [`Tensor.narrow_copy`](generated/torch.Tensor.narrow_copy.html#torch.Tensor.narrow_copy "torch.Tensor.narrow_copy") | 查看 [`torch.narrow_copy()`](generated/torch.narrow_copy.html#torch.narrow_copy "torch.narrow_copy") | -| [`Tensor.ndimension`](generated/torch.Tensor.ndimension.html#torch.Tensor.ndimension "torch.Tensor.ndimension") | [`dim()`](generated/torch.Tensor.dim.html#torch.Tensor.dim "torch.Tensor.dim") 的别名 | -| [`Tensor.nan_to_num`](generated/torch.Tensor.nan_to_num.html#torch.Tensor.nan_to_num "torch.Tensor.nan_to_num") | 查看 [`torch.nan_to_num()`](generated/torch.nan_to_num.html#torch.nan_to_num "torch.nan_to_num") | -| [`Tensor.nan_to_num_`](generated/torch.Tensor.nan_to_num_.html#torch.Tensor.nan_to_num_ "torch.Tensor.nan_to_num_") | [`nan_to_num()`](generated/torch.Tensor.nan_to_num.html#torch.Tensor.nan_to_num "torch.Tensor.nan_to_num") 的原地版本。 | -| [`Tensor.ne`](generated/torch.Tensor.ne.html#torch.Tensor.ne "torch.Tensor.ne") | 参见 [`torch.ne()`](generated/torch.ne.html#torch.ne "torch.ne") | -| [`Tensor.ne_`](generated/torch.Tensor.ne_.html#torch.Tensor.ne_ "torch.Tensor.ne_") | [`ne()`](generated/torch.Tensor.ne.html#torch.Tensor.ne "torch.Tensor.ne") 的原地版本。 | -| [`Tensor.not_equal`](generated/torch.Tensor.not_equal.html#torch.Tensor.not_equal "torch.Tensor.not_equal") | 参见 [`torch.not_equal()`](generated/torch.not_equal.html#torch.not_equal "torch.not_equal") | -| [`Tensor.not_equal_`](generated/torch.Tensor.not_equal_.html#torch.Tensor.not_equal_ "torch.Tensor.not_equal_") | [`not_equal()`](generated/torch.Tensor.not_equal.html#torch.Tensor.not_equal "torch.Tensor.not_equal") 的原地版本。 | -| [`Tensor.neg`](generated/torch.Tensor.neg.html#torch.Tensor.neg "torch.Tensor.neg") | 参见 [`torch.neg()`](generated/torch.neg.html#torch.neg "torch.neg") | -| [`Tensor.neg_`](generated/torch.Tensor.neg_.html#torch.Tensor.neg_ "torch.Tensor.neg_") | [`neg()`](generated/torch.Tensor.neg.html#torch.Tensor.neg "torch.Tensor.neg") 的原地版本。 | -| [`Tensor.negative`](generated/torch.Tensor.negative.html#torch.Tensor.negative "torch.Tensor.negative") | 参见 [`torch.negative()`](generated/torch.negative.html#torch.negative "torch.negative") | -| [`Tensor.negative_`](generated/torch.Tensor.negative_.html#torch.Tensor.negative_ "torch.Tensor.negative_") | [`negative()`](generated/torch.Tensor.negative.html#torch.Tensor.negative "torch.Tensor.negative") 的原地版本。 | -| [`Tensor.nelement`](generated/torch.Tensor.nelement.html#torch.Tensor.nelement "torch.Tensor.nelement") | [`numel()`](generated/torch.Tensor.numel.html#torch.Tensor.numel "torch.Tensor.numel") 的别名 | -| [`Tensor.nextafter`](generated/torch.Tensor.nextafter.html#torch.Tensor.nextafter "torch.Tensor.nextafter") | 参见 [`torch.nextafter()`](generated/torch.nextafter.html#torch.nextafter "torch.nextafter") | -| [`Tensor.nextafter_`](generated/torch.Tensor.nextafter_.html#torch.Tensor.nextafter_ "torch.Tensor.nextafter_") | [`nextafter()`](generated/torch.Tensor.nextafter.html#torch.Tensor.nextafter "torch.Tensor.nextafter") 的原地版本。 | -| [`Tensor.nonzero`](generated/torch.Tensor.nonzero.html#torch.Tensor.nonzero "torch.Tensor.nonzero") | 参见 [`torch.nonzero()`](generated/torch.nonzero.html#torch.nonzero "torch.nonzero") | -| [`Tensor.norm`](generated/torch.Tensor.norm.html#torch.Tensor.norm "torch.Tensor.norm") | 参见 [`torch.norm()`](generated/torch.norm.html#torch.norm "torch.norm") | -| [`Tensor.normal_`](generated/torch.Tensor.normal_.html#torch.Tensor.normal_ "torch.Tensor.normal_") | 使用由 [`mean`](generated/torch.mean.html#torch.mean "torch.mean") 和 [`std`](generated/torch.std.html#torch.std "torch.std") 参数化的正态分布样本填充 `self` 张量。 | -| [`Tensor.numel`](generated/torch.Tensor.numel.html#torch.Tensor.numel "torch.Tensor.numel") | 参见 [`torch.numel()`](generated/torch.numel.html#torch.numel "torch.numel") | -| [`Tensor.numpy`](generated/torch.Tensor.numpy.html#torch.Tensor.numpy "torch.Tensor.numpy") | 将张量返回为 NumPy `ndarray`。 | -| [`Tensor.orgqr`](generated/torch.Tensor.orgqr.html#torch.Tensor.orgqr "torch.Tensor.orgqr") | 参见 [`torch.orgqr()`](generated/torch.orgqr.html#torch.orgqr "torch.orgqr") | -| [`Tensor.ormqr`](generated/torch.Tensor.ormqr.html#torch.Tensor.ormqr "torch.Tensor.ormqr") | 参见 [`torch.ormqr()`](generated/torch.ormqr.html#torch.ormqr "torch.ormqr") | -| [`Tensor.outer`](generated/torch.Tensor.outer.html#torch.Tensor.outer "torch.Tensor.outer") | 参见 [`torch.outer()`](generated/torch.outer.html#torch.outer "torch.outer") | -| [`Tensor.permute`](generated/torch.Tensor.permute.html#torch.Tensor.permute "torch.Tensor.permute") | 查看 [`torch.permute()`](generated/torch.permute.html#torch.permute "torch.permute") | -| [`Tensor.pin_memory`](generated/torch.Tensor.pin_memory.html#torch.Tensor.pin_memory "torch.Tensor.pin_memory") | 如果尚未固定，将张量复制到固定内存中。 | -| [`Tensor.pinverse`](generated/torch.Tensor.pinverse.html#torch.Tensor.pinverse "torch.Tensor.pinverse") | 查看 [`torch.pinverse()`](generated/torch.pinverse.html#torch.pinverse "torch.pinverse") | -| [`Tensor.polygamma`](generated/torch.Tensor.polygamma.html#torch.Tensor.polygamma "torch.Tensor.polygamma") | 查看 [`torch.polygamma()`](generated/torch.polygamma.html#torch.polygamma "torch.polygamma") | -| [`Tensor.polygamma_`](generated/torch.Tensor.polygamma_.html#torch.Tensor.polygamma_ "torch.Tensor.polygamma_") | [`polygamma()`](generated/torch.Tensor.polygamma.html#torch.Tensor.polygamma "torch.Tensor.polygamma") 的原地版本 | -| [`Tensor.positive`](generated/torch.Tensor.positive.html#torch.Tensor.positive "torch.Tensor.positive") | 查看 [`torch.positive()`](generated/torch.positive.html#torch.positive "torch.positive") | -| [`Tensor.pow`](generated/torch.Tensor.pow.html#torch.Tensor.pow "torch.Tensor.pow") | 查看 [`torch.pow()`](generated/torch.pow.html#torch.pow "torch.pow") | -| [`Tensor.pow_`](generated/torch.Tensor.pow_.html#torch.Tensor.pow_ "torch.Tensor.pow_") | [`pow()`](generated/torch.Tensor.pow.html#torch.Tensor.pow "torch.Tensor.pow") 的原地版本 | -| [`Tensor.prod`](generated/torch.Tensor.prod.html#torch.Tensor.prod "torch.Tensor.prod") | 查看 [`torch.prod()`](generated/torch.prod.html#torch.prod "torch.prod") | -| [`Tensor.put_`](generated/torch.Tensor.put_.html#torch.Tensor.put_ "torch.Tensor.put_") | 将 `source` 中的元素复制到由 `index` 指定的位置。 | -| [`Tensor.qr`](generated/torch.Tensor.qr.html#torch.Tensor.qr "torch.Tensor.qr") | 查看 [`torch.qr()`](generated/torch.qr.html#torch.qr "torch.qr") | -| [`Tensor.qscheme`](generated/torch.Tensor.qscheme.html#torch.Tensor.qscheme "torch.Tensor.qscheme") | 返回给定 QTensor 的量化方案。 | -| [`Tensor.quantile`](generated/torch.Tensor.quantile.html#torch.Tensor.quantile "torch.Tensor.quantile") | 查看 [`torch.quantile()`](generated/torch.quantile.html#torch.quantile "torch.quantile") | -| [`Tensor.nanquantile`](generated/torch.Tensor.nanquantile.html#torch.Tensor.nanquantile "torch.Tensor.nanquantile") | 查看 [`torch.nanquantile()`](generated/torch.nanquantile.html#torch.nanquantile "torch.nanquantile") | -| [`Tensor.q_scale`](generated/torch.Tensor.q_scale.html#torch.Tensor.q_scale "torch.Tensor.q_scale") | 给定通过线性（仿射）量化的张量，返回底层量化器的比例。 | -| [`Tensor.q_zero_point`](generated/torch.Tensor.q_zero_point.html#torch.Tensor.q_zero_point "torch.Tensor.q_zero_point") | 给定通过线性（仿射）量化的张量，返回底层量化器的零点。 | -| [`Tensor.q_per_channel_scales`](generated/torch.Tensor.q_per_channel_scales.html#torch.Tensor.q_per_channel_scales "torch.Tensor.q_per_channel_scales") | 给定通过线性（仿射）逐通道量化的张量，返回底层量化器的比例张量。 | -| [`Tensor.q_per_channel_zero_points`](generated/torch.Tensor.q_per_channel_zero_points.html#torch.Tensor.q_per_channel_zero_points "torch.Tensor.q_per_channel_zero_points") | 给定通过线性（仿射）逐通道量化的张量，返回底层量化器的零点张量。 | -| [`Tensor.q_per_channel_axis`](generated/torch.Tensor.q_per_channel_axis.html#torch.Tensor.q_per_channel_axis "torch.Tensor.q_per_channel_axis") | 给定通过线性（仿射）逐通道量化的张量，返回应用逐通道量化的维度索引。 | -| [`Tensor.rad2deg`](generated/torch.Tensor.rad2deg.html#torch.Tensor.rad2deg "torch.Tensor.rad2deg") | 参见[`torch.rad2deg()`](generated/torch.rad2deg.html#torch.rad2deg "torch.rad2deg") | -| [`Tensor.random_`](generated/torch.Tensor.random_.html#torch.Tensor.random_ "torch.Tensor.random_") | 用从离散均匀分布`[from, to - 1]`中抽样的数字填充`self`张量。 | -| [`Tensor.ravel`](generated/torch.Tensor.ravel.html#torch.Tensor.ravel "torch.Tensor.ravel") | 参见[`torch.ravel()`](generated/torch.ravel.html#torch.ravel "torch.ravel") | -| [`Tensor.reciprocal`](generated/torch.Tensor.reciprocal.html#torch.Tensor.reciprocal "torch.Tensor.reciprocal") | 参见[`torch.reciprocal()`](generated/torch.reciprocal.html#torch.reciprocal "torch.reciprocal") | -| [`Tensor.reciprocal_`](generated/torch.Tensor.reciprocal_.html#torch.Tensor.reciprocal_ "torch.Tensor.reciprocal_") | [`reciprocal()`](generated/torch.Tensor.reciprocal.html#torch.Tensor.reciprocal "torch.Tensor.reciprocal")的原位版本 | -| [`Tensor.record_stream`](generated/torch.Tensor.record_stream.html#torch.Tensor.record_stream "torch.Tensor.record_stream") | 将张量标记为此流程已使用。 | -| [`Tensor.register_hook`](generated/torch.Tensor.register_hook.html#torch.Tensor.register_hook "torch.Tensor.register_hook") | 注册一个反向钩子。 | -| [`Tensor.register_post_accumulate_grad_hook`](generated/torch.Tensor.register_post_accumulate_grad_hook.html#torch.Tensor.register_post_accumulate_grad_hook "torch.Tensor.register_post_accumulate_grad_hook") | 注册一个在梯度累积后运行的反向钩子。 | -| [`Tensor.remainder`](generated/torch.Tensor.remainder.html#torch.Tensor.remainder "torch.Tensor.remainder") | 参见[`torch.remainder()`](generated/torch.remainder.html#torch.remainder "torch.remainder") | -| [`Tensor.remainder_`](generated/torch.Tensor.remainder_.html#torch.Tensor.remainder_ "torch.Tensor.remainder_") | [`remainder()`](generated/torch.Tensor.remainder.html#torch.Tensor.remainder "torch.Tensor.remainder")的原位版本 | -| [`Tensor.renorm`](generated/torch.Tensor.renorm.html#torch.Tensor.renorm "torch.Tensor.renorm") | 参见[`torch.renorm()`](generated/torch.renorm.html#torch.renorm "torch.renorm") | -| [`Tensor.renorm_`](generated/torch.Tensor.renorm_.html#torch.Tensor.renorm_ "torch.Tensor.renorm_") | [`renorm()`](generated/torch.Tensor.renorm.html#torch.Tensor.renorm "torch.Tensor.renorm")的原位版本 | -| [`Tensor.repeat`](generated/torch.Tensor.repeat.html#torch.Tensor.repeat "torch.Tensor.repeat") | 沿指定维度重复此张量。 | -| [`Tensor.repeat_interleave`](generated/torch.Tensor.repeat_interleave.html#torch.Tensor.repeat_interleave "torch.Tensor.repeat_interleave") | 参见[`torch.repeat_interleave()`](generated/torch.repeat_interleave.html#torch.repeat_interleave "torch.repeat_interleave")。 | -| [`Tensor.requires_grad`](generated/torch.Tensor.requires_grad.html#torch.Tensor.requires_grad "torch.Tensor.requires_grad") | 如果需要为此张量计算梯度，则为`True`，否则为`False`。 | -| [`Tensor.requires_grad_`](generated/torch.Tensor.requires_grad_.html#torch.Tensor.requires_grad_ "torch.Tensor.requires_grad_") | 更改是否应记录此张量上的操作的自动微分：就地设置此张量的`requires_grad`属性。 | -| [`Tensor.reshape`](generated/torch.Tensor.reshape.html#torch.Tensor.reshape "torch.Tensor.reshape") | 返回一个与`self`具有相同数据和元素数量但具有指定形状的张量。 | -| [`Tensor.reshape_as`](generated/torch.Tensor.reshape_as.html#torch.Tensor.reshape_as "torch.Tensor.reshape_as") | 将此张量返回为与`other`相同形状的张量。 | -| [`Tensor.resize_`](generated/torch.Tensor.resize_.html#torch.Tensor.resize_ "torch.Tensor.resize_") | 将`self`张量调整为指定大小。 | -| [`Tensor.resize_as_`](generated/torch.Tensor.resize_as_.html#torch.Tensor.resize_as_ "torch.Tensor.resize_as_") | 将 `self` 张量调整为与指定的 [`tensor`](generated/torch.tensor.html#torch.tensor "torch.tensor") 相同大小 | -| [`Tensor.retain_grad`](generated/torch.Tensor.retain_grad.html#torch.Tensor.retain_grad "torch.Tensor.retain_grad") | 在 `backward()` 过程中使此张量的 `grad` 被填充 | -| [`Tensor.retains_grad`](generated/torch.Tensor.retains_grad.html#torch.Tensor.retains_grad "torch.Tensor.retains_grad") | 如果此张量是非叶子节点且其 `grad` 已启用填充，则为 `True`，否则为 `False` | -| [`Tensor.roll`](generated/torch.Tensor.roll.html#torch.Tensor.roll "torch.Tensor.roll") | 查看 [`torch.roll()`](generated/torch.roll.html#torch.roll "torch.roll") | -| [`Tensor.rot90`](generated/torch.Tensor.rot90.html#torch.Tensor.rot90 "torch.Tensor.rot90") | 查看 [`torch.rot90()`](generated/torch.rot90.html#torch.rot90 "torch.rot90") | -| [`Tensor.round`](generated/torch.Tensor.round.html#torch.Tensor.round "torch.Tensor.round") | 查看 [`torch.round()`](generated/torch.round.html#torch.round "torch.round") | -| [`Tensor.round_`](generated/torch.Tensor.round_.html#torch.Tensor.round_ "torch.Tensor.round_") | [`round()`](generated/torch.Tensor.round.html#torch.Tensor.round "torch.Tensor.round") 的就地版本 | -| [`Tensor.rsqrt`](generated/torch.Tensor.rsqrt.html#torch.Tensor.rsqrt "torch.Tensor.rsqrt") | 查看 [`torch.rsqrt()`](generated/torch.rsqrt.html#torch.rsqrt "torch.rsqrt") | -| [`Tensor.rsqrt_`](generated/torch.Tensor.rsqrt_.html#torch.Tensor.rsqrt_ "torch.Tensor.rsqrt_") | [`rsqrt()`](generated/torch.Tensor.rsqrt.html#torch.Tensor.rsqrt "torch.Tensor.rsqrt") 的就地版本 | -| [`Tensor.scatter`](generated/torch.Tensor.scatter.html#torch.Tensor.scatter "torch.Tensor.scatter") | [`torch.Tensor.scatter_()`](generated/torch.Tensor.scatter_.html#torch.Tensor.scatter_ "torch.Tensor.scatter_") 的非就地版本 | -| [`Tensor.scatter_`](generated/torch.Tensor.scatter_.html#torch.Tensor.scatter_ "torch.Tensor.scatter_") | 将张量 `src` 中的所有值写入到指定在 `index` 张量中的 `self` 中 | -| [`Tensor.scatter_add_`](generated/torch.Tensor.scatter_add_.html#torch.Tensor.scatter_add_ "torch.Tensor.scatter_add_") | 将张量 `src` 中的所有值添加到 `index` 张量中指定的 `self` 中，类似于 [`scatter_()`](generated/torch.Tensor.scatter_.html#torch.Tensor.scatter_ "torch.Tensor.scatter_") 的方式 | -| [`Tensor.scatter_add`](generated/torch.Tensor.scatter_add.html#torch.Tensor.scatter_add "torch.Tensor.scatter_add") | [`torch.Tensor.scatter_add_()`](generated/torch.Tensor.scatter_add_.html#torch.Tensor.scatter_add_ "torch.Tensor.scatter_add_") 的非就地版本 | -| [`Tensor.scatter_reduce_`](generated/torch.Tensor.scatter_reduce_.html#torch.Tensor.scatter_reduce_ "torch.Tensor.scatter_reduce_") | 将 `src` 张量中的所有值按照应用的减少方式（`"sum"`、`"prod"`、`"mean"`、`"amax"`、`"amin"`）减少到 `index` 张量中指定的索引中的 `self` 张量中 | -| [`Tensor.scatter_reduce`](generated/torch.Tensor.scatter_reduce.html#torch.Tensor.scatter_reduce "torch.Tensor.scatter_reduce") | [`torch.Tensor.scatter_reduce_()`](generated/torch.Tensor.scatter_reduce_.html#torch.Tensor.scatter_reduce_ "torch.Tensor.scatter_reduce_") 的非就地版本 | -| [`Tensor.select`](generated/torch.Tensor.select.html#torch.Tensor.select "torch.Tensor.select") | 查看 [`torch.select()`](generated/torch.select.html#torch.select "torch.select") | -| [`Tensor.select_scatter`](generated/torch.Tensor.select_scatter.html#torch.Tensor.select_scatter "torch.Tensor.select_scatter") | 查看 [`torch.select_scatter()`](generated/torch.select_scatter.html#torch.select_scatter "torch.select_scatter") | -| [`Tensor.set_`](generated/torch.Tensor.set_.html#torch.Tensor.set_ "torch.Tensor.set_") | 设置底层存储、大小和步幅。 | -| [`Tensor.share_memory_`](generated/torch.Tensor.share_memory_.html#torch.Tensor.share_memory_ "torch.Tensor.share_memory_") | 将底层存储移动到共享内存。 | -| [`Tensor.short`](generated/torch.Tensor.short.html#torch.Tensor.short "torch.Tensor.short") | `self.short()` 等同于 `self.to(torch.int16)`。 | -| [`Tensor.sigmoid`](generated/torch.Tensor.sigmoid.html#torch.Tensor.sigmoid "torch.Tensor.sigmoid") | 查看 [`torch.sigmoid()`](generated/torch.sigmoid.html#torch.sigmoid "torch.sigmoid") | -| [`Tensor.sigmoid_`](generated/torch.Tensor.sigmoid_.html#torch.Tensor.sigmoid_ "torch.Tensor.sigmoid_") | [`sigmoid()`](generated/torch.Tensor.sigmoid.html#torch.Tensor.sigmoid "torch.Tensor.sigmoid") 的原地版本 | -| [`Tensor.sign`](generated/torch.Tensor.sign.html#torch.Tensor.sign "torch.Tensor.sign") | 查看 [`torch.sign()`](generated/torch.sign.html#torch.sign "torch.sign") | -| [`Tensor.sign_`](generated/torch.Tensor.sign_.html#torch.Tensor.sign_ "torch.Tensor.sign_") | [`sign()`](generated/torch.Tensor.sign.html#torch.Tensor.sign "torch.Tensor.sign") 的原地版本 | -| [`Tensor.signbit`](generated/torch.Tensor.signbit.html#torch.Tensor.signbit "torch.Tensor.signbit") | 查看 [`torch.signbit()`](generated/torch.signbit.html#torch.signbit "torch.signbit") | -| [`Tensor.sgn`](generated/torch.Tensor.sgn.html#torch.Tensor.sgn "torch.Tensor.sgn") | 查看 [`torch.sgn()`](generated/torch.sgn.html#torch.sgn "torch.sgn") | -| [`Tensor.sgn_`](generated/torch.Tensor.sgn_.html#torch.Tensor.sgn_ "torch.Tensor.sgn_") | [`sgn()`](generated/torch.Tensor.sgn.html#torch.Tensor.sgn "torch.Tensor.sgn") 的原地版本 | -| [`Tensor.sin`](generated/torch.Tensor.sin.html#torch.Tensor.sin "torch.Tensor.sin") | 查看 [`torch.sin()`](generated/torch.sin.html#torch.sin "torch.sin") | -| [`Tensor.sin_`](generated/torch.Tensor.sin_.html#torch.Tensor.sin_ "torch.Tensor.sin_") | [`sin()`](generated/torch.Tensor.sin.html#torch.Tensor.sin "torch.Tensor.sin") 的原地版本 | -| [`Tensor.sinc`](generated/torch.Tensor.sinc.html#torch.Tensor.sinc "torch.Tensor.sinc") | 查看 [`torch.sinc()`](generated/torch.sinc.html#torch.sinc "torch.sinc") | -| [`Tensor.sinc_`](generated/torch.Tensor.sinc_.html#torch.Tensor.sinc_ "torch.Tensor.sinc_") | [`sinc()`](generated/torch.Tensor.sinc.html#torch.Tensor.sinc "torch.Tensor.sinc") 的原地版本 | -| [`Tensor.sinh`](generated/torch.Tensor.sinh.html#torch.Tensor.sinh "torch.Tensor.sinh") | 查看 [`torch.sinh()`](generated/torch.sinh.html#torch.sinh "torch.sinh") | -| [`Tensor.sinh_`](generated/torch.Tensor.sinh_.html#torch.Tensor.sinh_ "torch.Tensor.sinh_") | [`sinh()`](generated/torch.Tensor.sinh.html#torch.Tensor.sinh "torch.Tensor.sinh") 的原地版本 | -| [`Tensor.asinh`](generated/torch.Tensor.asinh.html#torch.Tensor.asinh "torch.Tensor.asinh") | 查看 [`torch.asinh()`](generated/torch.asinh.html#torch.asinh "torch.asinh") | -| [`Tensor.asinh_`](generated/torch.Tensor.asinh_.html#torch.Tensor.asinh_ "torch.Tensor.asinh_") | [`asinh()`](generated/torch.Tensor.asinh.html#torch.Tensor.asinh "torch.Tensor.asinh") 的原地版本 | -| [`Tensor.arcsinh`](generated/torch.Tensor.arcsinh.html#torch.Tensor.arcsinh "torch.Tensor.arcsinh") | 查看 [`torch.arcsinh()`](generated/torch.arcsinh.html#torch.arcsinh "torch.arcsinh") | -| [`Tensor.arcsinh_`](generated/torch.Tensor.arcsinh_.html#torch.Tensor.arcsinh_ "torch.Tensor.arcsinh_") | [`arcsinh()`](generated/torch.Tensor.arcsinh.html#torch.Tensor.arcsinh "torch.Tensor.arcsinh") 的原地版本 | -| [`Tensor.shape`](generated/torch.Tensor.shape.html#torch.Tensor.shape "torch.Tensor.shape") | 返回 `self` 张量的大小。 | -| [`Tensor.size`](generated/torch.Tensor.size.html#torch.Tensor.size "torch.Tensor.size") | 返回 `self` 张量的大小。 | -| [`Tensor.slogdet`](generated/torch.Tensor.slogdet.html#torch.Tensor.slogdet "torch.Tensor.slogdet") | 查看 [`torch.slogdet()`](generated/torch.slogdet.html#torch.slogdet "torch.slogdet") | -| [`Tensor.slice_scatter`](generated/torch.Tensor.slice_scatter.html#torch.Tensor.slice_scatter "torch.Tensor.slice_scatter") | 查看 [`torch.slice_scatter()`](generated/torch.slice_scatter.html#torch.slice_scatter "torch.slice_scatter") | -| [`Tensor.softmax`](generated/torch.Tensor.softmax.html#torch.Tensor.softmax "torch.Tensor.softmax") | [`torch.nn.functional.softmax()`](generated/torch.nn.functional.softmax.html#torch.nn.functional.softmax "torch.nn.functional.softmax") 的别名。 | -| [`Tensor.sort`](generated/torch.Tensor.sort.html#torch.Tensor.sort "torch.Tensor.sort") | 查看 [`torch.sort()`](generated/torch.sort.html#torch.sort "torch.sort") | -| [`Tensor.split`](generated/torch.Tensor.split.html#torch.Tensor.split "torch.Tensor.split") | 查看 [`torch.split()`](generated/torch.split.html#torch.split "torch.split") | -| [`Tensor.sparse_mask`](generated/torch.Tensor.sparse_mask.html#torch.Tensor.sparse_mask "torch.Tensor.sparse_mask") | 使用稀疏张量 `mask` 的索引过滤来自分块张量 `self` 的值，返回一个新的 [稀疏张量](sparse.html#sparse-docs)。 | -| [`Tensor.sparse_dim`](generated/torch.Tensor.sparse_dim.html#torch.Tensor.sparse_dim "torch.Tensor.sparse_dim") | 返回 [稀疏张量](sparse.html#sparse-docs) `self` 中稀疏维度的数量。 | -| [`Tensor.sqrt`](generated/torch.Tensor.sqrt.html#torch.Tensor.sqrt "torch.Tensor.sqrt") | 查看 [`torch.sqrt()`](generated/torch.sqrt.html#torch.sqrt "torch.sqrt") | -| [`Tensor.sqrt_`](generated/torch.Tensor.sqrt_.html#torch.Tensor.sqrt_ "torch.Tensor.sqrt_") | [`sqrt()`](generated/torch.Tensor.sqrt.html#torch.Tensor.sqrt "torch.Tensor.sqrt") 的原地版本 | -| [`Tensor.square`](generated/torch.Tensor.square.html#torch.Tensor.square "torch.Tensor.square") | 查看 [`torch.square()`](generated/torch.square.html#torch.square "torch.square") | -| [`Tensor.square_`](generated/torch.Tensor.square_.html#torch.Tensor.square_ "torch.Tensor.square_") | [`square()`](generated/torch.Tensor.square.html#torch.Tensor.square "torch.Tensor.square") 的原地版本 | -| [`Tensor.squeeze`](generated/torch.Tensor.squeeze.html#torch.Tensor.squeeze "torch.Tensor.squeeze") | 查看 [`torch.squeeze()`](generated/torch.squeeze.html#torch.squeeze "torch.squeeze") | -| [`Tensor.squeeze_`](generated/torch.Tensor.squeeze_.html#torch.Tensor.squeeze_ "torch.Tensor.squeeze_") | [`squeeze()`](generated/torch.Tensor.squeeze.html#torch.Tensor.squeeze "torch.Tensor.squeeze") 的原地版本 | -| [`Tensor.std`](generated/torch.Tensor.std.html#torch.Tensor.std "torch.Tensor.std") | 查看 [`torch.std()`](generated/torch.std.html#torch.std "torch.std") | -| [`Tensor.stft`](generated/torch.Tensor.stft.html#torch.Tensor.stft "torch.Tensor.stft") | 查看 [`torch.stft()`](generated/torch.stft.html#torch.stft "torch.stft") | -| [`Tensor.storage`](generated/torch.Tensor.storage.html#torch.Tensor.storage "torch.Tensor.storage") | 返回底层的 [`TypedStorage`](storage.html#torch.TypedStorage "torch.TypedStorage")。 | -| [`Tensor.untyped_storage`](generated/torch.Tensor.untyped_storage.html#torch.Tensor.untyped_storage "torch.Tensor.untyped_storage") | 返回底层的 [`UntypedStorage`](storage.html#torch.UntypedStorage "torch.UntypedStorage")。 | -| [`Tensor.storage_offset`](generated/torch.Tensor.storage_offset.html#torch.Tensor.storage_offset "torch.Tensor.storage_offset") | 返回 `self` 张量在底层存储中的偏移量，以存储元素的数量表示（不是字节）。 | -| [`Tensor.storage_type`](generated/torch.Tensor.storage_type.html#torch.Tensor.storage_type "torch.Tensor.storage_type") | 返回底层存储的类型。 | -| [`Tensor.stride`](generated/torch.Tensor.stride.html#torch.Tensor.stride "torch.Tensor.stride") | 返回 `self` 张量的步幅。 | -| [`Tensor.sub`](generated/torch.Tensor.sub.html#torch.Tensor.sub "torch.Tensor.sub") | 查看 [`torch.sub()`](generated/torch.sub.html#torch.sub "torch.sub") | -| [`Tensor.sub_`](generated/torch.Tensor.sub_.html#torch.Tensor.sub_ "torch.Tensor.sub_") | [`sub()`](generated/torch.Tensor.sub.html#torch.Tensor.sub "torch.Tensor.sub") 的原地版本 | -| [`Tensor.subtract`](generated/torch.Tensor.subtract.html#torch.Tensor.subtract "torch.Tensor.subtract") | 查看 [`torch.subtract()`](generated/torch.subtract.html#torch.subtract "torch.subtract") | -| [`Tensor.subtract_`](generated/torch.Tensor.subtract_.html#torch.Tensor.subtract_ "torch.Tensor.subtract_") | [`subtract()`](generated/torch.Tensor.subtract.html#torch.Tensor.subtract "torch.Tensor.subtract") 的原地版本 | -| [`Tensor.sum`](generated/torch.Tensor.sum.html#torch.Tensor.sum "torch.Tensor.sum") | 查看 [`torch.sum()`](generated/torch.sum.html#torch.sum "torch.sum") | -| [`Tensor.sum_to_size`](generated/torch.Tensor.sum_to_size.html#torch.Tensor.sum_to_size "torch.Tensor.sum_to_size") | 将 `this` 张量求和到 `size` | -| [`Tensor.svd`](generated/torch.Tensor.svd.html#torch.Tensor.svd "torch.Tensor.svd") | 查看 [`torch.svd()`](generated/torch.svd.html#torch.svd "torch.svd") | -| [`Tensor.swapaxes`](generated/torch.Tensor.swapaxes.html#torch.Tensor.swapaxes "torch.Tensor.swapaxes") | 查看 [`torch.swapaxes()`](generated/torch.swapaxes.html#torch.swapaxes "torch.swapaxes") | -| [`Tensor.swapdims`](generated/torch.Tensor.swapdims.html#torch.Tensor.swapdims "torch.Tensor.swapdims") | 查看 [`torch.swapdims()`](generated/torch.swapdims.html#torch.swapdims "torch.swapdims") | -| [`Tensor.t`](generated/torch.Tensor.t.html#torch.Tensor.t "torch.Tensor.t") | 查看 [`torch.t()`](generated/torch.t.html#torch.t "torch.t") | -| [`Tensor.t_`](generated/torch.Tensor.t_.html#torch.Tensor.t_ "torch.Tensor.t_") | [`t()`](generated/torch.Tensor.t.html#torch.Tensor.t "torch.Tensor.t") 的原地版本 | -| [`Tensor.tensor_split`](generated/torch.Tensor.tensor_split.html#torch.Tensor.tensor_split "torch.Tensor.tensor_split") | 查看 [`torch.tensor_split()`](generated/torch.tensor_split.html#torch.tensor_split "torch.tensor_split") | -| [`Tensor.tile`](generated/torch.Tensor.tile.html#torch.Tensor.tile "torch.Tensor.tile") | 查看 [`torch.tile()`](generated/torch.tile.html#torch.tile "torch.tile") | -| [`Tensor.to`](generated/torch.Tensor.to.html#torch.Tensor.to "torch.Tensor.to") | 执行张量的数据类型和/或设备转换 | -| [`Tensor.to_mkldnn`](generated/torch.Tensor.to_mkldnn.html#torch.Tensor.to_mkldnn "torch.Tensor.to_mkldnn") | 返回在 `torch.mkldnn` 布局中的张量的副本 | -| [`Tensor.take`](generated/torch.Tensor.take.html#torch.Tensor.take "torch.Tensor.take") | 查看 [`torch.take()`](generated/torch.take.html#torch.take "torch.take") | -| [`Tensor.take_along_dim`](generated/torch.Tensor.take_along_dim.html#torch.Tensor.take_along_dim "torch.Tensor.take_along_dim") | 查看 [`torch.take_along_dim()`](generated/torch.take_along_dim.html#torch.take_along_dim "torch.take_along_dim") | -| [`Tensor.tan`](generated/torch.Tensor.tan.html#torch.Tensor.tan "torch.Tensor.tan") | 查看 [`torch.tan()`](generated/torch.tan.html#torch.tan "torch.tan") | -| [`Tensor.tan_`](generated/torch.Tensor.tan_.html#torch.Tensor.tan_ "torch.Tensor.tan_") | [`tan()`](generated/torch.Tensor.tan.html#torch.Tensor.tan "torch.Tensor.tan") 的原地版本 | -| [`Tensor.tanh`](generated/torch.Tensor.tanh.html#torch.Tensor.tanh "torch.Tensor.tanh") | 查看 [`torch.tanh()`](generated/torch.tanh.html#torch.tanh "torch.tanh") | -| [`Tensor.tanh_`](generated/torch.Tensor.tanh_.html#torch.Tensor.tanh_ "torch.Tensor.tanh_") | [`tanh()`](generated/torch.Tensor.tanh.html#torch.Tensor.tanh "torch.Tensor.tanh") 的原地版本 | -| [`Tensor.atanh`](generated/torch.Tensor.atanh.html#torch.Tensor.atanh "torch.Tensor.atanh") | 查看 [`torch.atanh()`](generated/torch.atanh.html#torch.atanh "torch.atanh") | -| [`Tensor.atanh_`](generated/torch.Tensor.atanh_.html#torch.Tensor.atanh_ "torch.Tensor.atanh_") | [`atanh()`](generated/torch.Tensor.atanh.html#torch.Tensor.atanh "torch.Tensor.atanh") 的原地版本 | -| [`Tensor.arctanh`](generated/torch.Tensor.arctanh.html#torch.Tensor.arctanh "torch.Tensor.arctanh") | 参见 [`torch.arctanh()`](generated/torch.arctanh.html#torch.arctanh "torch.arctanh") | -| [`Tensor.arctanh_`](generated/torch.Tensor.arctanh_.html#torch.Tensor.arctanh_ "torch.Tensor.arctanh_") | [`arctanh()`](generated/torch.Tensor.arctanh.html#torch.Tensor.arctanh "torch.Tensor.arctanh") 的原地版本 | -| [`Tensor.tolist`](generated/torch.Tensor.tolist.html#torch.Tensor.tolist "torch.Tensor.tolist") | 将张量返回为（嵌套的）列表。 | -| [`Tensor.topk`](generated/torch.Tensor.topk.html#torch.Tensor.topk "torch.Tensor.topk") | 参见 [`torch.topk()`](generated/torch.topk.html#torch.topk "torch.topk") | -| [`Tensor.to_dense`](generated/torch.Tensor.to_dense.html#torch.Tensor.to_dense "torch.Tensor.to_dense") | 如果 `self` 不是分块张量，则创建 `self` 的分块副本，否则返回 `self`。 | -| [`Tensor.to_sparse`](generated/torch.Tensor.to_sparse.html#torch.Tensor.to_sparse "torch.Tensor.to_sparse") | 返回张量的稀疏副本。 | -| [`Tensor.to_sparse_csr`](generated/torch.Tensor.to_sparse_csr.html#torch.Tensor.to_sparse_csr "torch.Tensor.to_sparse_csr") | 将张量转换为压缩行存储格式（CSR）。 | -| [`Tensor.to_sparse_csc`](generated/torch.Tensor.to_sparse_csc.html#torch.Tensor.to_sparse_csc "torch.Tensor.to_sparse_csc") | 将张量转换为压缩列存储（CSC）格式。 | -| [`Tensor.to_sparse_bsr`](generated/torch.Tensor.to_sparse_bsr.html#torch.Tensor.to_sparse_bsr "torch.Tensor.to_sparse_bsr") | 将张量转换为给定块大小的块稀疏行（BSR）存储格式。 | -| [`Tensor.to_sparse_bsc`](generated/torch.Tensor.to_sparse_bsc.html#torch.Tensor.to_sparse_bsc "torch.Tensor.to_sparse_bsc") | 将张量转换为给定块大小的块稀疏列（BSC）存储格式。 | -| [`Tensor.trace`](generated/torch.Tensor.trace.html#torch.Tensor.trace "torch.Tensor.trace") | 参见 [`torch.trace()`](generated/torch.trace.html#torch.trace "torch.trace") | -| [`Tensor.transpose`](generated/torch.Tensor.transpose.html#torch.Tensor.transpose "torch.Tensor.transpose") | 参见 [`torch.transpose()`](generated/torch.transpose.html#torch.transpose "torch.transpose") | -| [`Tensor.transpose_`](generated/torch.Tensor.transpose_.html#torch.Tensor.transpose_ "torch.Tensor.transpose_") | [`transpose()`](generated/torch.Tensor.transpose.html#torch.Tensor.transpose "torch.Tensor.transpose") 的原地版本 | -| [`Tensor.triangular_solve`](generated/torch.Tensor.triangular_solve.html#torch.Tensor.triangular_solve "torch.Tensor.triangular_solve") | 参见 [`torch.triangular_solve()`](generated/torch.triangular_solve.html#torch.triangular_solve "torch.triangular_solve") | -| [`Tensor.tril`](generated/torch.Tensor.tril.html#torch.Tensor.tril "torch.Tensor.tril") | 参见 [`torch.tril()`](generated/torch.tril.html#torch.tril "torch.tril") | -| [`Tensor.tril_`](generated/torch.Tensor.tril_.html#torch.Tensor.tril_ "torch.Tensor.tril_") | [`tril()`](generated/torch.Tensor.tril.html#torch.Tensor.tril "torch.Tensor.tril") 的原地版本 | -| [`Tensor.triu`](generated/torch.Tensor.triu.html#torch.Tensor.triu "torch.Tensor.triu") | 参见 [`torch.triu()`](generated/torch.triu.html#torch.triu "torch.triu") | -| [`Tensor.triu_`](generated/torch.Tensor.triu_.html#torch.Tensor.triu_ "torch.Tensor.triu_") | [`triu()`](generated/torch.Tensor.triu.html#torch.Tensor.triu "torch.Tensor.triu") 的原地版本 | -| [`Tensor.true_divide`](generated/torch.Tensor.true_divide.html#torch.Tensor.true_divide "torch.Tensor.true_divide") | 参见 [`torch.true_divide()`](generated/torch.true_divide.html#torch.true_divide "torch.true_divide") | -| [`Tensor.true_divide_`](generated/torch.Tensor.true_divide_.html#torch.Tensor.true_divide_ "torch.Tensor.true_divide_") | `true_divide_()` 的原位版本 | -| [`Tensor.trunc`](generated/torch.Tensor.trunc.html#torch.Tensor.trunc "torch.Tensor.trunc") | 参见 `torch.trunc()` | -| [`Tensor.trunc_`](generated/torch.Tensor.trunc_.html#torch.Tensor.trunc_ "torch.Tensor.trunc_") | `trunc()` 的原位版本 | -| [`Tensor.type`](generated/torch.Tensor.type.html#torch.Tensor.type "torch.Tensor.type") | 如果未提供 dtype，则返回类型，否则将此对象转换为指定类型 | -| [`Tensor.type_as`](generated/torch.Tensor.type_as.html#torch.Tensor.type_as "torch.Tensor.type_as") | 返回此张量转换为给定张量类型的结果 | -| [`Tensor.unbind`](generated/torch.Tensor.unbind.html#torch.Tensor.unbind "torch.Tensor.unbind") | 参见 `torch.unbind()` | -| [`Tensor.unflatten`](generated/torch.Tensor.unflatten.html#torch.Tensor.unflatten "torch.Tensor.unflatten") | 参见 `torch.unflatten()` | -| [`Tensor.unfold`](generated/torch.Tensor.unfold.html#torch.Tensor.unfold "torch.Tensor.unfold") | 返回原始张量的视图，其中包含 `self` 张量在维度 `dimension` 中大小为 `size` 的所有切片 | -| [`Tensor.uniform_`](generated/torch.Tensor.uniform_.html#torch.Tensor.uniform_ "torch.Tensor.uniform_") | 用从连续均匀分布中抽样的数字填充 `self` 张量 | -| [`Tensor.unique`](generated/torch.Tensor.unique.html#torch.Tensor.unique "torch.Tensor.unique") | 返回输入张量的唯一元素 | -| [`Tensor.unique_consecutive`](generated/torch.Tensor.unique_consecutive.html#torch.Tensor.unique_consecutive "torch.Tensor.unique_consecutive") | 消除每个连续等价元素组的除第一个元素之外的所有元素 | -| [`Tensor.unsqueeze`](generated/torch.Tensor.unsqueeze.html#torch.Tensor.unsqueeze "torch.Tensor.unsqueeze") | 参见 `torch.unsqueeze()` | -| [`Tensor.unsqueeze_`](generated/torch.Tensor.unsqueeze_.html#torch.Tensor.unsqueeze_ "torch.Tensor.unsqueeze_") | `unsqueeze()` 的原位版本 | -| [`Tensor.values`](generated/torch.Tensor.values.html#torch.Tensor.values "torch.Tensor.values") | 返回 [稀疏 COO 张量](sparse.html#sparse-coo-docs) 的值张量 | -| [`Tensor.var`](generated/torch.Tensor.var.html#torch.Tensor.var "torch.Tensor.var") | 参见 `torch.var()` | -| [`Tensor.vdot`](generated/torch.Tensor.vdot.html#torch.Tensor.vdot "torch.Tensor.vdot") | 参见 `torch.vdot()` | -| [`Tensor.view`](generated/torch.Tensor.view.html#torch.Tensor.view "torch.Tensor.view") | 返回一个与 `self` 张量具有相同数据但不同 `shape` 的新张量 | -| [`Tensor.view_as`](generated/torch.Tensor.view_as.html#torch.Tensor.view_as "torch.Tensor.view_as") | 将此张量视为与 `other` 相同大小 | -| [`Tensor.vsplit`](generated/torch.Tensor.vsplit.html#torch.Tensor.vsplit "torch.Tensor.vsplit") | 参见 `torch.vsplit()` | -| [`Tensor.where`](generated/torch.Tensor.where.html#torch.Tensor.where "torch.Tensor.where") | `self.where(condition, y)` 等同于 `torch.where(condition, self, y)` | -| [`Tensor.xlogy`](generated/torch.Tensor.xlogy.html#torch.Tensor.xlogy "torch.Tensor.xlogy") | 查看 [`torch.xlogy()`](generated/torch.xlogy.html#torch.xlogy "torch.xlogy") | -| [`Tensor.xlogy_`](generated/torch.Tensor.xlogy_.html#torch.Tensor.xlogy_ "torch.Tensor.xlogy_") | [`xlogy()`](generated/torch.Tensor.xlogy.html#torch.Tensor.xlogy "torch.Tensor.xlogy") 的原地版本 | -| [`Tensor.zero_`](generated/torch.Tensor.zero_.html#torch.Tensor.zero_ "torch.Tensor.zero_") | 用零填充 `self` 张量。 | +| `Tensor.max` | 查看 `torch.max()` | +| `Tensor.maximum` | 查看 `torch.maximum()` | +| `Tensor.mean` | 查看 `torch.mean()` | +| `Tensor.nanmean` | 查看 `torch.nanmean()` | +| `Tensor.median` | 查看 `torch.median()` | +| `Tensor.nanmedian` | 查看 `torch.nanmedian()` | +| `Tensor.min` | 查看 `torch.min()` | +| `Tensor.minimum` | 查看 `torch.minimum()` | +| `Tensor.mm` | 查看 `torch.mm()` | +| `Tensor.smm` | 查看 `torch.smm()` | +| `Tensor.mode` | 查看 `torch.mode()` | +| `Tensor.movedim` | 查看 `torch.movedim()` | +| `Tensor.moveaxis` | 查看 `torch.moveaxis()` | +| `Tensor.msort` | 查看 `torch.msort()` | +| `Tensor.mul` | 查看 `torch.mul()` | +| `Tensor.mul_` | `mul()` 的原地版本 | +| `Tensor.multiply` | 查看 `torch.multiply()` | +| `Tensor.multiply_` | `multiply()` 的原地版本 | +| `Tensor.multinomial` | 查看 `torch.multinomial()` | +| `Tensor.mv` | 查看 `torch.mv()` | +| `Tensor.mvlgamma` | 查看 `torch.mvlgamma()` | +| `Tensor.mvlgamma_` | `mvlgamma()` 的原地版本 | +| `Tensor.nansum` | 查看 `torch.nansum()` | +| `Tensor.narrow` | 查看 `torch.narrow()` | +| `Tensor.narrow_copy` | 查看 `torch.narrow_copy()` | +| `Tensor.ndimension` | `dim()` 的别名 | +| `Tensor.nan_to_num` | 查看 `torch.nan_to_num()` | +| `Tensor.nan_to_num_` | `nan_to_num()` 的原地版本。 | +| `Tensor.ne` | 参见 `torch.ne()` | +| `Tensor.ne_` | `ne()` 的原地版本。 | +| `Tensor.not_equal` | 参见 `torch.not_equal()` | +| `Tensor.not_equal_` | `not_equal()` 的原地版本。 | +| `Tensor.neg` | 参见 `torch.neg()` | +| `Tensor.neg_` | `neg()` 的原地版本。 | +| `Tensor.negative` | 参见 `torch.negative()` | +| `Tensor.negative_` | `negative()` 的原地版本。 | +| `Tensor.nelement` | `numel()` 的别名 | +| `Tensor.nextafter` | 参见 `torch.nextafter()` | +| `Tensor.nextafter_` | `nextafter()` 的原地版本。 | +| `Tensor.nonzero` | 参见 `torch.nonzero()` | +| `Tensor.norm` | 参见 `torch.norm()` | +| `Tensor.normal_` | 使用由 `mean` 和 `std` 参数化的正态分布样本填充 `self` 张量。 | +| `Tensor.numel` | 参见 `torch.numel()` | +| `Tensor.numpy` | 将张量返回为 NumPy `ndarray`。 | +| `Tensor.orgqr` | 参见 `torch.orgqr()` | +| `Tensor.ormqr` | 参见 `torch.ormqr()` | +| `Tensor.outer` | 参见 `torch.outer()` | +| `Tensor.permute` | 查看 `torch.permute()` | +| `Tensor.pin_memory` | 如果尚未固定，将张量复制到固定内存中。 | +| `Tensor.pinverse` | 查看 `torch.pinverse()` | +| `Tensor.polygamma` | 查看 `torch.polygamma()` | +| `Tensor.polygamma_` | `polygamma()` 的原地版本 | +| `Tensor.positive` | 查看 `torch.positive()` | +| `Tensor.pow` | 查看 `torch.pow()` | +| `Tensor.pow_` | `pow()` 的原地版本 | +| `Tensor.prod` | 查看 `torch.prod()` | +| `Tensor.put_` | 将 `source` 中的元素复制到由 `index` 指定的位置。 | +| `Tensor.qr` | 查看 `torch.qr()` | +| `Tensor.qscheme` | 返回给定 QTensor 的量化方案。 | +| `Tensor.quantile` | 查看 `torch.quantile()` | +| `Tensor.nanquantile` | 查看 `torch.nanquantile()` | +| `Tensor.q_scale` | 给定通过线性（仿射）量化的张量，返回底层量化器的比例。 | +| `Tensor.q_zero_point` | 给定通过线性（仿射）量化的张量，返回底层量化器的零点。 | +| `Tensor.q_per_channel_scales` | 给定通过线性（仿射）逐通道量化的张量，返回底层量化器的比例张量。 | +| `Tensor.q_per_channel_zero_points` | 给定通过线性（仿射）逐通道量化的张量，返回底层量化器的零点张量。 | +| `Tensor.q_per_channel_axis` | 给定通过线性（仿射）逐通道量化的张量，返回应用逐通道量化的维度索引。 | +| `Tensor.rad2deg` | 参见`torch.rad2deg()` | +| `Tensor.random_` | 用从离散均匀分布`[from, to - 1]`中抽样的数字填充`self`张量。 | +| `Tensor.ravel` | 参见`torch.ravel()` | +| `Tensor.reciprocal` | 参见`torch.reciprocal()` | +| `Tensor.reciprocal_` | `reciprocal()`的原位版本 | +| `Tensor.record_stream` | 将张量标记为此流程已使用。 | +| `Tensor.register_hook` | 注册一个反向钩子。 | +| `Tensor.register_post_accumulate_grad_hook` | 注册一个在梯度累积后运行的反向钩子。 | +| `Tensor.remainder` | 参见`torch.remainder()` | +| `Tensor.remainder_` | `remainder()`的原位版本 | +| `Tensor.renorm` | 参见`torch.renorm()` | +| `Tensor.renorm_` | `renorm()`的原位版本 | +| `Tensor.repeat` | 沿指定维度重复此张量。 | +| `Tensor.repeat_interleave` | 参见`torch.repeat_interleave()`。 | +| `Tensor.requires_grad` | 如果需要为此张量计算梯度，则为`True`，否则为`False`。 | +| `Tensor.requires_grad_` | 更改是否应记录此张量上的操作的自动微分：就地设置此张量的`requires_grad`属性。 | +| `Tensor.reshape` | 返回一个与`self`具有相同数据和元素数量但具有指定形状的张量。 | +| `Tensor.reshape_as` | 将此张量返回为与`other`相同形状的张量。 | +| `Tensor.resize_` | 将`self`张量调整为指定大小。 | +| `Tensor.resize_as_` | 将 `self` 张量调整为与指定的 `tensor` 相同大小 | +| `Tensor.retain_grad` | 在 `backward()` 过程中使此张量的 `grad` 被填充 | +| `Tensor.retains_grad` | 如果此张量是非叶子节点且其 `grad` 已启用填充，则为 `True`，否则为 `False` | +| `Tensor.roll` | 查看 `torch.roll()` | +| `Tensor.rot90` | 查看 `torch.rot90()` | +| `Tensor.round` | 查看 `torch.round()` | +| `Tensor.round_` | `round()` 的就地版本 | +| `Tensor.rsqrt` | 查看 `torch.rsqrt()` | +| `Tensor.rsqrt_` | `rsqrt()` 的就地版本 | +| `Tensor.scatter` | `torch.Tensor.scatter_()` 的非就地版本 | +| `Tensor.scatter_` | 将张量 `src` 中的所有值写入到指定在 `index` 张量中的 `self` 中 | +| `Tensor.scatter_add_` | 将张量 `src` 中的所有值添加到 `index` 张量中指定的 `self` 中，类似于 `scatter_()` 的方式 | +| `Tensor.scatter_add` | `torch.Tensor.scatter_add_()` 的非就地版本 | +| `Tensor.scatter_reduce_` | 将 `src` 张量中的所有值按照应用的减少方式（`"sum"`、`"prod"`、`"mean"`、`"amax"`、`"amin"`）减少到 `index` 张量中指定的索引中的 `self` 张量中 | +| `Tensor.scatter_reduce` | `torch.Tensor.scatter_reduce_()` 的非就地版本 | +| `Tensor.select` | 查看 `torch.select()` | +| `Tensor.select_scatter` | 查看 `torch.select_scatter()` | +| `Tensor.set_` | 设置底层存储、大小和步幅。 | +| `Tensor.share_memory_` | 将底层存储移动到共享内存。 | +| `Tensor.short` | `self.short()` 等同于 `self.to(torch.int16)`。 | +| `Tensor.sigmoid` | 查看 `torch.sigmoid()` | +| `Tensor.sigmoid_` | `sigmoid()` 的原地版本 | +| `Tensor.sign` | 查看 `torch.sign()` | +| `Tensor.sign_` | `sign()` 的原地版本 | +| `Tensor.signbit` | 查看 `torch.signbit()` | +| `Tensor.sgn` | 查看 `torch.sgn()` | +| `Tensor.sgn_` | `sgn()` 的原地版本 | +| `Tensor.sin` | 查看 `torch.sin()` | +| `Tensor.sin_` | `sin()` 的原地版本 | +| `Tensor.sinc` | 查看 `torch.sinc()` | +| `Tensor.sinc_` | `sinc()` 的原地版本 | +| `Tensor.sinh` | 查看 `torch.sinh()` | +| `Tensor.sinh_` | `sinh()` 的原地版本 | +| `Tensor.asinh` | 查看 `torch.asinh()` | +| `Tensor.asinh_` | `asinh()` 的原地版本 | +| `Tensor.arcsinh` | 查看 `torch.arcsinh()` | +| `Tensor.arcsinh_` | `arcsinh()` 的原地版本 | +| `Tensor.shape` | 返回 `self` 张量的大小。 | +| `Tensor.size` | 返回 `self` 张量的大小。 | +| `Tensor.slogdet` | 查看 `torch.slogdet()` | +| `Tensor.slice_scatter` | 查看 `torch.slice_scatter()` | +| `Tensor.softmax` | `torch.nn.functional.softmax()` 的别名。 | +| `Tensor.sort` | 查看 `torch.sort()` | +| `Tensor.split` | 查看 `torch.split()` | +| `Tensor.sparse_mask` | 使用稀疏张量 `mask` 的索引过滤来自分块张量 `self` 的值，返回一个新的 稀疏张量。 | +| `Tensor.sparse_dim` | 返回 稀疏张量 `self` 中稀疏维度的数量。 | +| `Tensor.sqrt` | 查看 `torch.sqrt()` | +| `Tensor.sqrt_` | `sqrt()` 的原地版本 | +| `Tensor.square` | 查看 `torch.square()` | +| `Tensor.square_` | `square()` 的原地版本 | +| `Tensor.squeeze` | 查看 `torch.squeeze()` | +| `Tensor.squeeze_` | `squeeze()` 的原地版本 | +| `Tensor.std` | 查看 `torch.std()` | +| `Tensor.stft` | 查看 `torch.stft()` | +| `Tensor.storage` | 返回底层的 `TypedStorage`。 | +| `Tensor.untyped_storage` | 返回底层的 `UntypedStorage`。 | +| `Tensor.storage_offset` | 返回 `self` 张量在底层存储中的偏移量，以存储元素的数量表示（不是字节）。 | +| `Tensor.storage_type` | 返回底层存储的类型。 | +| `Tensor.stride` | 返回 `self` 张量的步幅。 | +| `Tensor.sub` | 查看 `torch.sub()` | +| `Tensor.sub_` | `sub()` 的原地版本 | +| `Tensor.subtract` | 查看 `torch.subtract()` | +| `Tensor.subtract_` | `subtract()` 的原地版本 | +| `Tensor.sum` | 查看 `torch.sum()` | +| `Tensor.sum_to_size` | 将 `this` 张量求和到 `size` | +| `Tensor.svd` | 查看 `torch.svd()` | +| `Tensor.swapaxes` | 查看 `torch.swapaxes()` | +| `Tensor.swapdims` | 查看 `torch.swapdims()` | +| `Tensor.t` | 查看 `torch.t()` | +| `Tensor.t_` | `t()` 的原地版本 | +| `Tensor.tensor_split` | 查看 `torch.tensor_split()` | +| `Tensor.tile` | 查看 `torch.tile()` | +| `Tensor.to` | 执行张量的数据类型和/或设备转换 | +| `Tensor.to_mkldnn` | 返回在 `torch.mkldnn` 布局中的张量的副本 | +| `Tensor.take` | 查看 `torch.take()` | +| `Tensor.take_along_dim` | 查看 `torch.take_along_dim()` | +| `Tensor.tan` | 查看 `torch.tan()` | +| `Tensor.tan_` | `tan()` 的原地版本 | +| `Tensor.tanh` | 查看 `torch.tanh()` | +| `Tensor.tanh_` | `tanh()` 的原地版本 | +| `Tensor.atanh` | 查看 `torch.atanh()` | +| `Tensor.atanh_` | `atanh()` 的原地版本 | +| `Tensor.arctanh` | 参见 `torch.arctanh()` | +| `Tensor.arctanh_` | `arctanh()` 的原地版本 | +| `Tensor.tolist` | 将张量返回为（嵌套的）列表。 | +| `Tensor.topk` | 参见 `torch.topk()` | +| `Tensor.to_dense` | 如果 `self` 不是分块张量，则创建 `self` 的分块副本，否则返回 `self`。 | +| `Tensor.to_sparse` | 返回张量的稀疏副本。 | +| `Tensor.to_sparse_csr` | 将张量转换为压缩行存储格式（CSR）。 | +| `Tensor.to_sparse_csc` | 将张量转换为压缩列存储（CSC）格式。 | +| `Tensor.to_sparse_bsr` | 将张量转换为给定块大小的块稀疏行（BSR）存储格式。 | +| `Tensor.to_sparse_bsc` | 将张量转换为给定块大小的块稀疏列（BSC）存储格式。 | +| `Tensor.trace` | 参见 `torch.trace()` | +| `Tensor.transpose` | 参见 `torch.transpose()` | +| `Tensor.transpose_` | `transpose()` 的原地版本 | +| `Tensor.triangular_solve` | 参见 `torch.triangular_solve()` | +| `Tensor.tril` | 参见 `torch.tril()` | +| `Tensor.tril_` | `tril()` 的原地版本 | +| `Tensor.triu` | 参见 `torch.triu()` | +| `Tensor.triu_` | `triu()` 的原地版本 | +| `Tensor.true_divide` | 参见 `torch.true_divide()` | +| `Tensor.true_divide_` | `true_divide_()` 的原位版本 | +| `Tensor.trunc` | 参见 `torch.trunc()` | +| `Tensor.trunc_` | `trunc()` 的原位版本 | +| `Tensor.type` | 如果未提供 dtype，则返回类型，否则将此对象转换为指定类型 | +| `Tensor.type_as` | 返回此张量转换为给定张量类型的结果 | +| `Tensor.unbind` | 参见 `torch.unbind()` | +| `Tensor.unflatten` | 参见 `torch.unflatten()` | +| `Tensor.unfold` | 返回原始张量的视图，其中包含 `self` 张量在维度 `dimension` 中大小为 `size` 的所有切片 | +| `Tensor.uniform_` | 用从连续均匀分布中抽样的数字填充 `self` 张量 | +| `Tensor.unique` | 返回输入张量的唯一元素 | +| `Tensor.unique_consecutive` | 消除每个连续等价元素组的除第一个元素之外的所有元素 | +| `Tensor.unsqueeze` | 参见 `torch.unsqueeze()` | +| `Tensor.unsqueeze_` | `unsqueeze()` 的原位版本 | +| `Tensor.values` | 返回 稀疏 COO 张量 的值张量 | +| `Tensor.var` | 参见 `torch.var()` | +| `Tensor.vdot` | 参见 `torch.vdot()` | +| `Tensor.view` | 返回一个与 `self` 张量具有相同数据但不同 `shape` 的新张量 | +| `Tensor.view_as` | 将此张量视为与 `other` 相同大小 | +| `Tensor.vsplit` | 参见 `torch.vsplit()` | +| `Tensor.where` | `self.where(condition, y)` 等同于 `torch.where(condition, self, y)` | +| `Tensor.xlogy` | 查看 `torch.xlogy()` | +| `Tensor.xlogy_` | `xlogy()` 的原地版本 | +| `Tensor.zero_` | 用零填充 `self` 张量。 | diff --git a/totrans/doc22_035.md b/totrans/doc22_035.md index e20b813c..39718ee0 100644 --- a/totrans/doc22_035.md +++ b/totrans/doc22_035.md @@ -1,8 +1,8 @@ # 张量属性 -> 原文：[https://pytorch.org/docs/stable/tensor_attributes.html](https://pytorch.org/docs/stable/tensor_attributes.html) +> 原文：[`pytorch.org/docs/stable/tensor_attributes.html`](https://pytorch.org/docs/stable/tensor_attributes.html) -每个`torch.Tensor`都有一个[`torch.dtype`](#torch.dtype "torch.dtype")、[`torch.device`](#torch.device "torch.device")和[`torch.layout`](#torch.layout "torch.layout")。 +每个`torch.Tensor`都有一个`torch.dtype`、`torch.device`和`torch.layout`。 ## torch.dtype @@ -10,36 +10,36 @@ class torch.dtype¶ ``` -[`torch.dtype`](#torch.dtype "torch.dtype")是表示[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")的数据类型的对象。PyTorch有12种不同的数据类型： +`torch.dtype`是表示`torch.Tensor`的数据类型的对象。PyTorch 有 12 种不同的数据类型： | 数据类型 | dtype | 旧构造函数 | | --- | --- | --- | -| 32位浮点数 | `torch.float32`或`torch.float` | `torch.*.FloatTensor` | -| 64位浮点数 | `torch.float64`或`torch.double` | `torch.*.DoubleTensor` | -| 64位复数 | `torch.complex64`或`torch.cfloat` | | -| 128位复数 | `torch.complex128`或`torch.cdouble` | | -| 16位浮点数[1](#id3) | `torch.float16`或`torch.half` | `torch.*.HalfTensor` | -| 16位浮点数[2](#id4) | `torch.bfloat16` | `torch.*.BFloat16Tensor` | -| 8位整数（无符号） | `torch.uint8` | `torch.*.ByteTensor` | -| 8位整数（有符号） | `torch.int8` | `torch.*.CharTensor` | -| 16位整数（有符号） | `torch.int16`或`torch.short` | `torch.*.ShortTensor` | -| 32位整数（有符号） | `torch.int32`或`torch.int` | `torch.*.IntTensor` | -| 64位整数（有符号） | `torch.int64`或`torch.long` | `torch.*.LongTensor` | +| 32 位浮点数 | `torch.float32`或`torch.float` | `torch.*.FloatTensor` | +| 64 位浮点数 | `torch.float64`或`torch.double` | `torch.*.DoubleTensor` | +| 64 位复数 | `torch.complex64`或`torch.cfloat` | | +| 128 位复数 | `torch.complex128`或`torch.cdouble` | | +| 16 位浮点数 1 | `torch.float16`或`torch.half` | `torch.*.HalfTensor` | +| 16 位浮点数 2 | `torch.bfloat16` | `torch.*.BFloat16Tensor` | +| 8 位整数（无符号） | `torch.uint8` | `torch.*.ByteTensor` | +| 8 位整数（有符号） | `torch.int8` | `torch.*.CharTensor` | +| 16 位整数（有符号） | `torch.int16`或`torch.short` | `torch.*.ShortTensor` | +| 32 位整数（有符号） | `torch.int32`或`torch.int` | `torch.*.IntTensor` | +| 64 位整数（有符号） | `torch.int64`或`torch.long` | `torch.*.LongTensor` | | 布尔值 | `torch.bool` | `torch.*.BoolTensor` | -[1](#id1) +1 -有时被称为binary16：使用1个符号位，5个指数位和10个有效数字位。当精度重要时很有用。 +有时被称为 binary16：使用 1 个符号位，5 个指数位和 10 个有效数字位。当精度重要时很有用。 -[2](#id2) +2 -有时被称为Brain Floating Point：使用1个符号位，8个指数位和7个有效数字位。当范围重要时很有用，因为它具有与`float32`相同数量的指数位。 +有时被称为 Brain Floating Point：使用 1 个符号位，8 个指数位和 7 个有效数字位。当范围重要时很有用，因为它具有与`float32`相同数量的指数位。 -要确定[`torch.dtype`](#torch.dtype "torch.dtype")是否为浮点数据类型，可以使用属性[`is_floating_point`](generated/torch.is_floating_point.html#torch.is_floating_point "torch.is_floating_point")，如果数据类型是浮点数据类型，则返回`True`。 +要确定`torch.dtype`是否为浮点数据类型，可以使用属性`is_floating_point`，如果数据类型是浮点数据类型，则返回`True`。 -要确定[`torch.dtype`](#torch.dtype "torch.dtype")是否为复数数据类型，可以使用属性[`is_complex`](generated/torch.is_complex.html#torch.is_complex "torch.is_complex")，如果数据类型是复数数据类型，则返回`True`。 +要确定`torch.dtype`是否为复数数据类型，可以使用属性`is_complex`，如果数据类型是复数数据类型，则返回`True`。 -当输入到算术操作（add、sub、div、mul）的dtype不同时，我们通过找到满足以下规则的最小dtype来提升： +当输入到算术操作（add、sub、div、mul）的 dtype 不同时，我们通过找到满足以下规则的最小 dtype 来提升： + 如果标量操作数的类型高于张量操作数的类型（其中复数 > 浮点 > 整数 > 布尔），则提升为具有足够大小以容纳该类别的所有标量操作数的类型。 @@ -47,7 +47,7 @@ class torch.dtype¶ + 如果没有更高类别的零维操作数，则提升为具有足够大小和类别以容纳所有有尺寸的操作数的类型。 -浮点标量操作数具有dtype torch.get_default_dtype()，整数非布尔标量操作数具有dtype torch.int64。与numpy不同，我们在确定操作数的最小dtype时不检查值。目前不支持量化和复杂类型。 +浮点标量操作数具有 dtype torch.get_default_dtype()，整数非布尔标量操作数具有 dtype torch.int64。与 numpy 不同，我们在确定操作数的最小 dtype 时不检查值。目前不支持量化和复杂类型。 提升示例： @@ -90,7 +90,7 @@ torch.int32 torch.float32 ``` -当指定算术操作的输出张量时，我们允许将其转换为其dtype，除非： +当指定算术操作的输出张量时，我们允许将其转换为其 dtype，除非： + 整数输出张量不能接受浮点张量。 @@ -122,13 +122,13 @@ torch.float32 class torch.device¶ ``` -[`torch.device`](#torch.device "torch.device")是表示[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")分配或将要分配的设备的对象。 +`torch.device`是表示`torch.Tensor`分配或将要分配的设备的对象。 -[`torch.device`](#torch.device "torch.device") 包含设备类型（`'cpu'`、`'cuda'` 或 `'mps'`）和设备类型的可选设备序数。如果设备序数不存在，这个对象将始终表示设备类型的当前设备，即使调用了 [`torch.cuda.set_device()`](generated/torch.cuda.set_device.html#torch.cuda.set_device "torch.cuda.set_device")；例如，使用设备 `'cuda'` 构造的 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 等同于 `'cuda:X'`，其中 X 是 [`torch.cuda.current_device()`](generated/torch.cuda.current_device.html#torch.cuda.current_device "torch.cuda.current_device") 的结果。 +`torch.device` 包含设备类型（`'cpu'`、`'cuda'` 或 `'mps'`）和设备类型的可选设备序数。如果设备序数不存在，这个对象将始终表示设备类型的当前设备，即使调用了 `torch.cuda.set_device()`；例如，使用设备 `'cuda'` 构造的 `torch.Tensor` 等同于 `'cuda:X'`，其中 X 是 `torch.cuda.current_device()` 的结果。 -可以通过 [`Tensor.device`](generated/torch.Tensor.device.html#torch.Tensor.device "torch.Tensor.device") 属性访问 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 的设备。 +可以通过 `Tensor.device` 属性访问 `torch.Tensor` 的设备。 -可以通过字符串或字符串和设备序数构造 [`torch.device`](#torch.device "torch.device")。 +可以通过字符串或字符串和设备序数构造 `torch.device`。 通过字符串： @@ -168,15 +168,15 @@ device(type='cpu', index=0) device(type='cuda', index=1) ``` -如果工厂函数传递了显式的、非 None 的设备参数，则此上下文管理器不起作用。要全局更改默认设备，请参见 [`torch.set_default_device()`](generated/torch.set_default_device.html#torch.set_default_device "torch.set_default_device")。 +如果工厂函数传递了显式的、非 None 的设备参数，则此上下文管理器不起作用。要全局更改默认设备，请参见 `torch.set_default_device()`。 警告 -此函数会对每次调用 torch API（不仅是工厂函数）产生轻微的性能成本。如果这给您带来问题，请在 [https://github.com/pytorch/pytorch/issues/92701](https://github.com/pytorch/pytorch/issues/92701) 上发表评论。 +此函数会对每次调用 torch API（不仅是工厂函数）产生轻微的性能成本。如果这给您带来问题，请在 [`github.com/pytorch/pytorch/issues/92701`](https://github.com/pytorch/pytorch/issues/92701) 上发表评论。 注意 -函数中的 [`torch.device`](#torch.device "torch.device") 参数通常可以用字符串替换。这样可以快速原型化代码。 +函数中的 `torch.device` 参数通常可以用字符串替换。这样可以快速原型化代码。 ```py >>> # Example of a function that takes in a torch.device @@ -191,7 +191,7 @@ device(type='cuda', index=1) 注意 -出于传统原因，可以通过单个设备序数构造设备，该设备被视为 cuda 设备。这与 [`Tensor.get_device()`](generated/torch.Tensor.get_device.html#torch.Tensor.get_device "torch.Tensor.get_device") 相匹配，它返回 cuda 张量的序数，不支持 cpu 张量。 +出于传统原因，可以通过单个设备序数构造设备，该设备被视为 cuda 设备。这与 `Tensor.get_device()` 相匹配，它返回 cuda 张量的序数，不支持 cpu 张量。 ```py >>> torch.device(1) @@ -216,7 +216,7 @@ class torch.layout¶ `torch.layout` 类处于 beta 阶段，可能会发生变化。 -[`torch.layout`](#torch.layout "torch.layout") 是一个表示 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 的内存布局的对象。目前，我们支持 `torch.strided`（稠密张量），并且对 `torch.sparse_coo`（稀疏 COO 张量）提供 beta 支持。 +`torch.layout` 是一个表示 `torch.Tensor` 的内存布局的对象。目前，我们支持 `torch.strided`（稠密张量），并且对 `torch.sparse_coo`（稀疏 COO 张量）提供 beta 支持。 `torch.strided` 表示稠密张量，是最常用的内存布局。每个步幅张量都有一个关联的 `torch.Storage`，用于保存其数据。这些张量提供了一个多维、[步幅](https://en.wikipedia.org/wiki/Stride_of_an_array) 视图的存储。步幅是一个整数列表：第 k 个步幅表示在张量的第 k 维中从一个元素到下一个元素所需的内存跳跃。这个概念使得能够高效地执行许多张量操作。 @@ -231,7 +231,7 @@ class torch.layout¶ (1, 5) ``` -有关 `torch.sparse_coo` 张量的更多信息，请参阅 [torch.sparse](sparse.html#sparse-docs)。 +有关 `torch.sparse_coo` 张量的更多信息，请参阅 torch.sparse。 ## torch.memory_format @@ -239,7 +239,7 @@ class torch.layout¶ class torch.memory_format¶ ``` -[`torch.memory_format`](#torch.memory_format "torch.memory_format") 是一个表示 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 分配或将要分配的内存格式的对象。 +`torch.memory_format` 是一个表示 `torch.Tensor` 分配或将要分配的内存格式的对象。 可能的值有： @@ -247,6 +247,6 @@ class torch.memory_format¶ + `torch.channels_last`：张量被分配在稠密、非重叠的内存中。步幅由 `strides[0] > strides[2] > strides[3] > strides[1] == 1` 表示，即 NHWC 顺序。 -+ `torch.channels_last_3d`: 张量将被分配在稠密且不重叠的内存中。步幅由`strides[0] > strides[2] > strides[3] > strides[4] > strides[1] == 1`中的值表示，也称为NDHWC顺序。 ++ `torch.channels_last_3d`: 张量将被分配在稠密且不重叠的内存中。步幅由`strides[0] > strides[2] > strides[3] > strides[4] > strides[1] == 1`中的值表示，也称为 NDHWC 顺序。 + `torch.preserve_format`: 在像克隆这样的函数中使用，以保留输入张量的内存格式。如果输入张量是在稠密且不重叠的内存中分配的，则输出张量的步幅将从输入中复制。否则，输出步幅将遵循`torch.contiguous_format`。 diff --git a/totrans/doc22_036.md b/totrans/doc22_036.md index 594b493e..04ad5b14 100644 --- a/totrans/doc22_036.md +++ b/totrans/doc22_036.md @@ -1,6 +1,6 @@ # Tensor Views -> 原文：[https://pytorch.org/docs/stable/tensor_view.html](https://pytorch.org/docs/stable/tensor_view.html) +> 原文：[`pytorch.org/docs/stable/tensor_view.html`](https://pytorch.org/docs/stable/tensor_view.html) PyTorch 允许一个张量是现有张量的 `View`。视图张量与其基本张量共享相同的基础数据。支持 `View` 避免了显式数据复制，因此允许我们进行快速和内存高效的重塑、切片和逐元素操作。 @@ -19,7 +19,7 @@ tensor(3.14) 由于视图与其基本张量共享基础数据，如果在视图中编辑数据，将会反映在基本张量中。 -通常，PyTorch 操作会返回一个新的张量作为输出，例如 [`add()`](generated/torch.Tensor.add.html#torch.Tensor.add "torch.Tensor.add")。但是在视图操作中，输出是输入张量的视图，以避免不必要的数据复制。创建视图时不会发生数据移动，视图张量只是改变了解释相同数据的方式。对连续张量进行视图操作可能会产生非连续张量。用户应额外注意，因为连续性可能会对性能产生隐含影响。[`transpose()`](generated/torch.Tensor.transpose.html#torch.Tensor.transpose "torch.Tensor.transpose") 是一个常见示例。 +通常，PyTorch 操作会返回一个新的张量作为输出，例如 `add()`。但是在视图操作中，输出是输入张量的视图，以避免不必要的数据复制。创建视图时不会发生数据移动，视图张量只是改变了解释相同数据的方式。对连续张量进行视图操作可能会产生非连续张量。用户应额外注意，因为连续性可能会对性能产生隐含影响。`transpose()` 是一个常见示例。 ```py >>> base = torch.tensor([[0, 1],[2, 3]]) @@ -38,86 +38,86 @@ False + 基本的切片和索引操作，例如 `tensor[0, 2:, 1:7:2]` 返回基本 `tensor` 的视图，请参见下面的说明。 -+ [`adjoint()`](generated/torch.Tensor.adjoint.html#torch.Tensor.adjoint "torch.Tensor.adjoint") ++ `adjoint()` -+ [`as_strided()`](generated/torch.Tensor.as_strided.html#torch.Tensor.as_strided "torch.Tensor.as_strided") ++ `as_strided()` -+ [`detach()`](generated/torch.Tensor.detach.html#torch.Tensor.detach "torch.Tensor.detach") ++ `detach()` -+ [`diagonal()`](generated/torch.Tensor.diagonal.html#torch.Tensor.diagonal "torch.Tensor.diagonal") ++ `diagonal()` -+ [`expand()`](generated/torch.Tensor.expand.html#torch.Tensor.expand "torch.Tensor.expand") ++ `expand()` -+ [`expand_as()`](generated/torch.Tensor.expand_as.html#torch.Tensor.expand_as "torch.Tensor.expand_as") ++ `expand_as()` -+ [`movedim()`](generated/torch.Tensor.movedim.html#torch.Tensor.movedim "torch.Tensor.movedim") ++ `movedim()` -+ [`narrow()`](generated/torch.Tensor.narrow.html#torch.Tensor.narrow "torch.Tensor.narrow") ++ `narrow()` -+ [`permute()`](generated/torch.Tensor.permute.html#torch.Tensor.permute "torch.Tensor.permute") ++ `permute()` -+ [`select()`](generated/torch.Tensor.select.html#torch.Tensor.select "torch.Tensor.select") ++ `select()` -+ [`squeeze()`](generated/torch.Tensor.squeeze.html#torch.Tensor.squeeze "torch.Tensor.squeeze") ++ `squeeze()` -+ [`transpose()`](generated/torch.Tensor.transpose.html#torch.Tensor.transpose "torch.Tensor.transpose") ++ `transpose()` -+ [`t()`](generated/torch.Tensor.t.html#torch.Tensor.t "torch.Tensor.t") ++ `t()` -+ [`T`](tensors.html#torch.Tensor.T "torch.Tensor.T") ++ `T` -+ [`H`](tensors.html#torch.Tensor.H "torch.Tensor.H") ++ `H` -+ [`mT`](tensors.html#torch.Tensor.mT "torch.Tensor.mT") ++ `mT` -+ [`mH`](tensors.html#torch.Tensor.mH "torch.Tensor.mH") ++ `mH` -+ [`real`](generated/torch.Tensor.real.html#torch.Tensor.real "torch.Tensor.real") ++ `real` -+ [`imag`](generated/torch.Tensor.imag.html#torch.Tensor.imag "torch.Tensor.imag") ++ `imag` + `view_as_real()` -+ [`unflatten()`](generated/torch.Tensor.unflatten.html#torch.Tensor.unflatten "torch.Tensor.unflatten") ++ `unflatten()` -+ [`unfold()`](generated/torch.Tensor.unfold.html#torch.Tensor.unfold "torch.Tensor.unfold") ++ `unfold()` -+ [`unsqueeze()`](generated/torch.Tensor.unsqueeze.html#torch.Tensor.unsqueeze "torch.Tensor.unsqueeze") ++ `unsqueeze()` -+ [`view()`](generated/torch.Tensor.view.html#torch.Tensor.view "torch.Tensor.view") ++ `view()` -+ [`view_as()`](generated/torch.Tensor.view_as.html#torch.Tensor.view_as "torch.Tensor.view_as") ++ `view_as()` -+ [`unbind()`](generated/torch.Tensor.unbind.html#torch.Tensor.unbind "torch.Tensor.unbind") ++ `unbind()` -+ [`split()`](generated/torch.Tensor.split.html#torch.Tensor.split "torch.Tensor.split") ++ `split()` -+ [`hsplit()`](generated/torch.Tensor.hsplit.html#torch.Tensor.hsplit "torch.Tensor.hsplit") ++ `hsplit()` -+ [`vsplit()`](generated/torch.Tensor.vsplit.html#torch.Tensor.vsplit "torch.Tensor.vsplit") ++ `vsplit()` -+ [`tensor_split()`](generated/torch.Tensor.tensor_split.html#torch.Tensor.tensor_split "torch.Tensor.tensor_split") ++ `tensor_split()` + `split_with_sizes()` -+ [`swapaxes()`](generated/torch.Tensor.swapaxes.html#torch.Tensor.swapaxes "torch.Tensor.swapaxes") ++ `swapaxes()` -+ [`swapdims()`](generated/torch.Tensor.swapdims.html#torch.Tensor.swapdims "torch.Tensor.swapdims") ++ `swapdims()` -+ [`chunk()`](generated/torch.Tensor.chunk.html#torch.Tensor.chunk "torch.Tensor.chunk") ++ `chunk()` -+ [`indices()`](generated/torch.Tensor.indices.html#torch.Tensor.indices "torch.Tensor.indices")（仅适用于稀疏张量） ++ `indices()`（仅适用于稀疏张量） -+ [`values()`](generated/torch.Tensor.values.html#torch.Tensor.values "torch.Tensor.values")（仅适用于稀疏张量） ++ `values()`（仅适用于稀疏张量） 注意 -当通过索引访问张量的内容时，PyTorch遵循Numpy的行为，基本索引返回视图，而高级索引返回副本。通过基本或高级索引进行赋值是原地的。在[Numpy索引文档](https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)中查看更多示例。 +当通过索引访问张量的内容时，PyTorch 遵循 Numpy 的行为，基本索引返回视图，而高级索引返回副本。通过基本或高级索引进行赋值是原地的。在[Numpy 索引文档](https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)中查看更多示例。 还值得一提的是一些具有特殊行为的操作： -+ [`reshape()`](generated/torch.Tensor.reshape.html#torch.Tensor.reshape "torch.Tensor.reshape")、[`reshape_as()`](generated/torch.Tensor.reshape_as.html#torch.Tensor.reshape_as "torch.Tensor.reshape_as")和[`flatten()`](generated/torch.Tensor.flatten.html#torch.Tensor.flatten "torch.Tensor.flatten")可能返回视图或新张量，用户代码不应该依赖于它是视图还是不是。 ++ `reshape()`、`reshape_as()`和`flatten()`可能返回视图或新张量，用户代码不应该依赖于它是视图还是不是。 -+ [`contiguous()`](generated/torch.Tensor.contiguous.html#torch.Tensor.contiguous "torch.Tensor.contiguous")如果输入张量已经是连续的，则返回**自身**，否则通过复制数据返回一个新的连续张量。 ++ `contiguous()`如果输入张量已经是连续的，则返回**自身**，否则通过复制数据返回一个新的连续张量。 -有关PyTorch内部实现的更详细介绍，请参考[ezyang关于PyTorch内部的博文](http://blog.ezyang.com/2019/05/pytorch-internals/)。 +有关 PyTorch 内部实现的更详细介绍，请参考[ezyang 关于 PyTorch 内部的博文](http://blog.ezyang.com/2019/05/pytorch-internals/)。 diff --git a/totrans/doc22_037.md b/totrans/doc22_037.md index f7cae57d..c400ea28 100644 --- a/totrans/doc22_037.md +++ b/totrans/doc22_037.md @@ -1,10 +1,10 @@ # 自动混合精度包 - torch.amp -> 原文：[https://pytorch.org/docs/stable/amp.html](https://pytorch.org/docs/stable/amp.html) +> 原文：[`pytorch.org/docs/stable/amp.html`](https://pytorch.org/docs/stable/amp.html) -[`torch.amp`](#module-torch.amp "torch.amp") 提供了混合精度的便利方法，其中一些操作使用 `torch.float32` (`float`) 数据类型，而其他操作使用较低精度的浮点数据类型 (`lower_precision_fp`)：`torch.float16` (`half`) 或 `torch.bfloat16`。一些操作，如线性层和卷积，使用 `lower_precision_fp` 更快。其他操作，如缩减操作，通常需要 `float32` 的动态范围。混合精度尝试将每个操作匹配到其适当的数据类型。 +`torch.amp` 提供了混合精度的便利方法，其中一些操作使用 `torch.float32` (`float`) 数据类型，而其他操作使用较低精度的浮点数据类型 (`lower_precision_fp`)：`torch.float16` (`half`) 或 `torch.bfloat16`。一些操作，如线性层和卷积，使用 `lower_precision_fp` 更快。其他操作，如缩减操作，通常需要 `float32` 的动态范围。混合精度尝试将每个操作匹配到其适当的数据类型。 -通常，“使用 `torch.float16` 数据类型的自动混合精度训练”使用 [`torch.autocast`](#torch.autocast "torch.autocast") 和 [`torch.cuda.amp.GradScaler`](#torch.cuda.amp.GradScaler "torch.cuda.amp.GradScaler") 一起，如 [CUDA 自动混合精度示例](notes/amp_examples.html#amp-examples) 和 [CUDA 自动混合精度配方](https://pytorch.org/tutorials/recipes/recipes/amp_recipe.html) 中所示。但是，如果需要，[`torch.autocast`](#torch.autocast "torch.autocast") 和 [`torch.cuda.amp.GradScaler`](#torch.cuda.amp.GradScaler "torch.cuda.amp.GradScaler") 是模块化的，可以分开使用。如 [`torch.autocast`](#torch.autocast "torch.autocast") 的 CPU 示例部分所示，“使用 `torch.bfloat16` 数据类型的 CPU 上的自动混合精度训练/推理” 仅使用 [`torch.autocast`](#torch.autocast "torch.autocast")。 +通常，“使用 `torch.float16` 数据类型的自动混合精度训练”使用 `torch.autocast` 和 `torch.cuda.amp.GradScaler` 一起，如 CUDA 自动混合精度示例 和 [CUDA 自动混合精度配方](https://pytorch.org/tutorials/recipes/recipes/amp_recipe.html) 中所示。但是，如果需要，`torch.autocast` 和 `torch.cuda.amp.GradScaler` 是模块化的，可以分开使用。如 `torch.autocast` 的 CPU 示例部分所示，“使用 `torch.bfloat16` 数据类型的 CPU 上的自动混合精度训练/推理” 仅使用 `torch.autocast`。 对于 CUDA 和 CPU，还提供了单独的 API： @@ -12,47 +12,47 @@ + `torch.autocast("cpu", args...)` 等同于 `torch.cpu.amp.autocast(args...)`。目前，对于 CPU，仅支持 `torch.bfloat16` 的较低精度浮点数据类型。 -[`torch.autocast`](#torch.autocast "torch.autocast") 和 [`torch.cpu.amp.autocast`](#torch.cpu.amp.autocast "torch.cpu.amp.autocast") 是 1.10 版本中的新功能。 +`torch.autocast` 和 `torch.cpu.amp.autocast` 是 1.10 版本中的新功能。 -+ [自动转换](#autocasting) ++ 自动转换 -+ [梯度缩放](#gradient-scaling) ++ 梯度缩放 -+ [Autocast Op 参考](#autocast-op-reference) ++ Autocast Op 参考 - + [Op Eligibility](#op-eligibility) + + Op Eligibility - + [CUDA Op-Specific Behavior](#cuda-op-specific-behavior) + + CUDA Op-Specific Behavior - + [CUDA Ops that can autocast to `float16`](#cuda-ops-that-can-autocast-to-float16) + + CUDA Ops that can autocast to `float16` - + [CUDA Ops that can autocast to `float32`](#cuda-ops-that-can-autocast-to-float32) + + CUDA Ops that can autocast to `float32` - + [CUDA Ops that promote to the widest input type](#cuda-ops-that-promote-to-the-widest-input-type) + + CUDA Ops that promote to the widest input type - + [推荐使用 `binary_cross_entropy_with_logits` 而不是 `binary_cross_entropy`](#prefer-binary-cross-entropy-with-logits) + + 推荐使用 `binary_cross_entropy_with_logits` 而不是 `binary_cross_entropy` - + [CPU Op-Specific Behavior](#cpu-op-specific-behavior) + + CPU Op-Specific Behavior - + [CPU Ops that can autocast to `bfloat16`](#cpu-ops-that-can-autocast-to-bfloat16) + + CPU Ops that can autocast to `bfloat16` - + [CPU Ops that can autocast to `float32`](#cpu-ops-that-can-autocast-to-float32) + + CPU Ops that can autocast to `float32` - + [CPU Ops that promote to the widest input type](#cpu-ops-that-promote-to-the-widest-input-type) + + CPU Ops that promote to the widest input type -## [自动转换](#id4) +## 自动转换 ```py class torch.autocast(device_type, dtype=None, enabled=True, cache_enabled=None)¶ ``` -[`autocast`](#torch.autocast "torch.autocast") 的实例充当上下文管理器或装饰器，允许脚本的区域以混合精度运行。 +`autocast` 的实例充当上下文管理器或装饰器，允许脚本的区域以混合精度运行。 -在这些区域中，操作以由 autocast 选择的 op-specific dtype 运行，以提高性能同时保持准确性。详细信息请参阅 [Autocast Op 参考](#autocast-op-reference)。 +在这些区域中，操作以由 autocast 选择的 op-specific dtype 运行，以提高性能同时保持准确性。详细信息请参阅 Autocast Op 参考。 进入启用 autocast 的区域时，张量可以是任何类型。在使用自动转换时，不应在模型或输入上调用 `half()` 或 `bfloat16()`。 -[`autocast`](#torch.autocast "torch.autocast") 应该仅包装网络的前向传递，包括损失计算。不建议在 autocast 下进行反向传递。反向操作以 autocast 用于相应前向操作的相同类型运行。 +`autocast` 应该仅包装网络的前向传递，包括损失计算。不建议在 autocast 下进行反向传递。反向操作以 autocast 用于相应前向操作的相同类型运行。 CUDA 设备示例： @@ -74,9 +74,9 @@ for input, target in data: optimizer.step() ``` -有关在更复杂的情况下（例如梯度惩罚、多个模型/损失、自定义自动求导函数）的用法（以及梯度缩放），请参阅[CUDA自动混合精度示例](notes/amp_examples.html#amp-examples)。 +有关在更复杂的情况下（例如梯度惩罚、多个模型/损失、自定义自动求导函数）的用法（以及梯度缩放），请参阅 CUDA 自动混合精度示例。 -[`autocast`](#torch.autocast "torch.autocast")也可以用作装饰器，例如，用于模型的`forward`方法： +`autocast`也可以用作装饰器，例如，用于模型的`forward`方法： ```py class AutocastModel(nn.Module): @@ -86,7 +86,7 @@ class AutocastModel(nn.Module): ... ``` -在自动转换启用的区域中生成的浮点张量可能是`float16`。在返回到禁用自动转换的区域后，将其与不同dtype的浮点张量一起使用可能会导致类型不匹配错误。如果是这样，请将在自动转换区域中生成的张量重新转换为`float32`（或其他所需的dtype）。如果来自自动转换区域的张量已经是`float32`，则转换是一个空操作，并且不会产生额外的开销。CUDA示例： +在自动转换启用的区域中生成的浮点张量可能是`float16`。在返回到禁用自动转换的区域后，将其与不同 dtype 的浮点张量一起使用可能会导致类型不匹配错误。如果是这样，请将在自动转换区域中生成的张量重新转换为`float32`（或其他所需的 dtype）。如果来自自动转换区域的张量已经是`float32`，则转换是一个空操作，并且不会产生额外的开销。CUDA 示例： ```py # Creates some tensors in default dtype (here assumed to be float32) @@ -107,7 +107,7 @@ with torch.autocast(device_type="cuda"): g_float32 = torch.mm(d_float32, f_float16.float()) ``` -CPU训练示例： +CPU 训练示例： ```py # Creates model and optimizer in default precision @@ -127,7 +127,7 @@ for epoch in epochs: optimizer.step() ``` -CPU推理示例： +CPU 推理示例： ```py # Creates model in default precision @@ -139,7 +139,7 @@ with torch.autocast(device_type="cpu", dtype=torch.bfloat16): output = model(input) ``` -具有Jit Trace的CPU推理示例： +具有 Jit Trace 的 CPU 推理示例： ```py class TestModel(nn.Module): @@ -188,15 +188,15 @@ with torch.autocast(device_type="cuda"): g_float16 = torch.mm(d_float32, f_float32) ``` -自动转换状态是线程本地的。如果要在新线程中启用它，则必须在该线程中调用上下文管理器或装饰器。这会影响当与一个进程中的多个GPU一起使用时的[`torch.nn.DataParallel`](generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel")和[`torch.nn.parallel.DistributedDataParallel`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")（请参阅[使用多个GPU](notes/amp_examples.html#amp-multigpu)）。 +自动转换状态是线程本地的。如果要在新线程中启用它，则必须在该线程中调用上下文管理器或装饰器。这会影响当与一个进程中的多个 GPU 一起使用时的`torch.nn.DataParallel`和`torch.nn.parallel.DistributedDataParallel`（请参阅使用多个 GPU）。 参数 -+ **device_type**（*str*，*必需*）- 要使用的设备类型。可能的值为：'cuda'、'cpu'、'xpu'和'hpu'。该类型与[`torch.device`](tensor_attributes.html#torch.device "torch.device")的类型属性相同。因此，您可以使用Tensor.device.type获取张量的设备类型。 ++ **device_type**（*str*，*必需*）- 要使用的设备类型。可能的值为：'cuda'、'cpu'、'xpu'和'hpu'。该类型与`torch.device`的类型属性相同。因此，您可以使用 Tensor.device.type 获取张量的设备类型。 + **enabled**（*bool*，*可选*）- 是否应在该区域启用自动转换。默认值：`True` -+ **dtype**（*torch_dtype**,* *可选*）- 是否使用torch.float16或torch.bfloat16。 ++ **dtype**（*torch_dtype**,* *可选*）- 是否使用 torch.float16 或 torch.bfloat16。 + **cache_enabled**（*bool*，*可选*）- 是否启用自动转换内部的权重缓存。默认值：`True` @@ -204,7 +204,7 @@ with torch.autocast(device_type="cuda"): class torch.cuda.amp.autocast(enabled=True, dtype=torch.float16, cache_enabled=True)¶ ``` -请参阅[`torch.autocast`](#torch.autocast "torch.autocast")。 +请参阅`torch.autocast`。 `torch.cuda.amp.autocast(args...)`等同于`torch.autocast("cuda", args...)` @@ -214,15 +214,15 @@ torch.cuda.amp.custom_fwd(fwd=None, *, cast_inputs=None)¶ 为自定义自动求导函数的`forward`方法创建一个辅助装饰器。 -自动求导函数是[`torch.autograd.Function`](autograd.html#torch.autograd.Function "torch.autograd.Function")的子类。有关更多详细信息，请参阅[示例页面](notes/amp_examples.html#amp-custom-examples)。 +自动求导函数是`torch.autograd.Function`的子类。有关更多详细信息，请参阅示例页面。 参数 -**cast_inputs**（[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")或None，可选，默认为None）- 如果不是`None`，当`forward`在自动转换启用的区域运行时，将传入的浮点CUDA张量转换为目标dtype（非浮点张量不受影响），然后在禁用自动转换的情况下执行`forward`。如果为`None`，`forward`的内部操作将以当前自动转换状态执行。 +**cast_inputs**（`torch.dtype`或 None，可选，默认为 None）- 如果不是`None`，当`forward`在自动转换启用的区域运行时，将传入的浮点 CUDA 张量转换为目标 dtype（非浮点张量不受影响），然后在禁用自动转换的情况下执行`forward`。如果为`None`，`forward`的内部操作将以当前自动转换状态执行。 注意 -如果装饰的`forward`在自动转换启用的区域之外被调用，则[`custom_fwd`](#torch.cuda.amp.custom_fwd "torch.cuda.amp.custom_fwd")是一个空操作，`cast_inputs`没有效果。 +如果装饰的`forward`在自动转换启用的区域之外被调用，则`custom_fwd`是一个空操作，`cast_inputs`没有效果。 ```py torch.cuda.amp.custom_bwd(bwd)¶ @@ -230,13 +230,13 @@ torch.cuda.amp.custom_bwd(bwd)¶ 为自定义自动求导函数的反向方法创建一个辅助装饰器。 -自动求导函数是`torch.autograd.Function`的子类。确保`backward`以与`forward`相同的自动转换状态执行。更多细节请参见[示例页面](notes/amp_examples.html#amp-custom-examples)。 +自动求导函数是`torch.autograd.Function`的子类。确保`backward`以与`forward`相同的自动转换状态执行。更多细节请参见示例页面。 ```py class torch.cpu.amp.autocast(enabled=True, dtype=torch.bfloat16, cache_enabled=True)¶ ``` -请参见`torch.autocast`。`torch.cpu.amp.autocast(args...)`等同于`torch.autocast("cpu", args...)` ## [梯度缩放](#id5)[](#gradient-scaling "跳转到此标题") +请参见`torch.autocast`。`torch.cpu.amp.autocast(args...)`等同于`torch.autocast("cpu", args...)` ## 梯度缩放[](#gradient-scaling "跳转到此标题") 如果特定操作的前向传递具有`float16`输入，则该操作的反向传递将产生`float16`梯度。具有较小幅度的梯度值可能无法在`float16`中表示。这些值将刷新为零（“下溢”），因此相应参数的更新将丢失。 @@ -246,7 +246,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，请验证您的模型是否兼容。 +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)¶ @@ -286,9 +286,9 @@ for epoch in epochs: scaler.update() ``` -查看[自动混合精度示例](notes/amp_examples.html#amp-examples)以获取更复杂情况下（包括自动转换）的用法，如梯度裁剪、梯度累积、梯度惩罚和多个损失/优化器。 +查看自动混合精度示例以获取更复杂情况下（包括自动转换）的用法，如梯度裁剪、梯度累积、梯度惩罚和多个损失/优化器。 -`scaler`会动态估计每次迭代的比例因子。为了最小化梯度下溢，应该使用一个较大的比例因子。但是，如果比例因子太大，`float16`值可能会“溢出”（变为无穷大或NaN）。因此，最佳比例因子是可以在不产生无穷大或NaN梯度值的情况下使用的最大因子。`scaler`通过在每次`scaler.step(optimizer)`（或可选的单独`scaler.unscale_(optimizer)`，参见`unscale_()`）期间检查梯度中的无穷大和NaN来随时间近似最佳比例因子。 +`scaler`会动态估计每次迭代的比例因子。为了最小化梯度下溢，应该使用一个较大的比例因子。但是，如果比例因子太大，`float16`值可能会“溢出”（变为无穷大或 NaN）。因此，最佳比例因子是可以在不产生无穷大或 NaN 梯度值的情况下使用的最大因子。`scaler`通过在每次`scaler.step(optimizer)`（或可选的单独`scaler.unscale_(optimizer)`，参见`unscale_()`）期间检查梯度中的无穷大和 NaN 来随时间近似最佳比例因子。 + 如果发现无穷大/NaN，`scaler.step(optimizer)`会跳过底层的`optimizer.step()`（因此参数本身保持不受损坏），`update()`会将比例乘以`backoff_factor`。 @@ -300,57 +300,57 @@ for epoch in epochs: + **init_scale**（*float*，*可选*，*默认=2.**16*）- 初始比例因子。 -+ **growth_factor** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*,* *可选**,* *默认=2.0*) – 如果在`growth_interval`连续迭代中没有inf/NaN梯度，则在[`update()`](#torch.cuda.amp.GradScaler.update "torch.cuda.amp.GradScaler.update")期间将缩放乘以的因子。 ++ **growth_factor** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*,* *可选**,* *默认=2.0*) – 如果在`growth_interval`连续迭代中没有 inf/NaN 梯度，则在`update()`期间将缩放乘以的因子。 -+ **backoff_factor** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*,* *可选**,* *默认=0.5*) – 如果在迭代中出现inf/NaN梯度，则在[`update()`](#torch.cuda.amp.GradScaler.update "torch.cuda.amp.GradScaler.update")期间将缩放乘以的因子。 ++ **backoff_factor** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*,* *可选**,* *默认=0.5*) – 如果在迭代中出现 inf/NaN 梯度，则在`update()`期间将缩放乘以的因子。 -+ **growth_interval** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")*,* *可选**,* *默认=2000*) – 必须在没有inf/NaN梯度的连续迭代中发生的次数，以便将比例乘以`growth_factor`。 ++ **growth_interval** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*,* *可选**,* *默认=2000*) – 必须在没有 inf/NaN 梯度的连续迭代中发生的次数，以便将比例乘以`growth_factor`。 -+ **enabled** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*) – 如果为`False`，则禁用梯度缩放。[`step()`](#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")只会调用底层的`optimizer.step()`，其他方法将变为无操作。默认值：`True` ++ **enabled** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*) – 如果为`False`，则禁用梯度缩放。`step()`只会调用底层的`optimizer.step()`，其他方法将变为无操作。默认值：`True` ```py get_backoff_factor()¶ ``` -返回一个包含缩放退避因子的Python浮点数。 +返回一个包含缩放退避因子的 Python 浮点数。 返回类型 -[float](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") +[float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") ```py get_growth_factor()¶ ``` -返回一个包含增长因子的Python浮点数。 +返回一个包含增长因子的 Python 浮点数。 返回类型 -[float](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") +[float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") ```py get_growth_interval()¶ ``` -返回一个包含增长间隔的Python整数。 +返回一个包含增长间隔的 Python 整数。 返回类型 -[int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)") +[int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)") ```py get_scale()¶ ``` -返回一个包含当前比例的Python浮点数，如果禁用了缩放，则返回1.0。 +返回一个包含当前比例的 Python 浮点数，如果禁用了缩放，则返回 1.0。 警告 -[`get_scale()`](#torch.cuda.amp.GradScaler.get_scale "torch.cuda.amp.GradScaler.get_scale") 会导致CPU-GPU同步。 +`get_scale()` 会导致 CPU-GPU 同步。 返回类型 -[float](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") +[float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") ```py is_enabled()¶ @@ -360,7 +360,7 @@ is_enabled()¶ 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py load_state_dict(state_dict)¶ @@ -368,11 +368,11 @@ load_state_dict(state_dict)¶ 加载缩放器状态。 -如果此实例已禁用，则[`load_state_dict()`](#torch.cuda.amp.GradScaler.load_state_dict "torch.cuda.amp.GradScaler.load_state_dict")将不执行任何操作。 +如果此实例已禁用，则`load_state_dict()`将不执行任何操作。 参数 -**state_dict** ([*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12中)")) – 缩放器状态。应该是从调用[`state_dict()`](#torch.cuda.amp.GradScaler.state_dict "torch.cuda.amp.GradScaler.state_dict")返回的对象。 +**state_dict** ([*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")) – 缩放器状态。应该是从调用`state_dict()`返回的对象。 ```py scale(outputs: Tensor) → Tensor¶ @@ -392,11 +392,11 @@ scale(outputs: Iterable[Tensor]) → Iterable[Tensor] 通过比例因子将张量或张量列表进行乘法（“缩放”）。 -返回缩放后的输出。如果此[`GradScaler`](#torch.cuda.amp.GradScaler "torch.cuda.amp.GradScaler")实例未启用，则输出将保持不变。 +返回缩放后的输出。如果此`GradScaler`实例未启用，则输出将保持不变。 参数 -**outputs** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor") *或* *可迭代* *的* *Tensors*) – 要缩放的输出。 +**outputs** (*Tensor* *或* *可迭代* *的* *Tensors*) – 要缩放的输出。 ```py set_backoff_factor(new_factor)¶ @@ -406,7 +406,7 @@ set_backoff_factor(new_factor)¶ 参数 -**new_scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")) – 用作新的缩放退避因子的值。 +**new_scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) – 用作新的缩放退避因子的值。 ```py set_growth_factor(new_factor)¶ @@ -416,7 +416,7 @@ set_growth_factor(new_factor)¶ 参数 -**new_scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")) – 用作新的增长因子的值。 +**new_scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) – 用作新的增长因子的值。 ```py set_growth_interval(new_interval)¶ @@ -426,31 +426,31 @@ set_growth_interval(new_interval)¶ 参数 -**new_interval** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) – 用作新增长间隔的值。 +**new_interval** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – 用作新增长间隔的值。 ```py state_dict()¶ ``` -返回一个[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12中)")形式的缩放器状态。 +返回一个[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")形式的缩放器状态。 它包含五个条目： -+ `"scale"` - 包含当前比例的Python浮点数 ++ `"scale"` - 包含当前比例的 Python 浮点数 -+ `"growth_factor"` - 包含当前增长因子的Python浮点数 ++ `"growth_factor"` - 包含当前增长因子的 Python 浮点数 -+ `"backoff_factor"` - 包含当前退避因子的Python浮点数 ++ `"backoff_factor"` - 包含当前退避因子的 Python 浮点数 -+ `"growth_interval"` - 包含当前增长间隔的Python整数 ++ `"growth_interval"` - 包含当前增长间隔的 Python 整数 -+ `"_growth_tracker"` - 包含最近连续未跳过步骤的Python int。 ++ `"_growth_tracker"` - 包含最近连续未跳过步骤的 Python int。 如果此实例未启用，则返回空字典。 注意 -如果您希望在特定迭代之后检查标量器的状态，应在[`update()`](#torch.cuda.amp.GradScaler.update "torch.cuda.amp.GradScaler.update")之后调用[`state_dict()`](#torch.cuda.amp.GradScaler.state_dict "torch.cuda.amp.GradScaler.state_dict")。 +如果您希望在特定迭代之后检查标量器的状态，应在`update()`之后调用`state_dict()`。 返回类型 @@ -462,11 +462,11 @@ step(optimizer, *args, **kwargs)¶ 如果梯度不是无穷大/NaN，则调用`unscale_(optimizer)`，然后进行参数更新。 -[`step()`](#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")执行以下两个操作： +`step()`执行以下两个操作： -1. 在迭代中未为`optimizer`显式调用[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")时，内部调用`unscale_(optimizer)`。作为[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")的一部分，梯度将被检查是否有无穷大/NaN。 +1. 在迭代中未为`optimizer`显式调用`unscale_()`时，内部调用`unscale_(optimizer)`。作为`unscale_()`的一部分，梯度将被检查是否有无穷大/NaN。 -1. 如果未发现无穷大/NaN梯度，则使用未缩放梯度调用`optimizer.step()`。否则，将跳过`optimizer.step()`以避免损坏参数。 +1. 如果未发现无穷大/NaN 梯度，则使用未缩放梯度调用`optimizer.step()`。否则，将跳过`optimizer.step()`以避免损坏参数。 `*args`和`**kwargs`将被转发到`optimizer.step()`。 @@ -474,7 +474,7 @@ step(optimizer, *args, **kwargs)¶ 参数 -+ **optimizer** ([*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")) – 应用梯度的优化器。 ++ **optimizer** (*torch.optim.Optimizer*) – 应用梯度的优化器。 + **args** ([*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")) – 任意参数。 @@ -494,9 +494,9 @@ unscale_(optimizer)¶ 通过比例因子除（“取消缩放”）优化器的梯度张量。 -[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")是可选的，用于需要在反向传播和[`step()`](#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")之间修改或检查梯度的情况。如果未显式调用[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")，梯度将在[`step()`](#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")期间自动取消缩放。 +`unscale_()`是可选的，用于需要在反向传播和`step()`之间修改或检查梯度的情况。如果未显式调用`unscale_()`，梯度将在`step()`期间自动取消缩放。 -简单示例，使用[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")启用未缩放梯度的裁剪： +简单示例，使用`unscale_()`启用未缩放梯度的裁剪： ```py ... @@ -509,19 +509,19 @@ scaler.update() 参数 -**optimizer** ([*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")) – 拥有待取消缩放梯度的优化器。 +**optimizer** (*torch.optim.Optimizer*) – 拥有待取消缩放梯度的优化器。 注意 -[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")不会导致CPU-GPU同步。 +`unscale_()`不会导致 CPU-GPU 同步。 警告 -每次调用[`step()`](#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")时，应仅对每个优化器调用一次[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")，并且仅在为该优化器分配的参数累积了所有梯度之后才调用。在每个[`step()`](#torch.cuda.amp.GradScaler.step "torch.cuda.amp.GradScaler.step")之间两次为给定优化器调用[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")会触发运行时错误。 +每次调用`step()`时，应仅对每个优化器调用一次`unscale_()`，并且仅在为该优化器分配的参数累积了所有梯度之后才调用。在每个`step()`之间两次为给定优化器调用`unscale_()`会触发运行时错误。 警告 -[`unscale_()`](#torch.cuda.amp.GradScaler.unscale_ "torch.cuda.amp.GradScaler.unscale_")可能会在原地取消缩放稀疏梯度，替换`.grad`属性。 +`unscale_()`可能会在原地取消缩放稀疏梯度，替换`.grad`属性。 ```py update(new_scale=None)¶ @@ -539,65 +539,65 @@ update(new_scale=None)¶ 警告 -[`update()`](#torch.cuda.amp.GradScaler.update "torch.cuda.amp.GradScaler.update") 应该只在迭代结束后调用，在此迭代中已为所有使用的优化器调用了 `scaler.step(optimizer)`。 +`update()` 应该只在迭代结束后调用，在此迭代中已为所有使用的优化器调用了 `scaler.step(optimizer)`。 警告 -出于性能原因，我们不检查比例因子的值以避免同步，因此不能保证比例因子大于 1。如果比例低于 1 和/或在梯度或损失中看到 NaN，则可能有问题。例如，由于动态范围不同，bf16 预训练模型通常与 AMP/fp16 不兼容。 ## [自动混合精度操作参考](#id6)[](#autocast-op-reference "跳转到此标题") +出于性能原因，我们不检查比例因子的值以避免同步，因此不能保证比例因子大于 1。如果比例低于 1 和/或在梯度或损失中看到 NaN，则可能有问题。例如，由于动态范围不同，bf16 预训练模型通常与 AMP/fp16 不兼容。 ## 自动混合精度操作参考[](#autocast-op-reference "跳转到此标题") -### [操作资格](#id7) +### 操作资格 在 `float64` 或非浮点数据类型中运行的操作不符合条件，无论是否启用了自动混合精度，它们都将以这些类型运行。 只有不改变原始数据的操作和张量方法才符合条件。在启用自动混合精度的区域中，可以使用就地变体和显式提供 `out=...` 张量的调用，但不会经过自动混合精度。例如，在启用自动混合精度的区域中，`a.addmm(b, c)` 可以自动混合精度，但 `a.addmm_(b, c)` 和 `a.addmm(b, c, out=d)` 不能。为了获得最佳性能和稳定性，请在启用自动混合精度的区域中使用不改变原始数据的操作。 -使用显式 `dtype=...` 参数调用的操作不符合条件，并将生成符合 `dtype` 参数的输出。 ### [CUDA 操作特定行为](#id8)[](#cuda-op-specific-behavior "跳转到此标题") +使用显式 `dtype=...` 参数调用的操作不符合条件，并将生成符合 `dtype` 参数的输出。 ### CUDA 操作特定行为[](#cuda-op-specific-behavior "跳转到此标题") -以下列表描述了在启用自动混合精度的区域中符合条件的操作的行为。这些操作总是经过自动混合精度，无论它们作为 [`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module") 的一部分调用，作为一个函数调用，还是作为 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 方法调用。如果函数在多个命名空间中公开，无论命名空间如何，它们都会经过自动混合精度。 +以下列表描述了在启用自动混合精度的区域中符合条件的操作的行为。这些操作总是经过自动混合精度，无论它们作为 `torch.nn.Module` 的一部分调用，作为一个函数调用，还是作为 `torch.Tensor` 方法调用。如果函数在多个命名空间中公开，无论命名空间如何，它们都会经过自动混合精度。 下面未列出的操作不会经过自动混合精度。它们以其输入定义的类型运行。但是，如果它们在自动混合精度操作的下游，则自动混合精度可能会改变未列出操作运行的类型。 如果某个操作未列出，我们会假定它在 `float16` 中是数值稳定的。如果您认为某个未列出的操作在 `float16` 中是数值不稳定的，请提交一个问题。 -#### [可以自动混合精度为 `float16` 的 CUDA 操作](#id9)[](#cuda-ops-that-can-autocast-to-float16 "跳转到此标题") +#### 可以自动混合精度为 `float16` 的 CUDA 操作[](#cuda-ops-that-can-autocast-to-float16 "跳转到此标题") `__matmul__`, `addbmm`, `addmm`, `addmv`, `addr`, `baddbmm`, `bmm`, `chain_matmul`, `multi_dot`, `conv1d`, `conv2d`, `conv3d`, `conv_transpose1d`, `conv_transpose2d`, `conv_transpose3d`, `GRUCell`, `linear`, `LSTMCell`, `matmul`, `mm`, `mv`, `prelu`, `RNNCell` -#### [可以自动混合精度为 `float32` 的 CUDA 操作](#id10)[](#cuda-ops-that-can-autocast-to-float32 "跳转到此标题的永久链接") +#### 可以自动混合精度为 `float32` 的 CUDA 操作[](#cuda-ops-that-can-autocast-to-float32 "跳转到此标题的永久链接") `__pow__`, `__rdiv__`, `__rpow__`, `__rtruediv__`, `acos`, `asin`, `binary_cross_entropy_with_logits`, `cosh`, `cosine_embedding_loss`, `cdist`, `cosine_similarity`, `cross_entropy`, `cumprod`, `cumsum`, `dist`, `erfinv`, `exp`, `expm1`, `group_norm`, `hinge_embedding_loss`, `kl_div`, `l1_loss`, `layer_norm`, `log`, `log_softmax`, `log10`, `log1p`, `log2`, `margin_ranking_loss`, `mse_loss`, `multilabel_margin_loss`, `multi_margin_loss`, `nll_loss`, `norm`, `normalize`, `pdist`, `poisson_nll_loss`, `pow`, `prod`, `reciprocal`, `rsqrt`, `sinh`, `smooth_l1_loss`, `soft_margin_loss`, `softmax`, `softmin`, `softplus`, `sum`, `renorm`, `tan`, `triplet_margin_loss` -#### [CUDA操作会将输入类型提升为最宽的类型](#id11)[](#cuda-ops-that-promote-to-the-widest-input-type "跳转到此标题") +#### CUDA 操作会将输入类型提升为最宽的类型[](#cuda-ops-that-promote-to-the-widest-input-type "跳转到此标题") -这些操作不需要特定的dtype来保持稳定性，但需要多个输入并要求输入的dtype匹配。如果所有输入都是`float16`，则操作将在`float16`中运行。如果任何输入是`float32`，自动转换将所有输入转换为`float32`并在`float32`中运行操作。 +这些操作不需要特定的 dtype 来保持稳定性，但需要多个输入并要求输入的 dtype 匹配。如果所有输入都是`float16`，则操作将在`float16`中运行。如果任何输入是`float32`，自动转换将所有输入转换为`float32`并在`float32`中运行操作。 `addcdiv`, `addcmul`, `atan2`, `bilinear`, `cross`, `dot`, `grid_sample`, `index_put`, `scatter_add`, `tensordot` 这里未列出的一些操作（例如，`add`等二元操作）会在没有自动转换干预的情况下自然提升输入。如果输入是`float16`和`float32`的混合，这些操作将在`float32`中运行并产生`float32`输出，无论自动转换是否启用。 -#### [优先使用`binary_cross_entropy_with_logits`而不是`binary_cross_entropy`](#id12)[](#prefer-binary-cross-entropy-with-logits-over-binary-cross-entropy "跳转到此标题") +#### 优先使用`binary_cross_entropy_with_logits`而不是`binary_cross_entropy`[](#prefer-binary-cross-entropy-with-logits-over-binary-cross-entropy "跳转到此标题") -[`torch.nn.functional.binary_cross_entropy()`](generated/torch.nn.functional.binary_cross_entropy.html#torch.nn.functional.binary_cross_entropy "torch.nn.functional.binary_cross_entropy")的反向传播（以及包装它的[`torch.nn.BCELoss`](generated/torch.nn.BCELoss.html#torch.nn.BCELoss "torch.nn.BCELoss")）可能会产生在`float16`中无法表示的梯度。在启用自动转换的区域中，前向输入可能是`float16`，这意味着反向梯度必须在`float16`中表示（将`float16`前向输入自动转换为`float32`是没有帮助的，因为这种转换在反向传播中必须被逆转）。因此，在启用自动转换的区域中，`binary_cross_entropy`和`BCELoss`会引发错误。 +`torch.nn.functional.binary_cross_entropy()`的反向传播（以及包装它的`torch.nn.BCELoss`）可能会产生在`float16`中无法表示的梯度。在启用自动转换的区域中，前向输入可能是`float16`，这意味着反向梯度必须在`float16`中表示（将`float16`前向输入自动转换为`float32`是没有帮助的，因为这种转换在反向传播中必须被逆转）。因此，在启用自动转换的区域中，`binary_cross_entropy`和`BCELoss`会引发错误。 -许多模型在二元交叉熵层之前使用一个sigmoid层。在这种情况下，使用[`torch.nn.functional.binary_cross_entropy_with_logits()`](generated/torch.nn.functional.binary_cross_entropy_with_logits.html#torch.nn.functional.binary_cross_entropy_with_logits "torch.nn.functional.binary_cross_entropy_with_logits")或[`torch.nn.BCEWithLogitsLoss`](generated/torch.nn.BCEWithLogitsLoss.html#torch.nn.BCEWithLogitsLoss "torch.nn.BCEWithLogitsLoss")结合这两个层。`binary_cross_entropy_with_logits`和`BCEWithLogits`可以安全地进行自动转换。 ### [CPU操作特定行为](#id13)[](#cpu-op-specific-behavior "跳转到此标题") +许多模型在二元交叉熵层之前使用一个 sigmoid 层。在这种情况下，使用`torch.nn.functional.binary_cross_entropy_with_logits()`或`torch.nn.BCEWithLogitsLoss`结合这两个层。`binary_cross_entropy_with_logits`和`BCEWithLogits`可以安全地进行自动转换。 ### CPU 操作特定行为[](#cpu-op-specific-behavior "跳转到此标题") -以下列表描述了在启用自动转换的区域中合格操作的行为。这些操作始终经过自动转换，无论它们是作为[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")的一部分、作为函数还是作为[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")方法调用。如果函数在多个命名空间中公开，无论命名空间如何，它们都会经过自动转换。 +以下列表描述了在启用自动转换的区域中合格操作的行为。这些操作始终经过自动转换，无论它们是作为`torch.nn.Module`的一部分、作为函数还是作为`torch.Tensor`方法调用。如果函数在多个命名空间中公开，无论命名空间如何，它们都会经过自动转换。 以下未列出的操作不会经过自动转换。它们以其输入定义的类型运行。但是，如果它们在自动转换的操作之后，自动转换仍可能更改未列出操作运行的类型。 如果一个操作未列出，我们假定它在`bfloat16`中是数值稳定的。如果您认为未列出的操作在`bfloat16`中是数值不稳定的，请提交一个问题。 -#### [CPU操作可以自动转换为`bfloat16`](#id14)[](#cpu-ops-that-can-autocast-to-bfloat16 "跳转到此标题") +#### CPU 操作可以自动转换为`bfloat16`[](#cpu-ops-that-can-autocast-to-bfloat16 "跳转到此标题") `conv1d`，`conv2d`，`conv3d`，`bmm`，`mm`，`baddbmm`，`addmm`，`addbmm`，`linear`，`matmul`，`_convolution` -#### [可以自动转换为`float32`的CPU操作](#id15)[](#cpu-ops-that-can-autocast-to-float32 "跳转到此标题的永久链接") +#### 可以自动转换为`float32`的 CPU 操作[](#cpu-ops-that-can-autocast-to-float32 "跳转到此标题的永久链接") `conv_transpose1d`，`conv_transpose2d`，`conv_transpose3d`，`avg_pool3d`，`binary_cross_entropy`，`grid_sampler`，`grid_sampler_2d`，`_grid_sampler_2d_cpu_fallback`，`grid_sampler_3d`，`polar`，`prod`，`quantile`，`nanquantile`，`stft`，`cdist`，`trace`，`view_as_complex`，`cholesky`，`cholesky_inverse`，`cholesky_solve`，`inverse`，`lu_solve`，`orgqr`，`inverse`，`ormqr`，`pinverse`，`max_pool3d`，`max_unpool2d`，`max_unpool3d`，`adaptive_avg_pool3d`，`reflection_pad1d`，`reflection_pad2d`，`replication_pad1d`，`replication_pad2d`，`replication_pad3d`，`mse_loss`，`ctc_loss`，`kl_div`，`multilabel_margin_loss`，`fft_fft`，`fft_ifft`，`fft_fft2`，`fft_ifft2`，`fft_fftn`，`fft_ifftn`，`fft_rfft`，`fft_irfft`，`fft_rfft2`，`fft_irfft2`，`fft_rfftn`，`fft_irfftn`，`fft_hfft`，`fft_ihfft`，`linalg_matrix_norm`，`linalg_cond`，`linalg_matrix_rank`，`linalg_solve`，`linalg_cholesky`，`linalg_svdvals`，`linalg_eigvals`，`linalg_eigvalsh`，`linalg_inv`，`linalg_householder_product`，`linalg_tensorinv`，`linalg_tensorsolve`，`fake_quantize_per_tensor_affine`，`eig`，`geqrf`，`lstsq`，`_lu_with_info`，`qr`，`solve`，`svd`，`symeig`，`triangular_solve`，`fractional_max_pool2d`，`fractional_max_pool3d`，`adaptive_max_pool3d`，`multilabel_margin_loss_forward`，`linalg_qr`，`linalg_cholesky_ex`，`linalg_svd`，`linalg_eig`，`linalg_eigh`，`linalg_lstsq`，`linalg_inv_ex` -#### [将输入类型提升为最宽的CPU操作](#id16)[](#cpu-ops-that-promote-to-the-widest-input-type "跳转到此标题的永久链接") +#### 将输入类型提升为最宽的 CPU 操作[](#cpu-ops-that-promote-to-the-widest-input-type "跳转到此标题的永久链接") -这些操作不需要特定的dtype来保持稳定性，但需要多个输入并要求输入的dtypes匹配。如果所有输入都是`bfloat16`，则该操作将在`bfloat16`中运行。如果任何输入是`float32`，自动转换将将所有输入转换为`float32`并在`float32`中运行该操作。 +这些操作不需要特定的 dtype 来保持稳定性，但需要多个输入并要求输入的 dtypes 匹配。如果所有输入都是`bfloat16`，则该操作将在`bfloat16`中运行。如果任何输入是`float32`，自动转换将将所有输入转换为`float32`并在`float32`中运行该操作。 `cat`，`stack`，`index_copy` diff --git a/totrans/doc22_038.md b/totrans/doc22_038.md index 3664168c..1512ff32 100644 --- a/totrans/doc22_038.md +++ b/totrans/doc22_038.md @@ -1,12 +1,12 @@ # 自动微分包 - torch.autograd -> 原文：[https://pytorch.org/docs/stable/autograd.html](https://pytorch.org/docs/stable/autograd.html) +> 原文：[`pytorch.org/docs/stable/autograd.html`](https://pytorch.org/docs/stable/autograd.html) `torch.autograd` 提供了实现任意标量值函数自动微分的类和函数。它对现有代码的更改很小 - 您只需要声明应计算梯度的 `Tensor`，并使用 `requires_grad=True` 关键字。目前，我们仅支持浮点 `Tensor` 类型（half、float、double 和 bfloat16）和复数 `Tensor` 类型（cfloat、cdouble）的自动微分。 -| [`backward`](generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward") | 计算给定张量相对于图叶子节点的梯度之和。 | +| `backward` | 计算给定张量相对于图叶子节点的梯度之和。 | | --- | --- | -| [`grad`](generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad") | 计算并返回输出相对于输入的梯度之和。 | +| `grad` | 计算并返回输出相对于输入的梯度之和。 | ## 前向模式自动微分[](#forward-mode-automatic-differentiation "跳转到此标题") @@ -16,11 +16,11 @@ 请查看[前向模式 AD 教程](https://pytorch.org/tutorials/intermediate/forward_ad_usage.html)以获取如何使用此 API 的详细步骤。 -| [`forward_ad.dual_level`](generated/torch.autograd.forward_ad.dual_level.html#torch.autograd.forward_ad.dual_level "torch.autograd.forward_ad.dual_level") | 用于前向 AD 的上下文管理器，在 `dual_level` 上下文中必须进行所有前向 AD 计算。 | +| `forward_ad.dual_level` | 用于前向 AD 的上下文管理器，在 `dual_level` 上下文中必须进行所有前向 AD 计算。 | | --- | --- | -| [`forward_ad.make_dual`](generated/torch.autograd.forward_ad.make_dual.html#torch.autograd.forward_ad.make_dual "torch.autograd.forward_ad.make_dual") | 将张量值与其切线关联起来，创建一个用于前向 AD 梯度计算的“双重张量”。 | +| `forward_ad.make_dual` | 将张量值与其切线关联起来，创建一个用于前向 AD 梯度计算的“双重张量”。 | -| [`forward_ad.unpack_dual`](generated/torch.autograd.forward_ad.unpack_dual.html#torch.autograd.forward_ad.unpack_dual "torch.autograd.forward_ad.unpack_dual") | 解包“双重张量”，获取其张量值和前向 AD 梯度。| ## 功能高级 API[](#functional-higher-level-api "跳转到此标题") +| `forward_ad.unpack_dual` | 解包“双重张量”，获取其张量值和前向 AD 梯度。| ## 功能高级 API[](#functional-higher-level-api "跳转到此标题") 警告 @@ -30,18 +30,18 @@ 此 API 适用于用户提供的仅以张量作为输入并返回张量的函数。如果您的函数接受其他非张量参数或未设置 requires_grad 的张量，您可以使用 lambda 来捕获它们。例如，对于一个接受三个输入的函数 `f`，一个张量用于计算雅可比矩阵，另一个应被视为常数的张量，以及一个布尔标志作为 `f(input, constant, flag=flag)`，您可以使用 `functional.jacobian(lambda x: f(x, constant, flag=flag), input)`。 -| [`functional.jacobian`](generated/torch.autograd.functional.jacobian.html#torch.autograd.functional.jacobian "torch.autograd.functional.jacobian") | 计算给定函数的雅可比矩阵。 | +| `functional.jacobian` | 计算给定函数的雅可比矩阵。 | | --- | --- | -| [`functional.hessian`](generated/torch.autograd.functional.hessian.html#torch.autograd.functional.hessian "torch.autograd.functional.hessian") | 计算给定标量函数的 Hessian 矩阵。 | -| [`functional.vjp`](generated/torch.autograd.functional.vjp.html#torch.autograd.functional.vjp "torch.autograd.functional.vjp") | 计算给定函数在输入点处的 Jacobian 矩阵与向量 `v` 的点积。 | -| [`functional.jvp`](generated/torch.autograd.functional.jvp.html#torch.autograd.functional.jvp "torch.autograd.functional.jvp") | 计算给定函数在输入点处的 Jacobian 矩阵与向量 `v` 的点积。 | -| [`functional.vhp`](generated/torch.autograd.functional.vhp.html#torch.autograd.functional.vhp "torch.autograd.functional.vhp") | 计算向量`v`与给定标量函数在指定点处的Hessian的点积。 | +| `functional.hessian` | 计算给定标量函数的 Hessian 矩阵。 | +| `functional.vjp` | 计算给定函数在输入点处的 Jacobian 矩阵与向量 `v` 的点积。 | +| `functional.jvp` | 计算给定函数在输入点处的 Jacobian 矩阵与向量 `v` 的点积。 | +| `functional.vhp` | 计算向量`v`与给定标量函数在指定点处的 Hessian 的点积。 | -| [`functional.hvp`](generated/torch.autograd.functional.hvp.html#torch.autograd.functional.hvp "torch.autograd.functional.hvp") | 计算标量函数的Hessian和向量`v`在指定点处的点积。 |## 本地禁用梯度计算[](#locally-disabling-gradient-computation "跳转到此标题的永久链接") +| `functional.hvp` | 计算标量函数的 Hessian 和向量`v`在指定点处的点积。 |## 本地禁用梯度计算[](#locally-disabling-gradient-computation "跳转到此标题的永久链接") -有关无梯度和推断模式之间的区别以及可能与两者混淆的其他相关机制的更多信息，请参阅[本地禁用梯度计算](notes/autograd.html#locally-disable-grad-doc)。还请参阅[本地禁用梯度计算](torch.html#torch-rst-local-disable-grad)以获取可用于本地禁用梯度的函数列表。## 默认梯度布局 +有关无梯度和推断模式之间的区别以及可能与两者混淆的其他相关机制的更多信息，请参阅本地禁用梯度计算。还请参阅本地禁用梯度计算以获取可用于本地禁用梯度的函数列表。## 默认梯度布局 -当非稀疏`param`在[`torch.autograd.backward()`](generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward")或[`torch.Tensor.backward()`](generated/torch.Tensor.backward.html#torch.Tensor.backward "torch.Tensor.backward")期间接收到非稀疏梯度时，`param.grad`将按以下方式累积。 +当非稀疏`param`在`torch.autograd.backward()`或`torch.Tensor.backward()`期间接收到非稀疏梯度时，`param.grad`将按以下方式累积。 如果`param.grad`最初为`None`： @@ -55,7 +55,7 @@ 1. 如果`create_graph=True`，`backward()`将用新张量`.grad + new grad`替换`.grad`，尝试（但不保证）匹配现有`.grad`的步幅。 -推荐默认行为（在第一次`backward()`之前让`.grad`为`None`，使其布局根据1或2创建，并根据3或4保留）以获得最佳性能。调用`model.zero_grad()`或`optimizer.zero_grad()`不会影响`.grad`的布局。 +推荐默认行为（在第一次`backward()`之前让`.grad`为`None`，使其布局根据 1 或 2 创建，并根据 3 或 4 保留）以获得最佳性能。调用`model.zero_grad()`或`optimizer.zero_grad()`不会影响`.grad`的布局。 事实上，在每个累积阶段之前将所有的`.grad`重置为`None`，例如： @@ -67,15 +67,15 @@ for iterations... loss.backward() ``` -每次根据1或2重新创建它们，是`model.zero_grad()`或`optimizer.zero_grad()`的有效替代方法，可能会提高某些网络的性能。 +每次根据 1 或 2 重新创建它们，是`model.zero_grad()`或`optimizer.zero_grad()`的有效替代方法，可能会提高某些网络的性能。 ### 手动梯度布局 -如果您需要手动控制`.grad`的步幅，在第一次`backward()`之前将`param.grad =`分配为具有所需步幅的零张量，并永远不要将其重置为`None`。3保证只要`create_graph=False`，您的布局就会被保留。4表明即使`create_graph=True`，您的布局也*可能*会被保留。 +如果您需要手动控制`.grad`的步幅，在第一次`backward()`之前将`param.grad =`分配为具有所需步幅的零张量，并永远不要将其重置为`None`。3 保证只要`create_graph=False`，您的布局就会被保留。4 表明即使`create_graph=True`，您的布局也*可能*会被保留。 ## 张量的原地操作[](#in-place-operations-on-tensors "跳转到此标题的永久链接") -在autograd中支持原地操作是一个棘手的问题，我们不鼓励在大多数情况下使用它们。Autograd的积极缓冲区释放和重用使其非常高效，只有在极度内存压力下，才有很少的情况下原地操作实际上会显著降低内存使用量。除非您在极度内存压力下操作，否则您可能永远不需要使用它们。 +在 autograd 中支持原地操作是一个棘手的问题，我们不鼓励在大多数情况下使用它们。Autograd 的积极缓冲区释放和重用使其非常高效，只有在极度内存压力下，才有很少的情况下原地操作实际上会显著降低内存使用量。除非您在极度内存压力下操作，否则您可能永远不需要使用它们。 ### 原地正确性检查[](#in-place-correctness-checks "跳转到此标题的永久链接") @@ -93,13 +93,13 @@ Variable API 已被弃用：不再需要使用 Variables 来使用带有 `requir + 现在，`var.backward()、var.detach()、var.register_hook()` 等方法在具有相同方法名称的张量上也可以使用。 -此外，现在可以使用工厂方法（如 [`torch.randn()`](generated/torch.randn.html#torch.randn "torch.randn")、[`torch.zeros()`](generated/torch.zeros.html#torch.zeros "torch.zeros")、[`torch.ones()`](generated/torch.ones.html#torch.ones "torch.ones") 等）创建 `requires_grad=True` 的张量，如下所示： +此外，现在可以使用工厂方法（如 `torch.randn()`、`torch.zeros()`、`torch.ones()` 等）创建 `requires_grad=True` 的张量，如下所示： `autograd_tensor = torch.randn((2, 3, 4), requires_grad=True)` ## 张量自动求导函数 -| `torch.Tensor.grad` | 默认情况下，此属性为 `None`，并且在第一次调用 [`backward()`](generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward") 为 `self` 计算梯度时变为张量。 | +| `torch.Tensor.grad` | 默认情况下，此属性为 `None`，并且在第一次调用 `backward()` 为 `self` 计算梯度时变为张量。 | | --- | --- | | `torch.Tensor.requires_grad` | 如果需要为此张量计算梯度，则为 `True`，否则为 `False`。 | | `torch.Tensor.is_leaf` | 所有 `requires_grad` 为 `False` 的张量将按照惯例成为叶子张量。 | @@ -108,7 +108,7 @@ Variable API 已被弃用：不再需要使用 Variables 来使用带有 `requir | `torch.Tensor.detach_` | 从创建它的图中分离张量，使其成为叶子。 | | `torch.Tensor.register_hook`(hook) | 注册一个反向钩子。 | | `torch.Tensor.register_post_accumulate_grad_hook`(hook) | 注册一个在梯度累积后运行的反向钩子。 | -| `torch.Tensor.retain_grad`() | 允许此张量在 [`backward()`](generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward") 运行时填充其 [`grad`](generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad")。 | +| `torch.Tensor.retain_grad`() | 允许此张量在 `backward()` 运行时填充其 `grad`。 | ## Function @@ -118,11 +118,11 @@ class torch.autograd.Function(*args, **kwargs)¶ 用于创建自定义自动求导函数的基类。 -要创建自定义自动求导函数，请继承此类并实现 [`forward()`](generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") 和 [`backward()`](generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward") 静态方法。然后，在前向传播中使用您的自定义操作，调用类方法 `apply`。不要直接调用 [`forward()`](generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward")。 +要创建自定义自动求导函数，请继承此类并实现 `forward()` 和 `backward()` 静态方法。然后，在前向传播中使用您的自定义操作，调用类方法 `apply`。不要直接调用 `forward()`。 -为了确保正确性和最佳性能，请确保在 `ctx` 上调用正确的方法，并使用 [`torch.autograd.gradcheck()`](#module-torch.autograd.gradcheck "torch.autograd.gradcheck") 验证您的反向函数。 +为了确保正确性和最佳性能，请确保在 `ctx` 上调用正确的方法，并使用 `torch.autograd.gradcheck()` 验证您的反向函数。 -有关如何使用此类的更多详细信息，请参阅 [扩展 torch.autograd](notes/extending.html#extending-autograd)。 +有关如何使用此类的更多详细信息，请参阅 扩展 torch.autograd。 示例： @@ -143,31 +143,31 @@ class torch.autograd.Function(*args, **kwargs)¶ >>> output = Exp.apply(input) ``` -| [`Function.forward`](generated/torch.autograd.Function.forward.html#torch.autograd.Function.forward "torch.autograd.Function.forward") | 定义自定义自动求导函数的前向传播。 | +| `Function.forward` | 定义自定义自动求导函数的前向传播。 | | --- | --- | -| [`Function.backward`](generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward") | 定义使用反向模式自动微分操作的微分公式。 | -| [`Function.jvp`](generated/torch.autograd.Function.jvp.html#torch.autograd.Function.jvp "torch.autograd.Function.jvp") | 定义使用前向模式自动微分操作的微分公式。 | -| [`Function.vmap`](generated/torch.autograd.Function.vmap.html#torch.autograd.Function.vmap "torch.autograd.Function.vmap") | 定义此autograd.Function在[`torch.vmap()`](generated/torch.vmap.html#torch.vmap "torch.vmap")下的行为。 | +| `Function.backward` | 定义使用反向模式自动微分操作的微分公式。 | +| `Function.jvp` | 定义使用前向模式自动微分操作的微分公式。 | +| `Function.vmap` | 定义此 autograd.Function 在`torch.vmap()`下的行为。 | ## 上下文方法混合 -创建新的[`Function`](#torch.autograd.Function "torch.autograd.Function")时，以下方法可用于ctx。 +创建新的`Function`时，以下方法可用于 ctx。 -| [`function.FunctionCtx.mark_dirty`](generated/torch.autograd.function.FunctionCtx.mark_dirty.html#torch.autograd.function.FunctionCtx.mark_dirty "torch.autograd.function.FunctionCtx.mark_dirty") | 将给定张量标记为原位操作中修改的张量。 | +| `function.FunctionCtx.mark_dirty` | 将给定张量标记为原位操作中修改的张量。 | | --- | --- | -| [`function.FunctionCtx.mark_non_differentiable`](generated/torch.autograd.function.FunctionCtx.mark_non_differentiable.html#torch.autograd.function.FunctionCtx.mark_non_differentiable "torch.autograd.function.FunctionCtx.mark_non_differentiable") | 将输出标记为不可微分。 | -| [`function.FunctionCtx.save_for_backward`](generated/torch.autograd.function.FunctionCtx.save_for_backward.html#torch.autograd.function.FunctionCtx.save_for_backward "torch.autograd.function.FunctionCtx.save_for_backward") | 保存给定张量，以便将来调用[`backward()`](generated/torch.autograd.Function.backward.html#torch.autograd.Function.backward "torch.autograd.Function.backward")。 | -| [`function.FunctionCtx.set_materialize_grads`](generated/torch.autograd.function.FunctionCtx.set_materialize_grads.html#torch.autograd.function.FunctionCtx.set_materialize_grads "torch.autograd.function.FunctionCtx.set_materialize_grads") | 设置是否实现梯度张量。 | +| `function.FunctionCtx.mark_non_differentiable` | 将输出标记为不可微分。 | +| `function.FunctionCtx.save_for_backward` | 保存给定张量，以便将来调用`backward()`。 | +| `function.FunctionCtx.set_materialize_grads` | 设置是否实现梯度张量。 | ## 数值梯度检查[](#module-torch.autograd.gradcheck "Permalink to this heading") -| [`gradcheck`](generated/torch.autograd.gradcheck.gradcheck.html#torch.autograd.gradcheck.gradcheck "torch.autograd.gradcheck.gradcheck") | 检查通过小的有限差分计算的梯度与`inputs`中的浮点或复数类型张量相对于解析梯度的梯度，这些张量具有`requires_grad=True`。 | +| `gradcheck` | 检查通过小的有限差分计算的梯度与`inputs`中的浮点或复数类型张量相对于解析梯度的梯度，这些张量具有`requires_grad=True`。 | | --- | --- | -| [`gradgradcheck`](generated/torch.autograd.gradcheck.gradgradcheck.html#torch.autograd.gradcheck.gradgradcheck "torch.autograd.gradcheck.gradgradcheck") | 检查通过小的有限差分计算的梯度的梯度与`inputs`和`grad_outputs`中的浮点或复数类型张量相对于解析梯度的梯度，这些张量具有`requires_grad=True`。 | +| `gradgradcheck` | 检查通过小的有限差分计算的梯度的梯度与`inputs`和`grad_outputs`中的浮点或复数类型张量相对于解析梯度的梯度，这些张量具有`requires_grad=True`。 | ## 性能分析器 -Autograd包括一个性能分析器，让您可以检查模型内不同运算符的成本 - 包括在CPU和GPU上。目前实现了三种模式 - 仅CPU使用[`profile`](#torch.autograd.profiler.profile "torch.autograd.profiler.profile")。基于nvprof的（同时注册CPU和GPU活动）使用[`emit_nvtx`](#torch.autograd.profiler.emit_nvtx "torch.autograd.profiler.emit_nvtx")。基于vtune性能分析器的使用[`emit_itt`](#torch.autograd.profiler.emit_itt "torch.autograd.profiler.emit_itt")。 +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)¶ @@ -175,29 +175,29 @@ class torch.autograd.profiler.profile(enabled=True, *, use_cuda=False, use_devic 上下文管理器，管理自动求导分析器状态并保存结果摘要。 -在底层，它只记录在C++中执行的函数事件，并将这些事件暴露给Python。您可以将任何代码包装在其中，它只会报告PyTorch函数的运行时。注意：性能分析器是线程本地的，并自动传播到异步任务中 +在底层，它只记录在 C++中执行的函数事件，并将这些事件暴露给 Python。您可以将任何代码包装在其中，它只会报告 PyTorch 函数的运行时。注意：性能分析器是线程本地的，并自动传播到异步任务中 参数 -+ **enabled**（*bool*，可选）- 将其设置为False会使此上下文管理器无效。 ++ **enabled**（*bool*，可选）- 将其设置为 False 会使此上下文管理器无效。 -+ **use_cuda**（*bool*，可选）- 启用使用cudaEvent API对CUDA事件进行计时。每个张量操作大约增加4微秒的开销。 ++ **use_cuda**（*bool*，可选）- 启用使用 cudaEvent API 对 CUDA 事件进行计时。每个张量操作大约增加 4 微秒的开销。 -+ **record_shapes**（*bool*） – 如果设置了形状记录，将收集有关输入维度的信息。这允许查看在幕后使用了哪些维度，并进一步通过使用prof.key_averages(group_by_input_shape=True)按它们进行分组。请注意，形状记录可能会使您的分析数据产生偏差。建议使用分别具有和不具有形状记录的运行来验证时间。在嵌套函数调用的情况下，最底层事件的偏差可能可以忽略不计。但对于更高级别的函数，总自身CPU时间可能会因为形状收集而人为增加。 ++ **record_shapes**（*bool*） – 如果设置了形状记录，将收集有关输入维度的信息。这允许查看在幕后使用了哪些维度，并进一步通过使用 prof.key_averages(group_by_input_shape=True)按它们进行分组。请注意，形状记录可能会使您的分析数据产生偏差。建议使用分别具有和不具有形状记录的运行来验证时间。在嵌套函数调用的情况下，最底层事件的偏差可能可以忽略不计。但对于更高级别的函数，总自身 CPU 时间可能会因为形状收集而人为增加。 -+ **with_flops**（*bool*） – 如果设置了with_flops，分析器将使用操作符的输入形状来估计FLOPs（浮点运算）值。这允许估计硬件性能。目前，此选项仅适用于矩阵乘法和2D卷积操作。 ++ **with_flops**（*bool*） – 如果设置了 with_flops，分析器将使用操作符的输入形状来估计 FLOPs（浮点运算）值。这允许估计硬件性能。目前，此选项仅适用于矩阵乘法和 2D 卷积操作。 + **profile_memory**（*bool*） – 跟踪张量的内存分配/释放。 + **with_stack**（*bool*） – 记录操作的源信息（文件和行号）。 -+ **with_modules**（*bool*） – 记录与操作的调用堆栈对应的模块层次结构（包括函数名）。例如，如果模块A的前向调用模块B的前向，其中包含一个aten::add操作，那么aten::add的模块层次结构是A.B。请注意，目前此支持仅适用于TorchScript模型，而不适用于急切模式模型。 ++ **with_modules**（*bool*） – 记录与操作的调用堆栈对应的模块层次结构（包括函数名）。例如，如果模块 A 的前向调用模块 B 的前向，其中包含一个 aten::add 操作，那么 aten::add 的模块层次结构是 A.B。请注意，目前此支持仅适用于 TorchScript 模型，而不适用于急切模式模型。 -+ **use_kineto**（*bool*） – 实验性的，启用使用Kineto分析器进行分析。 ++ **use_kineto**（*bool*） – 实验性的，启用使用 Kineto 分析器进行分析。 -+ **use_cpu**（*bool*） – 分析CPU事件；将其设置为`False`需要`use_kineto=True`，可用于降低仅针对GPU的分析的开销。 ++ **use_cpu**（*bool*） – 分析 CPU 事件；将其设置为`False`需要`use_kineto=True`，可用于降低仅针对 GPU 的分析的开销。 -+ **experimental_config**（*_ExperimentalConfig*） – 由像Kineto这样的分析器库使用的一组实验选项。请注意，不保证向后兼容性。 ++ **experimental_config**（*_ExperimentalConfig*） – 由像 Kineto 这样的分析器库使用的一组实验选项。请注意，不保证向后兼容性。 示例 @@ -220,31 +220,31 @@ torch::autograd::GraphRoot 691.816us 691.816us 100 ----------------------------------- --------------- --------------- --------------- ``` -| [`profiler.profile.export_chrome_trace`](generated/torch.autograd.profiler.profile.export_chrome_trace.html#torch.autograd.profiler.profile.export_chrome_trace "torch.autograd.profiler.profile.export_chrome_trace") | 将事件列表导出为Chrome跟踪工具文件。 | +| `profiler.profile.export_chrome_trace` | 将事件列表导出为 Chrome 跟踪工具文件。 | | --- | --- | -| [`profiler.profile.key_averages`](generated/torch.autograd.profiler.profile.key_averages.html#torch.autograd.profiler.profile.key_averages "torch.autograd.profiler.profile.key_averages") | 对所有函数事件按其键进行平均。 | -| [`profiler.profile.self_cpu_time_total`](generated/torch.autograd.profiler.profile.self_cpu_time_total.html#torch.autograd.profiler.profile.self_cpu_time_total "torch.autograd.profiler.profile.self_cpu_time_total") | 返回在CPU上花费的总时间。 | -| [`profiler.profile.total_average`](generated/torch.autograd.profiler.profile.total_average.html#torch.autograd.profiler.profile.total_average "torch.autograd.profiler.profile.total_average") | 对所有事件进行平均。 | +| `profiler.profile.key_averages` | 对所有函数事件按其键进行平均。 | +| `profiler.profile.self_cpu_time_total` | 返回在 CPU 上花费的总时间。 | +| `profiler.profile.total_average` | 对所有事件进行平均。 | ```py class torch.autograd.profiler.emit_nvtx(enabled=True, record_shapes=False)¶ ``` -使每个自动求导操作发出一个NVTX范围的上下文管理器。 +使每个自动求导操作发出一个 NVTX 范围的上下文管理器。 -在使用nvprof运行程序时很有用： +在使用 nvprof 运行程序时很有用： ```py nvprof --profile-from-start off -o trace_name.prof -- ``` -不幸的是，没有办法强制nvprof将其收集的数据刷新到磁盘上，因此对于CUDA分析，人们必须使用此上下文管理器来注释nvprof跟踪，并等待进程退出后再进行检查。然后，可以使用NVIDIA Visual Profiler（nvvp）来可视化时间轴，或者[`torch.autograd.profiler.load_nvprof()`](generated/torch.autograd.profiler.load_nvprof.html#torch.autograd.profiler.load_nvprof "torch.autograd.profiler.load_nvprof")可以加载结果以供在Python REPL中检查。 +不幸的是，没有办法强制 nvprof 将其收集的数据刷新到磁盘上，因此对于 CUDA 分析，人们必须使用此上下文管理器来注释 nvprof 跟踪，并等待进程退出后再进行检查。然后，可以使用 NVIDIA Visual Profiler（nvvp）来可视化时间轴，或者`torch.autograd.profiler.load_nvprof()`可以加载结果以供在 Python REPL 中检查。 参数 + **enabled**（*bool*，可选）- 设置`enabled=False`会使此上下文管理器无效。默认值：`True`。 -+ **record_shapes**（*bool*，可选）- 如果`record_shapes=True`，则每个自动求导操作包装的nvtx范围将附加有关该操作接收的Tensor参数大小的信息，格式如下：`[[arg0.size(0), arg0.size(1), ...], [arg1.size(0), arg1.size(1), ...], ...]` 非张量参数将用`[]`表示。参数将按照后端操作接收它们的顺序列出。请注意，此顺序可能与这些参数在Python端传递的顺序不匹配。还请注意，形状记录可能会增加nvtx范围创建的开销。默认值：`False` ++ **record_shapes**（*bool*，可选）- 如果`record_shapes=True`，则每个自动求导操作包装的 nvtx 范围将附加有关该操作接收的 Tensor 参数大小的信息，格式如下：`[[arg0.size(0), arg0.size(1), ...], [arg1.size(0), arg1.size(1), ...], ...]` 非张量参数将用`[]`表示。参数将按照后端操作接收它们的顺序列出。请注意，此顺序可能与这些参数在 Python 端传递的顺序不匹配。还请注意，形状记录可能会增加 nvtx 范围创建的开销。默认值：`False` 示例 @@ -257,29 +257,29 @@ nvprof --profile-from-start off -o trace_name.prof -- **前向-反向相关性** -在使用Nvidia Visual Profiler创建的配置文件时，将每个反向传递操作与相应的前向传递操作进行关联可能会很困难。为了简化这个任务，[`emit_nvtx`](#torch.autograd.profiler.emit_nvtx "torch.autograd.profiler.emit_nvtx")会向其生成的范围附加序列号信息。 +在使用 Nvidia Visual Profiler 创建的配置文件时，将每个反向传递操作与相应的前向传递操作进行关联可能会很困难。为了简化这个任务，`emit_nvtx`会向其生成的范围附加序列号信息。 -在前向传递期间，每个函数范围都被装饰为`seq=`。`seq`是一个运行计数器，每次创建一个新的反向Function对象并存储用于反向传递时递增。因此，与每个前向函数范围相关联的`seq=`注释告诉您，如果此前向函数创建了一个反向Function对象，那么反向对象将接收序列号N。在反向传递期间，包装每个C++反向Function的`apply()`调用的顶级范围都被装饰为`stashed seq=`。`M`是创建反向对象时的序列号。通过在反向传递中比较反向中的`stashed seq`号和前向中的`seq`号，您可以追踪哪个前向操作创建了每个反向Function。 +在前向传递期间，每个函数范围都被装饰为`seq=`。`seq`是一个运行计数器，每次创建一个新的反向 Function 对象并存储用于反向传递时递增。因此，与每个前向函数范围相关联的`seq=`注释告诉您，如果此前向函数创建了一个反向 Function 对象，那么反向对象将接收序列号 N。在反向传递期间，包装每个 C++反向 Function 的`apply()`调用的顶级范围都被装饰为`stashed seq=`。`M`是创建反向对象时的序列号。通过在反向传递中比较反向中的`stashed seq`号和前向中的`seq`号，您可以追踪哪个前向操作创建了每个反向 Function。 -在反向传递期间执行的任何函数也都被装饰为`seq=`。在默认反向传递（`create_graph=False`）中，此信息是无关紧要的，实际上，对于所有这样的函数，`N`可能只是0。只有与反向Function对象的`apply()`方法相关联的顶级范围是有用的，作为将这些Function对象与之前的前向传递相关联的一种方式。 +在反向传递期间执行的任何函数也都被装饰为`seq=`。在默认反向传递（`create_graph=False`）中，此信息是无关紧要的，实际上，对于所有这样的函数，`N`可能只是 0。只有与反向 Function 对象的`apply()`方法相关联的顶级范围是有用的，作为将这些 Function 对象与之前的前向传递相关联的一种方式。 **双向传递** -另一方面，如果正在进行带有`create_graph=True`的反向传递（换句话说，如果您正在为双向传递做准备），则在反向期间执行的每个函数都会获得一个非零、有用的`seq=`。这些函数本身可能会创建Function对象，以便稍后在双向传递期间执行，就像前向传递中的原始函数一样。反向和双向之间的关系在概念上与前向和反向之间的关系相同：函数仍然发出当前序列号标记的范围，它们创建的Function对象仍然存储这些序列号，并且在最终的双向传递期间，Function对象的`apply()`范围仍然标记有`stashed seq`号，可以与反向传递中的seq号进行比较。 +另一方面，如果正在进行带有`create_graph=True`的反向传递（换句话说，如果您正在为双向传递做准备），则在反向期间执行的每个函数都会获得一个非零、有用的`seq=`。这些函数本身可能会创建 Function 对象，以便稍后在双向传递期间执行，就像前向传递中的原始函数一样。反向和双向之间的关系在概念上与前向和反向之间的关系相同：函数仍然发出当前序列号标记的范围，它们创建的 Function 对象仍然存储这些序列号，并且在最终的双向传递期间，Function 对象的`apply()`范围仍然标记有`stashed seq`号，可以与反向传递中的 seq 号进行比较。 ```py class torch.autograd.profiler.emit_itt(enabled=True, record_shapes=False)¶ ``` -上下文管理器，使每个自动求导操作都发出一个ITT范围。 +上下文管理器，使每个自动求导操作都发出一个 ITT 范围。 -在运行程序时在英特尔(R) VTune Profiler下很有用： +在运行程序时在英特尔(R) VTune Profiler 下很有用： ```py vtune <--vtune-flags> ``` -仪器和跟踪技术（ITT）API使您的应用程序能够在其执行过程中生成和控制跨不同英特尔工具的跟踪数据的收集。这个上下文管理器是用来注释英特尔(R) VTune Profiling跟踪的。借助这个上下文管理器，您将能够在英特尔(R) VTune Profiler GUI 中看到标记的范围。 +仪器和跟踪技术（ITT）API 使您的应用程序能够在其执行过程中生成和控制跨不同英特尔工具的跟踪数据的收集。这个上下文管理器是用来注释英特尔(R) VTune Profiling 跟踪的。借助这个上下文管理器，您将能够在英特尔(R) VTune Profiler GUI 中看到标记的范围。 参数 @@ -294,7 +294,7 @@ vtune <--vtune-flags> ... model(x) ``` -| [`profiler.load_nvprof`](generated/torch.autograd.profiler.load_nvprof.html#torch.autograd.profiler.load_nvprof "torch.autograd.profiler.load_nvprof") | 打开一个 nvprof 跟踪文件并解析自动求导注释。 | +| `profiler.load_nvprof` | 打开一个 nvprof 跟踪文件并解析自动求导注释。 | | --- | --- | ## 异常检测 @@ -386,14 +386,14 @@ class torch.autograd.set_detect_anomaly(mode, check_nan=True)¶ 自动求导公开了允许检查图并在反向传播期间插入行为的方法。 -如果张量是由自动求导记录的操作的输出（即启用了 grad_mode 并且至少一个输入需要梯度），则 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 的 `grad_fn` 属性将保存一个 `torch.autograd.graph.Node`，否则为 `None`。 +如果张量是由自动求导记录的操作的输出（即启用了 grad_mode 并且至少一个输入需要梯度），则 `torch.Tensor` 的 `grad_fn` 属性将保存一个 `torch.autograd.graph.Node`，否则为 `None`。 -| [`graph.Node.name`](generated/torch.autograd.graph.Node.name.html#torch.autograd.graph.Node.name "torch.autograd.graph.Node.name") | 返回名称。 | +| `graph.Node.name` | 返回名称。 | | --- | --- | -| [`graph.Node.metadata`](generated/torch.autograd.graph.Node.metadata.html#torch.autograd.graph.Node.metadata "torch.autograd.graph.Node.metadata") | 返回元数据。 | -| [`graph.Node.next_functions`](generated/torch.autograd.graph.Node.next_functions.html#torch.autograd.graph.Node.next_functions "torch.autograd.graph.Node.next_functions") | | -| [`graph.Node.register_hook`](generated/torch.autograd.graph.Node.register_hook.html#torch.autograd.graph.Node.register_hook "torch.autograd.graph.Node.register_hook") | 注册一个反向钩子。 | -| [`graph.Node.register_prehook`](generated/torch.autograd.graph.Node.register_prehook.html#torch.autograd.graph.Node.register_prehook "torch.autograd.graph.Node.register_prehook") | 注册一个反向预钩子。 | +| `graph.Node.metadata` | 返回元数据。 | +| `graph.Node.next_functions` | | +| `graph.Node.register_hook` | 注册一个反向钩子。 | +| `graph.Node.register_prehook` | 注册一个反向预钩子。 | 一些操作需要在前向传递期间保存中间结果以执行反向传递。这些中间结果保存为`grad_fn`上的属性，并可以访问。例如： @@ -408,7 +408,7 @@ True True ``` -您还可以使用钩子定义这些保存的张量应如何打包/解包。一个常见的应用是通过将这些中间结果保存到磁盘或 CPU 来交换计算和内存，而不是将它们留在 GPU 上。如果您注意到您的模型在评估期间适合 GPU，但在训练期间不适合，则这是非常有用的。另请参阅[保存张量的钩子](notes/autograd.html#saved-tensors-hooks-doc)。 +您还可以使用钩子定义这些保存的张量应如何打包/解包。一个常见的应用是通过将这些中间结果保存到磁盘或 CPU 来交换计算和内存，而不是将它们留在 GPU 上。如果您注意到您的模型在评估期间适合 GPU，但在训练期间不适合，则这是非常有用的。另请参阅保存张量的钩子。 ```py class torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook)¶ @@ -420,7 +420,7 @@ class torch.autograd.graph.saved_tensors_hooks(pack_hook, unpack_hook)¶ 在这种情况下，每次操作保存张量进行反向传递时（包括使用`save_for_backward()`保存的中间结果以及由 PyTorch 定义的操作记录的结果），都会调用`pack_hook`函数。然后，`pack_hook`的输出将存储在计算图中，而不是原始张量。 -当需要访问保存的张量时，即在执行[`torch.Tensor.backward()`](generated/torch.Tensor.backward.html#torch.Tensor.backward "torch.Tensor.backward")或[`torch.autograd.grad()`](generated/torch.autograd.grad.html#torch.autograd.grad "torch.autograd.grad")时，将调用`unpack_hook`。它以`pack_hook`返回的*packed*对象作为参数，并应返回一个与原始张量内容相同的张量（作为输入传递给相应的`pack_hook`）。 +当需要访问保存的张量时，即在执行`torch.Tensor.backward()`或`torch.autograd.grad()`时，将调用`unpack_hook`。它以`pack_hook`返回的*packed*对象作为参数，并应返回一个与原始张量内容相同的张量（作为输入传递给相应的`pack_hook`）。 钩子应具有以下签名： @@ -474,7 +474,7 @@ class torch.autograd.graph.save_on_cpu(pin_memory=False, device_type='cuda')¶ 参数 -**pin_memory**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 如果为`True`，张量将在打包期间保存到 CPU 固定内存，并在解包期间异步复制到 GPU。默认为`False`。另请参阅[使用固定内存缓冲区](notes/cuda.html#cuda-memory-pinning)。 +**pin_memory**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 如果为`True`，张量将在打包期间保存到 CPU 固定内存，并在解包期间异步复制到 GPU。默认为`False`。另请参阅使用固定内存缓冲区。 示例： @@ -536,7 +536,7 @@ class torch.autograd.graph.register_multi_grad_hook(tensors, fn)¶ 注意 -有关此钩子的执行时间以及其执行顺序与其他钩子的关系的更多信息，请参见[反向钩子执行](notes/autograd.html#backward-hooks-execution)。 +有关此钩子的执行时间以及其执行顺序与其他钩子的关系的更多信息，请参见反向钩子执行。 示例： @@ -595,7 +595,7 @@ tensor([[0.8415, 0.8415, 0.8415], class torch.autograd.graph.GradientEdge(node, output_nr)¶ ``` -表示autograd图中给定梯度边缘的对象。要获取将计算给定张量梯度的梯度边缘，可以执行`edge = autograd.graph.get_gradient_edge(tensor)`。 +表示 autograd 图中给定梯度边缘的对象。要获取将计算给定张量梯度的梯度边缘，可以执行`edge = autograd.graph.get_gradient_edge(tensor)`。 ```py torch.autograd.graph.get_gradient_edge(tensor)¶ diff --git a/totrans/doc22_039.md b/totrans/doc22_039.md index 9141f4ef..a64a698a 100644 --- a/totrans/doc22_039.md +++ b/totrans/doc22_039.md @@ -1,12 +1,12 @@ # torch.library -> 原文：[https://pytorch.org/docs/stable/library.html](https://pytorch.org/docs/stable/library.html) +> 原文：[`pytorch.org/docs/stable/library.html`](https://pytorch.org/docs/stable/library.html) -torch.library是一组用于扩展PyTorch核心运算符库的API。它包含用于创建新的自定义运算符以及扩展使用PyTorch的C++运算符注册API（例如aten运算符）定义的运算符的实用程序。 +torch.library 是一组用于扩展 PyTorch 核心运算符库的 API。它包含用于创建新的自定义运算符以及扩展使用 PyTorch 的 C++运算符注册 API（例如 aten 运算符）定义的运算符的实用程序。 -有关有效使用这些API的详细指南，请参阅[此gdoc](https://docs.google.com/document/d/1W--T6wz8IY8fOI0Vm8BF44PdBgs283QvpelJZWieQWQ/edit) +有关有效使用这些 API 的详细指南，请参阅[此 gdoc](https://docs.google.com/document/d/1W--T6wz8IY8fOI0Vm8BF44PdBgs283QvpelJZWieQWQ/edit) -使用[`torch.library.define()`](#torch.library.define "torch.library.define")来定义新的自定义运算符。使用impl方法，例如[`torch.library.impl()`](#torch.library.impl "torch.library.impl")和func:torch.library.impl_abstract，为任何运算符添加实现（它们可以使用[`torch.library.define()`](#torch.library.define "torch.library.define")创建，或通过PyTorch的C++运算符注册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=())¶ @@ -18,19 +18,19 @@ torch.library.define(lib, schema, alias_analysis='') 定义一个新的运算符。 -在PyTorch中，定义一个op（即“运算符”）是一个两步过程：- 我们需要定义op（提供运算符名称和模式）- 我们需要实现运算符与各种PyTorch子系统（如CPU/CUDA张量，Autograd等）交互的行为。 +在 PyTorch 中，定义一个 op（即“运算符”）是一个两步过程：- 我们需要定义 op（提供运算符名称和模式）- 我们需要实现运算符与各种 PyTorch 子系统（如 CPU/CUDA 张量，Autograd 等）交互的行为。 -此入口点定义了自定义运算符（第一步），然后您必须通过调用各种`impl_*` API（如[`torch.library.impl()`](#torch.library.impl "torch.library.impl")或[`torch.library.impl_abstract()`](#torch.library.impl_abstract "torch.library.impl_abstract")）执行第二步。 +此入口点定义了自定义运算符（第一步），然后您必须通过调用各种`impl_*` API（如`torch.library.impl()`或`torch.library.impl_abstract()`）执行第二步。 参数 -+ **qualname**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")) - 运算符的限定名称。应该是一个看起来像“namespace::name”的字符串，例如“aten::sin”。PyTorch中的运算符需要一个命名空间以避免名称冲突；给定的运算符只能创建一次。如果您正在编写Python库，我们建议命名空间为顶级模块的名称。 ++ **qualname**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")) - 运算符的限定名称。应该是一个看起来像“namespace::name”的字符串，例如“aten::sin”。PyTorch 中的运算符需要一个命名空间以避免名称冲突；给定的运算符只能创建一次。如果您正在编写 Python 库，我们建议命名空间为顶级模块的名称。 -+ **schema**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")) - 运算符的模式。例如，对于一个接受一个张量并返回一个张量的op，“（张量x）->张量”。它不包含运算符名称（传递给`qualname`）。 ++ **schema**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")) - 运算符的模式。例如，对于一个接受一个张量并返回一个张量的 op，“（张量 x）->张量”。它不包含运算符名称（传递给`qualname`）。 -+ **lib**（*可选**[*[*Library*](#torch.library.Library "torch.library.Library")*]）- 如果提供，此运算符的生命周期将与Library对象的生命周期绑定。 ++ **lib**（*可选***[*Library**]）- 如果提供，此运算符的生命周期将与 Library 对象的生命周期绑定。 -+ **标签**（[*标签*](torch.html#torch.Tag "torch.Tag") *|* *序列**[*[*标签*](torch.html#torch.Tag "torch.Tag")*]）- 一个或多个torch.Tag，应用于此运算符。对运算符进行标记会改变运算符在各种PyTorch子系统下的行为；请在应用之前仔细阅读torch.Tag的文档。 ++ **标签**（*标签* *|* *序列***[*标签**]）- 一个或多个 torch.Tag，应用于此运算符。对运算符进行标记会改变运算符在各种 PyTorch 子系统下的行为；请在应用之前仔细阅读 torch.Tag 的文档。 示例:: @@ -62,17 +62,17 @@ torch.library.impl(lib, name, dispatch_key='') 为此运算符的设备类型注册一个实现。 -您可以将“default”传递给`types`，以将此实现注册为所有设备类型的默认实现。只有在实现真正支持所有设备类型时才使用此选项；例如，如果它是内置PyTorch运算符的组合，则为真。 +您可以将“default”传递给`types`，以将此实现注册为所有设备类型的默认实现。只有在实现真正支持所有设备类型时才使用此选项；例如，如果它是内置 PyTorch 运算符的组合，则为真。 一些有效的类型是：“cpu”，“cuda”，“xla”，“mps”，“ipu”，“xpu”。 参数 -+ **qualname**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")) - 应该是一个看起来像“namespace::operator_name”的字符串。 ++ **qualname**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")) - 应该是一个看起来像“namespace::operator_name”的字符串。 -+ **types**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)") *|* *序列**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")*]）- 要注册实现的设备类型。 ++ **types**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)") *|* *序列**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")*]）- 要注册实现的设备类型。 -+ **lib**（*可选**[*[*Library*](#torch.library.Library "torch.library.Library")*]）- 如果提供，此注册的生命周期将与Library对象的生命周期绑定。 ++ **lib**（*可选***[*Library**]）- 如果提供，此注册的生命周期将与 Library 对象的生命周期绑定。 示例 @@ -101,11 +101,11 @@ torch.library.impl_abstract(qualname, func=None, *, lib=None, _stacklevel=1)¶ “抽象实现”指定了在携带无数据的张量上的操作符的行为。给定具有某些属性（大小/步幅/存储偏移/设备）的输入张量，它指定了输出张量的属性是什么。 -抽象实现与操作符具有相同的签名。它适用于FakeTensors和元张量。要编写抽象实现，请假设操作符的所有张量输入都是常规的CPU/CUDA/Meta张量，但它们没有存储，并且您正在尝试返回常规的CPU/CUDA/Meta张量作为输出。抽象实现必须仅包含PyTorch操作（不能直接访问任何输入或中间张量的存储或数据）。 +抽象实现与操作符具有相同的签名。它适用于 FakeTensors 和元张量。要编写抽象实现，请假设操作符的所有张量输入都是常规的 CPU/CUDA/Meta 张量，但它们没有存储，并且您正在尝试返回常规的 CPU/CUDA/Meta 张量作为输出。抽象实现必须仅包含 PyTorch 操作（不能直接访问任何输入或中间张量的存储或数据）。 -此API可以用作装饰器（请参阅示例）。 +此 API 可以用作装饰器（请参阅示例）。 -有关自定义操作的详细指南，请参阅[https://docs.google.com/document/d/1W--T6wz8IY8fOI0Vm8BF44PdBgs283QvpelJZWieQWQ/edit](https://docs.google.com/document/d/1W--T6wz8IY8fOI0Vm8BF44PdBgs283QvpelJZWieQWQ/edit) +有关自定义操作的详细指南，请参阅[`docs.google.com/document/d/1W--T6wz8IY8fOI0Vm8BF44PdBgs283QvpelJZWieQWQ/edit`](https://docs.google.com/document/d/1W--T6wz8IY8fOI0Vm8BF44PdBgs283QvpelJZWieQWQ/edit) 示例 @@ -156,31 +156,31 @@ torch.library.impl_abstract(qualname, func=None, *, lib=None, _stacklevel=1)¶ torch.library.get_ctx()¶ ``` -get_ctx()返回当前的AbstractImplCtx对象。 +get_ctx()返回当前的 AbstractImplCtx 对象。 -只有在抽象实现内部调用`get_ctx()`才有效（有关更多用法细节，请参见[`torch.library.impl_abstract()`](#torch.library.impl_abstract "torch.library.impl_abstract")）。 +只有在抽象实现内部调用`get_ctx()`才有效（有关更多用法细节，请参见`torch.library.impl_abstract()`）。 返回类型 *AbstractImplCtx* -## 低级API +## 低级 API -以下API是直接绑定到PyTorch的C++低级操作符注册API。 +以下 API 是直接绑定到 PyTorch 的 C++低级操作符注册 API。 警告 -低级操作符注册API和PyTorch调度程序是一个复杂的PyTorch概念。我们建议在可能的情况下使用上面的更高级API（不需要torch.library.Library对象）。这篇博文<[http://blog.ezyang.com/2020/09/lets-talk-about-the-pytorch-dispatcher/](http://blog.ezyang.com/2020/09/lets-talk-about-the-pytorch-dispatcher/)>`_ 是了解PyTorch调度程序的好起点。 +低级操作符注册 API 和 PyTorch 调度程序是一个复杂的 PyTorch 概念。我们建议在可能的情况下使用上面的更高级 API（不需要 torch.library.Library 对象）。这篇博文<[`blog.ezyang.com/2020/09/lets-talk-about-the-pytorch-dispatcher/`](http://blog.ezyang.com/2020/09/lets-talk-about-the-pytorch-dispatcher/)>`_ 是了解 PyTorch 调度程序的好起点。 -有关如何使用此API的一些示例的教程可在[Google Colab](https://colab.research.google.com/drive/1RRhSfk7So3Cn02itzLWE9K4Fam-8U011?usp=sharing)上找到。 +有关如何使用此 API 的一些示例的教程可在[Google Colab](https://colab.research.google.com/drive/1RRhSfk7So3Cn02itzLWE9K4Fam-8U011?usp=sharing)上找到。 ```py class torch.library.Library(ns, kind, dispatch_key='')¶ ``` -一个用于创建库的类，可以用于注册新操作符或从Python中覆盖现有库中的操作符。用户可以选择传递调度键名称，如果他们只想注册与特定调度键对应的内核。 +一个用于创建库的类，可以用于注册新操作符或从 Python 中覆盖现有库中的操作符。用户可以选择传递调度键名称，如果他们只想注册与特定调度键对应的内核。 -要创建一个库以覆盖现有库中的操作符（名称为ns），将kind设置为“IMPL”。要创建一个新库（名称为ns）以注册新操作符，请将kind设置为“DEF”。要创建一个可能存在的库的片段以注册操作符（并绕过只有一个给定命名空间的库的限制），将kind设置为“FRAGMENT”。 +要创建一个库以覆盖现有库中的操作符（名称为 ns），将 kind 设置为“IMPL”。要创建一个新库（名称为 ns）以注册新操作符，请将 kind 设置为“DEF”。要创建一个可能存在的库的片段以注册操作符（并绕过只有一个给定命名空间的库的限制），将 kind 设置为“FRAGMENT”。 参数 @@ -188,13 +188,13 @@ class torch.library.Library(ns, kind, dispatch_key='')¶ + **kind** – “DEF”, “IMPL”（默认：“IMPL”）, “FRAGMENT” -+ **dispatch_key** – PyTorch调度键（默认：“”） ++ **dispatch_key** – PyTorch 调度键（默认：“”） ```py define(schema, alias_analysis='', *, tags=())¶ ``` -在ns命名空间中定义一个新操作符及其语义。 +在 ns 命名空间中定义一个新操作符及其语义。 参数 @@ -202,7 +202,7 @@ define(schema, alias_analysis='', *, tags=())¶ + **alias_analysis** (*可选*) – 指示是否可以从模式推断操作符参数的别名属性（默认行为）或不可以（“CONSERVATIVE”）。 -+ **tags** ([*Tag*](torch.html#torch.Tag "torch.Tag") *|* *Sequence**[*[*Tag*](torch.html#torch.Tag "torch.Tag")*]*) – 一个或多个torch.Tag，应用于此操作符。对操作符进行标记会更改操作符在各种PyTorch子系统下的行为；请在应用之前仔细阅读torch.Tag的文档。 ++ **tags** (*Tag* *|* *Sequence***[*Tag**]*) – 一个或多个 torch.Tag，应用于此操作符。对操作符进行标记会更改操作符在各种 PyTorch 子系统下的行为；请在应用之前仔细阅读 torch.Tag 的文档。 返回 @@ -223,9 +223,9 @@ impl(op_name, fn, dispatch_key='')¶ 参数 -+ **op_name** – 操作符名称（连同重载）或OpOverload对象。 ++ **op_name** – 操作符名称（连同重载）或 OpOverload 对象。 -+ **fn** – 作为输入调度键的操作符实现的函数或[`fallthrough_kernel()`](#torch.library.fallthrough_kernel "torch.library.fallthrough_kernel")以注册一个fallthrough。 ++ **fn** – 作为输入调度键的操作符实现的函数或`fallthrough_kernel()`以注册一个 fallthrough。 + **dispatch_key** - 输入函数应注册的调度键。默认情况下，它使用创建库时使用的调度键。 diff --git a/totrans/doc22_040.md b/totrans/doc22_040.md index 6371762f..d25e169a 100644 --- a/totrans/doc22_040.md +++ b/totrans/doc22_040.md @@ -1,20 +1,20 @@ # torch.cpu -> 原文：[https://pytorch.org/docs/stable/cpu.html](https://pytorch.org/docs/stable/cpu.html) +> 原文：[`pytorch.org/docs/stable/cpu.html`](https://pytorch.org/docs/stable/cpu.html) 该软件包实现了在`torch.cuda`中找到的抽象，以便编写与设备无关的代码。 -| [`current_device`](generated/torch.cpu.current_device.html#torch.cpu.current_device "torch.cpu.current_device") | 返回CPU的当前设备。 | +| `current_device` | 返回 CPU 的当前设备。 | | --- | --- | -| [`current_stream`](generated/torch.cpu.current_stream.html#torch.cpu.current_stream "torch.cpu.current_stream") | 返回给定设备的当前选择的[`Stream`](generated/torch.cpu.Stream.html#torch.cpu.Stream "torch.cpu.Stream")。 | -| [`is_available`](generated/torch.cpu.is_available.html#torch.cpu.is_available "torch.cpu.is_available") | 返回一个布尔值，指示CPU当前是否可用。 | -| [`synchronize`](generated/torch.cpu.synchronize.html#torch.cpu.synchronize "torch.cpu.synchronize") | 等待CPU设备上所有流中的所有内核完成。 | -| [`stream`](generated/torch.cpu.stream.html#torch.cpu.stream "torch.cpu.stream") | 包装器，围绕选择给定流的上下文管理器StreamContext。 | -| [`set_device`](generated/torch.cpu.set_device.html#torch.cpu.set_device "torch.cpu.set_device") | 设置当前设备，在CPU上我们不做任何操作。 | -| [`device_count`](generated/torch.cpu.device_count.html#torch.cpu.device_count "torch.cpu.device_count") | 返回CPU设备的数量（不是核心数）。 | -| [`StreamContext`](generated/torch.cpu.StreamContext.html#torch.cpu.StreamContext "torch.cpu.StreamContext") | 选择给定流的上下文管理器。 | +| `current_stream` | 返回给定设备的当前选择的`Stream`。 | +| `is_available` | 返回一个布尔值，指示 CPU 当前是否可用。 | +| `synchronize` | 等待 CPU 设备上所有流中的所有内核完成。 | +| `stream` | 包装器，围绕选择给定流的上下文管理器 StreamContext。 | +| `set_device` | 设置当前设备，在 CPU 上我们不做任何操作。 | +| `device_count` | 返回 CPU 设备的数量（不是核心数）。 | +| `StreamContext` | 选择给定流的上下文管理器。 | ## 流和事件 -| [`Stream`](generated/torch.cpu.Stream.html#torch.cpu.Stream "torch.cpu.Stream") | 注： | +| `Stream` | 注： | | --- | --- | diff --git a/totrans/doc22_041.md b/totrans/doc22_041.md index 70e46e04..04a21a8a 100644 --- a/totrans/doc22_041.md +++ b/totrans/doc22_041.md @@ -1,123 +1,123 @@ # torch.cuda -> 原文：[https://pytorch.org/docs/stable/cuda.html](https://pytorch.org/docs/stable/cuda.html) +> 原文：[`pytorch.org/docs/stable/cuda.html`](https://pytorch.org/docs/stable/cuda.html) -此软件包添加了对CUDA张量类型的支持。 +此软件包添加了对 CUDA 张量类型的支持。 -它实现了与CPU张量相同的功能，但利用GPU进行计算。 +它实现了与 CPU 张量相同的功能，但利用 GPU 进行计算。 -它是懒惰初始化的，所以您可以随时导入它，并使用[`is_available()`](generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available")来确定您的系统是否支持CUDA。 +它是懒惰初始化的，所以您可以随时导入它，并使用`is_available()`来确定您的系统是否支持 CUDA。 -[CUDA语义](notes/cuda.html#cuda-semantics)有关使用CUDA的更多详细信息。 +CUDA 语义有关使用 CUDA 的更多详细信息。 -| [`StreamContext`](generated/torch.cuda.StreamContext.html#torch.cuda.StreamContext "torch.cuda.StreamContext") | 选择给定流的上下文管理器。 | +| `StreamContext` | 选择给定流的上下文管理器。 | | --- | --- | -| [`can_device_access_peer`](generated/torch.cuda.can_device_access_peer.html#torch.cuda.can_device_access_peer "torch.cuda.can_device_access_peer") | 检查两个设备之间是否可以进行对等访问。 | -| [`current_blas_handle`](generated/torch.cuda.current_blas_handle.html#torch.cuda.current_blas_handle "torch.cuda.current_blas_handle") | 返回当前cuBLAS句柄的cublasHandle_t指针 | -| [`current_device`](generated/torch.cuda.current_device.html#torch.cuda.current_device "torch.cuda.current_device") | 返回当前选择设备的索引。 | -| [`current_stream`](generated/torch.cuda.current_stream.html#torch.cuda.current_stream "torch.cuda.current_stream") | 返回给定设备当前选择的[`Stream`](generated/torch.cuda.Stream.html#torch.cuda.Stream "torch.cuda.Stream")。 | -| [`default_stream`](generated/torch.cuda.default_stream.html#torch.cuda.default_stream "torch.cuda.default_stream") | 返回给定设备的默认[`Stream`](generated/torch.cuda.Stream.html#torch.cuda.Stream "torch.cuda.Stream")。 | -| [`device`](generated/torch.cuda.device.html#torch.cuda.device "torch.cuda.device") | 上下文管理器，更改所选设备。 | -| [`device_count`](generated/torch.cuda.device_count.html#torch.cuda.device_count "torch.cuda.device_count") | 返回可用的GPU数量。 | -| [`device_of`](generated/torch.cuda.device_of.html#torch.cuda.device_of "torch.cuda.device_of") | 上下文管理器，将当前设备更改为给定对象的设备。 | -| [`get_arch_list`](generated/torch.cuda.get_arch_list.html#torch.cuda.get_arch_list "torch.cuda.get_arch_list") | 返回此库编译的CUDA架构列表。 | -| [`get_device_capability`](generated/torch.cuda.get_device_capability.html#torch.cuda.get_device_capability "torch.cuda.get_device_capability") | 获取设备的cuda能力。 | -| [`get_device_name`](generated/torch.cuda.get_device_name.html#torch.cuda.get_device_name "torch.cuda.get_device_name") | 获取设备的名称。 | -| [`get_device_properties`](generated/torch.cuda.get_device_properties.html#torch.cuda.get_device_properties "torch.cuda.get_device_properties") | 获取设备的属性。 | -| [`get_gencode_flags`](generated/torch.cuda.get_gencode_flags.html#torch.cuda.get_gencode_flags "torch.cuda.get_gencode_flags") | 返回此库编译时使用的NVCC gencode标志。 | -| [`get_sync_debug_mode`](generated/torch.cuda.get_sync_debug_mode.html#torch.cuda.get_sync_debug_mode "torch.cuda.get_sync_debug_mode") | 返回cuda同步操作的调试模式的当前值。 | -| [`init`](generated/torch.cuda.init.html#torch.cuda.init "torch.cuda.init") | 初始化PyTorch的CUDA状态。 | -| [`ipc_collect`](generated/torch.cuda.ipc_collect.html#torch.cuda.ipc_collect "torch.cuda.ipc_collect") | 在CUDA IPC释放GPU内存后强制收集。 | -| [`is_available`](generated/torch.cuda.is_available.html#torch.cuda.is_available "torch.cuda.is_available") | 返回一个布尔值，指示当前是否可用CUDA。 | -| [`is_initialized`](generated/torch.cuda.is_initialized.html#torch.cuda.is_initialized "torch.cuda.is_initialized") | 返回PyTorch的CUDA状态是否已初始化。 | -| [`memory_usage`](generated/torch.cuda.memory_usage.html#torch.cuda.memory_usage "torch.cuda.memory_usage") | 返回过去采样周期内全局（设备）内存被读取或写入的时间百分比，由 nvidia-smi 给出。 | -| [`set_device`](generated/torch.cuda.set_device.html#torch.cuda.set_device "torch.cuda.set_device") | 设置当前设备。 | -| [`set_stream`](generated/torch.cuda.set_stream.html#torch.cuda.set_stream "torch.cuda.set_stream") | 设置当前流。这是一个包装 API，用于设置流。 | -| [`set_sync_debug_mode`](generated/torch.cuda.set_sync_debug_mode.html#torch.cuda.set_sync_debug_mode "torch.cuda.set_sync_debug_mode") | 设置 cuda 同步操作的调试模式。 | -| [`stream`](generated/torch.cuda.stream.html#torch.cuda.stream "torch.cuda.stream") | 包装上下文管理器 StreamContext，选择给定的流。 | -| [`synchronize`](generated/torch.cuda.synchronize.html#torch.cuda.synchronize "torch.cuda.synchronize") | 等待 CUDA 设备上所有流中的所有内核完成。 | -| [`utilization`](generated/torch.cuda.utilization.html#torch.cuda.utilization "torch.cuda.utilization") | 返回过去采样周期内 GPU 上一个或多个内核执行的时间百分比，由 nvidia-smi 给出。 | -| [`temperature`](generated/torch.cuda.temperature.html#torch.cuda.temperature "torch.cuda.temperature") | 返回 GPU 传感器的平均温度，单位为摄氏度（C）。 | -| [`power_draw`](generated/torch.cuda.power_draw.html#torch.cuda.power_draw "torch.cuda.power_draw") | 返回 GPU 传感器的平均功耗，单位为毫瓦（mW） | -| [`clock_rate`](generated/torch.cuda.clock_rate.html#torch.cuda.clock_rate "torch.cuda.clock_rate") | 返回 GPU SM 的时钟速度，单位为赫兹（Hz），在过去的采样周期内由 nvidia-smi 给出。 | -| [`OutOfMemoryError`](generated/torch.cuda.OutOfMemoryError.html#torch.cuda.OutOfMemoryError "torch.cuda.OutOfMemoryError") | 当 CUDA 内存不足时引发的异常 | +| `can_device_access_peer` | 检查两个设备之间是否可以进行对等访问。 | +| `current_blas_handle` | 返回当前 cuBLAS 句柄的 cublasHandle_t 指针 | +| `current_device` | 返回当前选择设备的索引。 | +| `current_stream` | 返回给定设备当前选择的`Stream`。 | +| `default_stream` | 返回给定设备的默认`Stream`。 | +| `device` | 上下文管理器，更改所选设备。 | +| `device_count` | 返回可用的 GPU 数量。 | +| `device_of` | 上下文管理器，将当前设备更改为给定对象的设备。 | +| `get_arch_list` | 返回此库编译的 CUDA 架构列表。 | +| `get_device_capability` | 获取设备的 cuda 能力。 | +| `get_device_name` | 获取设备的名称。 | +| `get_device_properties` | 获取设备的属性。 | +| `get_gencode_flags` | 返回此库编译时使用的 NVCC gencode 标志。 | +| `get_sync_debug_mode` | 返回 cuda 同步操作的调试模式的当前值。 | +| `init` | 初始化 PyTorch 的 CUDA 状态。 | +| `ipc_collect` | 在 CUDA IPC 释放 GPU 内存后强制收集。 | +| `is_available` | 返回一个布尔值，指示当前是否可用 CUDA。 | +| `is_initialized` | 返回 PyTorch 的 CUDA 状态是否已初始化。 | +| `memory_usage` | 返回过去采样周期内全局（设备）内存被读取或写入的时间百分比，由 nvidia-smi 给出。 | +| `set_device` | 设置当前设备。 | +| `set_stream` | 设置当前流。这是一个包装 API，用于设置流。 | +| `set_sync_debug_mode` | 设置 cuda 同步操作的调试模式。 | +| `stream` | 包装上下文管理器 StreamContext，选择给定的流。 | +| `synchronize` | 等待 CUDA 设备上所有流中的所有内核完成。 | +| `utilization` | 返回过去采样周期内 GPU 上一个或多个内核执行的时间百分比，由 nvidia-smi 给出。 | +| `temperature` | 返回 GPU 传感器的平均温度，单位为摄氏度（C）。 | +| `power_draw` | 返回 GPU 传感器的平均功耗，单位为毫瓦（mW） | +| `clock_rate` | 返回 GPU SM 的时钟速度，单位为赫兹（Hz），在过去的采样周期内由 nvidia-smi 给出。 | +| `OutOfMemoryError` | 当 CUDA 内存不足时引发的异常 | ## 随机数生成器 -| [`get_rng_state`](generated/torch.cuda.get_rng_state.html#torch.cuda.get_rng_state "torch.cuda.get_rng_state") | 返回指定 GPU 的随机数生成器状态，作为 ByteTensor。 | +| `get_rng_state` | 返回指定 GPU 的随机数生成器状态，作为 ByteTensor。 | | --- | --- | -| [`get_rng_state_all`](generated/torch.cuda.get_rng_state_all.html#torch.cuda.get_rng_state_all "torch.cuda.get_rng_state_all") | 返回表示所有设备的随机数状态的 ByteTensor 列表。 | -| [`set_rng_state`](generated/torch.cuda.set_rng_state.html#torch.cuda.set_rng_state "torch.cuda.set_rng_state") | 设置指定 GPU 的随机数生成器状态。 | -| [`set_rng_state_all`](generated/torch.cuda.set_rng_state_all.html#torch.cuda.set_rng_state_all "torch.cuda.set_rng_state_all") | 设置所有设备的随机数生成器状态。 | -| [`manual_seed`](generated/torch.cuda.manual_seed.html#torch.cuda.manual_seed "torch.cuda.manual_seed") | 为当前 GPU 设置生成随机数的种子。 | -| [`manual_seed_all`](generated/torch.cuda.manual_seed_all.html#torch.cuda.manual_seed_all "torch.cuda.manual_seed_all") | 在所有 GPU 上设置生成随机数的种子。 | -| [`seed`](generated/torch.cuda.seed.html#torch.cuda.seed "torch.cuda.seed") | 为当前 GPU 将生成随机数的种子设置为随机数。 | -| [`seed_all`](generated/torch.cuda.seed_all.html#torch.cuda.seed_all "torch.cuda.seed_all") | 将生成随机数的种子设置为所有 GPU 上的随机数。 | -| [`initial_seed`](generated/torch.cuda.initial_seed.html#torch.cuda.initial_seed "torch.cuda.initial_seed") | 返回当前 GPU 的当前随机种子。 | +| `get_rng_state_all` | 返回表示所有设备的随机数状态的 ByteTensor 列表。 | +| `set_rng_state` | 设置指定 GPU 的随机数生成器状态。 | +| `set_rng_state_all` | 设置所有设备的随机数生成器状态。 | +| `manual_seed` | 为当前 GPU 设置生成随机数的种子。 | +| `manual_seed_all` | 在所有 GPU 上设置生成随机数的种子。 | +| `seed` | 为当前 GPU 将生成随机数的种子设置为随机数。 | +| `seed_all` | 将生成随机数的种子设置为所有 GPU 上的随机数。 | +| `initial_seed` | 返回当前 GPU 的当前随机种子。 | ## 通信集合 -| [`comm.broadcast`](generated/torch.cuda.comm.broadcast.html#torch.cuda.comm.broadcast "torch.cuda.comm.broadcast") | 将张量广播到指定的 GPU 设备。 | +| `comm.broadcast` | 将张量广播到指定的 GPU 设备。 | | --- | --- | -| [`comm.broadcast_coalesced`](generated/torch.cuda.comm.broadcast_coalesced.html#torch.cuda.comm.broadcast_coalesced "torch.cuda.comm.broadcast_coalesced") | 将一系列张量广播到指定的 GPU。 | -| [`comm.reduce_add`](generated/torch.cuda.comm.reduce_add.html#torch.cuda.comm.reduce_add "torch.cuda.comm.reduce_add") | 对多个 GPU 的张量求和。 | -| [`comm.scatter`](generated/torch.cuda.comm.scatter.html#torch.cuda.comm.scatter "torch.cuda.comm.scatter") | 在多个 GPU 上分散张量。 | -| [`comm.gather`](generated/torch.cuda.comm.gather.html#torch.cuda.comm.gather "torch.cuda.comm.gather") | 从多个 GPU 设备中收集张量。 | +| `comm.broadcast_coalesced` | 将一系列张量广播到指定的 GPU。 | +| `comm.reduce_add` | 对多个 GPU 的张量求和。 | +| `comm.scatter` | 在多个 GPU 上分散张量。 | +| `comm.gather` | 从多个 GPU 设备中收集张量。 | ## 流和事件 -| [`Stream`](generated/torch.cuda.Stream.html#torch.cuda.Stream "torch.cuda.Stream") | CUDA 流的包装器。 | +| `Stream` | CUDA 流的包装器。 | | --- | --- | -| [`ExternalStream`](generated/torch.cuda.ExternalStream.html#torch.cuda.ExternalStream "torch.cuda.ExternalStream") | 外部分配的 CUDA 流的包装器。 | -| [`Event`](generated/torch.cuda.Event.html#torch.cuda.Event "torch.cuda.Event") | CUDA 事件的包装器。 | +| `ExternalStream` | 外部分配的 CUDA 流的包装器。 | +| `Event` | CUDA 事件的包装器。 | ## 图（测试版） -| [`is_current_stream_capturing`](generated/torch.cuda.is_current_stream_capturing.html#torch.cuda.is_current_stream_capturing "torch.cuda.is_current_stream_capturing") | 如果当前 CUDA 流正在进行 CUDA 图捕获，则返回 True，否则返回 False。 | +| `is_current_stream_capturing` | 如果当前 CUDA 流正在进行 CUDA 图捕获，则返回 True，否则返回 False。 | | --- | --- | -| [`graph_pool_handle`](generated/torch.cuda.graph_pool_handle.html#torch.cuda.graph_pool_handle "torch.cuda.graph_pool_handle") | 返回表示图形内存池 id 的不透明令牌。 | -| [`CUDAGraph`](generated/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph "torch.cuda.CUDAGraph") | CUDA 图的包装器。 | -| [`graph`](generated/torch.cuda.graph.html#torch.cuda.graph "torch.cuda.graph") | 上下文管理器，将 CUDA 工作捕获到一个 [`torch.cuda.CUDAGraph`](generated/torch.cuda.CUDAGraph.html#torch.cuda.CUDAGraph "torch.cuda.CUDAGraph") 对象中以供以后重播。 | -| [`make_graphed_callables`](generated/torch.cuda.make_graphed_callables.html#torch.cuda.make_graphed_callables "torch.cuda.make_graphed_callables") | 接受可调用对象（函数或 [`nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")）并返回图形化版本。 | +| `graph_pool_handle` | 返回表示图形内存池 id 的不透明令牌。 | +| `CUDAGraph` | CUDA 图的包装器。 | +| `graph` | 上下文管理器，将 CUDA 工作捕获到一个 `torch.cuda.CUDAGraph` 对象中以供以后重播。 | +| `make_graphed_callables` | 接受可调用对象（函数或 `nn.Module`）并返回图形化版本。 | ## 内存管理 -| [`empty_cache`](generated/torch.cuda.empty_cache.html#torch.cuda.empty_cache "torch.cuda.empty_cache") | 释放缓存分配器当前持有的所有未使用内存，以便其他 GPU 应用程序可以使用，并在 nvidia-smi 中可见。 | +| `empty_cache` | 释放缓存分配器当前持有的所有未使用内存，以便其他 GPU 应用程序可以使用，并在 nvidia-smi 中可见。 | | --- | --- | -| [`list_gpu_processes`](generated/torch.cuda.list_gpu_processes.html#torch.cuda.list_gpu_processes "torch.cuda.list_gpu_processes") | 返回给定设备的正在运行进程及其 GPU 内存使用情况的人类可读打印输出。 | -| [`mem_get_info`](generated/torch.cuda.mem_get_info.html#torch.cuda.mem_get_info "torch.cuda.mem_get_info") | 使用 cudaMemGetInfo 返回给定设备的全局空闲和总 GPU 内存。 | -| [`memory_stats`](generated/torch.cuda.memory_stats.html#torch.cuda.memory_stats "torch.cuda.memory_stats") | 返回给定设备的 CUDA 内存分配器统计信息字典。 | -| [`memory_summary`](generated/torch.cuda.memory_summary.html#torch.cuda.memory_summary "torch.cuda.memory_summary") | 返回给定设备的当前内存分配器统计信息的人类可读打印输出。 | -| [`memory_snapshot`](generated/torch.cuda.memory_snapshot.html#torch.cuda.memory_snapshot "torch.cuda.memory_snapshot") | 返回跨所有设备的 CUDA 内存分配器状态的快照。 | -| [`memory_allocated`](generated/torch.cuda.memory_allocated.html#torch.cuda.memory_allocated "torch.cuda.memory_allocated") | 返回给定设备上张量占用的当前 GPU 内存（以字节为单位）。 | -| [`max_memory_allocated`](generated/torch.cuda.max_memory_allocated.html#torch.cuda.max_memory_allocated "torch.cuda.max_memory_allocated") | 返回给定设备张量占用的最大GPU内存（以字节为单位）。 | -| [`reset_max_memory_allocated`](generated/torch.cuda.reset_max_memory_allocated.html#torch.cuda.reset_max_memory_allocated "torch.cuda.reset_max_memory_allocated") | 重置跟踪给定设备张量占用的最大GPU内存的起始点。 | -| [`memory_reserved`](generated/torch.cuda.memory_reserved.html#torch.cuda.memory_reserved "torch.cuda.memory_reserved") | 返回由缓存分配器管理的给定设备的当前GPU内存（以字节为单位）。 | -| [`max_memory_reserved`](generated/torch.cuda.max_memory_reserved.html#torch.cuda.max_memory_reserved "torch.cuda.max_memory_reserved") | 返回由缓存分配器管理的给定设备的最大GPU内存（以字节为单位）。 | -| [`set_per_process_memory_fraction`](generated/torch.cuda.set_per_process_memory_fraction.html#torch.cuda.set_per_process_memory_fraction "torch.cuda.set_per_process_memory_fraction") | 为进程设置内存分数。 | -| [`memory_cached`](generated/torch.cuda.memory_cached.html#torch.cuda.memory_cached "torch.cuda.memory_cached") | 已弃用；请参阅 [`memory_reserved()`](generated/torch.cuda.memory_reserved.html#torch.cuda.memory_reserved "torch.cuda.memory_reserved")。 | -| [`max_memory_cached`](generated/torch.cuda.max_memory_cached.html#torch.cuda.max_memory_cached "torch.cuda.max_memory_cached") | 已弃用；请参阅 [`max_memory_reserved()`](generated/torch.cuda.max_memory_reserved.html#torch.cuda.max_memory_reserved "torch.cuda.max_memory_reserved")。 | -| [`reset_max_memory_cached`](generated/torch.cuda.reset_max_memory_cached.html#torch.cuda.reset_max_memory_cached "torch.cuda.reset_max_memory_cached") | 重置跟踪由缓存分配器管理的给定设备的最大GPU内存的起始点。 | -| [`reset_peak_memory_stats`](generated/torch.cuda.reset_peak_memory_stats.html#torch.cuda.reset_peak_memory_stats "torch.cuda.reset_peak_memory_stats") | 重置CUDA内存分配器跟踪的“峰值”统计信息。 | -| [`caching_allocator_alloc`](generated/torch.cuda.caching_allocator_alloc.html#torch.cuda.caching_allocator_alloc "torch.cuda.caching_allocator_alloc") | 使用CUDA内存分配器执行内存分配。 | -| [`caching_allocator_delete`](generated/torch.cuda.caching_allocator_delete.html#torch.cuda.caching_allocator_delete "torch.cuda.caching_allocator_delete") | 删除使用CUDA内存分配器分配的内存。 | -| [`get_allocator_backend`](generated/torch.cuda.get_allocator_backend.html#torch.cuda.get_allocator_backend "torch.cuda.get_allocator_backend") | 返回一个描述由 `PYTORCH_CUDA_ALLOC_CONF` 设置的活动分配器后端的字符串。 | -| [`CUDAPluggableAllocator`](generated/torch.cuda.CUDAPluggableAllocator.html#torch.cuda.CUDAPluggableAllocator "torch.cuda.CUDAPluggableAllocator") | 从so文件加载的CUDA内存分配器。 | -| [`change_current_allocator`](generated/torch.cuda.change_current_allocator.html#torch.cuda.change_current_allocator "torch.cuda.change_current_allocator") | 将当前使用的内存分配器更改为提供的内存分配器。 | - -## NVIDIA工具扩展（NVTX）[](#nvidia-tools-extension-nvtx "跳转到此标题") - -| [`nvtx.mark`](generated/torch.cuda.nvtx.mark.html#torch.cuda.nvtx.mark "torch.cuda.nvtx.mark") | 描述在某个时间点发生的瞬时事件。 | +| `list_gpu_processes` | 返回给定设备的正在运行进程及其 GPU 内存使用情况的人类可读打印输出。 | +| `mem_get_info` | 使用 cudaMemGetInfo 返回给定设备的全局空闲和总 GPU 内存。 | +| `memory_stats` | 返回给定设备的 CUDA 内存分配器统计信息字典。 | +| `memory_summary` | 返回给定设备的当前内存分配器统计信息的人类可读打印输出。 | +| `memory_snapshot` | 返回跨所有设备的 CUDA 内存分配器状态的快照。 | +| `memory_allocated` | 返回给定设备上张量占用的当前 GPU 内存（以字节为单位）。 | +| `max_memory_allocated` | 返回给定设备张量占用的最大 GPU 内存（以字节为单位）。 | +| `reset_max_memory_allocated` | 重置跟踪给定设备张量占用的最大 GPU 内存的起始点。 | +| `memory_reserved` | 返回由缓存分配器管理的给定设备的当前 GPU 内存（以字节为单位）。 | +| `max_memory_reserved` | 返回由缓存分配器管理的给定设备的最大 GPU 内存（以字节为单位）。 | +| `set_per_process_memory_fraction` | 为进程设置内存分数。 | +| `memory_cached` | 已弃用；请参阅 `memory_reserved()`。 | +| `max_memory_cached` | 已弃用；请参阅 `max_memory_reserved()`。 | +| `reset_max_memory_cached` | 重置跟踪由缓存分配器管理的给定设备的最大 GPU 内存的起始点。 | +| `reset_peak_memory_stats` | 重置 CUDA 内存分配器跟踪的“峰值”统计信息。 | +| `caching_allocator_alloc` | 使用 CUDA 内存分配器执行内存分配。 | +| `caching_allocator_delete` | 删除使用 CUDA 内存分配器分配的内存。 | +| `get_allocator_backend` | 返回一个描述由 `PYTORCH_CUDA_ALLOC_CONF` 设置的活动分配器后端的字符串。 | +| `CUDAPluggableAllocator` | 从 so 文件加载的 CUDA 内存分配器。 | +| `change_current_allocator` | 将当前使用的内存分配器更改为提供的内存分配器。 | + +## NVIDIA 工具扩展（NVTX）[](#nvidia-tools-extension-nvtx "跳转到此标题") + +| `nvtx.mark` | 描述在某个时间点发生的瞬时事件。 | | --- | --- | -| [`nvtx.range_push`](generated/torch.cuda.nvtx.range_push.html#torch.cuda.nvtx.range_push "torch.cuda.nvtx.range_push") | 将范围推送到嵌套范围跨度的堆栈上。 | -| [`nvtx.range_pop`](generated/torch.cuda.nvtx.range_pop.html#torch.cuda.nvtx.range_pop "torch.cuda.nvtx.range_pop") | 从嵌套范围跨度堆栈中弹出范围。 | +| `nvtx.range_push` | 将范围推送到嵌套范围跨度的堆栈上。 | +| `nvtx.range_pop` | 从嵌套范围跨度堆栈中弹出范围。 | ## Jiterator（beta） -| [`jiterator._create_jit_fn`](generated/torch.cuda.jiterator._create_jit_fn.html#torch.cuda.jiterator._create_jit_fn "torch.cuda.jiterator._create_jit_fn") | 创建一个由jiterator生成的cuda内核，用于逐元素操作。 | +| `jiterator._create_jit_fn` | 创建一个由 jiterator 生成的 cuda 内核，用于逐元素操作。 | | --- | --- | -| [`jiterator._create_multi_output_jit_fn`](generated/torch.cuda.jiterator._create_multi_output_jit_fn.html#torch.cuda.jiterator._create_multi_output_jit_fn "torch.cuda.jiterator._create_multi_output_jit_fn") | 创建一个由jiterator生成的cuda内核，用于支持返回一个或多个输出的逐元素操作。 | +| `jiterator._create_multi_output_jit_fn` | 创建一个由 jiterator 生成的 cuda 内核，用于支持返回一个或多个输出的逐元素操作。 | ## 流消毒器（原型）[](#stream-sanitizer-prototype "跳转到此标题的永久链接") -CUDA消毒器是一个用于检测PyTorch中流之间同步错误的原型工具。请查看[文档](cuda._sanitizer.html)以获取如何使用它的信息。 +CUDA 消毒器是一个用于检测 PyTorch 中流之间同步错误的原型工具。请查看文档以获取如何使用它的信息。 diff --git a/totrans/doc22_042.md b/totrans/doc22_042.md index 0c1d0409..f8a46ec9 100644 --- a/totrans/doc22_042.md +++ b/totrans/doc22_042.md @@ -1,14 +1,14 @@ -# 了解CUDA内存使用情况 +# 了解 CUDA 内存使用情况 -> 原文：[https://pytorch.org/docs/stable/torch_cuda_memory.html](https://pytorch.org/docs/stable/torch_cuda_memory.html) +> 原文：[`pytorch.org/docs/stable/torch_cuda_memory.html`](https://pytorch.org/docs/stable/torch_cuda_memory.html) -为了调试CUDA内存使用，PyTorch提供了一种生成内存快照的方法，记录分配的CUDA内存在任何时间点的状态，并可选择记录导致该快照的分配事件的历史记录。 +为了调试 CUDA 内存使用，PyTorch 提供了一种生成内存快照的方法，记录分配的 CUDA 内存在任何时间点的状态，并可选择记录导致该快照的分配事件的历史记录。 然后，可以将生成的快照拖放到托管在[pytorch.org/memory_viz](https://pytorch.org/memory_viz)上的交互式查看器中，用于探索快照。 # 生成快照 -记录快照的常见模式是启用内存历史记录，运行要观察的代码，然后保存一个包含pickled快照的文件： +记录快照的常见模式是启用内存历史记录，运行要观察的代码，然后保存一个包含 pickled 快照的文件： ```py # enable memory history, which will @@ -21,53 +21,53 @@ torch.cuda.memory._dump_snapshot("my_snapshot.pickle") # 使用可视化工具 -打开[pytorch.org/memory_viz](https://pytorch.org/memory_viz)，将pickled快照文件拖放到可视化工具中。该可视化工具是一个在您的计算机上本地运行的JavaScript应用程序。它不会上传任何快照数据。 +打开[pytorch.org/memory_viz](https://pytorch.org/memory_viz)，将 pickled 快照文件拖放到可视化工具中。该可视化工具是一个在您的计算机上本地运行的 JavaScript 应用程序。它不会上传任何快照数据。 ## 活动内存时间线 -活动内存时间线显示了快照中特定GPU上的所有张量随时间的变化。在图表上进行平移/缩放，以查看较小的分配。将鼠标悬停在分配的块上，以查看分配该块时的堆栈跟踪，以及其地址等详细信息。可以调整详细滑块以渲染更少的分配，并在数据量较大时提高性能。 +活动内存时间线显示了快照中特定 GPU 上的所有张量随时间的变化。在图表上进行平移/缩放，以查看较小的分配。将鼠标悬停在分配的块上，以查看分配该块时的堆栈跟踪，以及其地址等详细信息。可以调整详细滑块以渲染更少的分配，并在数据量较大时提高性能。 -![_images/active_memory_timeline.png](../Images/eed5d13530c32a9ffc147fbef83865d2.png) +![_images/active_memory_timeline.png](img/eed5d13530c32a9ffc147fbef83865d2.png) ## 分配器状态历史 -分配器状态历史在左侧的时间轴上显示了单个分配器事件。在时间轴中选择一个事件，以查看该事件时的分配器状态的可视摘要。此摘要显示了从cudaMalloc返回的每个单独段以及如何将其分割为单个分配或空闲空间的块。将鼠标悬停在段和块上，以查看内存分配时的堆栈跟踪。将鼠标悬停在事件上，以查看事件发生时的堆栈跟踪，例如张量何时被释放。内存不足错误报告为OOM事件。查看OOM时的内存状态可能有助于了解为什么分配失败，即使保留的内存仍然存在。 +分配器状态历史在左侧的时间轴上显示了单个分配器事件。在时间轴中选择一个事件，以查看该事件时的分配器状态的可视摘要。此摘要显示了从 cudaMalloc 返回的每个单独段以及如何将其分割为单个分配或空闲空间的块。将鼠标悬停在段和块上，以查看内存分配时的堆栈跟踪。将鼠标悬停在事件上，以查看事件发生时的堆栈跟踪，例如张量何时被释放。内存不足错误报告为 OOM 事件。查看 OOM 时的内存状态可能有助于了解为什么分配失败，即使保留的内存仍然存在。 -![_images/allocator_state_history.png](../Images/330e9ea5e1c7c9cf54145afa5cde9d6e.png) +![_images/allocator_state_history.png](img/330e9ea5e1c7c9cf54145afa5cde9d6e.png) -堆栈跟踪信息还报告了分配发生的地址。地址b7f064c000000_0指的是地址为7f064c000000的块，这是该地址被分配的“_0”次。可以在活动内存时间线中查找此唯一字符串，并在活动状态历史中搜索，以检查张量分配或释放时的内存状态。 +堆栈跟踪信息还报告了分配发生的地址。地址 b7f064c000000_0 指的是地址为 7f064c000000 的块，这是该地址被分配的“_0”次。可以在活动内存时间线中查找此唯一字符串，并在活动状态历史中搜索，以检查张量分配或释放时的内存状态。 -# 快照API参考 +# 快照 API 参考 ```py torch.cuda.memory._record_memory_history(enabled='all', context='all', stacks='all', max_entries=9223372036854775807, device=None)¶ ``` -启用与内存分配相关的堆栈跟踪记录，这样您就可以知道[`torch.cuda.memory._snapshot()`](#torch.cuda.memory._snapshot "torch.cuda.memory._snapshot")中分配了哪些内存片段。 +启用与内存分配相关的堆栈跟踪记录，这样您就可以知道`torch.cuda.memory._snapshot()`中分配了哪些内存片段。 除了保留每个当前分配和释放的堆栈跟踪，这也将启用记录所有分配/释放事件的历史记录。 -使用[`torch.cuda.memory._snapshot()`](#torch.cuda.memory._snapshot "torch.cuda.memory._snapshot")来检索此信息，并使用_memory_viz.py中的工具来可视化快照。 +使用`torch.cuda.memory._snapshot()`来检索此信息，并使用 _memory_viz.py 中的工具来可视化快照。 -Python跟踪收集速度快（每个跟踪为2us），因此如果您预计需要调试内存问题，则可以考虑在生产作业中启用此功能。 +Python 跟踪收集速度快（每个跟踪为 2us），因此如果您预计需要调试内存问题，则可以考虑在生产作业中启用此功能。 -C++跟踪收集也很快（~50ns/帧），对于许多典型程序来说，每个跟踪大约为2us，但可能会因堆栈深度而有所变化。 +C++跟踪收集也很快（~50ns/帧），对于许多典型程序来说，每个跟踪大约为 2us，但可能会因堆栈深度而有所变化。 参数 + **enabled**（*字面值*[**None**,* *"state"**,* *"all"**]**,* *可选*) – None，禁用记录内存历史。 “state”，保留当前分配内存的信息。 “all”，此外还保留所有分配/释放调用的历史记录。默认为“all”。 -+ **context**（*Literal**[**None**,* *"state"**,* *"alloc"**,* *"all"**]**，“可选”） - None，不记录任何tracebacks。“state”，记录当前分配的内存的tracebacks。“alloc”，另外保留分配调用的tracebacks。“all”，另外保留释放调用的tracebacks。默认为“all”。 ++ **context**（*Literal**[**None**,* *"state"**,* *"alloc"**,* *"all"**]**，“可选”） - None，不记录任何 tracebacks。“state”，记录当前分配的内存的 tracebacks。“alloc”，另外保留分配调用的 tracebacks。“all”，另外保留释放调用的 tracebacks。默认为“all”。 -+ **stacks**（*Literal**[**"python"**,* *"all"**]**，“可选”） - “python”，包括Python、TorchScript和感应器帧在tracebacks中，“all”，另外包括C++帧，默认为“all”。 ++ **stacks**（*Literal**[**"python"**,* *"all"**]**，“可选”） - “python”，包括 Python、TorchScript 和感应器帧在 tracebacks 中，“all”，另外包括 C++帧，默认为“all”。 -+ **max_entries**（[*int*](https://docs.python.org/3/library/functions.html#int)，“可选”） - 在记录的历史记录中保留最多max_entries个分配/释放事件。 ++ **max_entries**（[*int*](https://docs.python.org/3/library/functions.html#int)，“可选”） - 在记录的历史记录中保留最多 max_entries 个分配/释放事件。 ```py torch.cuda.memory._snapshot(device=None)¶ ``` -在调用时保存CUDA内存状态的快照。 +在调用时保存 CUDA 内存状态的快照。 状态表示为具有以下结构的字典。 @@ -145,9 +145,9 @@ class TraceEntry(TypedDict): torch.cuda.memory._dump_snapshot(filename='dump_snapshot.pickle')¶ ``` -将torch.memory._snapshot()字典的pickled版本保存到文件中。 +将 torch.memory._snapshot()字典的 pickled 版本保存到文件中。 -此文件可以由pytorch.org/memory_viz上的交互式快照查看器打开 +此文件可以由 pytorch.org/memory_viz 上的交互式快照查看器打开 参数 diff --git a/totrans/doc22_043.md b/totrans/doc22_043.md index 9d3ba2da..3c550e0e 100644 --- a/totrans/doc22_043.md +++ b/totrans/doc22_043.md @@ -1,28 +1,28 @@ # torch.mps -> 原文：[https://pytorch.org/docs/stable/mps.html](https://pytorch.org/docs/stable/mps.html) +> 原文：[`pytorch.org/docs/stable/mps.html`](https://pytorch.org/docs/stable/mps.html) -该软件包提供了一个接口，用于在Python中访问MPS（Metal Performance Shaders）后端。Metal是苹果用于编程金属GPU（图形处理器单元）的API。使用MPS意味着可以通过在金属GPU上运行工作来实现增加的性能。有关更多详细信息，请参见[https://developer.apple.com/documentation/metalperformanceshaders](https://developer.apple.com/documentation/metalperformanceshaders)。 +该软件包提供了一个接口，用于在 Python 中访问 MPS（Metal Performance Shaders）后端。Metal 是苹果用于编程金属 GPU（图形处理器单元）的 API。使用 MPS 意味着可以通过在金属 GPU 上运行工作来实现增加的性能。有关更多详细信息，请参见[`developer.apple.com/documentation/metalperformanceshaders`](https://developer.apple.com/documentation/metalperformanceshaders)。 -| [`synchronize`](generated/torch.mps.synchronize.html#torch.mps.synchronize "torch.mps.synchronize") | 等待MPS设备上所有流中的所有内核完成。 | +| `synchronize` | 等待 MPS 设备上所有流中的所有内核完成。 | | --- | --- | -| [`get_rng_state`](generated/torch.mps.get_rng_state.html#torch.mps.get_rng_state "torch.mps.get_rng_state") | 将随机数生成器状态作为ByteTensor返回。 | -| [`set_rng_state`](generated/torch.mps.set_rng_state.html#torch.mps.set_rng_state "torch.mps.set_rng_state") | 设置随机数生成器状态。 | -| [`manual_seed`](generated/torch.mps.manual_seed.html#torch.mps.manual_seed "torch.mps.manual_seed") | 设置生成随机数的种子。 | -| [`seed`](generated/torch.mps.seed.html#torch.mps.seed "torch.mps.seed") | 将生成随机数的种子设置为一个随机数。 | -| [`empty_cache`](generated/torch.mps.empty_cache.html#torch.mps.empty_cache "torch.mps.empty_cache") | 释放缓存分配器当前持有的所有未使用缓存内存，以便这些内存可以用于其他GPU应用程序。 | -| [`set_per_process_memory_fraction`](generated/torch.mps.set_per_process_memory_fraction.html#torch.mps.set_per_process_memory_fraction "torch.mps.set_per_process_memory_fraction") | 设置限制进程在MPS设备上内存分配的内存分数。 | -| [`current_allocated_memory`](generated/torch.mps.current_allocated_memory.html#torch.mps.current_allocated_memory "torch.mps.current_allocated_memory") | 返回张量占用的当前GPU内存（以字节为单位）。 | -| [`driver_allocated_memory`](generated/torch.mps.driver_allocated_memory.html#torch.mps.driver_allocated_memory "torch.mps.driver_allocated_memory") | 返回Metal驱动程序为进程分配的总GPU内存（以字节为单位）。 | +| `get_rng_state` | 将随机数生成器状态作为 ByteTensor 返回。 | +| `set_rng_state` | 设置随机数生成器状态。 | +| `manual_seed` | 设置生成随机数的种子。 | +| `seed` | 将生成随机数的种子设置为一个随机数。 | +| `empty_cache` | 释放缓存分配器当前持有的所有未使用缓存内存，以便这些内存可以用于其他 GPU 应用程序。 | +| `set_per_process_memory_fraction` | 设置限制进程在 MPS 设备上内存分配的内存分数。 | +| `current_allocated_memory` | 返回张量占用的当前 GPU 内存（以字节为单位）。 | +| `driver_allocated_memory` | 返回 Metal 驱动程序为进程分配的总 GPU 内存（以字节为单位）。 | ## MPS Profiler -| [`profiler.start`](generated/torch.mps.profiler.start.html#torch.mps.profiler.start "torch.mps.profiler.start") | 从MPS后端开始OS Signpost跟踪。 | +| `profiler.start` | 从 MPS 后端开始 OS Signpost 跟踪。 | | --- | --- | -| [`profiler.stop`](generated/torch.mps.profiler.stop.html#torch.mps.profiler.stop "torch.mps.profiler.stop") | 停止从MPS后端生成OS Signpost跟踪。 | -| [`profiler.profile`](generated/torch.mps.profiler.profile.html#torch.mps.profiler.profile "torch.mps.profiler.profile") | 上下文管理器，用于启用从MPS后端生成OS Signpost跟踪。 | +| `profiler.stop` | 停止从 MPS 后端生成 OS Signpost 跟踪。 | +| `profiler.profile` | 上下文管理器，用于启用从 MPS 后端生成 OS Signpost 跟踪。 | ## MPS Event -| [`event.Event`](generated/torch.mps.event.Event.html#torch.mps.event.Event "torch.mps.event.Event") | MPS事件的包装器。 | +| `event.Event` | MPS 事件的包装器。 | | --- | --- | diff --git a/totrans/doc22_044.md b/totrans/doc22_044.md index 18f89d77..876d784b 100644 --- a/totrans/doc22_044.md +++ b/totrans/doc22_044.md @@ -1,8 +1,8 @@ # torch.backends -> 原文：[https://pytorch.org/docs/stable/backends.html](https://pytorch.org/docs/stable/backends.html) +> 原文：[`pytorch.org/docs/stable/backends.html`](https://pytorch.org/docs/stable/backends.html) -torch.backends控制PyTorch支持的各种后端的行为。 +torch.backends 控制 PyTorch 支持的各种后端的行为。 这些后端包括： @@ -30,7 +30,7 @@ torch.backends控制PyTorch支持的各种后端的行为。 torch.backends.cpu.get_cpu_capability()¶ ``` -返回CPU能力作为字符串值。 +返回 CPU 能力作为字符串值。 可能的值：- “DEFAULT” - “VSX” - “Z VECTOR” - “NO AVX” - “AVX2” - “AVX512” @@ -42,105 +42,105 @@ torch.backends.cpu.get_cpu_capability()¶ torch.backends.cuda.is_built()¶ ``` -返回PyTorch是否构建有CUDA支持。 +返回 PyTorch 是否构建有 CUDA 支持。 -请注意，这并不一定意味着CUDA可用；只是如果在具有工作CUDA驱动程序和设备的机器上运行此PyTorch二进制文件，我们将能够使用它。 +请注意，这并不一定意味着 CUDA 可用；只是如果在具有工作 CUDA 驱动程序和设备的机器上运行此 PyTorch 二进制文件，我们将能够使用它。 ```py torch.backends.cuda.matmul.allow_tf32¶ ``` -一个控制在安培或更新的GPU上是否可以使用TensorFloat-32张量核心进行矩阵乘法的布尔值。请参阅[Ampere（以及更高版本）设备上的TensorFloat-32（TF32）](notes/cuda.html#tf32-on-ampere)。 +一个控制在安培或更新的 GPU 上是否可以使用 TensorFloat-32 张量核心进行矩阵乘法的布尔值。请参阅 Ampere（以及更高版本）设备上的 TensorFloat-32（TF32）。 ```py torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction¶ ``` -一个控制是否允许使用减少精度的规约（例如，使用fp16累积类型）与fp16 GEMM一起使用的布尔值。 +一个控制是否允许使用减少精度的规约（例如，使用 fp16 累积类型）与 fp16 GEMM 一起使用的布尔值。 ```py torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction¶ ``` -一个控制是否允许使用bf16 GEMM的减少精度规约的布尔值。 +一个控制是否允许使用 bf16 GEMM 的减少精度规约的布尔值。 ```py torch.backends.cuda.cufft_plan_cache¶ ``` -`cufft_plan_cache`包含每个CUDA设备的cuFFT计划缓存。通过torch.backends.cuda.cufft_plan_cache[i]查询特定设备i的缓存。 +`cufft_plan_cache`包含每个 CUDA 设备的 cuFFT 计划缓存。通过 torch.backends.cuda.cufft_plan_cache[i]查询特定设备 i 的缓存。 ```py torch.backends.cuda.cufft_plan_cache.size¶ ``` -一个只读[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")，显示cuFFT计划缓存中当前计划的数量。 +一个只读[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")，显示 cuFFT 计划缓存中当前计划的数量。 ```py torch.backends.cuda.cufft_plan_cache.max_size¶ ``` -一个[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")，控制cuFFT计划缓存的容量。 +一个[`int`](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")，控制 cuFFT 计划缓存的容量。 ```py torch.backends.cuda.cufft_plan_cache.clear()¶ ``` -清除cuFFT计划缓存。 +清除 cuFFT 计划缓存。 ```py torch.backends.cuda.preferred_linalg_library(backend=None)¶ ``` -覆盖PyTorch用于在CUDA线性代数操作中选择cuSOLVER和MAGMA之间的启发式。 +覆盖 PyTorch 用于在 CUDA 线性代数操作中选择 cuSOLVER 和 MAGMA 之间的启发式。 警告 此标志是实验性的，可能会更改。 -当PyTorch运行CUDA线性代数操作时，通常会使用cuSOLVER或MAGMA库，如果两者都可用，则会根据启发式决定使用哪个。此标志（一个[`str`](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")）允许覆盖这些启发式。 +当 PyTorch 运行 CUDA 线性代数操作时，通常会使用 cuSOLVER 或 MAGMA 库，如果两者都可用，则会根据启发式决定使用哪个。此标志（一个[`str`](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")）允许覆盖这些启发式。 -+ 如果设置为“cusolver”，则将尽可能使用cuSOLVER。 ++ 如果设置为“cusolver”，则将尽可能使用 cuSOLVER。 -+ 如果设置为“magma”，则将尽可能使用MAGMA。 ++ 如果设置为“magma”，则将尽可能使用 MAGMA。 -+ 如果设置为“default”（默认），则将使用启发式来在cuSOLVER和MAGMA之间进行选择（如果两者都可用）。 ++ 如果设置为“default”（默认），则将使用启发式来在 cuSOLVER 和 MAGMA 之间进行选择（如果两者都可用）。 + 当没有输入时，此函数返回当前首选库。 -+ 用户可以使用环境变量TORCH_LINALG_PREFER_CUSOLVER=1全局设置首选库为cuSOLVER。此标志仅设置首选库的初始值，首选库仍可能在脚本中的后续函数调用中被覆盖。 ++ 用户可以使用环境变量 TORCH_LINALG_PREFER_CUSOLVER=1 全局设置首选库为 cuSOLVER。此标志仅设置首选库的初始值，首选库仍可能在脚本中的后续函数调用中被覆盖。 -注意：当首选库为其他库时，如果首选库未实现所调用的操作，则仍然可以使用其他库。如果PyTorch的启发式库选择对您应用程序的输入不正确，则此标志可能会实现更好的性能。 +注意：当首选库为其他库时，如果首选库未实现所调用的操作，则仍然可以使用其他库。如果 PyTorch 的启发式库选择对您应用程序的输入不正确，则此标志可能会实现更好的性能。 -当前支持的linalg运算符： +当前支持的 linalg 运算符： -+ [`torch.linalg.inv()`](generated/torch.linalg.inv.html#torch.linalg.inv "torch.linalg.inv") ++ `torch.linalg.inv()` -+ [`torch.linalg.inv_ex()`](generated/torch.linalg.inv_ex.html#torch.linalg.inv_ex "torch.linalg.inv_ex") ++ `torch.linalg.inv_ex()` -+ [`torch.linalg.cholesky()`](generated/torch.linalg.cholesky.html#torch.linalg.cholesky "torch.linalg.cholesky") ++ `torch.linalg.cholesky()` -+ [`torch.linalg.cholesky_ex()`](generated/torch.linalg.cholesky_ex.html#torch.linalg.cholesky_ex "torch.linalg.cholesky_ex") ++ `torch.linalg.cholesky_ex()` -+ [`torch.cholesky_solve()`](generated/torch.cholesky_solve.html#torch.cholesky_solve "torch.cholesky_solve") ++ `torch.cholesky_solve()` -+ [`torch.cholesky_inverse()`](generated/torch.cholesky_inverse.html#torch.cholesky_inverse "torch.cholesky_inverse") ++ `torch.cholesky_inverse()` -+ [`torch.linalg.lu_factor()`](generated/torch.linalg.lu_factor.html#torch.linalg.lu_factor "torch.linalg.lu_factor") ++ `torch.linalg.lu_factor()` -+ [`torch.linalg.lu()`](generated/torch.linalg.lu.html#torch.linalg.lu "torch.linalg.lu") ++ `torch.linalg.lu()` -+ [`torch.linalg.lu_solve()`](generated/torch.linalg.lu_solve.html#torch.linalg.lu_solve "torch.linalg.lu_solve") ++ `torch.linalg.lu_solve()` -+ [`torch.linalg.qr()`](generated/torch.linalg.qr.html#torch.linalg.qr "torch.linalg.qr") ++ `torch.linalg.qr()` -+ [`torch.linalg.eigh()`](generated/torch.linalg.eigh.html#torch.linalg.eigh "torch.linalg.eigh") ++ `torch.linalg.eigh()` + `torch.linalg.eighvals()` -+ [`torch.linalg.svd()`](generated/torch.linalg.svd.html#torch.linalg.svd "torch.linalg.svd") ++ `torch.linalg.svd()` -+ [`torch.linalg.svdvals()`](generated/torch.linalg.svdvals.html#torch.linalg.svdvals "torch.linalg.svdvals") ++ `torch.linalg.svdvals()` 返回类型 @@ -228,11 +228,11 @@ torch.backends.cuda.can_use_flash_attention(params, debug=False)¶ + **params** (*_SDPAParams*) – 包含查询、键、值张量、可选注意力掩码、丢弃率以及指示注意力是否因果的标志的 SDPAParams 实例。 -+ **debug** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 是否记录警告调试信息，说明为什么无法运行 FlashAttention。默认为False。 ++ **debug** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 是否记录警告调试信息，说明为什么无法运行 FlashAttention。默认为 False。 返回 -如果可以使用给定参数，则为True；否则为False。 +如果可以使用给定参数，则为 True；否则为 False。 返回类型 @@ -240,7 +240,7 @@ torch.backends.cuda.can_use_flash_attention(params, debug=False)¶ 注意 -此函数依赖于 PyTorch 的 CUDA 版本。在非CUDA环境中将返回False。 +此函数依赖于 PyTorch 的 CUDA 版本。在非 CUDA 环境中将返回 False。 ```py torch.backends.cuda.can_use_efficient_attention(params, debug=False)¶ @@ -252,11 +252,11 @@ torch.backends.cuda.can_use_efficient_attention(params, debug=False)¶ + **params** (*_SDPAParams*) – 包含查询、键、值张量、可选注意力掩码、丢弃率以及指示注意力是否因果的标志的 SDPAParams 实例。 -+ **debug** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 是否记录警告信息，说明为什么无法运行 efficient_attention。默认为False。 ++ **debug** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 是否记录警告信息，说明为什么无法运行 efficient_attention。默认为 False。 返回 -如果可以使用给定参数，则为True；否则为False。 +如果可以使用给定参数，则为 True；否则为 False。 返回类型 @@ -264,7 +264,7 @@ torch.backends.cuda.can_use_efficient_attention(params, debug=False)¶ 注意 -此函数依赖于 PyTorch 的 CUDA 版本。在非CUDA环境中将返回False。 +此函数依赖于 PyTorch 的 CUDA 版本。在非 CUDA 环境中将返回 False。 ```py torch.backends.cuda.sdp_kernel(enable_flash=True, enable_math=True, enable_mem_efficient=True)¶ @@ -298,61 +298,61 @@ torch.backends.cudnn.enabled¶ 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）](notes/cuda.html#tf32-on-ampere)。 +一个[`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¶ ``` -一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，如果为True，则导致cuDNN仅使用确定性卷积算法。另请参阅[`torch.are_deterministic_algorithms_enabled()`](generated/torch.are_deterministic_algorithms_enabled.html#torch.are_deterministic_algorithms_enabled "torch.are_deterministic_algorithms_enabled")和[`torch.use_deterministic_algorithms()`](generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms "torch.use_deterministic_algorithms")。 +一个[`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¶ ``` -一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，如果为True，则导致cuDNN对多个卷积算法进行基准测试并选择最快的。 +一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，如果为 True，则导致 cuDNN 对多个卷积算法进行基准测试并选择最快的。 ```py 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 "跳转到此标题的永久链接") +一个[`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()¶ ``` -返回一个指示当前是否可用MPS的布尔值。 +返回一个指示当前是否可用 MPS 的布尔值。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py torch.backends.mps.is_built()¶ ``` -返回PyTorch是否构建有MPS支持。 +返回 PyTorch 是否构建有 MPS 支持。 -请注意，这并不一定意味着MPS可用；只是如果在具有工作MPS驱动程序和设备的机器上运行此PyTorch二进制文件，我们将能够使用它。 +请注意，这并不一定意味着 MPS 可用；只是如果在具有工作 MPS 驱动程序和设备的机器上运行此 PyTorch 二进制文件，我们将能够使用它。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") ## torch.backends.mkl +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ## torch.backends.mkl ```py torch.backends.mkl.is_available()¶ ``` -返回PyTorch是否构建有MKL支持。 +返回 PyTorch 是否构建有 MKL 支持。 ```py class torch.backends.mkl.verbose(enable)¶ ``` -按需oneMKL详细功能。 +按需 oneMKL 详细功能。 -为了更容易调试性能问题，oneMKL可以转储包含执行信息（如持续时间）的详细消息，同时执行内核。可以通过名为MKL_VERBOSE的环境变量调用详细功能。但是，这种方法在所有步骤中转储消息。这些是大量详细消息。此外，通常仅对单个迭代获取详细消息就足够用于调查性能问题。这种按需详细功能使得可以控制详细消息转储的范围。在以下示例中，仅为第二个推理转储详细消息。 +为了更容易调试性能问题，oneMKL 可以转储包含执行信息（如持续时间）的详细消息，同时执行内核。可以通过名为 MKL_VERBOSE 的环境变量调用详细功能。但是，这种方法在所有步骤中转储消息。这些是大量详细消息。此外，通常仅对单个迭代获取详细消息就足够用于调查性能问题。这种按需详细功能使得可以控制详细消息转储的范围。在以下示例中，仅为第二个推理转储详细消息。 ```py import torch @@ -369,15 +369,15 @@ with torch.backends.mkl.verbose(torch.backends.mkl.VERBOSE_ON): torch.backends.mkldnn.is_available()¶ ``` -返回PyTorch是否构建有MKL-DNN支持。 +返回 PyTorch 是否构建有 MKL-DNN 支持。 ```py class torch.backends.mkldnn.verbose(level)¶ ``` -按需oneDNN（前MKL-DNN）详细功能。 +按需 oneDNN（前 MKL-DNN）详细功能。 -为了更容易调试性能问题，oneDNN可以转储包含内核大小、输入数据大小和执行持续时间等信息的详细消息，同时执行内核。可以通过名为DNNL_VERBOSE的环境变量调用详细功能。但是，这种方法在所有步骤中转储消息。这些是大量详细消息。此外，通常仅对单个迭代获取详细消息就足够用于调查性能问题。这种按需详细功能使得可以控制详细消息转储的范围。在以下示例中，仅为第二个推理转储详细消息。 +为了更容易调试性能问题，oneDNN 可以转储包含内核大小、输入数据大小和执行持续时间等信息的详细消息，同时执行内核。可以通过名为 DNNL_VERBOSE 的环境变量调用详细功能。但是，这种方法在所有步骤中转储消息。这些是大量详细消息。此外，通常仅对单个迭代获取详细消息就足够用于调查性能问题。这种按需详细功能使得可以控制详细消息转储的范围。在以下示例中，仅为第二个推理转储详细消息。 ```py import torch @@ -388,44 +388,44 @@ 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 "跳转到此标题的永久链接") +**level** – 详细级别 - `VERBOSE_OFF`：禁用详细 - `VERBOSE_ON`：启用详细 - `VERBOSE_ON_CREATION`：启用详细，包括 oneDNN 内核创建 ## torch.backends.openmp[](#module-torch.backends.openmp "跳转到此标题的永久链接") ```py torch.backends.openmp.is_available()¶ ``` -返回PyTorch是否构建有OpenMP支持。 ## torch.backends.opt_einsum[](#module-torch.backends.opt_einsum "跳转到此标题") +返回 PyTorch 是否构建有 OpenMP 支持。 ## torch.backends.opt_einsum[](#module-torch.backends.opt_einsum "跳转到此标题") ```py torch.backends.opt_einsum.is_available()¶ ``` -返回一个指示opt_einsum当前是否可用的bool值。 +返回一个指示 opt_einsum 当前是否可用的 bool 值。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py torch.backends.opt_einsum.get_opt_einsum()¶ ``` -如果当前可用，则返回opt_einsum包，否则返回None。 +如果当前可用，则返回 opt_einsum 包，否则返回 None。 返回类型 -[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)") +[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)") ```py torch.backends.opt_einsum.enabled¶ ``` -一个控制是否启用opt_einsum的`bool`（默认为`True`）。如果启用，torch.einsum将使用opt_einsum（[https://optimized-einsum.readthedocs.io/en/stable/path_finding.html](https://optimized-einsum.readthedocs.io/en/stable/path_finding.html)）来计算更快性能的最佳收缩路径。 +一个控制是否启用 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)）来计算更快性能的最佳收缩路径。 -如果opt_einsum不可用，torch.einsum将退回到默认的从左到右的收缩路径。 +如果 opt_einsum 不可用，torch.einsum 将退回到默认的从左到右的收缩路径。 ```py torch.backends.opt_einsum.strategy¶ ``` -一个指定当`torch.backends.opt_einsum.enabled`为`True`时要尝试哪些策略的`str`。默认情况下，torch.einsum将尝试“auto”策略，但也支持“greedy”和“optimal”策略。请注意，“optimal”策略在尝试所有可能路径时与输入数量的阶乘成正比。在opt_einsum的文档中查看更多细节（[https://optimized-einsum.readthedocs.io/en/stable/path_finding.html](https://optimized-einsum.readthedocs.io/en/stable/path_finding.html)）。 ## torch.backends.xeon +一个指定当`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 diff --git a/totrans/doc22_045.md b/totrans/doc22_045.md index 6bf25a77..b59c26fe 100644 --- a/totrans/doc22_045.md +++ b/totrans/doc22_045.md @@ -1,6 +1,6 @@ # torch.export -> 原文：[https://pytorch.org/docs/stable/export.html](https://pytorch.org/docs/stable/export.html) +> 原文：[`pytorch.org/docs/stable/export.html`](https://pytorch.org/docs/stable/export.html) 警告 @@ -8,7 +8,7 @@ ## 概述 -[`torch.export.export()`](#torch.export.export "torch.export.export") 接受一个任意的 Python 可调用对象（一个 [`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")、一个函数或一个方法），并以 Ahead-of-Time (AOT) 方式生成一个表示函数的张量计算的追踪图，随后可以用不同的输出或序列化执行。 +`torch.export.export()` 接受一个任意的 Python 可调用对象（一个 `torch.nn.Module`、一个函数或一个方法），并以 Ahead-of-Time (AOT) 方式生成一个表示函数的张量计算的追踪图，随后可以用不同的输出或序列化执行。 ```py import torch @@ -56,13 +56,13 @@ ExportedProgram: Equality constraints: [] ``` -`torch.export` 生成一个干净的中间表示（IR），具有以下不变性。关于 IR 的更多规范可以在[这里](export.ir_spec.html#export-ir-spec)找到。 +`torch.export` 生成一个干净的中间表示（IR），具有以下不变性。关于 IR 的更多规范可以在这里找到。 + **正确性**：它保证是原始程序的正确表示，并保持原始程序的相同调用约定。 + **标准化**：图中没有 Python 语义。原始程序中的子模块被内联以形成一个完全扁平化的计算图。 -+ **定义的操作集**：生成的图仅包含一个小的定义的 [Core ATen IR](torch.compiler_ir.html#torch-compiler-ir) 操作集和注册的自定义操作符。 ++ **定义的操作集**：生成的图仅包含一个小的定义的 Core ATen IR 操作集和注册的自定义操作符。 + **图属性**：图是纯函数的，意味着它不包含具有副作用的操作，比如突变或别名。它不会改变任何中间值、参数或缓冲区。 @@ -78,25 +78,25 @@ ExportedProgram: ### 现有框架 -[`torch.compile()`](generated/torch.compile.html#torch.compile "torch.compile") 也利用与 `torch.export` 相同的 PT2 栈，但略有不同： +`torch.compile()` 也利用与 `torch.export` 相同的 PT2 栈，但略有不同： -+ **JIT vs. AOT**: [`torch.compile()`](generated/torch.compile.html#torch.compile "torch.compile") 是一个 JIT 编译器，而不是用来生成部署外编译成果的。 ++ **JIT vs. AOT**: `torch.compile()` 是一个 JIT 编译器，而不是用来生成部署外编译成果的。 -+ **部分 vs. 完整图捕获**：当 [`torch.compile()`](generated/torch.compile.html#torch.compile "torch.compile") 遇到模型中无法追踪的部分时，它将“图断裂”，并回退到在急切的 Python 运行时中运行程序。相比之下，`torch.export` 旨在获得 PyTorch 模型的完整图表示，因此当达到无法追踪的内容时会报错。由于 `torch.export` 生成的完整图与任何 Python 特性或运行时无关，因此该图可以保存、加载并在不同环境和语言中运行。 ++ **部分 vs. 完整图捕获**：当 `torch.compile()` 遇到模型中无法追踪的部分时，它将“图断裂”，并回退到在急切的 Python 运行时中运行程序。相比之下，`torch.export` 旨在获得 PyTorch 模型的完整图表示，因此当达到无法追踪的内容时会报错。由于 `torch.export` 生成的完整图与任何 Python 特性或运行时无关，因此该图可以保存、加载并在不同环境和语言中运行。 -+ **可用性权衡**：由于 [`torch.compile()`](generated/torch.compile.html#torch.compile "torch.compile") 能够在遇到无法追踪的内容时回退到 Python 运行时，因此它更加灵活。相反，`torch.export` 将要求用户提供更多信息或重写他们的代码以使其可追踪。 ++ **可用性权衡**：由于 `torch.compile()` 能够在遇到无法追踪的内容时回退到 Python 运行时，因此它更加灵活。相反，`torch.export` 将要求用户提供更多信息或重写他们的代码以使其可追踪。 -与[`torch.fx.symbolic_trace()`](fx.html#torch.fx.symbolic_trace "torch.fx.symbolic_trace")相比，`torch.export`使用TorchDynamo进行跟踪，它在Python字节码级别操作，使其能够跟踪任意Python构造，不受Python运算符重载支持的限制。此外，`torch.export`精细跟踪张量元数据，因此对于像张量形状这样的条件语句不会导致跟踪失败。总的来说，预计`torch.export`能够处理更多用户程序，并生成更低级别的图（在`torch.ops.aten`运算符级别）。请注意，用户仍然可以在`torch.export`之前使用[`torch.fx.symbolic_trace()`](fx.html#torch.fx.symbolic_trace "torch.fx.symbolic_trace")作为预处理步骤。 +与`torch.fx.symbolic_trace()`相比，`torch.export`使用 TorchDynamo 进行跟踪，它在 Python 字节码级别操作，使其能够跟踪任意 Python 构造，不受 Python 运算符重载支持的限制。此外，`torch.export`精细跟踪张量元数据，因此对于像张量形状这样的条件语句不会导致跟踪失败。总的来说，预计`torch.export`能够处理更多用户程序，并生成更低级别的图（在`torch.ops.aten`运算符级别）。请注意，用户仍然可以在`torch.export`之前使用`torch.fx.symbolic_trace()`作为预处理步骤。 -与[`torch.jit.script()`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")相比，`torch.export`不捕获Python控制流或数据结构，但支持比TorchScript更多的Python语言特性（因为更容易对Python字节码进行全面覆盖）。生成的图更简单，只有直线控制流（除了显式控制流操作）。 +与`torch.jit.script()`相比，`torch.export`不捕获 Python 控制流或数据结构，但支持比 TorchScript 更多的 Python 语言特性（因为更容易对 Python 字节码进行全面覆盖）。生成的图更简单，只有直线控制流（除了显式控制流操作）。 -与[`torch.jit.trace()`](generated/torch.jit.trace.html#torch.jit.trace "torch.jit.trace")相比，`torch.export`是可靠的：它能够跟踪对大小进行整数计算的代码，并记录所有必要的副条件，以表明特定跟踪对其他输入是有效的。 +与`torch.jit.trace()`相比，`torch.export`是可靠的：它能够跟踪对大小进行整数计算的代码，并记录所有必要的副条件，以表明特定跟踪对其他输入是有效的。 -## 导出PyTorch模型 +## 导出 PyTorch 模型 ### 一个例子 -主要入口点是通过[`torch.export.export()`](#torch.export.export "torch.export.export")，它接受一个可调用对象（[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")、函数或方法）和示例输入，并将计算图捕获到一个[`torch.export.ExportedProgram`](#torch.export.ExportedProgram "torch.export.ExportedProgram")中。一个例子： +主要入口点是通过`torch.export.export()`，它接受一个可调用对象（`torch.nn.Module`、函数或方法）和示例输入，并将计算图捕获到一个`torch.export.ExportedProgram`中。一个例子： ```py import torch @@ -167,19 +167,19 @@ ExportedProgram: 检查`ExportedProgram`，我们可以注意到以下内容： -+ [`torch.fx.Graph`](fx.html#torch.fx.Graph "torch.fx.Graph")包含原始程序的计算图，以及原始代码的记录，便于调试。 ++ `torch.fx.Graph`包含原始程序的计算图，以及原始代码的记录，便于调试。 -+ 图中只包含在[Core ATen IR](torch.compiler_ir.html#torch-compiler-ir) opset中找到的`torch.ops.aten`运算符和自定义运算符，是完全功能的，没有任何像`torch.add_`这样的原位运算符。 ++ 图中只包含在 Core ATen IR opset 中找到的`torch.ops.aten`运算符和自定义运算符，是完全功能的，没有任何像`torch.add_`这样的原位运算符。 -+ 参数（权重和卷积偏置）被提升为图的输入，导致图中没有`get_attr`节点，这在[`torch.fx.symbolic_trace()`](fx.html#torch.fx.symbolic_trace "torch.fx.symbolic_trace")的结果中以前存在。 ++ 参数（权重和卷积偏置）被提升为图的输入，导致图中没有`get_attr`节点，这在`torch.fx.symbolic_trace()`的结果中以前存在。 -+ [`torch.export.ExportGraphSignature`](#torch.export.ExportGraphSignature "torch.export.ExportGraphSignature")模型化了输入和输出签名，并指定了哪些输入是参数。 ++ `torch.export.ExportGraphSignature`模型化了输入和输出签名，并指定了哪些输入是参数。 + 图中每个节点产生的张量的形状和数据类型都有记录。例如，`卷积`节点将产生一个数据类型为`torch.float32`，形状为（1, 16, 256, 256）的张量。 ### 表达动态性 -默认情况下，`torch.export`将跟踪程序，假设所有输入形状都是**静态**的，并将导出的程序专门化到这些维度。然而，一些维度，如批处理维度，可以是动态的，并且在每次运行时会有所变化。这些维度必须通过使用[`torch.export.Dim()`](#torch.export.Dim "torch.export.Dim") API来指定，并通过将它们传递给[`torch.export.export()`](#torch.export.export "torch.export.export")的`dynamic_shapes`参数来创建它们。例如： +默认情况下，`torch.export`将跟踪程序，假设所有输入形状都是**静态**的，并将导出的程序专门化到这些维度。然而，一些维度，如批处理维度，可以是动态的，并且在每次运行时会有所变化。这些维度必须通过使用`torch.export.Dim()` API 来指定，并通过将它们传递给`torch.export.export()`的`dynamic_shapes`参数来创建它们。例如： ```py import torch @@ -261,17 +261,17 @@ ExportedProgram: 一些额外需要注意的事项： -+ 通过[`torch.export.Dim()`](#torch.export.Dim "torch.export.Dim") API和`dynamic_shapes`参数，我们指定了每个输入的第一个维度为动态。查看输入`arg5_1`和`arg6_1`，它们具有符号形状（s0，64）和（s0，128），而不是我们传入的示例输入的形状为（32，64）和（32，128）的张量。`s0`是一个表示这个维度可以是一系列值的符号。 ++ 通过`torch.export.Dim()` API 和`dynamic_shapes`参数，我们指定了每个输入的第一个维度为动态。查看输入`arg5_1`和`arg6_1`，它们具有符号形状（s0，64）和（s0，128），而不是我们传入的示例输入的形状为（32，64）和（32，128）的张量。`s0`是一个表示这个维度可以是一系列值的符号。 -+ `exported_program.range_constraints`描述了图中每个符号的范围。在这种情况下，我们看到`s0`的范围为[2，inf]。由于在这里很难解释的技术原因，它们被假定不是0或1。这不是一个错误，并不一定意味着导出的程序不适用于维度0或1。请参阅[0/1专门化问题](https://docs.google.com/document/d/16VPOa3d-Liikf48teAOmxLc92rgvJdfosIy-yoT38Io/edit?fbclid=IwAR3HNwmmexcitV0pbZm_x1a4ykdXZ9th_eJWK-3hBtVgKnrkmemz6Pm5jRQ#heading=h.ez923tomjvyk)以深入讨论这个主题。 ++ `exported_program.range_constraints`描述了图中每个符号的范围。在这种情况下，我们看到`s0`的范围为[2，inf]。由于在这里很难解释的技术原因，它们被假定不是 0 或 1。这不是一个错误，并不一定意味着导出的程序不适用于维度 0 或 1。请参阅[0/1 专门化问题](https://docs.google.com/document/d/16VPOa3d-Liikf48teAOmxLc92rgvJdfosIy-yoT38Io/edit?fbclid=IwAR3HNwmmexcitV0pbZm_x1a4ykdXZ9th_eJWK-3hBtVgKnrkmemz6Pm5jRQ#heading=h.ez923tomjvyk)以深入讨论这个主题。 -+ `exported_program.equality_constraints`描述了哪些维度需要相等。由于我们在约束中指定了每个参数的第一个维度是等价的（`dynamic_dim(example_args[0], 0) == dynamic_dim(example_args[1], 0)`），我们在等式约束中看到了指定`arg5_1`维度0和`arg6_1`维度0相等的元组。 ++ `exported_program.equality_constraints`描述了哪些维度需要相等。由于我们在约束中指定了每个参数的第一个维度是等价的（`dynamic_dim(example_args[0], 0) == dynamic_dim(example_args[1], 0)`），我们在等式约束中看到了指定`arg5_1`维度 0 和`arg6_1`维度 0 相等的元组。 -（一种用于指定动态形状的传统机制涉及使用[`torch.export.dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")API标记和约束动态维度，并通过`constraints`参数将它们传递给[`torch.export.export()`](#torch.export.export "torch.export.export")。该机制现在已经**弃用**，并且将来不会得到支持。） +（一种用于指定动态形状的传统机制涉及使用`torch.export.dynamic_dim()`API 标记和约束动态维度，并通过`constraints`参数将它们传递给`torch.export.export()`。该机制现在已经**弃用**，并且将来不会得到支持。） ### 序列化 -为了保存`ExportedProgram`，用户可以使用[`torch.export.save()`](#torch.export.save "torch.export.save")和[`torch.export.load()`](#torch.export.load "torch.export.load")API。一个惯例是使用`.pt2`文件扩展名保存`ExportedProgram`。 +为了保存`ExportedProgram`，用户可以使用`torch.export.save()`和`torch.export.load()`API。一个惯例是使用`.pt2`文件扩展名保存`ExportedProgram`。 一个例子： @@ -293,7 +293,7 @@ saved_exported_program = torch.export.load('exported_program.pt2') #### 输入形状 -如前所述，默认情况下，`torch.export`将跟踪程序，专门化输入张量的形状，除非通过[`torch.export.dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")API指定了一个维度为动态。这意味着如果存在形状相关的控制流，`torch.export`将专门化采取给定示例输入的分支。例如： +如前所述，默认情况下，`torch.export`将跟踪程序，专门化输入张量的形状，除非通过`torch.export.dynamic_dim()`API 指定了一个维度为动态。这意味着如果存在形状相关的控制流，`torch.export`将专门化采取给定示例输入的分支。例如： ```py import torch @@ -318,7 +318,7 @@ ExportedProgram: return (add,) ``` -（`x.shape[0] > 5`）的条件不会出现在`ExportedProgram`中，因为示例输入具有静态形状（10，2）。由于`torch.export`专门针对输入的静态形状，否则分支（`x - 1`）永远不会被执行。为了保留基于张量形状的动态分支行为，需要使用[`torch.export.dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")来指定输入张量（`x.shape[0]`）的维度为动态，并且源代码需要被[重写](#data-shape-dependent-control-flow)。 +（`x.shape[0] > 5`）的条件不会出现在`ExportedProgram`中，因为示例输入具有静态形状（10，2）。由于`torch.export`专门针对输入的静态形状，否则分支（`x - 1`）永远不会被执行。为了保留基于张量形状的动态分支行为，需要使用`torch.export.dynamic_dim()`来指定输入张量（`x.shape[0]`）的维度为动态，并且源代码需要被重写。 #### 非张量输入 @@ -350,103 +350,103 @@ ExportedProgram: return (add_2,) ``` -由于整数是专门化的，`torch.ops.aten.add.Tensor`操作都是使用内联常量`1`计算的，而不是`arg1_1`。此外，在`for`循环中使用的`times`迭代器也通过3个重复的`torch.ops.aten.add.Tensor`调用“内联”在图中，并且输入`arg2_1`从未被使用。 +由于整数是专门化的，`torch.ops.aten.add.Tensor`操作都是使用内联常量`1`计算的，而不是`arg1_1`。此外，在`for`循环中使用的`times`迭代器也通过 3 个重复的`torch.ops.aten.add.Tensor`调用“内联”在图中，并且输入`arg2_1`从未被使用。 ## torch.export[](#limitations-of-torch-export "此标题的永久链接")的限制 ### 图中断 -由于`torch.export`是从PyTorch程序中捕获计算图的一次性过程，因此最终可能会遇到程序的无法追踪部分，因为几乎不可能支持追踪所有PyTorch和Python功能。在`torch.compile`的情况下，不支持的操作将导致“图中断”，并且不支持的操作将使用默认的Python评估运行。相比之下，`torch.export`将要求用户提供额外信息或重写部分代码以使其可追踪。由于追踪基于TorchDynamo，在Python字节码级别进行评估，相比以前的追踪框架，需要进行的重写将大大减少。 +由于`torch.export`是从 PyTorch 程序中捕获计算图的一次性过程，因此最终可能会遇到程序的无法追踪部分，因为几乎不可能支持追踪所有 PyTorch 和 Python 功能。在`torch.compile`的情况下，不支持的操作将导致“图中断”，并且不支持的操作将使用默认的 Python 评估运行。相比之下，`torch.export`将要求用户提供额外信息或重写部分代码以使其可追踪。由于追踪基于 TorchDynamo，在 Python 字节码级别进行评估，相比以前的追踪框架，需要进行的重写将大大减少。 -当遇到图形中断时，[ExportDB](generated/exportdb/index.html#torch-export-db)是一个很好的资源，可以了解支持和不支持的程序类型，以及重写程序使其可追踪的方法。 +当遇到图形中断时，ExportDB 是一个很好的资源，可以了解支持和不支持的程序类型，以及重写程序使其可追踪的方法。 ### 数据/形状相关的控制流[](#data-shape-dependent-control-flow "跳转到此标题") -当遇到数据相关的控制流（`if x.shape[0] > 2`）时，也可能出现图形中断，因为在没有专门化形状的情况下，追踪编译器无法处理生成代码的组合爆炸路径。在这种情况下，用户需要使用特殊的控制流操作符重写他们的代码。目前，我们支持[torch.cond](cond.html#cond)来表达类似if-else的控制流（更多功能即将推出！）。 +当遇到数据相关的控制流（`if x.shape[0] > 2`）时，也可能出现图形中断，因为在没有专门化形状的情况下，追踪编译器无法处理生成代码的组合爆炸路径。在这种情况下，用户需要使用特殊的控制流操作符重写他们的代码。目前，我们支持 torch.cond 来表达类似 if-else 的控制流（更多功能即将推出！）。 ### 操作符缺失的元内核[](#missing-meta-kernels-for-operators "跳转到此标题") -在追踪时，所有操作符都需要一个META实现（或“元内核”）来推断该操作符的输入/输出形状。 +在追踪时，所有操作符都需要一个 META 实现（或“元内核”）来推断该操作符的输入/输出形状。 -要为C++自定义操作符注册一个元内核，请参考[此文档](https://docs.google.com/document/d/1_W62p8WJOQQUzPsJYa7s701JXt0qf2OfLub2sbkHOaU/edit#heading=h.ahugy69p2jmz)。 +要为 C++自定义操作符注册一个元内核，请参考[此文档](https://docs.google.com/document/d/1_W62p8WJOQQUzPsJYa7s701JXt0qf2OfLub2sbkHOaU/edit#heading=h.ahugy69p2jmz)。 -目前正在开发用于在Python中实现自定义操作符的自定义元内核的官方API。在最终API得到完善之前，您可以参考[此文档](https://docs.google.com/document/d/1GgvOe7C8_NVOMLOCwDaYV1mXXyHMXY7ExoewHqooxrs/edit#heading=h.64r4npvq0w0)。 +目前正在开发用于在 Python 中实现自定义操作符的自定义元内核的官方 API。在最终 API 得到完善之前，您可以参考[此文档](https://docs.google.com/document/d/1GgvOe7C8_NVOMLOCwDaYV1mXXyHMXY7ExoewHqooxrs/edit#heading=h.64r4npvq0w0)。 -如果您的模型使用了尚未具有元内核实现的ATen操作符，请提交问题。 +如果您的模型使用了尚未具有元内核实现的 ATen 操作符，请提交问题。 ## 阅读更多 -Export用户的其他链接 +Export 用户的其他链接 -+ [torch.export IR规范](export.ir_spec.html) ++ torch.export IR 规范 -+ [在ATen IR上编写图形转换](torch.compiler_transformations.html) ++ 在 ATen IR 上编写图形转换 -+ [IRs](torch.compiler_ir.html) ++ IRs -+ [ExportDB](generated/exportdb/index.html) ++ ExportDB -+ [控制流 - Cond](cond.html) ++ 控制流 - Cond -PyTorch开发者深入了解 +PyTorch 开发者深入了解 -+ [TorchDynamo深入了解](torch.compiler_deepdive.html) ++ TorchDynamo 深入了解 -+ [动态形状](torch.compiler_dynamic_shapes.html) ++ 动态形状 -+ [虚假张量](torch.compiler_fake_tensor.html) ++ 虚假张量 -## API参考 +## API 参考 ```py torch.export.export(f, args, kwargs=None, *, constraints=None, dynamic_shapes=None, strict=True, preserve_module_call_signature=())¶ ``` -[`export()`](#torch.export.export "torch.export.export")接受任意的Python可调用对象（nn.Module、函数或方法）以及示例输入，并以Ahead-of-Time（AOT）方式生成表示函数的张量计算的追踪图，随后可以使用不同的输入或序列化执行。追踪图（1）生成功能性ATen操作符集中的标准化操作符（以及任何用户指定的自定义操作符），（2）消除了所有Python控制流和数据结构（某些例外情况除外），（3）记录了为了证明这种标准化和控制流消除对未来输入是有效的所需的形状约束集。 +`export()`接受任意的 Python 可调用对象（nn.Module、函数或方法）以及示例输入，并以 Ahead-of-Time（AOT）方式生成表示函数的张量计算的追踪图，随后可以使用不同的输入或序列化执行。追踪图（1）生成功能性 ATen 操作符集中的标准化操作符（以及任何用户指定的自定义操作符），（2）消除了所有 Python 控制流和数据结构（某些例外情况除外），（3）记录了为了证明这种标准化和控制流消除对未来输入是有效的所需的形状约束集。 **正确性保证** -在追踪过程中，[`export()`](#torch.export.export "torch.export.export")会注意用户程序和底层PyTorch操作符内核所做的与形状相关的假设。只有当这些假设成立时，输出的[`ExportedProgram`](#torch.export.ExportedProgram "torch.export.ExportedProgram")才被认为有效。 +在追踪过程中，`export()`会注意用户程序和底层 PyTorch 操作符内核所做的与形状相关的假设。只有当这些假设成立时，输出的`ExportedProgram`才被认为有效。 -追踪对输入张量的形状（而不是值）做出假设。这些假设必须在图捕获时验证，以便[`export()`](#torch.export.export "torch.export.export")成功。具体来说： +追踪对输入张量的形状（而不是值）做出假设。这些假设必须在图捕获时验证，以便`export()`成功。具体来说： + 对输入张量的静态形状的假设将自动验证，无需额外努力。 -+ 对输入张量的动态形状的假设需要通过使用[`Dim()`](#torch.export.Dim "torch.export.Dim") API显式指定，并通过将其与示例输入关联到`dynamic_shapes`参数中。 ++ 对输入张量的动态形状的假设需要通过使用`Dim()` API 显式指定，并通过将其与示例输入关联到`dynamic_shapes`参数中。 -如果任何假设无法验证，将引发致命错误。当发生这种情况时，错误消息将包含建议的修复，以验证假设所需的规范。例如，[`export()`](#torch.export.export "torch.export.export")可能会建议以下修复动态维度`dim0_x`的定义，例如出现在与输入`x`相关联的形状中，先前定义为`Dim("dim0_x")`： +如果任何假设无法验证，将引发致命错误。当发生这种情况时，错误消息将包含建议的修复，以验证假设所需的规范。例如，`export()`可能会建议以下修复动态维度`dim0_x`的定义，例如出现在与输入`x`相关联的形状中，先前定义为`Dim("dim0_x")`： ```py dim = Dim("dim0_x", max=5) ``` -这个示例表示生成的代码要求输入`x`的维度0小于或等于5才有效。您可以检查动态维度定义的建议修复，并将其逐字复制到您的代码中，而无需更改对[`export()`](#torch.export.export "torch.export.export")的调用中的`dynamic_shapes`参数。 +这个示例表示生成的代码要求输入`x`的维度 0 小于或等于 5 才有效。您可以检查动态维度定义的建议修复，并将其逐字复制到您的代码中，而无需更改对`export()`的调用中的`dynamic_shapes`参数。 参数 -+ **f**（[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在Python v3.12版本)")）– 要追踪的可调用函数。 ++ **f**（[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在 Python v3.12 版本)")）– 要追踪的可调用函数。 -+ **args**（[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在Python v3.12版本)")*[*[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12版本)")*,* *...**]*) – 示例位置输入。 ++ **args**（[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12 版本)")*[*[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 版本)")*,* *...**]*) – 示例位置输入。 -+ **kwargs**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12版本)")*[*[*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版本)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12版本)")*]**]*) – 可选的示例关键字输入。 ++ **kwargs**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 版本)")*[*[*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 版本)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 版本)")*]**]*) – 可选的示例关键字输入。 -+ **constraints**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12版本)")*[*[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12版本)")*[*[*Constraint*](#torch.export.Constraint "torch.export.Constraint")*]**]*) – [已弃用：请改用`dynamic_shapes`，请参见下文] 动态参数的约束条件列表，指定它们可能的形状范围。默认情况下，假定输入torch.Tensors的形状是静态的。如果预期输入torch.Tensor具有动态形状，请使用[`dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")来定义[`Constraint`](#torch.export.Constraint "torch.export.Constraint")对象，指定动态性和可能的形状范围。查看[`dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")文档字符串，了解如何使用的示例。 ++ **constraints**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 版本)")*[*[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 版本)")**[*Constraint**]**]*) – [已弃用：请改用`dynamic_shapes`，请参见下文] 动态参数的约束条件列表，指定它们可能的形状范围。默认情况下，假定输入 torch.Tensors 的形状是静态的。如果预期输入 torch.Tensor 具有动态形状，请使用`dynamic_dim()`来定义`Constraint`对象，指定动态性和可能的形状范围。查看`dynamic_dim()`文档字符串，了解如何使用的示例。 -+ **dynamic_shapes**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12版本)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12版本)")*[*[*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版本)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12版本)")*]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在Python v3.12版本)")*[*[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12版本)")*]**]**]*) – ++ **dynamic_shapes**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 版本)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 版本)")*[*[*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 版本)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 版本)")*]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12 版本)")*[*[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 版本)")*]**]**]*) – 应为：1）从`f`的参数名称到其动态形状规范的字典，2）指定原始顺序中每个输入的动态形状规范的元组。如果您在关键字参数上指定动态性，您需要按照原始函数签名中定义的顺序传递它们。 - 张量参数的动态形状可以指定为（1）从动态维度索引到[`Dim()`](#torch.export.Dim "torch.export.Dim")类型的字典，其中在此字典中不需要包含静态维度索引，但当包含时，应将其映射到None；或（2）[`Dim()`](#torch.export.Dim "torch.export.Dim")类型或None的元组/列表，其中[`Dim()`](#torch.export.Dim "torch.export.Dim")类型对应于动态维度，静态维度用None表示。通过使用包含规范的映射或序列，递归指定为字典或张量的元组/列表的参数。 + 张量参数的动态形状可以指定为（1）从动态维度索引到`Dim()`类型的字典，其中在此字典中不需要包含静态维度索引，但当包含时，应将其映射到 None；或（2）`Dim()`类型或 None 的元组/列表，其中`Dim()`类型对应于动态维度，静态维度用 None 表示。通过使用包含规范的映射或序列，递归指定为字典或张量的元组/列表的参数。 -+ **strict**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 启用时（默认），导出函数将通过TorchDynamo跟踪程序，确保生成的图的完整性。否则，导出的程序将不验证嵌入到图中的隐含假设，可能导致原始模型和导出模型之间的行为分歧。当用户需要解决跟踪器中的错误或希望逐步在其模型中启用安全性时，这是有用的。请注意，这不会影响生成的IR规范不同，无论传递什么值，模型都将以相同的方式序列化。警告：此选项是实验性的，请自行承担风险使用。 ++ **strict**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 启用时（默认），导出函数将通过 TorchDynamo 跟踪程序，确保生成的图的完整性。否则，导出的程序将不验证嵌入到图中的隐含假设，可能导致原始模型和导出模型之间的行为分歧。当用户需要解决跟踪器中的错误或希望逐步在其模型中启用安全性时，这是有用的。请注意，这不会影响生成的 IR 规范不同，无论传递什么值，模型都将以相同的方式序列化。警告：此选项是实验性的，请自行承担风险使用。 返回 -包含跟踪可调用程序的[`ExportedProgram`](#torch.export.ExportedProgram "torch.export.ExportedProgram")。 +包含跟踪可调用程序的`ExportedProgram`。 返回类型 -[*ExportedProgram*](#torch.export.ExportedProgram "torch.export.exported_program.ExportedProgram") +*ExportedProgram* **可接受的输入/输出类型** @@ -454,7 +454,7 @@ dim = Dim("dim0_x", max=5) + 原始类型，即`torch.Tensor`、`int`、`float`、`bool`和`str`。 -+ 数据类，但必须通过调用[`register_dataclass()`](#torch.export.register_dataclass "torch.export.register_dataclass")进行注册。 ++ 数据类，但必须通过调用`register_dataclass()`进行注册。 + 包含所有上述类型的`dict`、`list`、`tuple`、`namedtuple`和`OrderedDict`组成的（嵌套）数据结构。 @@ -464,21 +464,21 @@ torch.export.dynamic_dim(t, index)¶ 警告 -（此功能已弃用。请改用[`Dim()`](#torch.export.Dim "torch.export.Dim")。） +（此功能已弃用。请改用`Dim()`。） -[`dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")构造一个描述张量`t`的维度`index`的动态性的[`Constraint`](#torch.export.Constraint "torch.export.Constraint")对象。应将[`Constraint`](#torch.export.Constraint "torch.export.Constraint")对象传递给[`export()`](#torch.export.export "torch.export.export")的`constraints`参数。 +`dynamic_dim()`构造一个描述张量`t`的维度`index`的动态性的`Constraint`对象。应将`Constraint`对象传递给`export()`的`constraints`参数。 参数 -+ **t**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 具有动态维度大小的示例输入张量 ++ **t**（*torch.Tensor*） - 具有动态维度大小的示例输入张量 + **index**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 动态维度的索引 返回 -描述形状动态性的[`Constraint`](#torch.export.Constraint "torch.export.Constraint")对象。它可以传递给[`export()`](#torch.export.export "torch.export.export")，以便[`export()`](#torch.export.export "torch.export.export")不会假定指定张量的静态大小，即保持其动态作为符号大小，而不是根据示例跟踪输入的大小进行特化。 +描述形状动态性的`Constraint`对象。它可以传递给`export()`，以便`export()`不会假定指定张量的静态大小，即保持其动态作为符号大小，而不是根据示例跟踪输入的大小进行特化。 -具体来说，[`dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")可用于表示以下类型的动态性。 +具体来说，`dynamic_dim()`可用于表示以下类型的动态性。 + 维度大小是动态且无限制的： @@ -542,19 +542,19 @@ torch.export.save(ep, f, *, extra_files=None, opset_version=None)¶ 警告 -正在积极开发中，保存的文件可能无法在较新版本的PyTorch中使用。 +正在积极开发中，保存的文件可能无法在较新版本的 PyTorch 中使用。 -将[`ExportedProgram`](#torch.export.ExportedProgram "torch.export.ExportedProgram")保存到类似文件的对象中。然后可以使用Python API [`torch.export.load`](#torch.export.load "torch.export.load")加载它。 +将`ExportedProgram`保存到类似文件的对象中。然后可以使用 Python API `torch.export.load`加载它。 参数 -+ **ep** ([*ExportedProgram*](#torch.export.ExportedProgram "torch.export.ExportedProgram")) – 要保存的导出程序。 ++ **ep** (*ExportedProgram*) – 要保存的导出程序。 -+ **f** (*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*pathlib.Path*](https://docs.python.org/3/library/pathlib.html#pathlib.Path "(in Python v3.12)")*,* [*io.BytesIO*](https://docs.python.org/3/library/io.html#io.BytesIO "(in Python v3.12)")) – 类似文件的对象（必须实现write和flush）或包含文件名的字符串。 ++ **f** (*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*pathlib.Path*](https://docs.python.org/3/library/pathlib.html#pathlib.Path "(in Python v3.12)")*,* [*io.BytesIO*](https://docs.python.org/3/library/io.html#io.BytesIO "(in Python v3.12)")) – 类似文件的对象（必须实现 write 和 flush）或包含文件名的字符串。 -+ **extra_files** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]*) – 从文件名到内容的映射，这些内容将作为f的一部分存储。 ++ **extra_files** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]*) – 从文件名到内容的映射，这些内容将作为 f 的一部分存储。 -+ **opset_version** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**]*) – opset名称与此opset版本的映射 ++ **opset_version** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**]*) – opset 名称与此 opset 版本的映射 示例： @@ -586,27 +586,27 @@ torch.export.load(f, *, extra_files=None, expected_opset_version=None)¶ 警告 -正在积极开发中，保存的文件可能无法在较新版本的PyTorch中使用。 +正在积极开发中，保存的文件可能无法在较新版本的 PyTorch 中使用。 -加载以前使用[`torch.export.save`](#torch.export.save "torch.export.save")保存的[`ExportedProgram`](#torch.export.ExportedProgram "torch.export.ExportedProgram")。 +加载以前使用`torch.export.save`保存的`ExportedProgram`。 参数 -+ **ep** ([*ExportedProgram*](#torch.export.ExportedProgram "torch.export.ExportedProgram")) – 要保存的导出程序。 ++ **ep** (*ExportedProgram*) – 要保存的导出程序。 -+ **f** (*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*pathlib.Path*](https://docs.python.org/3/library/pathlib.html#pathlib.Path "(in Python v3.12)")*,* [*io.BytesIO*](https://docs.python.org/3/library/io.html#io.BytesIO "(in Python v3.12)")) – 类似文件的对象（必须实现write和flush）或包含文件名的字符串。 ++ **f** (*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*pathlib.Path*](https://docs.python.org/3/library/pathlib.html#pathlib.Path "(in Python v3.12)")*,* [*io.BytesIO*](https://docs.python.org/3/library/io.html#io.BytesIO "(in Python v3.12)")) – 类似文件的对象（必须实现 write 和 flush）或包含文件名的字符串。 + **extra_files** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]*) – 此映射中提供的额外文件名将被加载，其内容将存储在提供的映射中。 -+ **expected_opset_version** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**]*) – opset名称到预期opset版本的映射 ++ **expected_opset_version** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**]*) – opset 名称到预期 opset 版本的映射 返回 -一个[`ExportedProgram`](#torch.export.ExportedProgram "torch.export.ExportedProgram")对象 +一个`ExportedProgram`对象 返回类型 -[*ExportedProgram*](#torch.export.ExportedProgram "torch.export.exported_program.ExportedProgram") +*ExportedProgram* 示例： @@ -634,7 +634,7 @@ print(ep(torch.randn(5))) torch.export.register_dataclass(cls)¶ ``` -将数据类注册为[`torch.export.export()`](#torch.export.export "torch.export.export")的有效输入/输出类型。 +将数据类注册为`torch.export.export()`的有效输入/输出类型。 参数 @@ -666,15 +666,15 @@ print(ep) torch.export.Dim(name, *, min=None, max=None)¶ ``` -[`Dim()`](#torch.export.Dim "torch.export.Dim")构造类似于具有范围的命名符号整数的类型。它可用于描述动态张量维度的多个可能值。请注意，同一张量的不同动态维度，或不同张量的动态维度，可以由相同类型描述。 +`Dim()`构造类似于具有范围的命名符号整数的类型。它可用于描述动态张量维度的多个可能值。请注意，同一张量的不同动态维度，或不同张量的动态维度，可以由相同类型描述。 参数 + **name** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")) – 用于调试的人类可读名称。 -+ **min** (*可选**[*[*整数*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")*]*) – 给定符号的最小可能值（包括） ++ **min** (*可选**[*[*整数*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*]*) – 给定符号的最小可能值（包括） -+ **max** (*可选**[*[*整数*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")*]*) – 给定符号的最大可能值（包括） ++ **max** (*可选**[*[*整数*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*]*) – 给定符号的最大可能值（包括） 返回 @@ -684,7 +684,7 @@ torch.export.Dim(name, *, min=None, max=None)¶ torch.export.dims(*names, min=None, max=None)¶ ``` -用于创建多个[`Dim()`](#torch.export.Dim "torch.export.Dim")类型的工具。 +用于创建多个`Dim()`类型的工具。 ```py class torch.export.Constraint(*args, **kwargs)¶ @@ -692,7 +692,7 @@ class torch.export.Constraint(*args, **kwargs)¶ 警告 -不要直接构造[`Constraint`](#torch.export.Constraint "torch.export.Constraint")，而是使用[`dynamic_dim()`](#torch.export.dynamic_dim "torch.export.dynamic_dim")。 +不要直接构造`Constraint`，而是使用`dynamic_dim()`。 这代表了对输入张量维度的约束，例如，要求它们是完全多态的或在某个范围内。 @@ -700,21 +700,21 @@ class torch.export.Constraint(*args, **kwargs)¶ 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.export.export "torch.export.export")导出的程序的包。它包含一个表示张量计算的torch.fx.Graph，一个包含所有提升参数和缓冲区的张量值的state_dict，以及各种元数据。 +从`export()`导出的程序的包。它包含一个表示张量计算的 torch.fx.Graph，一个包含所有提升参数和缓冲区的张量值的 state_dict，以及各种元数据。 -您可以像使用[`export()`](#torch.export.export "torch.export.export")跟踪的原始可调用对象一样调用ExportedProgram，使用相同的调用约定。 +您可以像使用`export()`跟踪的原始可调用对象一样调用 ExportedProgram，使用相同的调用约定。 -要对图进行转换，请使用`.module`属性来访问[`torch.fx.GraphModule`](fx.html#torch.fx.GraphModule "torch.fx.GraphModule")。然后，您可以使用[FX转换](https://pytorch.org/docs/stable/fx.html#writing-transformations)来重写图。之后，您可以简单地再次使用[`export()`](#torch.export.export "torch.export.export")来构建一个正确的ExportedProgram。 +要对图进行转换，请使用`.module`属性来访问`torch.fx.GraphModule`。然后，您可以使用[FX 转换](https://pytorch.org/docs/stable/fx.html#writing-transformations)来重写图。之后，您可以简单地再次使用`export()`来构建一个正确的 ExportedProgram。 ```py module(*, flat=True)¶ ``` -返回一个包含所有参数/缓冲区的自包含GraphModule。 +返回一个包含所有参数/缓冲区的自包含 GraphModule。 返回类型 -[*模块*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module") +*模块* ```py buffers()¶ @@ -724,11 +724,11 @@ buffers()¶ 警告 -这个API是实验性的，*不*向后兼容。 +这个 API 是实验性的，*不*向后兼容。 返回类型 -[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在Python v3.12中)")[[*张量*](tensors.html#torch.Tensor "torch.Tensor")] +[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在 Python v3.12 中)")[*张量*] ```py named_buffers()¶ @@ -738,11 +738,11 @@ named_buffers()¶ 警告 -这个API是实验性的，*不*向后兼容。 +这个 API 是实验性的，*不*向后兼容。 返回类型 -[*迭代器*](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中)"), [*张量*](tensors.html#torch.Tensor "torch.Tensor")]] +[*迭代器*](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()¶ @@ -752,11 +752,11 @@ parameters()¶ 警告 -这个API是实验性的，*不*向后兼容。 +这个 API 是实验性的，*不*向后兼容。 返回类型 -[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在Python v3.12中)")[[*参数*](generated/torch.nn.parameter.Parameter.html#torch.nn.parameter.Parameter "torch.nn.parameter.Parameter")] +[*迭代器*](https://docs.python.org/3/library/typing.html#typing.Iterator "(在 Python v3.12 中)")[*参数*] ```py named_parameters()¶ @@ -766,11 +766,11 @@ named_parameters()¶ 警告 -这个API是实验性的，*不*向后兼容。 +这个 API 是实验性的，*不*向后兼容。 返回类型 -[*迭代器*](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中)"), [*参数*](generated/torch.nn.parameter.Parameter.html#torch.nn.parameter.Parameter "torch.nn.parameter.Parameter")]] +[*迭代器*](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)¶ @@ -780,9 +780,9 @@ class torch.export.ExportBackwardSignature(gradients_to_parameters: Dict[str, st class torch.export.ExportGraphSignature(input_specs, output_specs)¶ ``` -[`ExportGraphSignature`](#torch.export.ExportGraphSignature "torch.export.ExportGraphSignature") 模型化导出图的输入/输出签名，这是一个具有更强不变性保证的fx.Graph。 +`ExportGraphSignature` 模型化导出图的输入/输出签名，这是一个具有更强不变性保证的 fx.Graph。 -导出图是功能性的，不会通过`getattr`节点访问图中的“状态”（如参数或缓冲区）。相反，[`export()`](#torch.export.export "torch.export.export")保证参数、缓冲区和常量张量被提取出图形作为输入。同样，对缓冲区的任何突变也不包括在图中，而是将突变缓冲区的更新值建模为导出图的附加输出。 +导出图是功能性的，不会通过`getattr`节点访问图中的“状态”（如参数或缓冲区）。相反，`export()`保证参数、缓冲区和常量张量被提取出图形作为输入。同样，对缓冲区的任何突变也不包括在图中，而是将突变缓冲区的更新值建模为导出图的附加输出。 所有输入和输出的顺序是： @@ -824,15 +824,15 @@ graph(): %arg2_1 := placeholder[target=arg2_1] %arg3_1 := placeholder[target=arg3_1] %arg4_1 := placeholder[target=arg4_1] - %add_tensor := call_function[target=torch.ops.aten.add.Tensor](args = (%arg3_1, %arg0_1), kwargs = {}) - %mul_tensor := call_function[target=torch.ops.aten.mul.Tensor](args = (%add_tensor, %arg1_1), kwargs = {}) - %mul_tensor_1 := call_function[target=torch.ops.aten.mul.Tensor](args = (%arg4_1, %arg2_1), kwargs = {}) - %add_tensor_1 := call_function[target=torch.ops.aten.add.Tensor](args = (%mul_tensor, %mul_tensor_1), kwargs = {}) - %add_tensor_2 := call_function[target=torch.ops.aten.add.Tensor](args = (%arg2_1, 1.0), kwargs = {}) + %add_tensor := call_functiontarget=torch.ops.aten.add.Tensor, kwargs = {}) + %mul_tensor := call_functiontarget=torch.ops.aten.mul.Tensor, kwargs = {}) + %mul_tensor_1 := call_functiontarget=torch.ops.aten.mul.Tensor, kwargs = {}) + %add_tensor_1 := call_functiontarget=torch.ops.aten.add.Tensor, kwargs = {}) + %add_tensor_2 := call_functiontarget=torch.ops.aten.add.Tensor, kwargs = {}) return (add_tensor_2, add_tensor_1) ``` -生成的ExportGraphSignature将是： +生成的 ExportGraphSignature 将是： ```py ExportGraphSignature( @@ -882,7 +882,7 @@ class torch.export.graph_signature.OutputSpec(kind: torch.export.graph_signature class torch.export.graph_signature.ExportGraphSignature(input_specs, output_specs)¶ ``` -[`ExportGraphSignature`](#torch.export.graph_signature.ExportGraphSignature "torch.export.graph_signature.ExportGraphSignature")模拟了导出图的输入/输出签名，这是一个具有更强不变性保证的fx.Graph。 +`ExportGraphSignature`模拟了导出图的输入/输出签名，这是一个具有更强不变性保证的 fx.Graph。 导出图是功能性的，不会通过`getattr`节点访问图中的“状态”（如参数或缓冲区）。相反，`export()`保证参数、缓冲区和常量张量被提取出图形作为输入。同样，对缓冲区的任何突变也不包括在图中，而是将突变缓冲区的更新值建模为导出图的附加输出。 @@ -926,15 +926,15 @@ graph(): %arg2_1 := placeholder[target=arg2_1] %arg3_1 := placeholder[target=arg3_1] %arg4_1 := placeholder[target=arg4_1] - %add_tensor := call_function[target=torch.ops.aten.add.Tensor](args = (%arg3_1, %arg0_1), kwargs = {}) - %mul_tensor := call_function[target=torch.ops.aten.mul.Tensor](args = (%add_tensor, %arg1_1), kwargs = {}) - %mul_tensor_1 := call_function[target=torch.ops.aten.mul.Tensor](args = (%arg4_1, %arg2_1), kwargs = {}) - %add_tensor_1 := call_function[target=torch.ops.aten.add.Tensor](args = (%mul_tensor, %mul_tensor_1), kwargs = {}) - %add_tensor_2 := call_function[target=torch.ops.aten.add.Tensor](args = (%arg2_1, 1.0), kwargs = {}) + %add_tensor := call_functiontarget=torch.ops.aten.add.Tensor, kwargs = {}) + %mul_tensor := call_functiontarget=torch.ops.aten.mul.Tensor, kwargs = {}) + %mul_tensor_1 := call_functiontarget=torch.ops.aten.mul.Tensor, kwargs = {}) + %add_tensor_1 := call_functiontarget=torch.ops.aten.add.Tensor, kwargs = {}) + %add_tensor_2 := call_functiontarget=torch.ops.aten.add.Tensor, kwargs = {}) return (add_tensor_2, add_tensor_1) ``` -生成的ExportGraphSignature将是： +生成的 ExportGraphSignature 将是： ```py ExportGraphSignature( diff --git a/totrans/doc22_046.md b/totrans/doc22_046.md index 63a6fea8..54a70b59 100644 --- a/totrans/doc22_046.md +++ b/totrans/doc22_046.md @@ -1,14 +1,14 @@ # 分布式通信包 - torch.distributed -> 原文：[https://pytorch.org/docs/stable/distributed.html](https://pytorch.org/docs/stable/distributed.html) +> 原文：[`pytorch.org/docs/stable/distributed.html`](https://pytorch.org/docs/stable/distributed.html) 注意 -请参考[PyTorch分布式概述](https://pytorch.org/tutorials/beginner/dist_overview.html)以了解与分布式训练相关的所有功能的简要介绍。 +请参考[PyTorch 分布式概述](https://pytorch.org/tutorials/beginner/dist_overview.html)以了解与分布式训练相关的所有功能的简要介绍。 ## 后端 -`torch.distributed`支持三种内置后端，每种具有不同的功能。下表显示了哪些函数可用于CPU / CUDA张量。如果用于构建PyTorch的实现支持，MPI仅支持CUDA。 +`torch.distributed`支持三种内置后端，每种具有不同的功能。下表显示了哪些函数可用于 CPU / CUDA 张量。如果用于构建 PyTorch 的实现支持，MPI 仅支持 CUDA。 | 后端 | `gloo` | `mpi` | `nccl` | | --- | --- | --- | --- | @@ -26,19 +26,19 @@ | all_to_all | ✘ | ✘ | ✓ | ? | ✘ | ✓ | | barrier | ✓ | ✘ | ✓ | ? | ✘ | ✓ | -### PyTorch附带的后端[](#backends-that-come-with-pytorch "跳转到此标题") +### PyTorch 附带的后端[](#backends-that-come-with-pytorch "跳转到此标题") -PyTorch分布式包支持Linux（稳定）、MacOS（稳定）和Windows（原型）。默认情况下，对于Linux，Gloo和NCCL后端已构建并包含在PyTorch分布式中（仅在使用CUDA构建时才包括NCCL）。MPI是一个可选的后端，只有在从源代码构建PyTorch时才能包含（例如，在安装了MPI的主机上构建PyTorch）。 +PyTorch 分布式包支持 Linux（稳定）、MacOS（稳定）和 Windows（原型）。默认情况下，对于 Linux，Gloo 和 NCCL 后端已构建并包含在 PyTorch 分布式中（仅在使用 CUDA 构建时才包括 NCCL）。MPI 是一个可选的后端，只有在从源代码构建 PyTorch 时才能包含（例如，在安装了 MPI 的主机上构建 PyTorch）。 注意 -截至PyTorch v1.8，Windows支持所有集体通信后端，但不支持NCCL，如果[`init_process_group()`](#torch.distributed.init_process_group "torch.distributed.init_process_group")的init_method参数指向文件，则必须遵循以下模式： +截至 PyTorch v1.8，Windows 支持所有集体通信后端，但不支持 NCCL，如果`init_process_group()`的 init_method 参数指向文件，则必须遵循以下模式： + 本地文件系统，`init_method="file:///d:/tmp/some_file"` + 共享文件系统，`init_method="file://////{machine_name}/{share_folder_name}/some_file"` -与Linux平台相同，您可以通过设置环境变量MASTER_ADDR和MASTER_PORT来启用TcpStore。 +与 Linux 平台相同，您可以通过设置环境变量 MASTER_ADDR 和 MASTER_PORT 来启用 TcpStore。 ### 应该使用哪个后端？ @@ -46,61 +46,61 @@ PyTorch分布式包支持Linux（稳定）、MacOS（稳定）和Windows（原 + 经验法则 - + 使用NCCL后端进行分布式**GPU**训练 + + 使用 NCCL 后端进行分布式**GPU**训练 - + 使用Gloo后端进行分布式**CPU**训练。 + + 使用 Gloo 后端进行分布式**CPU**训练。 -+ 具有InfiniBand互连的GPU主机 ++ 具有 InfiniBand 互连的 GPU 主机 - + 使用NCCL，因为它是目前唯一支持InfiniBand和GPUDirect的后端。 + + 使用 NCCL，因为它是目前唯一支持 InfiniBand 和 GPUDirect 的后端。 -+ 具有以太网互连的GPU主机 ++ 具有以太网互连的 GPU 主机 - + 使用NCCL，因为它目前提供了最佳的分布式GPU训练性能，特别适用于多进程单节点或多节点分布式训练。如果遇到任何NCCL问题，请使用Gloo作为备选方案。（请注意，目前Gloo在GPU上运行速度比NCCL慢。） + + 使用 NCCL，因为它目前提供了最佳的分布式 GPU 训练性能，特别适用于多进程单节点或多节点分布式训练。如果遇到任何 NCCL 问题，请使用 Gloo 作为备选方案。（请注意，目前 Gloo 在 GPU 上运行速度比 NCCL 慢。） -+ 具有InfiniBand互连的CPU主机 ++ 具有 InfiniBand 互连的 CPU 主机 - + 如果您的InfiniBand启用了IP over IB，请使用Gloo，否则请使用MPI。我们计划在即将发布的版本中为Gloo添加InfiniBand支持。 + + 如果您的 InfiniBand 启用了 IP over IB，请使用 Gloo，否则请使用 MPI。我们计划在即将发布的版本中为 Gloo 添加 InfiniBand 支持。 -+ 具有以太网互连的CPU主机 ++ 具有以太网互连的 CPU 主机 - + 除非有特定原因要使用MPI，否则请使用Gloo。 + + 除非有特定原因要使用 MPI，否则请使用 Gloo。 ### 常见环境变量[](#common-environment-variables "跳转到此标题") #### 选择要使用的网络接口[](#choosing-the-network-interface-to-use "跳转到此标题") -默认情况下，NCCL和Gloo后端都会尝试找到正确的网络接口。如果自动检测到的接口不正确，您可以使用以下环境变量覆盖它（适用于相应的后端）： +默认情况下，NCCL 和 Gloo 后端都会尝试找到正确的网络接口。如果自动检测到的接口不正确，您可以使用以下环境变量覆盖它（适用于相应的后端）： + **NCCL_SOCKET_IFNAME**，例如`export NCCL_SOCKET_IFNAME=eth0` + **GLOO_SOCKET_IFNAME**，例如`export GLOO_SOCKET_IFNAME=eth0` -如果您正在使用Gloo后端，可以通过逗号分隔它们来指定多个接口，就像这样：`export GLOO_SOCKET_IFNAME=eth0,eth1,eth2,eth3`。后端将在这些接口之间以循环方式分发操作。所有进程在此变量中指定相同数量的接口是至关重要的。 +如果您正在使用 Gloo 后端，可以通过逗号分隔它们来指定多个接口，就像这样：`export GLOO_SOCKET_IFNAME=eth0,eth1,eth2,eth3`。后端将在这些接口之间以循环方式分发操作。所有进程在此变量中指定相同数量的接口是至关重要的。 -#### 其他NCCL环境变量 +#### 其他 NCCL 环境变量 -**调试** - 在NCCL失败的情况下，您可以设置`NCCL_DEBUG=INFO`来打印明确的警告消息以及基本的NCCL初始化信息。 +**调试** - 在 NCCL 失败的情况下，您可以设置`NCCL_DEBUG=INFO`来打印明确的警告消息以及基本的 NCCL 初始化信息。 -您还可以使用`NCCL_DEBUG_SUBSYS`来获取有关NCCL特定方面的更多详细信息。例如，`NCCL_DEBUG_SUBSYS=COLL`将打印集体调用的日志，这在调试挂起时可能会有所帮助，特别是由于集体类型或消息大小不匹配而引起的情况。在拓扑检测失败的情况下，设置`NCCL_DEBUG_SUBSYS=GRAPH`以检查详细的检测结果，并在需要NCCL团队进一步帮助时保存为参考是有帮助的。 +您还可以使用`NCCL_DEBUG_SUBSYS`来获取有关 NCCL 特定方面的更多详细信息。例如，`NCCL_DEBUG_SUBSYS=COLL`将打印集体调用的日志，这在调试挂起时可能会有所帮助，特别是由于集体类型或消息大小不匹配而引起的情况。在拓扑检测失败的情况下，设置`NCCL_DEBUG_SUBSYS=GRAPH`以检查详细的检测结果，并在需要 NCCL 团队进一步帮助时保存为参考是有帮助的。 -**性能调优** - NCCL根据其拓扑检测执行自动调优，以节省用户的调优工作。在某些基于套接字的系统上，用户仍可以尝试调整`NCCL_SOCKET_NTHREADS`和`NCCL_NSOCKS_PERTHREAD`以增加套接字网络带宽。这两个环境变量已经被NCCL预调整，适用于一些云服务提供商，如AWS或GCP。 +**性能调优** - NCCL 根据其拓扑检测执行自动调优，以节省用户的调优工作。在某些基于套接字的系统上，用户仍可以尝试调整`NCCL_SOCKET_NTHREADS`和`NCCL_NSOCKS_PERTHREAD`以增加套接字网络带宽。这两个环境变量已经被 NCCL 预调整，适用于一些云服务提供商，如 AWS 或 GCP。 -有关NCCL环境变量的完整列表，请参考[NVIDIA NCCL官方文档](https://docs.nvidia.com/deeplearning/sdk/nccl-developer-guide/docs/env.html) +有关 NCCL 环境变量的完整列表，请参考[NVIDIA NCCL 官方文档](https://docs.nvidia.com/deeplearning/sdk/nccl-developer-guide/docs/env.html) 基础知识 -torch.distributed包提供了PyTorch支持和通信原语，用于在一个或多个机器上运行的多进程并行计算节点之间的支持。类[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")基于此功能构建，以提供同步分布式训练作为任何PyTorch模型的包装器。这与[Multiprocessing package - torch.multiprocessing](multiprocessing.html)和[`torch.nn.DataParallel()`](generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel")提供的并行方式不同，它支持多个网络连接的机器，并且用户必须显式启动主训练脚本的每个进程的单独副本。 +torch.distributed 包提供了 PyTorch 支持和通信原语，用于在一个或多个机器上运行的多进程并行计算节点之间的支持。类`torch.nn.parallel.DistributedDataParallel()`基于此功能构建，以提供同步分布式训练作为任何 PyTorch 模型的包装器。这与 Multiprocessing package - torch.multiprocessing 和`torch.nn.DataParallel()`提供的并行方式不同，它支持多个网络连接的机器，并且用户必须显式启动主训练脚本的每个进程的单独副本。 -在单机同步情况下，torch.distributed或[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")包装器可能仍然比其他数据并行方法具有优势，包括[`torch.nn.DataParallel()`](generated/torch.nn.DataParallel.html#torch.nn.DataParallel "torch.nn.DataParallel")： +在单机同步情况下，torch.distributed 或`torch.nn.parallel.DistributedDataParallel()`包装器可能仍然比其他数据并行方法具有优势，包括`torch.nn.DataParallel()`： + 每个进程维护自己的优化器，并在每次迭代中执行完整的优化步骤。虽然这可能看起来是多余的，因为梯度已经被收集并在进程之间平均化，因此对于每个进程来说是相同的，但这意味着不需要参数广播步骤，减少了在节点之间传输张量所花费的时间。 -+ 每个进程包含一个独立的Python解释器，消除了从单个Python进程驱动多个执行线程、模型副本或GPU时产生的额外解释器开销和“GIL-thrashing”。这对于大量使用Python运行时的模型特别重要，包括具有循环层或许多小组件的模型。 ++ 每个进程包含一个独立的 Python 解释器，消除了从单个 Python 进程驱动多个执行线程、模型副本或 GPU 时产生的额外解释器开销和“GIL-thrashing”。这对于大量使用 Python 运行时的模型特别重要，包括具有循环层或许多小组件的模型。 ## 初始化 -在调用任何其他方法之前，需要使用[`torch.distributed.init_process_group()`](#torch.distributed.init_process_group "torch.distributed.init_process_group")或[`torch.distributed.device_mesh.init_device_mesh()`](#torch.distributed.device_mesh.init_device_mesh "torch.distributed.device_mesh.init_device_mesh")函数初始化包。两者都会阻塞，直到所有进程都加入。 +在调用任何其他方法之前，需要使用`torch.distributed.init_process_group()`或`torch.distributed.device_mesh.init_device_mesh()`函数初始化包。两者都会阻塞，直到所有进程都加入。 ```py torch.distributed.is_available()¶ @@ -108,7 +108,7 @@ torch.distributed.is_available()¶ 如果分布式包可用，则返回`True`。 -否则，`torch.distributed`不公开任何其他API。目前，`torch.distributed`在Linux、MacOS和Windows上可用。在构建PyTorch时，设置`USE_DISTRIBUTED=1`以启用它。目前，默认值为Linux和Windows为`USE_DISTRIBUTED=1`，MacOS为`USE_DISTRIBUTED=0`。 +否则，`torch.distributed`不公开任何其他 API。目前，`torch.distributed`在 Linux、MacOS 和 Windows 上可用。在构建 PyTorch 时，设置`USE_DISTRIBUTED=1`以启用它。目前，默认值为 Linux 和 Windows 为`USE_DISTRIBUTED=1`，MacOS 为`USE_DISTRIBUTED=0`。 返回类型 @@ -126,67 +126,67 @@ torch.distributed.init_process_group(backend=None, init_method=None, timeout=Non 1. 明确指定`store`、`rank`和`world_size`。 -1. 指定`init_method`（一个URL字符串），指示在哪里/如何发现对等体。可选地指定`rank`和`world_size`，或在URL中编码所有必需的参数并省略它们。 +1. 指定`init_method`（一个 URL 字符串），指示在哪里/如何发现对等体。可选地指定`rank`和`world_size`，或在 URL 中编码所有必需的参数并省略它们。 如果没有指定，则假定`init_method`为“env://”。 参数 -+ **backend**（*str*或*Backend*，可选） - 要使用的后端。根据构建时的配置，有效值包括`mpi`、`gloo`、`nccl`和`ucc`。如果未提供后端，则将创建`gloo`和`nccl`后端，有关如何管理多个后端的说明，请参见下面的注释。此字段可以作为小写字符串（例如，`"gloo"`）给出，也可以通过[`Backend`](#torch.distributed.Backend "torch.distributed.Backend")属性（例如，`Backend.GLOO`）访问。如果使用`nccl`后端的每个机器上的多个进程，每个进程必须独占使用它使用的每个GPU，因为在进程之间共享GPU可能导致死锁。`ucc`后端是实验性的。 ++ **backend**（*str*或*Backend*，可选） - 要使用的后端。根据构建时的配置，有效值包括`mpi`、`gloo`、`nccl`和`ucc`。如果未提供后端，则将创建`gloo`和`nccl`后端，有关如何管理多个后端的说明，请参见下面的注释。此字段可以作为小写字符串（例如，`"gloo"`）给出，也可以通过`Backend`属性（例如，`Backend.GLOO`）访问。如果使用`nccl`后端的每个机器上的多个进程，每个进程必须独占使用它使用的每个 GPU，因为在进程之间共享 GPU 可能导致死锁。`ucc`后端是实验性的。 -+ **init_method**（*str*，可选） - 指定如何初始化进程组的URL。如果未指定`init_method`或`store`，则默认为“env://”。与`store`互斥。 ++ **init_method**（*str*，可选） - 指定如何初始化进程组的 URL。如果未指定`init_method`或`store`，则默认为“env://”。与`store`互斥。 + **world_size**（*int*，可选） - 参与作业的进程数。如果指定了`store`，则需要。 -+ **rank**（*int*，可选） - 当前进程的等级（应为0到`world_size`-1之间的数字）。如果指定了`store`，则需要。 ++ **rank**（*int*，可选） - 当前进程的等级（应为 0 到`world_size`-1 之间的数字）。如果指定了`store`，则需要。 + **store**（*Store*，可选） - 所有工作进程都可以访问的键/值存储，用于交换连接/地址信息。与`init_method`互斥。 -+ **timeout**（*timedelta*，可选） - 对执行的操作的超时时间。NCCL的默认值为10分钟，其他后端为30分钟。这是在此持续时间后异步中止集合，并且进程将崩溃。这是因为CUDA执行是异步的，不再安全继续执行用户代码，因为失败的异步NCCL操作可能导致后续CUDA操作在损坏的数据上运行。当设置TORCH_NCCL_BLOCKING_WAIT时，进程将阻塞并等待此超时。 ++ **timeout**（*timedelta*，可选） - 对执行的操作的超时时间。NCCL 的默认值为 10 分钟，其他后端为 30 分钟。这是在此持续时间后异步中止集合，并且进程将崩溃。这是因为 CUDA 执行是异步的，不再安全继续执行用户代码，因为失败的异步 NCCL 操作可能导致后续 CUDA 操作在损坏的数据上运行。当设置 TORCH_NCCL_BLOCKING_WAIT 时，进程将阻塞并等待此超时。 + **group_name**（*str*，可选，已弃用） - 组名。此参数将被忽略 -+ **pg_options**（*ProcessGroupOptions**,* *可选*） - 指定在构建特定进程组时需要传递的其他选项的进程组选项。目前，我们支持的唯一选项是`ProcessGroupNCCL.Options`用于`nccl`后端，可以指定`is_high_priority_stream`，以便nccl后端可以在有计算内核等待时选择高优先级的cuda流。 ++ **pg_options**（*ProcessGroupOptions**,* *可选*） - 指定在构建特定进程组时需要传递的其他选项的进程组选项。目前，我们支持的唯一选项是`ProcessGroupNCCL.Options`用于`nccl`后端，可以指定`is_high_priority_stream`，以便 nccl 后端可以在有计算内核等待时选择高优先级的 cuda 流。 注意 -要启用`backend == Backend.MPI`，PyTorch需要在支持MPI的系统上从源代码构建。 +要启用`backend == Backend.MPI`，PyTorch 需要在支持 MPI 的系统上从源代码构建。 注意 -支持多个后端是实验性的。当前，当未指定后端时，将创建`gloo`和`nccl`后端。`gloo`后端将用于CPU张量的集合，`nccl`后端将用于CUDA张量的集合。可以通过传入格式为“:,:”的字符串来指定自定义后端，例如“cpu:gloo,cuda:custom_backend”。 +支持多个后端是实验性的。当前，当未指定后端时，将创建`gloo`和`nccl`后端。`gloo`后端将用于 CPU 张量的集合，`nccl`后端将用于 CUDA 张量的集合。可以通过传入格式为“:,:”的字符串来指定自定义后端，例如“cpu:gloo,cuda:custom_backend”。 ```py torch.distributed.device_mesh.init_device_mesh(device_type, mesh_shape, *, mesh_dim_names=None)¶ ``` -根据device_type、mesh_shape和mesh_dim_names参数初始化一个DeviceMesh。 +根据 device_type、mesh_shape 和 mesh_dim_names 参数初始化一个 DeviceMesh。 -这将创建一个具有n维数组布局的DeviceMesh，其中n是mesh_shape的长度。如果提供了mesh_dim_names，则每个维度都标记为mesh_dim_names[i]。 +这将创建一个具有 n 维数组布局的 DeviceMesh，其中 n 是 mesh_shape 的长度。如果提供了 mesh_dim_names，则每个维度都标记为 mesh_dim_names[i]。 注意 -init_device_mesh遵循SPMD编程模型，这意味着相同的PyTorch Python程序在集群中的所有进程/排名上运行。确保mesh_shape（描述设备布局的nD数组的维度）在所有排名上都是相同的。不一致的mesh_shape可能导致挂起。 +init_device_mesh 遵循 SPMD 编程模型，这意味着相同的 PyTorch Python 程序在集群中的所有进程/排名上运行。确保 mesh_shape（描述设备布局的 nD 数组的维度）在所有排名上都是相同的。不一致的 mesh_shape 可能导致挂起。 注意 -如果未找到任何进程组，则init_device_mesh将在幕后初始化分布式通信所需的分布式进程组/组。 +如果未找到任何进程组，则 init_device_mesh 将在幕后初始化分布式通信所需的分布式进程组/组。 参数 -+ **device_type**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 网格的设备类型。目前支持："cpu"、"cuda/cuda-like"。 ++ **device_type**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 网格的设备类型。目前支持："cpu"、"cuda/cuda-like"。 -+ **mesh_shape**（*Tuple**[*[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")*]*) - 一个定义描述设备布局的多维数组的维度的元组。 ++ **mesh_shape**（*Tuple**[*[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*]*) - 一个定义描述设备布局的多维数组的维度的元组。 -+ **mesh_dim_names**（*Tuple**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]**,* *可选*） - 一个元组，包含要分配给描述设备布局的多维数组的每个维度的网格维度名称。其长度必须与mesh_shape的长度相匹配。mesh_dim_names中的每个字符串必须是唯一的。 ++ **mesh_dim_names**（*Tuple**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]**,* *可选*） - 一个元组，包含要分配给描述设备布局的多维数组的每个维度的网格维度名称。其长度必须与 mesh_shape 的长度相匹配。mesh_dim_names 中的每个字符串必须是唯一的。 返回 -一个[`DeviceMesh`](#torch.distributed.device_mesh.DeviceMesh "torch.distributed.device_mesh.DeviceMesh")对象，表示设备布局。 +一个`DeviceMesh`对象，表示设备布局。 返回类型 -[DeviceMesh](#torch.distributed.device_mesh.DeviceMesh "torch.distributed.device_mesh.DeviceMesh") +DeviceMesh 示例:: @@ -205,57 +205,57 @@ torch.distributed.is_initialized()¶ 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py torch.distributed.is_mpi_available()¶ ``` -检查MPI后端是否可用。 +检查 MPI 后端是否可用。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py torch.distributed.is_nccl_available()¶ ``` -检查NCCL后端是否可用。 +检查 NCCL 后端是否可用。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py torch.distributed.is_gloo_available()¶ ``` -检查Gloo后端是否可用。 +检查 Gloo 后端是否可用。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py torch.distributed.is_torchelastic_launched()¶ ``` -检查此进程是否是使用`torch.distributed.elastic`（又名torchelastic）启动的。 +检查此进程是否是使用`torch.distributed.elastic`（又名 torchelastic）启动的。 -`TORCHELASTIC_RUN_ID`环境变量的存在用作代理，以确定当前进程是否是使用torchelastic启动的。这是一个合理的代理，因为`TORCHELASTIC_RUN_ID`映射到总会是非空值的会合id，指示对等发现目的的作业id。 +`TORCHELASTIC_RUN_ID`环境变量的存在用作代理，以确定当前进程是否是使用 torchelastic 启动的。这是一个合理的代理，因为`TORCHELASTIC_RUN_ID`映射到总会是非空值的会合 id，指示对等发现目的的作业 id。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") * * * 目前支持三种初始化方法： -### TCP初始化 +### TCP 初始化 -有两种使用TCP进行初始化的方法，都需要一个所有进程都可以访问的网络地址和一个期望的`world_size`。第一种方法需要指定属于rank 0进程的地址。这种初始化方法要求所有进程都手动指定了rank。 +有两种使用 TCP 进行初始化的方法，都需要一个所有进程都可以访问的网络地址和一个期望的`world_size`。第一种方法需要指定属于 rank 0 进程的地址。这种初始化方法要求所有进程都手动指定了 rank。 请注意，在最新的分布式包中不再支持多播地址。`group_name`也已被弃用。 @@ -269,13 +269,13 @@ dist.init_process_group(backend, init_method='tcp://10.1.1.20:23456', ### 共享文件系统初始化 -另一种初始化方法利用了一个共享的文件系统，该文件系统对所有机器可见，并且具有所需的`world_size`。URL应以`file://`开头，并包含指向共享文件系统上不存在文件（在现有目录中）的路径。文件系统初始化将自动创建该文件（如果不存在），但不会删除该文件。因此，在下次在相同文件路径/名称上调用`init_process_group()`之前，您有责任确保清理文件。 +另一种初始化方法利用了一个共享的文件系统，该文件系统对所有机器可见，并且具有所需的`world_size`。URL 应以`file://`开头，并包含指向共享文件系统上不存在文件（在现有目录中）的路径。文件系统初始化将自动创建该文件（如果不存在），但不会删除该文件。因此，在下次在相同文件路径/名称上调用`init_process_group()`之前，您有责任确保清理文件。 -请注意，在最新的分布式包中不再支持自动分配rank，`group_name`也已被弃用。 +请注意，在最新的分布式包中不再支持自动分配 rank，`group_name`也已被弃用。 警告 -这种方法假定文件系统支持使用`fcntl`进行锁定 - 大多数本地系统和NFS都支持它。 +这种方法假定文件系统支持使用`fcntl`进行锁定 - 大多数本地系统和 NFS 都支持它。 警告 @@ -293,15 +293,15 @@ dist.init_process_group(backend, init_method='file:///mnt/nfs/sharedfile', 这种方法将从环境变量中读取配置，允许完全自定义信息的获取方式。需要设置的变量包括： -+ `MASTER_PORT` - 必需；必须是rank 0机器上的空闲端口 ++ `MASTER_PORT` - 必需；必须是 rank 0 机器上的空闲端口 -+ `MASTER_ADDR` - 必需（除了rank 0）；rank 0节点的地址 ++ `MASTER_ADDR` - 必需（除了 rank 0）；rank 0 节点的地址 + `WORLD_SIZE` - 必需；可以在这里设置，也可以在调用初始化函数时设置 + `RANK` - 必需；可以在这里设置，也可以在调用初始化函数时设置 -rank 0的机器将用于建立所有连接。 +rank 0 的机器将用于建立所有连接。 这是默认方法，意味着不必指定`init_method`（或者可以是`env://`）。 @@ -315,7 +315,7 @@ class torch.distributed.Backend(name)¶ 用于后端的类似枚举的类。 -可用的后端：GLOO、NCCL、UCC、MPI和其他已注册的后端。 +可用的后端：GLOO、NCCL、UCC、MPI 和其他已注册的后端。 此类的值是小写字符串，例如`"gloo"`。它们可以作为属性访问，例如`Backend.NCCL`。 @@ -341,7 +341,7 @@ classmethod register_backend(name, func, extended_api=False, devices=None)¶ + **extended_api**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *可选*）- 后端是否支持扩展参数结构。默认值：`False`。如果设置为`True`，后端将获得一个`c10d::DistributedBackendOptions`实例，以及由后端实现定义的进程组选项对象。 -+ **device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* [*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)") *of* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *可选*）- 此后端支持的设备类型，例如“cpu”，“cuda”等。如果为None，则假定同时支持“cpu”和“cuda”。 ++ **device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* [*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)") *of* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *可选*）- 此后端支持的设备类型，例如“cpu”，“cuda”等。如果为 None，则假定同时支持“cpu”和“cuda”。 注意 @@ -371,11 +371,11 @@ torch.distributed.get_rank(group=None)¶ 返回提供的`group`中当前进程的等级，否则默认。 -等级是分布式进程组中每个进程分配的唯一标识符。它们始终是从0到`world_size`的连续整数。 +等级是分布式进程组中每个进程分配的唯一标识符。它们始终是从 0 到`world_size`的连续整数。 参数 -**group**（*ProcessGroup**,* *可选*）- 要处理的进程组。如果为None，则将使用默认进程组。 +**group**（*ProcessGroup**,* *可选*）- 要处理的进程组。如果为 None，则将使用默认进程组。 返回 @@ -393,7 +393,7 @@ torch.distributed.get_world_size(group=None)¶ 参数 -**group**（*ProcessGroup**,* *可选*）- 要处理的进程组。如果为None，则将使用默认进程组。 +**group**（*ProcessGroup**,* *可选*）- 要处理的进程组。如果为 None，则将使用默认进程组。 返回 @@ -407,37 +407,37 @@ torch.distributed.get_world_size(group=None)¶ ## 分布式键值存储[](#distributed-key-value-store "跳转到此标题") -分布式包带有一个分布式键值存储，可用于在组中的进程之间共享信息，以及在[`torch.distributed.init_process_group()`](#torch.distributed.init_process_group "torch.distributed.init_process_group")中初始化分布式包（通过显式创建存储作为指定`init_method`的替代方法）。有3种键值存储选择：[`TCPStore`](#torch.distributed.TCPStore "torch.distributed.TCPStore")，[`FileStore`](#torch.distributed.FileStore "torch.distributed.FileStore")和[`HashStore`](#torch.distributed.HashStore "torch.distributed.HashStore")。 +分布式包带有一个分布式键值存储，可用于在组中的进程之间共享信息，以及在`torch.distributed.init_process_group()`中初始化分布式包（通过显式创建存储作为指定`init_method`的替代方法）。有 3 种键值存储选择：`TCPStore`，`FileStore`和`HashStore`。 ```py class torch.distributed.Store¶ ``` -所有存储实现的基类，例如PyTorch分布式提供的3个存储：（[`TCPStore`](#torch.distributed.TCPStore "torch.distributed.TCPStore")，[`FileStore`](#torch.distributed.FileStore "torch.distributed.FileStore")和[`HashStore`](#torch.distributed.HashStore "torch.distributed.HashStore")）。 +所有存储实现的基类，例如 PyTorch 分布式提供的 3 个存储：（`TCPStore`，`FileStore`和`HashStore`）。 ```py class torch.distributed.TCPStore¶ ``` -基于TCP的分布式键值存储实现。服务器存储保存数据，而客户端存储可以通过TCP连接到服务器存储并执行诸如`set()`（插入键值对）、`get()`（检索键值对）等操作。应始终初始化一个服务器存储，因为客户端存储将等待服务器建立连接。 +基于 TCP 的分布式键值存储实现。服务器存储保存数据，而客户端存储可以通过 TCP 连接到服务器存储并执行诸如`set()`（插入键值对）、`get()`（检索键值对）等操作。应始终初始化一个服务器存储，因为客户端存储将等待服务器建立连接。 参数 -+ **host_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 服务器存储应运行的主机名或IP地址。 ++ **host_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 服务器存储应运行的主机名或 IP 地址。 -+ **端口**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 服务器存储应监听传入请求的端口。 ++ **端口**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 服务器存储应监听传入请求的端口。 -+ **world_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")，*可选*） - 存储用户的总数（客户端数量+1为服务器）。默认值为None（None表示存储用户数量不固定）。 ++ **world_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")，*可选*） - 存储用户的总数（客户端数量+1 为服务器）。默认值为 None（None 表示存储用户数量不固定）。 -+ **is_master**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，*可选*） - 在初始化服务器存储时为True，对于客户端存储为False。默认值为False。 ++ **is_master**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，*可选*） - 在初始化服务器存储时为 True，对于客户端存储为 False。默认值为 False。 -+ **超时**（*timedelta**，*可选*） - 存储在初始化期间和诸如`get()`和`wait()`等方法中使用的超时。默认值为timedelta(seconds=300) ++ **超时**（*timedelta**，*可选*） - 存储在初始化期间和诸如`get()`和`wait()`等方法中使用的超时。默认值为 timedelta(seconds=300) -+ **wait_for_workers**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，*可选*） - 是否等待所有工作进程连接到服务器存储。仅当world_size是固定值时才适用。默认值为True。 ++ **wait_for_workers**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，*可选*） - 是否等待所有工作进程连接到服务器存储。仅当 world_size 是固定值时才适用。默认值为 True。 -+ **multi_tenant**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，*可选*） - 如果为True，则当前进程中所有具有相同主机/端口的`TCPStore`实例将使用相同的底层`TCPServer`。默认值为False。 ++ **multi_tenant**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，*可选*） - 如果为 True，则当前进程中所有具有相同主机/端口的`TCPStore`实例将使用相同的底层`TCPServer`。默认值为 False。 -+ **master_listen_fd**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")，*可选*） - 如果指定，底层的`TCPServer`将在此文件描述符上监听，该描述符必须是已绑定到`port`的套接字。在某些情况下，有助于避免端口分配竞争。默认值为None（表示服务器创建一个新套接字并尝试将其绑定到`port`）。 ++ **master_listen_fd**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")，*可选*） - 如果指定，底层的`TCPServer`将在此文件描述符上监听，该描述符必须是已绑定到`port`的套接字。在某些情况下，有助于避免端口分配竞争。默认值为 None（表示服务器创建一个新套接字并尝试将其绑定到`port`）。 示例:: @@ -477,9 +477,9 @@ class torch.distributed.FileStore¶ 参数 -+ **file_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 存储键值对的文件路径 ++ **file_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 存储键值对的文件路径 -+ **world_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")，*可选*） - 使用存储的进程总数。默认值为-1（负值表示存储用户数量不固定）。 ++ **world_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")，*可选*） - 使用存储的进程总数。默认值为-1（负值表示存储用户数量不固定）。 示例:: @@ -496,11 +496,11 @@ class torch.distributed.FileStore¶ class torch.distributed.PrefixStore¶ ``` -对任何3个键值存储（[`TCPStore`](#torch.distributed.TCPStore "torch.distributed.TCPStore")，[`FileStore`](#torch.distributed.FileStore "torch.distributed.FileStore")和[`HashStore`](#torch.distributed.HashStore "torch.distributed.HashStore")）的包装，将前缀添加到插入存储的每个键。 +对任何 3 个键值存储（`TCPStore`，`FileStore`和`HashStore`）的包装，将前缀添加到插入存储的每个键。 参数 -+ **前缀**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 在插入存储之前添加到每个键的前缀字符串。 ++ **前缀**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 在插入存储之前添加到每个键的前缀字符串。 + **store**（*torch.distributed.store*） - 形成底层键值存储的存储对象。 @@ -512,9 +512,9 @@ torch.distributed.Store.set(self: torch._C._distributed_c10d.Store, arg0: str, a 参数 -+ **key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 要添加到存储中的键。 ++ **key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 要添加到存储中的键。 -+ **value** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 要添加到存储中的与`key`关联的值。 ++ **value** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 要添加到存储中的与`key`关联的值。 示例:: @@ -535,7 +535,7 @@ torch.distributed.Store.get(self: torch._C._distributed_c10d.Store, arg0: str) 参数 -**key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 函数将返回与此键关联的值。 +**key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 函数将返回与此键关联的值。 返回 @@ -560,9 +560,9 @@ torch.distributed.Store.add(self: torch._C._distributed_c10d.Store, arg0: str, a 参数 -+ **key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 将增加计数器的存储中的键。 ++ **key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 将增加计数器的存储中的键。 -+ **amount** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) - 计数器将增加的数量。 ++ **amount** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) - 计数器将增加的数量。 示例:: @@ -585,11 +585,11 @@ torch.distributed.Store.compare_set(self: torch._C._distributed_c10d.Store, arg0 参数 -+ **key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 要在存储中检查的键。 ++ **key** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 要在存储中检查的键。 -+ **expected_value** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 在插入之前要检查与`key`关联的值。 ++ **expected_value** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 在插入之前要检查与`key`关联的值。 -+ **desired_value** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 要添加到存储中的与`key`关联的值。 ++ **desired_value** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 要添加到存储中的与`key`关联的值。 示例:: @@ -615,7 +615,7 @@ torch.distributed.Store.wait(*args, **kwargs)¶ 参数 -**keys** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")) - 等待直到它们在存储中设置的键列表。 +**keys** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")) - 等待直到它们在存储中设置的键列表。 示例:: @@ -634,7 +634,7 @@ torch.distributed.Store.wait(*args, **kwargs)¶ 参数 -+ **keys** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")) - 等待直到它们在存储中设置的键列表。 ++ **keys** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")) - 等待直到它们在存储中设置的键列表。 + **timeout** (*timedelta*) - 等待键添加到存储中的时间，然后抛出异常。 @@ -657,7 +657,7 @@ torch.distributed.Store.num_keys(self: torch._C._distributed_c10d.Store) → int 警告 -当与[`TCPStore`](#torch.distributed.TCPStore "torch.distributed.TCPStore")一起使用时，`num_keys`返回写入基础文件的键数。如果销毁存储并创建具有相同文件的另一个存储，则原始键将保留。 +当与`TCPStore`一起使用时，`num_keys`返回写入基础文件的键数。如果销毁存储并创建具有相同文件的另一个存储，则原始键将保留。 返回 @@ -679,19 +679,19 @@ torch.distributed.Store.num_keys(self: torch._C._distributed_c10d.Store) → int torch.distributed.Store.delete_key(self: torch._C._distributed_c10d.Store, arg0: str) → bool¶ ``` -从存储中删除与`key`关联的键值对。如果成功删除键，则返回true，如果未成功删除，则返回false。 +从存储中删除与`key`关联的键值对。如果成功删除键，则返回 true，如果未成功删除，则返回 false。 警告 -`delete_key` API仅由[`TCPStore`](#torch.distributed.TCPStore "torch.distributed.TCPStore")和[`HashStore`](#torch.distributed.HashStore "torch.distributed.HashStore")支持。在[`FileStore`](#torch.distributed.FileStore "torch.distributed.FileStore")中使用此API将导致异常。 +`delete_key` API 仅由`TCPStore`和`HashStore`支持。在`FileStore`中使用此 API 将导致异常。 参数 -**key**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 要从存储中删除的键 +**key**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 要从存储中删除的键 返回 -如果成功删除`key`，则为True，否则为False。 +如果成功删除`key`，则为 True，否则为 False。 示例:: @@ -731,7 +731,7 @@ torch.distributed.Store.set_timeout(self: torch._C._distributed_c10d.Store, arg0 ## 组 -默认情况下，集体操作在默认组（也称为全局组）上运行，并要求所有进程进入分布式函数调用。但是，某些工作负载可以从更精细的通信中受益。这就是分布式组发挥作用的地方。[`new_group()`](#torch.distributed.new_group "torch.distributed.new_group")函数可用于创建新组，其中包含所有进程的任意子集。它返回一个不透明的组句柄，可以作为所有集体操作的`group`参数传递（集体操作是在某些众所周知的编程模式中交换信息的分布式函数）。 +默认情况下，集体操作在默认组（也称为全局组）上运行，并要求所有进程进入分布式函数调用。但是，某些工作负载可以从更精细的通信中受益。这就是分布式组发挥作用的地方。`new_group()`函数可用于创建新组，其中包含所有进程的任意子集。它返回一个不透明的组句柄，可以作为所有集体操作的`group`参数传递（集体操作是在某些众所周知的编程模式中交换信息的分布式函数）。 ```py torch.distributed.new_group(ranks=None, timeout=None, backend=None, pg_options=None, use_local_synchronization=False)¶ @@ -743,17 +743,17 @@ torch.distributed.new_group(ranks=None, timeout=None, backend=None, pg_options=N 警告 -同时使用具有`NCCL`后端的多个进程组是不安全的，用户应在其应用程序中执行显式同步，以确保一次只使用一个进程组。这意味着一个进程组的集体操作应在设备上完成执行（而不仅仅是入队，因为CUDA执行是异步的），然后才能入队另一个进程组的集体操作。有关更多详细信息，请参阅[同时使用多个NCCL通信器](https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/usage/communicators.html#using-multiple-nccl-communicators-concurrently)。 +同时使用具有`NCCL`后端的多个进程组是不安全的，用户应在其应用程序中执行显式同步，以确保一次只使用一个进程组。这意味着一个进程组的集体操作应在设备上完成执行（而不仅仅是入队，因为 CUDA 执行是异步的），然后才能入队另一个进程组的集体操作。有关更多详细信息，请参阅[同时使用多个 NCCL 通信器](https://docs.nvidia.com/deeplearning/nccl/user-guide/docs/usage/communicators.html#using-multiple-nccl-communicators-concurrently)。 参数 -+ **ranks**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")*[*[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")*]*) - 组成员的排名列表。如果为`None`，将设置为所有排名。默认为`None`。 ++ **ranks**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")*[*[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*]*) - 组成员的排名列表。如果为`None`，将设置为所有排名。默认为`None`。 -+ **timeout**（*timedelta**,* *可选*) - 有关详细信息和默认值，请参见init_process_group。 ++ **timeout**（*timedelta**,* *可选*) - 有关详细信息和默认值，请参见 init_process_group。 -+ **backend**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)") *或* [*Backend*](#torch.distributed.Backend "torch.distributed.Backend")*,* *可选*) - 要使用的后端。根据构建时的配置，有效值为`gloo`和`nccl`。默认情况下使用与全局组相同的后端。此字段应作为小写字符串（例如，`"gloo"`）给出，也可以通过[`Backend`](#torch.distributed.Backend "torch.distributed.Backend")属性（例如，`Backend.GLOO`）访问。如果传入`None`，将使用与默认进程组对应的后端。默认为`None`。 ++ **backend**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)") *或* *Backend**,* *可选*) - 要使用的后端。根据构建时的配置，有效值为`gloo`和`nccl`。默认情况下使用与全局组相同的后端。此字段应作为小写字符串（例如，`"gloo"`）给出，也可以通过`Backend`属性（例如，`Backend.GLOO`）访问。如果传入`None`，将使用与默认进程组对应的后端。默认为`None`。 -+ **pg_options**（*ProcessGroupOptions**,* *可选*) - 指定在构建特定进程组时需要传递的其他选项的进程组选项。例如，对于`nccl`后端，可以指定`is_high_priority_stream`，以便进程组可以选择高优先级的cuda流。 ++ **pg_options**（*ProcessGroupOptions**,* *可选*) - 指定在构建特定进程组时需要传递的其他选项的进程组选项。例如，对于`nccl`后端，可以指定`is_high_priority_stream`，以便进程组可以选择高优先级的 cuda 流。 + **use_local_synchronization** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*) - 在进程组创建结束时执行组本地屏障。这与非成员排名不需要调用 API 并且不加入屏障不同。 @@ -831,7 +831,7 @@ torch.distributed.get_process_group_ranks(group)¶ ## DeviceMesh -DeviceMesh 是一个更高级的抽象，管理进程组（或 NCCL 通信器）。它允许用户轻松创建节点间和节点内的进程组，而无需担心如何为不同的子进程组正确设置排名，并且它有助于轻松管理这些分布式进程组。[`init_device_mesh()`](#torch.distributed.device_mesh.init_device_mesh "torch.distributed.device_mesh.init_device_mesh") 函数可用于创建新的 DeviceMesh，其中包含描述设备拓扑的网格形状。 +DeviceMesh 是一个更高级的抽象，管理进程组（或 NCCL 通信器）。它允许用户轻松创建节点间和节点内的进程组，而无需担心如何为不同的子进程组正确设置排名，并且它有助于轻松管理这些分布式进程组。`init_device_mesh()` 函数可用于创建新的 DeviceMesh，其中包含描述设备拓扑的网格形状。 ```py class torch.distributed.device_mesh.DeviceMesh(device_type, mesh, *, mesh_dim_names=None, _init_process_groups=True)¶ @@ -855,13 +855,13 @@ DeviceMesh 遵循 SPMD 编程模型，这意味着相同的 PyTorch Python 程 返回值 -表示设备布局的 [`DeviceMesh`](#torch.distributed.device_mesh.DeviceMesh "torch.distributed.device_mesh.DeviceMesh") 对象。 +表示设备布局的 `DeviceMesh` 对象。 返回类型 DeviceMesh -以下程序以 SPMD 方式在每个进程/等级上运行。在这个例子中，我们有2个主机，每个主机有4个GPU。对网格的第一维进行归约将横跨列（0, 4），.. 和（3, 7），对网格的第二维进行归约将横跨行（0, 1, 2, 3）和（4, 5, 6, 7）。 +以下程序以 SPMD 方式在每个进程/等级上运行。在这个例子中，我们有 2 个主机，每个主机有 4 个 GPU。对网格的第一维进行归约将横跨列（0, 4），.. 和（3, 7），对网格的第二维进行归约将横跨行（0, 1, 2, 3）和（4, 5, 6, 7）。 示例： @@ -887,7 +887,7 @@ torch.distributed.send(tensor, dst, group=None, tag=0)¶ + **dst**（*int*）- 目标等级。目标等级不应与当前进程的等级相同。 -+ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为 None，则将使用默认进程组。 + **tag**（*int*，可选）- 用于匹配发送和接收的标签 @@ -903,7 +903,7 @@ torch.distributed.recv(tensor, src=None, group=None, tag=0)¶ + **src**（*int*，可选）- 源等级。如果未指定，则将从任何进程接收。 -+ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为 None，则将使用默认进程组。 + **tag**（*int*，可选）- 用于匹配接收和远程发送的标签 @@ -917,9 +917,9 @@ int `isend()` 和 `irecv()` 在使用时返回分布式请求对象。一般来说，这个对象的类型是未指定的，因为它们不应该手动创建，但是它们保证支持两种方法： -+ `is_completed()` - 如果操作已完成则返回True ++ `is_completed()` - 如果操作已完成则返回 True -+ `wait()` - 将阻塞进程，直到操作完成。一旦返回，`is_completed()` 保证返回True。 ++ `wait()` - 将阻塞进程，直到操作完成。一旦返回，`is_completed()` 保证返回 True。 ```py torch.distributed.isend(tensor, dst, group=None, tag=0)¶ @@ -941,13 +941,13 @@ torch.distributed.isend(tensor, dst, group=None, tag=0)¶ + **dst**（*int*）- 目标等级。 -+ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为 None，则将使用默认进程组。 + **tag**（*int*，可选）- 用于匹配发送和远程接收的标签 返回 -分布式请求对象。如果不是组的一部分，则为None +分布式请求对象。如果不是组的一部分，则为 None 返回类型 @@ -969,13 +969,13 @@ torch.distributed.irecv(tensor, src=None, group=None, tag=0)¶ + **src**（*int*，可选）- 源等级。如果未指定，则将从任何进程接收。 -+ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup*，可选）- 要操作的进程组。如果为 None，则将使用默认进程组。 + **tag**（*int*，可选）- 用于匹配接收和远程发送的标签 返回 -分布式请求对象。如果不是组的一部分，则为None +分布式请求对象。如果不是组的一部分，则为 None 返回类型 @@ -991,11 +991,11 @@ torch.distributed.batch_isend_irecv(p2p_op_list)¶ 参数 -**p2p_op_list** - 一组点对点操作（每个操作符的类型是 `torch.distributed.P2POp`）。列表中isend/irecv的顺序很重要，需要与远程端对应的isend/irecv匹配。 +**p2p_op_list** - 一组点对点操作（每个操作符的类型是 `torch.distributed.P2POp`）。列表中 isend/irecv 的顺序很重要，需要与远程端对应的 isend/irecv 匹配。 返回 -通过调用op_list中相应的op返回的分布式请求对象列表。 +通过调用 op_list 中相应的 op 返回的分布式请求对象列表。 示例 @@ -1014,9 +1014,9 @@ tensor([0, 1]) # Rank 1 注意 -请注意，当此API与NCCL PG后端一起使用时，用户必须使用torch.cuda.set_device设置当前GPU设备，否则会导致意外挂起问题。 +请注意，当此 API 与 NCCL PG 后端一起使用时，用户必须使用 torch.cuda.set_device 设置当前 GPU 设备，否则会导致意外挂起问题。 -此外，如果此API是传递给`dist.P2POp`的`group`中的第一个集合调用，则`group`的所有等级必须参与此API调用；否则，行为是未定义的。如果此API调用不是`group`中的第一个集合调用，则允许涉及`group`的部分等级的批量P2P操作。 +此外，如果此 API 是传递给`dist.P2POp`的`group`中的第一个集合调用，则`group`的所有等级必须参与此 API 调用；否则，行为是未定义的。如果此 API 调用不是`group`中的第一个集合调用，则允许涉及`group`的部分等级的批量 P2P 操作。 ```py class torch.distributed.P2POp(op, tensor, peer, group=None, tag=0)¶ @@ -1024,17 +1024,17 @@ class torch.distributed.P2POp(op, tensor, peer, group=None, tag=0)¶ 用于构建`batch_isend_irecv`的点对点操作的类。 -此类构建P2P操作类型、通信缓冲区、对等等级、进程组和标签。此类的实例将传递给`batch_isend_irecv`以进行点对点通信。 +此类构建 P2P 操作类型、通信缓冲区、对等等级、进程组和标签。此类的实例将传递给`batch_isend_irecv`以进行点对点通信。 参数 + **op**（*Callable*） - 用于向对等进程发送数据或接收数据的函数。`op`的类型可以是`torch.distributed.isend`或`torch.distributed.irecv`。 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor)） - 要发送或接收的张量。 ++ **tensor**（*Tensor*） - 要发送或接收的张量。 + **peer**（[*int*](https://docs.python.org/3/library/functions.html#int)） - 目标或源等级。 -+ **group**（*ProcessGroup**,* *可选*） - 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup**,* *可选*） - 要操作的进程组。如果为 None，则将使用默认进程组。 + **tag**（[*int*](https://docs.python.org/3/library/functions.html#int) *，* *可选*） - 用于匹配发送和接收的标签。 @@ -1042,19 +1042,19 @@ class torch.distributed.P2POp(op, tensor, peer, group=None, tag=0)¶ 每个集合操作函数支持以下两种操作，取决于传入集合的`async_op`标志的设置： -**同步操作** - 默认模式，当`async_op`设置为`False`时。当函数返回时，保证执行集合操作。对于CUDA操作，不能保证CUDA操作已完成，因为CUDA操作是异步的。对于CPU集合，任何进一步使用集合调用输出的函数调用将按预期运行。对于CUDA集合，使用相同CUDA流上的输出的函数调用将按预期运行。用户必须在在不同流下运行的情况下进行同步处理。有关CUDA语义（如流同步）的详细信息，请参阅[CUDA语义](https://pytorch.org/docs/stable/notes/cuda.html)。请查看下面的脚本，了解CPU和CUDA操作中这些语义差异的示例。 +**同步操作** - 默认模式，当`async_op`设置为`False`时。当函数返回时，保证执行集合操作。对于 CUDA 操作，不能保证 CUDA 操作已完成，因为 CUDA 操作是异步的。对于 CPU 集合，任何进一步使用集合调用输出的函数调用将按预期运行。对于 CUDA 集合，使用相同 CUDA 流上的输出的函数调用将按预期运行。用户必须在在不同流下运行的情况下进行同步处理。有关 CUDA 语义（如流同步）的详细信息，请参阅[CUDA 语义](https://pytorch.org/docs/stable/notes/cuda.html)。请查看下面的脚本，了解 CPU 和 CUDA 操作中这些语义差异的示例。 -**异步操作** - 当`async_op`设置为True时。集合操作函数返回一个分布式请求对象。通常，您不需要手动创建它，它保证支持两种方法： +**异步操作** - 当`async_op`设置为 True 时。集合操作函数返回一个分布式请求对象。通常，您不需要手动创建它，它保证支持两种方法： -+ `is_completed()` - 对于CPU集合，如果已完成，则返回`True`。对于CUDA操作，如果操作已成功排队到CUDA流并且输出可以在默认流上使用而无需进一步同步，则返回`True`。 ++ `is_completed()` - 对于 CPU 集合，如果已完成，则返回`True`。对于 CUDA 操作，如果操作已成功排队到 CUDA 流并且输出可以在默认流上使用而无需进一步同步，则返回`True`。 -+ `wait()` - 对于CPU集合，将阻塞进程直到操作完成。对于CUDA集合，将阻塞直到操作已成功排队到CUDA流并且输出可以在默认流上使用而无需进一步同步。 ++ `wait()` - 对于 CPU 集合，将阻塞进程直到操作完成。对于 CUDA 集合，将阻塞直到操作已成功排队到 CUDA 流并且输出可以在默认流上使用而无需进一步同步。 -+ `get_future()` - 返回`torch._C.Future`对象。支持NCCL，也支持GLOO和MPI上的大多数操作，除了点对点操作。注意：随着我们继续采用Futures并合并API，`get_future()`调用可能变得多余。 ++ `get_future()` - 返回`torch._C.Future`对象。支持 NCCL，也支持 GLOO 和 MPI 上的大多数操作，除了点对点操作。注意：随着我们继续采用 Futures 并合并 API，`get_future()`调用可能变得多余。 **示例** -以下代码可作为使用分布式集合时CUDA操作语义的参考。它显示了在不同CUDA流上使用集合输出时显式需要同步的需求： +以下代码可作为使用分布式集合时 CUDA 操作语义的参考。它显示了在不同 CUDA 流上使用集合输出时显式需要同步的需求： ```py # Code runs on each rank. @@ -1087,35 +1087,33 @@ torch.distributed.broadcast(tensor, src, group=None, async_op=False)¶ 参数 -+ **张量**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 如果`src`是当前进程的等级，则要发送的数据，否则要用于保存接收到的数据的张量。 - -+ **src**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 源等级。 ++ **张量**（*张量*")） - 源等级。 -+ **组**（*ProcessGroup**,* *可选*） - 要处理的进程组。如果为None，则将使用默认进程组。 ++ **组**（*ProcessGroup**,* *可选*） - 要处理的进程组。如果为 None，则将使用默认进程组。 -+ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，可选） - 此操作是否应为异步操作 ++ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，可选） - 此操作是否应为异步操作 返回 -异步工作句柄，如果async_op设置为True。如果不是async_op或不是组的一部分，则为None +异步工作句柄，如果 async_op 设置为 True。如果不是 async_op 或不是组的一部分，则为 None ```py torch.distributed.broadcast_object_list(object_list, src=0, group=None, device=None)¶ ``` -将`object_list`中的可picklable对象广播到整个组。 +将`object_list`中的可 picklable 对象广播到整个组。 -与[`broadcast()`](#torch.distributed.broadcast "torch.distributed.broadcast")类似，但可以传递Python对象。请注意，`object_list`中的所有对象必须是可picklable的，以便进行广播。 +与`broadcast()`类似，但可以传递 Python 对象。请注意，`object_list`中的所有对象必须是可 picklable 的，以便进行广播。 参数 -+ **object_list**（*List**[**Any**]*） - 要广播的输入对象列表。每个对象必须是可picklable的。只有`src`等级上的对象将被广播，但每个等级必须提供相同大小的列表。 ++ **object_list**（*List**[**Any**]*） - 要广播的输入对象列表。每个对象必须是可 picklable 的。只有`src`等级上的对象将被广播，但每个等级必须提供相同大小的列表。 -+ **src**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 要广播`object_list`的源等级。 ++ **src**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 要广播`object_list`的源等级。 -+ **组** - （ProcessGroup，可选）：要处理的进程组。如果为None，则将使用默认进程组。默认为`None`。 ++ **组** - （ProcessGroup，可选）：要处理的进程组。如果为 None，则将使用默认进程组。默认为`None`。 -+ **设备**（`torch.device`，可选） - 如果不是None，则对象将被序列化并转换为张量，然后在广播之前移动到`device`。默认为`None`。 ++ **设备**（`torch.device`，可选） - 如果不是 None，则对象将被序列化并转换为张量，然后在广播之前移动到`device`。默认为`None`。 返回 @@ -1123,19 +1121,19 @@ torch.distributed.broadcast_object_list(object_list, src=0, group=None, device=N 注意 -对于基于NCCL的进程组，对象的内部张量表示必须在通信发生之前移动到GPU设备。在这种情况下，使用的设备由`torch.cuda.current_device()`给出，用户有责任确保设置了这一点，以便每个等级都有一个独立的GPU，通过`torch.cuda.set_device()`。 +对于基于 NCCL 的进程组，对象的内部张量表示必须在通信发生之前移动到 GPU 设备。在这种情况下，使用的设备由`torch.cuda.current_device()`给出，用户有责任确保设置了这一点，以便每个等级都有一个独立的 GPU，通过`torch.cuda.set_device()`。 注意 -请注意，此API与[`all_gather()`](#torch.distributed.all_gather "torch.distributed.all_gather")集合略有不同，因为它不提供`async_op`句柄，因此将是一个阻塞调用。 +请注意，此 API 与`all_gather()`集合略有不同，因为它不提供`async_op`句柄，因此将是一个阻塞调用。 警告 -[`broadcast_object_list()`](#torch.distributed.broadcast_object_list "torch.distributed.broadcast_object_list")隐式使用`pickle`模块，这是已知不安全的。可以构造恶意pickle数据，在解pickle时执行任意代码。只能使用信任的数据调用此函数。 +`broadcast_object_list()`隐式使用`pickle`模块，这是已知不安全的。可以构造恶意 pickle 数据，在解 pickle 时执行任意代码。只能使用信任的数据调用此函数。 警告 -使用GPU张量调用[`broadcast_object_list()`](#torch.distributed.broadcast_object_list "torch.distributed.broadcast_object_list")不受良好支持且效率低下，因为它会导致GPU -> CPU传输，因为张量将被pickled。请考虑使用[`broadcast()`](#torch.distributed.broadcast "torch.distributed.broadcast")代替。 +使用 GPU 张量调用`broadcast_object_list()`不受良好支持且效率低下，因为它会导致 GPU -> CPU 传输，因为张量将被 pickled。请考虑使用`broadcast()`代替。 示例:: @@ -1166,17 +1164,11 @@ torch.distributed.all_reduce(tensor, op=, group=None, async_op 参数 -+ **张量**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 集合的输入和输出。该函数原地操作。 - -+ **op**（*可选*） - `torch.distributed.ReduceOp`枚举中的一个值。指定用于逐元素减少的操作。 - -+ **组**（*ProcessGroup**,* *可选*） - 要处理的进程组。如果为None，则将使用默认进程组。 - -+ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*）- 此操作是否应为异步操作 ++ **张量**（*张量*")*,* *可选*）- 此操作是否应为异步操作 返回 -异步工作句柄，如果async_op设置为True。如果不是async_op或不是组的一部分，则为None +异步工作句柄，如果 async_op 设置为 True。如果不是 async_op 或不是组的一部分，则为 None 示例 @@ -1216,19 +1208,19 @@ torch.distributed.reduce(tensor, dst, op=, group=None, async_o 参数 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- 集体的输入和输出。该函数原地操作。 ++ **tensor**（*Tensor*）- 集体的输入和输出。该函数原地操作。 -+ **dst**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 目标等级 ++ **dst**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- 目标等级 + **op**（*可选*）- `torch.distributed.ReduceOp`枚举中的值之一。指定用于逐元素减少的操作。 -+ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为 None，则将使用默认进程组。 -+ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*）- 此操作是否应为异步操作 ++ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*）- 此操作是否应为异步操作 返回 -异步工作句柄，如果async_op设置为True。如果不是async_op或不是组的一部分，则为None +异步工作句柄，如果 async_op 设置为 True。如果不是 async_op 或不是组的一部分，则为 None ```py torch.distributed.all_gather(tensor_list, tensor, group=None, async_op=False)¶ @@ -1240,17 +1232,17 @@ torch.distributed.all_gather(tensor_list, tensor, group=None, async_op=False)¶ 参数 -+ **tensor_list**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")*[*[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*]*)- 输出列表。它应该包含正确大小的张量，用于集体的输出。 ++ **tensor_list**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")**[*Tensor**]*)- 输出列表。它应该包含正确大小的张量，用于集体的输出。 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- 要从当前进程广播的张量。 ++ **tensor**（*Tensor*）- 要从当前进程广播的张量。 -+ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为 None，则将使用默认进程组。 -+ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*）- 此操作是否应为异步操作 ++ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*）- 此操作是否应为异步操作 返回 -异步工作句柄，如果async_op设置为True。如果不是async_op或不是组的一部分，则为None +异步工作句柄，如果 async_op 设置为 True。如果不是 async_op 或不是组的一部分，则为 None 示例 @@ -1294,17 +1286,17 @@ torch.distributed.all_gather_into_tensor(output_tensor, input_tensor, group=None 参数 -+ **output_tensor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- 输出张量，用于容纳所有等级的张量元素。它必须正确大小，以具有以下形式之一：（i）沿着主要维度连接所有输入张量；有关“连接”的定义，请参见`torch.cat()`；（ii）沿着主要维度堆叠所有输入张量；有关“堆叠”的定义，请参见`torch.stack()`。下面的示例可能更好地解释支持的输出形式。 ++ **output_tensor**（*Tensor*）- 输出张量，用于容纳所有等级的张量元素。它必须正确大小，以具有以下形式之一：（i）沿着主要维度连接所有输入张量；有关“连接”的定义，请参见`torch.cat()`；（ii）沿着主要维度堆叠所有输入张量；有关“堆叠”的定义，请参见`torch.stack()`。下面的示例可能更好地解释支持的输出形式。 -+ **input_tensor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- 要从当前等级收集的张量。与`all_gather` API中的输入张量不同，此API中的输入张量在所有等级上必须具有相同的大小。 ++ **input_tensor**（*Tensor*）- 要从当前等级收集的张量。与`all_gather` API 中的输入张量不同，此 API 中的输入张量在所有等级上必须具有相同的大小。 -+ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为 None，则将使用默认进程组。 -+ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*）- 此操作是否应为异步操作 ++ **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*）- 此操作是否应为异步操作 返回 -异步工作句柄，如果async_op设置为True。如果不是async_op或不是组的一部分，则为None +异步工作句柄，如果 async_op 设置为 True。如果不是 async_op 或不是组的一部分，则为 None 示例 @@ -1334,23 +1326,23 @@ tensor([[1, 2], 警告 -Gloo后端不支持此API。 +Gloo 后端不支持此 API。 ```py torch.distributed.all_gather_object(object_list, obj, group=None)¶ ``` -从整个组中收集可picklable对象到列表中。 +从整个组中收集可 picklable 对象到列表中。 -类似于[`all_gather()`](#torch.distributed.all_gather "torch.distributed.all_gather")，但可以传递Python对象。请注意，对象必须是可picklable的才能被收集。 +类似于`all_gather()`，但可以传递 Python 对象。请注意，对象必须是可 picklable 的才能被收集。 参数 -+ **object_list**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")*[**Any**]*)- 输出列表。它应该正确大小，作为此集体的组大小，并将包含输出。 ++ **object_list**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")*[**Any**]*)- 输出列表。它应该正确大小，作为此集体的组大小，并将包含输出。 -+ **obj**（*Any*）- 要从当前进程广播的可pickable Python对象。 ++ **obj**（*Any*）- 要从当前进程广播的可 pickable Python 对象。 -+ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为None，则将使用默认进程组。默认为`None`。 ++ **group**（*ProcessGroup**,* *可选*）- 要操作的进程组。如果为 None，则将使用默认进程组。默认为`None`。 返回 @@ -1358,7 +1350,7 @@ torch.distributed.all_gather_object(object_list, obj, group=None)¶ 注意 -请注意，此 API 与 [`all_gather()`](#torch.distributed.all_gather "torch.distributed.all_gather") 集合略有不同，因为它不提供 `async_op` 句柄，因此将是一个阻塞调用。 +请注意，此 API 与 `all_gather()` 集合略有不同，因为它不提供 `async_op` 句柄，因此将是一个阻塞调用。 注意 @@ -1366,11 +1358,11 @@ torch.distributed.all_gather_object(object_list, obj, group=None)¶ 警告 -[`all_gather_object()`](#torch.distributed.all_gather_object "torch.distributed.all_gather_object") 隐式使用 `pickle` 模块，已知存在安全问题。可能构造恶意的 pickle 数据，在反序列化时执行任意代码。只能在信任的数据上调用此函数。 +`all_gather_object()` 隐式使用 `pickle` 模块，已知存在安全问题。可能构造恶意的 pickle 数据，在反序列化时执行任意代码。只能在信任的数据上调用此函数。 警告 -使用 GPU 张量调用 [`all_gather_object()`](#torch.distributed.all_gather_object "torch.distributed.all_gather_object") 不受良好支持且效率低下，因为会导致 GPU -> CPU 传输，因为张量将被 pickled。请考虑使用 [`all_gather()`](#torch.distributed.all_gather "torch.distributed.all_gather")。 +使用 GPU 张量调用 `all_gather_object()` 不受良好支持且效率低下，因为会导致 GPU -> CPU 传输，因为张量将被 pickled。请考虑使用 `all_gather()`。 示例:: @@ -1393,9 +1385,9 @@ torch.distributed.gather(tensor, gather_list=None, dst=0, group=None, async_op=F 参数 -+ **tensor** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 输入张量。 ++ **tensor** (*Tensor*) – 输入张量。 -+ **gather_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")*[*[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*]**,* *optional*) – 用于收集数据的适当大小的张量列表（默认为 None，在目标等级上必须指定） ++ **gather_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")**[*Tensor**]**,* *optional*) – 用于收集数据的适当大小的张量列表（默认为 None，在目标等级上必须指定） + **dst** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* *optional*) – 目标等级（默认为 0） @@ -1413,7 +1405,7 @@ torch.distributed.gather_object(obj, object_gather_list=None, dst=0, group=None) 在单个进程中从整个组中收集可 pickle 的对象。 -类似于 [`gather()`](#torch.distributed.gather "torch.distributed.gather")，但可以传递 Python 对象。请注意，对象必须是可 pickle 的才能被收集。 +类似于 `gather()`，但可以传递 Python 对象。请注意，对象必须是可 pickle 的才能被收集。 参数 @@ -1439,11 +1431,11 @@ None。在 `dst` 等级上，`object_gather_list` 将包含集合的输出。 警告 -[`gather_object()`](#torch.distributed.gather_object "torch.distributed.gather_object")隐式使用`pickle`模块，这是不安全的。可能构造恶意的pickle数据，在解pickle时执行任意代码。只能使用信任的数据调用此函数。 +`gather_object()`隐式使用`pickle`模块，这是不安全的。可能构造恶意的 pickle 数据，在解 pickle 时执行任意代码。只能使用信任的数据调用此函数。 警告 -使用GPU张量调用[`gather_object()`](#torch.distributed.gather_object "torch.distributed.gather_object")不受良好支持且效率低下，因为会导致GPU -> CPU传输，因为张量将被pickled。请考虑改用[`gather()`](#torch.distributed.gather "torch.distributed.gather")。 +使用 GPU 张量调用`gather_object()`不受良好支持且效率低下，因为会导致 GPU -> CPU 传输，因为张量将被 pickled。请考虑改用`gather()`。 示例:: @@ -1475,23 +1467,23 @@ torch.distributed.scatter(tensor, scatter_list=None, src=0, group=None, async_op 参数 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输出张量。 ++ **tensor**（*Tensor*） - 输出张量。 -+ **scatter_list**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")*[*[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*]*) - 要分散的张量列表（默认为None，必须在源秩上指定） ++ **scatter_list**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")**[*Tensor**]*) - 要分散的张量列表（默认为 None，必须在源秩上指定） -+ **src**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 源秩（默认为0） ++ **src**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 源秩（默认为 0） -+ **group**（*ProcessGroup**,* *可选*） - 要处理的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup**,* *可选*） - 要处理的进程组。如果为 None，则将使用默认进程组。 + **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")，可选） - 此操作是否应为异步操作 返回 -如果async_op设置为True，则为异步工作句柄。如果不是async_op或不是组的一部分，则为None +如果 async_op 设置为 True，则为异步工作句柄。如果不是 async_op 或不是组的一部分，则为 None 注意 -请注意，scatter_list中的所有张量必须具有相同的大小。 +请注意，scatter_list 中的所有张量必须具有相同的大小。 示例:: @@ -1518,19 +1510,19 @@ tensor([5., 5.]) torch.distributed.scatter_object_list(scatter_object_output_list, scatter_object_input_list, src=0, group=None)¶ ``` -将`scatter_object_input_list`中的可picklable对象分散到整个组中。 +将`scatter_object_input_list`中的可 picklable 对象分散到整个组中。 -类似于[`scatter()`](#torch.distributed.scatter "torch.distributed.scatter")，但可以传递Python对象。在每个秩上，分散的对象将存储为`scatter_object_output_list`的第一个元素。请注意，`scatter_object_input_list`中的所有对象必须是可picklable的才能被分散。 +类似于`scatter()`，但可以传递 Python 对象。在每个秩上，分散的对象将存储为`scatter_object_output_list`的第一个元素。请注意，`scatter_object_input_list`中的所有对象必须是可 picklable 的才能被分散。 参数 + **scatter_object_output_list**（*List**[**Any**]*） - 非空列表，其第一个元素将存储分散到此秩的对象。 -+ **scatter_object_input_list**（*List**[**Any**]*） - 要分散的输入对象列表。每个对象必须是可picklable的。只有`src`秩上的对象才会被分散，对于非src秩，参数可以为`None`。 ++ **scatter_object_input_list**（*List**[**Any**]*） - 要分散的输入对象列表。每个对象必须是可 picklable 的。只有`src`秩上的对象才会被分散，对于非 src 秩，参数可以为`None`。 + **src**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 从中分散`scatter_object_input_list`的源秩。 -+ **group** - （ProcessGroup，可选）：要处理的进程组。如果为None，则将使用默认进程组。默认为`None`。 ++ **group** - （ProcessGroup，可选）：要处理的进程组。如果为 None，则将使用默认进程组。默认为`None`。 返回 @@ -1538,15 +1530,15 @@ torch.distributed.scatter_object_list(scatter_object_output_list, scatter_object 注意 -请注意，此API与scatter collective略有不同，因为它不提供`async_op`句柄，因此将是一个阻塞调用。 +请注意，此 API 与 scatter collective 略有不同，因为它不提供`async_op`句柄，因此将是一个阻塞调用。 警告 -[`scatter_object_list()`](#torch.distributed.scatter_object_list "torch.distributed.scatter_object_list")隐式使用`pickle`模块，这是不安全的。可能构造恶意的pickle数据，在解pickle时执行任意代码。只能使用信任的数据调用此函数。 +`scatter_object_list()`隐式使用`pickle`模块，这是不安全的。可能构造恶意的 pickle 数据，在解 pickle 时执行任意代码。只能使用信任的数据调用此函数。 警告 -使用GPU张量调用[`scatter_object_list()`](#torch.distributed.scatter_object_list "torch.distributed.scatter_object_list")不受良好支持且效率低下，因为会导致GPU -> CPU传输，因为张量将被pickled。请考虑改用[`scatter()`](#torch.distributed.scatter "torch.distributed.scatter")。 +使用 GPU 张量调用`scatter_object_list()`不受良好支持且效率低下，因为会导致 GPU -> CPU 传输，因为张量将被 pickled。请考虑改用`scatter()`。 示例:: @@ -1574,19 +1566,19 @@ torch.distributed.reduce_scatter(output, input_list, op=, grou 参数 -+ **输出**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输出张量。 ++ **输出**（*Tensor*） - 输出张量。 -+ **input_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")*[*[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*]*) – 要减少和分散的张量列表。 ++ **input_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")**[*Tensor**]*) – 要减少和分散的张量列表。 + **op** (*optional*) – `torch.distributed.ReduceOp`枚举中的一个值。指定用于逐元素减少的操作。 -+ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为 None，则将使用默认进程组。 + **async_op** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 此操作是否应为异步操作。 返回 -如果async_op设置为True，则为异步工作句柄。如果不是async_op或不是组的一部分，则为None。 +如果 async_op 设置为 True，则为异步工作句柄。如果不是 async_op 或不是组的一部分，则为 None。 ```py torch.distributed.reduce_scatter_tensor(output, input, op=, group=None, async_op=False)¶ @@ -1596,17 +1588,17 @@ torch.distributed.reduce_scatter_tensor(output, input, op=, gr 参数 -+ **output** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 输出张量。在所有秩上应具有相同的大小。 ++ **output** (*Tensor*) – 输出张量。在所有秩上应具有相同的大小。 -+ **input** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 要减少和分散的输入张量。其大小应为输出张量大小乘以world size。输入张量可以具有以下形状之一：(i) 沿主维度连接的输出张量，或(ii) 沿主维度堆叠的输出张量。有关“连接”的定义，请参见`torch.cat()`。有关“堆叠”的定义，请参见`torch.stack()`。 ++ **input** (*Tensor*) – 要减少和分散的输入张量。其大小应为输出张量大小乘以 world size。输入张量可以具有以下形状之一：(i) 沿主维度连接的输出张量，或(ii) 沿主维度堆叠的输出张量。有关“连接”的定义，请参见`torch.cat()`。有关“堆叠”的定义，请参见`torch.stack()`。 -+ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为 None，则将使用默认进程组。 + **async_op** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 此操作是否应为异步操作。 返回 -如果async_op设置为True，则为异步工作句柄。如果不是async_op或不是组的一部分，则为None。 +如果 async_op 设置为 True，则为异步工作句柄。如果不是 async_op 或不是组的一部分，则为 None。 示例 @@ -1639,7 +1631,7 @@ tensor([4, 6], device='cuda:1') # Rank 1 警告 -Gloo后端不支持此API。 +Gloo 后端不支持此 API。 ```py torch.distributed.all_to_all_single(output, input, output_split_sizes=None, input_split_sizes=None, group=None, async_op=False)¶ @@ -1653,25 +1645,25 @@ torch.distributed.all_to_all_single(output, input, output_split_sizes=None, inpu 参数 -+ **output** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 收集的连接输出张量。 ++ **output** (*Tensor*) – 收集的连接输出张量。 -+ **input** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 要分散的输入张量。 ++ **input** (*Tensor*) – 要分散的输入张量。 -+ **output_split_sizes** – (list[Int], optional): 如果指定为None或为空，则dim 0的`output`张量的输出分割大小必须能够被`world_size`均匀分割。 ++ **output_split_sizes** – (list[Int], optional): 如果指定为 None 或为空，则 dim 0 的`output`张量的输出分割大小必须能够被`world_size`均匀分割。 -+ **input_split_sizes** – (list[Int], optional): 如果指定为None或为空，则dim 0的`input`张量的输入分割大小必须能够被`world_size`均匀分割。 ++ **input_split_sizes** – (list[Int], optional): 如果指定为 None 或为空，则 dim 0 的`input`张量的输入分割大小必须能够被`world_size`均匀分割。 -+ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为 None，则将使用默认进程组。 + **async_op** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 此操作是否应为异步操作。 返回 -如果async_op设置为True，则为异步工作句柄。如果不是async_op或不是组的一部分，则为None。 +如果 async_op 设置为 True，则为异步工作句柄。如果不是 async_op 或不是组的一部分，则为 None。 警告 -all_to_all_single是实验性的，可能会更改。 +all_to_all_single 是实验性的，可能会更改。 示例 @@ -1752,21 +1744,21 @@ torch.distributed.all_to_all(output_tensor_list, input_tensor_list, group=None, 参数 -+ **output_tensor_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")*[*[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*]*) – 要收集的张量列表，每个秩一个。 ++ **output_tensor_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")**[*Tensor**]*) – 要收集的张量列表，每个秩一个。 -+ **input_tensor_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")*[*[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*]*) – 要分散的张量列表，每个秩一个。 ++ **input_tensor_list** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")**[*Tensor**]*) – 要分散的张量列表，每个秩一个。 -+ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group** (*ProcessGroup**,* *optional*) – 要操作的进程组。如果为 None，则将使用默认进程组。 + **async_op** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 此操作是否应为异步操作。 返回 -如果async_op设置为True，则返回异步工作句柄。如果不是async_op或者不是组的一部分，则返回None。 +如果 async_op 设置为 True，则返回异步工作句柄。如果不是 async_op 或者不是组的一部分，则返回 None。 警告 -all_to_all是实验性的，可能会发生变化。 +all_to_all 是实验性的，可能会发生变化。 示例 @@ -1850,19 +1842,19 @@ torch.distributed.barrier(group=None, async_op=False, device_ids=None)¶ 同步所有进程。 -此集合会阻塞进程，直到整个组进入此函数，如果async_op为False，或者在wait()上调用异步工作句柄。 +此集合会阻塞进程，直到整个组进入此函数，如果 async_op 为 False，或者在 wait()上调用异步工作句柄。 参数 -+ **group**（*ProcessGroup**,* *可选*） - 要操作的进程组。如果为None，则将使用默认进程组。 ++ **group**（*ProcessGroup**,* *可选*） - 要操作的进程组。如果为 None，则将使用默认进程组。 + **async_op**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *可选*） - 此操作是否应为异步操作 -+ **device_ids**（*[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**,* *可选*） - 设备/GPU id列表。 ++ **device_ids**（*[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**,* *可选*） - 设备/GPU id 列表。 返回 -如果async_op设置为True，则返回异步工作句柄。如果不是async_op或者不是组的一部分，则返回None。 +如果 async_op 设置为 True，则返回异步工作句柄。如果不是 async_op 或者不是组的一部分，则返回 None。 ```py torch.distributed.monitored_barrier(group=None, timeout=None, wait_all_ranks=False)¶ @@ -1870,13 +1862,13 @@ torch.distributed.monitored_barrier(group=None, timeout=None, wait_all_ranks=Fal 类似于`torch.distributed.barrier`的进程同步，但考虑可配置的超时时间。 -它能够报告在提供的超时时间内未通过此屏障的排名。具体来说，对于非零排名，将阻塞直到从排名0处处理了一个发送/接收操作。排名0将阻塞直到所有其他排名的发送/接收操作都被处理，并将报告未能及时响应的排名的失败。请注意，如果一个排名未达到受监控的屏障（例如由于挂起），则所有其他排名都将在受监控的屏障中失败。 +它能够报告在提供的超时时间内未通过此屏障的排名。具体来说，对于非零排名，将阻塞直到从排名 0 处处理了一个发送/接收操作。排名 0 将阻塞直到所有其他排名的发送/接收操作都被处理，并将报告未能及时响应的排名的失败。请注意，如果一个排名未达到受监控的屏障（例如由于挂起），则所有其他排名都将在受监控的屏障中失败。 此集合将阻塞组中的所有进程/排名，直到整个组成功退出函数，这对于调试和同步非常有用。但是，它可能会对性能产生影响，应仅用于调试或需要在主机端进行完全同步点的情况。出于调试目的，可以在应用程序的集合调用之前插入此屏障，以检查是否有任何排名不同步。 注意 -请注意，此集合仅在使用GLOO后端时受支持。 +请注意，此集合仅在使用 GLOO 后端时受支持。 参数 @@ -1884,7 +1876,7 @@ torch.distributed.monitored_barrier(group=None, timeout=None, wait_all_ranks=Fal + **timeout**（[*datetime.timedelta*](https://docs.python.org/3/library/datetime.html#datetime.timedelta "(in Python v3.12)")*,* *可选*） - 受监控屏障的超时时间。如果为`None`，将使用默认的进程组超时时间。 -+ **wait_all_ranks**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *可选*） - 是否收集所有失败的排名。默认情况下，此值为`False`，并且在排名0处的`monitored_barrier`会在遇到第一个失败的排名时立即抛出异常。通过设置`wait_all_ranks=True`，`monitored_barrier`将收集所有失败的排名，并抛出一个包含所有失败排名信息的错误。 ++ **wait_all_ranks**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *可选*） - 是否收集所有失败的排名。默认情况下，此值为`False`，并且在排名 0 处的`monitored_barrier`会在遇到第一个失败的排名时立即抛出异常。通过设置`wait_all_ranks=True`，`monitored_barrier`将收集所有失败的排名，并抛出一个包含所有失败排名信息的错误。 返回 @@ -1913,13 +1905,13 @@ class torch.distributed.ReduceOp¶ 在使用`NCCL`后端时，`BAND`、`BOR`和`BXOR`规约不可用。 -`AVG`在跨排名求和之前将值除以世界大小。`AVG`仅在使用`NCCL`后端时可用，并且仅适用于NCCL版本2.10或更高版本。 +`AVG`在跨排名求和之前将值除以世界大小。`AVG`仅在使用`NCCL`后端时可用，并且仅适用于 NCCL 版本 2.10 或更高版本。 -`PREMUL_SUM`在规约之前本地将输入乘以给定的标量。`PREMUL_SUM`仅在使用`NCCL`后端时可用，并且仅适用于NCCL版本2.11或更高版本。用户应该使用`torch.distributed._make_nccl_premul_sum`。 +`PREMUL_SUM`在规约之前本地将输入乘以给定的标量。`PREMUL_SUM`仅在使用`NCCL`后端时可用，并且仅适用于 NCCL 版本 2.11 或更高版本。用户应该使用`torch.distributed._make_nccl_premul_sum`。 此外，对于复杂张量，不支持`MAX`、`MIN`和`PRODUCT`。 -可以将此类的值作为属性访问，例如`ReduceOp.SUM`。它们用于指定规约集合的策略，例如[`reduce()`](#torch.distributed.reduce "torch.distributed.reduce")。 +可以将此类的值作为属性访问，例如`ReduceOp.SUM`。它们用于指定规约集合的策略，例如`reduce()`。 此类不支持`__members__`属性。 @@ -1929,11 +1921,11 @@ class torch.distributed.reduce_op¶ 已弃用的类似枚举的规约操作类：`SUM`、`PRODUCT`、`MIN`和`MAX`。 -建议使用[`ReduceOp`](#torch.distributed.ReduceOp "torch.distributed.ReduceOp")。 +建议使用`ReduceOp`。 ## 集合通信性能分析[](#profiling-collective-communication "跳转到此标题") -请注意，您可以使用`torch.profiler`（推荐，仅在1.8.1之后可用）或`torch.autograd.profiler`来分析此处提到的集合通信和点对点通信API。所有开箱即用的后端（`gloo`、`nccl`、`mpi`）都受支持，并且集合通信的使用将如预期般呈现在分析输出/跟踪中。对您的代码进行分析与任何常规torch运算符相同： +请注意，您可以使用`torch.profiler`（推荐，仅在 1.8.1 之后可用）或`torch.autograd.profiler`来分析此处提到的集合通信和点对点通信 API。所有开箱即用的后端（`gloo`、`nccl`、`mpi`）都受支持，并且集合通信的使用将如预期般呈现在分析输出/跟踪中。对您的代码进行分析与任何常规 torch 运算符相同： ```py import torch @@ -1945,19 +1937,19 @@ with torch.profiler(): 有关分析器功能的完整概述，请参阅[分析器文档](https://pytorch.org/docs/main/profiler.html)。 -## 多GPU集合功能[](#multi-gpu-collective-functions "跳转到此标题") +## 多 GPU 集合功能[](#multi-gpu-collective-functions "跳转到此标题") 警告 -多GPU功能（代表每个CPU线程多个GPU）已被弃用。截至目前，PyTorch分布式的首选编程模型是每个线程一个设备，正如本文档中的API所示。如果您是后端开发人员，并希望支持每个线程多个设备，请联系PyTorch分布式的维护人员。 +多 GPU 功能（代表每个 CPU 线程多个 GPU）已被弃用。截至目前，PyTorch 分布式的首选编程模型是每个线程一个设备，正如本文档中的 API 所示。如果您是后端开发人员，并希望支持每个线程多个设备，请联系 PyTorch 分布式的维护人员。 ## 第三方后端 -除了内置的GLOO/MPI/NCCL后端，PyTorch分布式还通过运行时注册机制支持第三方后端。有关如何通过C++扩展开发第三方后端的参考，请参阅[Tutorials - Custom C++ and CUDA Extensions](https://pytorch.org/tutorials/advanced/cpp_extension.html)和`test/cpp_extensions/cpp_c10d_extension.cpp`。第三方后端的功能由其自身的实现决定。 +除了内置的 GLOO/MPI/NCCL 后端，PyTorch 分布式还通过运行时注册机制支持第三方后端。有关如何通过 C++扩展开发第三方后端的参考，请参阅[Tutorials - Custom C++ and CUDA Extensions](https://pytorch.org/tutorials/advanced/cpp_extension.html)和`test/cpp_extensions/cpp_c10d_extension.cpp`。第三方后端的功能由其自身的实现决定。 -新后端源自`c10d::ProcessGroup`，并在导入时通过[`torch.distributed.Backend.register_backend()`](#torch.distributed.Backend.register_backend "torch.distributed.Backend.register_backend")注册后端名称和实例化接口。 +新后端源自`c10d::ProcessGroup`，并在导入时通过`torch.distributed.Backend.register_backend()`注册后端名称和实例化接口。 -当手动导入此后端并调用[`torch.distributed.init_process_group()`](#torch.distributed.init_process_group "torch.distributed.init_process_group")与相应的后端名称时，`torch.distributed`包将在新后端上运行。 +当手动导入此后端并调用`torch.distributed.init_process_group()`与相应的后端名称时，`torch.distributed`包将在新后端上运行。 警告 @@ -1965,7 +1957,7 @@ with torch.profiler(): ## 启动实用程序 -torch.distributed包还提供了一个启动实用程序在torch.distributed.launch中。此辅助实用程序可用于在分布式训练中为每个节点启动多个进程。 +torch.distributed 包还提供了一个启动实用程序在 torch.distributed.launch 中。此辅助实用程序可用于在分布式训练中为每个节点启动多个进程。 模块`torch.distributed.launch`。 @@ -1973,11 +1965,11 @@ torch.distributed包还提供了一个启动实用程序在torch.distributed.lau 警告 -该模块将被弃用，转而使用[torchrun](elastic/run.html#launcher-api)。 +该模块将被弃用，转而使用 torchrun。 -此实用程序可用于单节点分布式训练，其中每个节点将生成一个或多个进程。此实用程序可用于CPU训练或GPU训练。如果用于GPU训练，每个分布式进程将在单个GPU上运行。这可以实现良好的单节点训练性能改进。它也可以用于多节点分布式训练，通过在每个节点上生成多个进程来实现良好的多节点分布式训练性能。这对于具有多个Infiniband接口并具有直接GPU支持的系统特别有益，因为所有这些接口都可以用于聚合通信带宽。 +此实用程序可用于单节点分布式训练，其中每个节点将生成一个或多个进程。此实用程序可用于 CPU 训练或 GPU 训练。如果用于 GPU 训练，每个分布式进程将在单个 GPU 上运行。这可以实现良好的单节点训练性能改进。它也可以用于多节点分布式训练，通过在每个节点上生成多个进程来实现良好的多节点分布式训练性能。这对于具有多个 Infiniband 接口并具有直接 GPU 支持的系统特别有益，因为所有这些接口都可以用于聚合通信带宽。 -无论是单节点分布式训练还是多节点分布式训练，此实用程序将在每个节点上启动给定数量的进程（`--nproc-per-node`）。如果用于GPU训练，此数字需要小于或等于当前系统上的GPU数量（`nproc_per_node`），并且每个进程将在从*GPU 0到GPU（nproc_per_node - 1）*的单个GPU上运行。 +无论是单节点分布式训练还是多节点分布式训练，此实用程序将在每个节点上启动给定数量的进程（`--nproc-per-node`）。如果用于 GPU 训练，此数字需要小于或等于当前系统上的 GPU 数量（`nproc_per_node`），并且每个进程将在从*GPU 0 到 GPU（nproc_per_node - 1）*的单个 GPU 上运行。 **如何使用此模块：** @@ -1991,7 +1983,7 @@ python -m torch.distributed.launch --nproc-per-node=NUM_GPUS_YOU_HAVE 1. 多节点多进程分布式训练：（例如两个节点） -节点1：*(IP：192.168.1.1，并且有一个空闲端口：1234)* +节点 1：*(IP：192.168.1.1，并且有一个空闲端口：1234)* ```py python -m torch.distributed.launch --nproc-per-node=NUM_GPUS_YOU_HAVE @@ -2000,7 +1992,7 @@ python -m torch.distributed.launch --nproc-per-node=NUM_GPUS_YOU_HAVE and all other arguments of your training script) ``` -节点2: +节点 2: ```py python -m torch.distributed.launch --nproc-per-node=NUM_GPUS_YOU_HAVE @@ -2017,9 +2009,9 @@ python -m torch.distributed.launch --help **重要通知：** -1\. 此实用程序和多进程分布式（单节点或多节点）GPU训练目前仅使用NCCL分布式后端实现最佳性能。因此，NCCL后端是GPU训练的推荐后端。 +1\. 此实用程序和多进程分布式（单节点或多节点）GPU 训练目前仅使用 NCCL 分布式后端实现最佳性能。因此，NCCL 后端是 GPU 训练的推荐后端。 -2\. 在您的训练程序中，您必须解析命令行参数：`--local-rank=LOCAL_PROCESS_RANK`，这将由此模块提供。如果您的训练程序使用GPU，您应该确保您的代码仅在LOCAL_PROCESS_RANK的GPU设备上运行。可以通过以下方式实现： +2\. 在您的训练程序中，您必须解析命令行参数：`--local-rank=LOCAL_PROCESS_RANK`，这将由此模块提供。如果您的训练程序使用 GPU，您应该确保您的代码仅在 LOCAL_PROCESS_RANK 的 GPU 设备上运行。可以通过以下方式实现： 解析`local_rank`参数 @@ -2051,7 +2043,7 @@ python -m torch.distributed.launch --help >>> init_method='env://') ``` -4\. 在您的训练程序中，您可以使用常规的分布式函数或使用[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")模块。如果您的训练程序使用GPU进行训练，并且您想要使用[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")模块，以下是如何配置它的方法。 +4\. 在您的训练程序中，您可以使用常规的分布式函数或使用`torch.nn.parallel.DistributedDataParallel()`模块。如果您的训练程序使用 GPU 进行训练，并且您想要使用`torch.nn.parallel.DistributedDataParallel()`模块，以下是如何配置它的方法。 ```py >>> model = torch.nn.parallel.DistributedDataParallel(model, @@ -2059,21 +2051,21 @@ python -m torch.distributed.launch --help >>> output_device=args.local_rank) ``` -请确保`device_ids`参数设置为您的代码将在其上运行的唯一GPU设备ID。通常这是进程的本地等级。换句话说，`device_ids`需要是`[args.local_rank]`，`output_device`需要是`args.local_rank`，以便使用此实用程序。 +请确保`device_ids`参数设置为您的代码将在其上运行的唯一 GPU 设备 ID。通常这是进程的本地等级。换句话说，`device_ids`需要是`[args.local_rank]`，`output_device`需要是`args.local_rank`，以便使用此实用程序。 5\. 通过环境变量`LOCAL_RANK`将`local_rank`传递给子进程的另一种方法。当您使用`--use-env=True`启动脚本时，将启用此行为。您必须调整上面的子进程示例，将`args.local_rank`替换为`os.environ['LOCAL_RANK']`；当您指定此标志时，启动器将不会传递`--local-rank`。 警告 -`local_rank`并非全局唯一：它仅在一台机器上的每个进程中是唯一的。因此，不要使用它来决定是否应该写入网络文件系统等。请参阅[https://github.com/pytorch/pytorch/issues/12042](https://github.com/pytorch/pytorch/issues/12042)以了解如果不正确处理可能会出现问题的示例。 +`local_rank`并非全局唯一：它仅在一台机器上的每个进程中是唯一的。因此，不要使用它来决定是否应该写入网络文件系统等。请参阅[`github.com/pytorch/pytorch/issues/12042`](https://github.com/pytorch/pytorch/issues/12042)以了解如果不正确处理可能会出现问题的示例。 ## 生成实用程序 -[Multiprocessing package - torch.multiprocessing](multiprocessing.html#multiprocessing-doc)包还提供了一个在[`torch.multiprocessing.spawn()`](multiprocessing.html#module-torch.multiprocessing.spawn "torch.multiprocessing.spawn")中的`spawn`函数。这个辅助函数可以用来生成多个进程。它通过传入您想要运行的函数并生成N个进程来运行它。这也可以用于多进程分布式训练。 +Multiprocessing package - torch.multiprocessing 包还提供了一个在`torch.multiprocessing.spawn()`中的`spawn`函数。这个辅助函数可以用来生成多个进程。它通过传入您想要运行的函数并生成 N 个进程来运行它。这也可以用于多进程分布式训练。 -有关如何使用它的参考，请参阅[PyTorch示例 - ImageNet实现](https://github.com/pytorch/examples/tree/master/imagenet) +有关如何使用它的参考，请参阅[PyTorch 示例 - ImageNet 实现](https://github.com/pytorch/examples/tree/master/imagenet) -请注意，此函数要求Python 3.4或更高版本。 +请注意，此函数要求 Python 3.4 或更高版本。 ## 调试`torch.distributed`应用程序[](#debugging-torch-distributed-applications "跳转到此标题的永久链接") @@ -2081,7 +2073,7 @@ python -m torch.distributed.launch --help ### 监控屏障 -从v1.10开始，[`torch.distributed.monitored_barrier()`](#torch.distributed.monitored_barrier "torch.distributed.monitored_barrier")作为[`torch.distributed.barrier()`](#torch.distributed.barrier "torch.distributed.barrier")的替代存在，当崩溃时提供有关可能存在故障的rank的有用信息，即在规定的超时内未调用到[`torch.distributed.monitored_barrier()`](#torch.distributed.monitored_barrier "torch.distributed.monitored_barrier")的所有rank。[`torch.distributed.monitored_barrier()`](#torch.distributed.monitored_barrier "torch.distributed.monitored_barrier")使用`send`/`recv`通信原语实现主机端的屏障，类似于确认，允许rank 0报告哪些rank未能及时确认屏障。例如，考虑以下函数，其中rank 1未能调用[`torch.distributed.monitored_barrier()`](#torch.distributed.monitored_barrier "torch.distributed.monitored_barrier")（实际上，这可能是由于应用程序错误或在先前的集体操作中挂起）： +从 v1.10 开始，`torch.distributed.monitored_barrier()`作为`torch.distributed.barrier()`的替代存在，当崩溃时提供有关可能存在故障的 rank 的有用信息，即在规定的超时内未调用到`torch.distributed.monitored_barrier()`的所有 rank。`torch.distributed.monitored_barrier()`使用`send`/`recv`通信原语实现主机端的屏障，类似于确认，允许 rank 0 报告哪些 rank 未能及时确认屏障。例如，考虑以下函数，其中 rank 1 未能调用`torch.distributed.monitored_barrier()`（实际上，这可能是由于应用程序错误或在先前的集体操作中挂起）： ```py import os @@ -2104,7 +2096,7 @@ if __name__ == "__main__": mp.spawn(worker, nprocs=2, args=()) ``` -在rank 0上产生以下错误消息，允许用户确定哪个rank可能存在故障并进一步调查： +在 rank 0 上产生以下错误消息，允许用户确定哪个 rank 可能存在故障并进一步调查： ```py RuntimeError: Rank 1 failed to pass monitoredBarrier in 2000 ms @@ -2114,9 +2106,9 @@ RuntimeError: Rank 1 failed to pass monitoredBarrier in 2000 ms ### `TORCH_DISTRIBUTED_DEBUG` -使用`TORCH_CPP_LOG_LEVEL=INFO`，环境变量`TORCH_DISTRIBUTED_DEBUG`可以用来触发额外有用的日志记录和集体同步检查，以确保所有rank同步适当。`TORCH_DISTRIBUTED_DEBUG`可以设置为`OFF`（默认）、`INFO`或`DETAIL`，取决于所需的调试级别。请注意，最详细的选项`DETAIL`可能会影响应用程序性能，因此只有在调试问题时才应使用。 +使用`TORCH_CPP_LOG_LEVEL=INFO`，环境变量`TORCH_DISTRIBUTED_DEBUG`可以用来触发额外有用的日志记录和集体同步检查，以确保所有 rank 同步适当。`TORCH_DISTRIBUTED_DEBUG`可以设置为`OFF`（默认）、`INFO`或`DETAIL`，取决于所需的调试级别。请注意，最详细的选项`DETAIL`可能会影响应用程序性能，因此只有在调试问题时才应使用。 -设置`TORCH_DISTRIBUTED_DEBUG=INFO`将导致在使用[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")训练的模型初始化时产生额外的调试日志，而`TORCH_DISTRIBUTED_DEBUG=DETAIL`还将在选择的迭代次数中记录运行时性能统计信息。这些运行时统计信息包括前向时间、反向时间、梯度通信时间等。例如，考虑以下应用程序： +设置`TORCH_DISTRIBUTED_DEBUG=INFO`将导致在使用`torch.nn.parallel.DistributedDataParallel()`训练的模型初始化时产生额外的调试日志，而`TORCH_DISTRIBUTED_DEBUG=DETAIL`还将在选择的迭代次数中记录运行时性能统计信息。这些运行时统计信息包括前向时间、反向时间、梯度通信时间等。例如，考虑以下应用程序： ```py import os @@ -2209,7 +2201,7 @@ Avg backward comm. time: 2357981 Avg backward comm/comp overlap time: 2234674 ``` -此外，`TORCH_DISTRIBUTED_DEBUG=INFO` 增强了[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")中的崩溃日志记录，因为模型中存在未使用的参数。目前，如果在前向传递中可能存在未使用的参数，则必须在[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")初始化时传入 `find_unused_parameters=True`，并且从 v1.10 开始，所有模型输出都必须在损失计算中使用，因为[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")不支持在反向传递中使用未使用的参数。这些约束对于较大的模型来说是具有挑战性的，因此当出现错误时，[`torch.nn.parallel.DistributedDataParallel()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")将记录所有未使用的参数的完全限定名称。例如，在上述应用中，如果我们将 `loss` 修改为 `loss = output[1]`，那么 `TwoLinLayerNet.a` 在反向传递中将不会接收到梯度，从而导致 `DDP` 失败。在崩溃时，用户将获得有关未使用参数的信息，对于大型模型来说可能很难手动找到： +此外，`TORCH_DISTRIBUTED_DEBUG=INFO` 增强了`torch.nn.parallel.DistributedDataParallel()`中的崩溃日志记录，因为模型中存在未使用的参数。目前，如果在前向传递中可能存在未使用的参数，则必须在`torch.nn.parallel.DistributedDataParallel()`初始化时传入 `find_unused_parameters=True`，并且从 v1.10 开始，所有模型输出都必须在损失计算中使用，因为`torch.nn.parallel.DistributedDataParallel()`不支持在反向传递中使用未使用的参数。这些约束对于较大的模型来说是具有挑战性的，因此当出现错误时，`torch.nn.parallel.DistributedDataParallel()`将记录所有未使用的参数的完全限定名称。例如，在上述应用中，如果我们将 `loss` 修改为 `loss = output[1]`，那么 `TwoLinLayerNet.a` 在反向传递中将不会接收到梯度，从而导致 `DDP` 失败。在崩溃时，用户将获得有关未使用参数的信息，对于大型模型来说可能很难手动找到： ```py RuntimeError: Expected to have finished reduction in the prior iteration before starting a new one. This error indicates that your module has parameters that were not used in producing loss. You can enable unused parameter detection by passing @@ -2221,7 +2213,7 @@ Parameters which did not receive grad for rank 0: a.weight Parameter indices which did not receive grad for rank 0: 0 ``` -设置 `TORCH_DISTRIBUTED_DEBUG=DETAIL` 将触发用户发出的每个集体调用（直接或间接，如 DDP `allreduce`）上的额外一致性和同步检查。这是通过创建一个包装器进程组来实现的，该包装器进程组包装了由[`torch.distributed.init_process_group()`](#torch.distributed.init_process_group "torch.distributed.init_process_group")和[`torch.distributed.new_group()`](#torch.distributed.new_group "torch.distributed.new_group") API返回的所有进程组。因此，这些 API 将返回一个包装器进程组，可以像常规进程组一样使用，但在将集体调度到底层进程组之前执行一致性检查。目前，这些检查包括[`torch.distributed.monitored_barrier()`](#torch.distributed.monitored_barrier "torch.distributed.monitored_barrier")，它确保所有等级完成其未完成的集体调用，并报告卡住的等级。接下来，通过确保所有集体函数匹配并使用一致的张量形状来检查集体本身的一致性。如果不是这种情况，应用程序崩溃时将包括详细的错误报告，而不是挂起或无信息的错误消息。例如，考虑以下函数，其中输入形状不匹配到[`torch.distributed.all_reduce()`](#torch.distributed.all_reduce "torch.distributed.all_reduce")： +设置 `TORCH_DISTRIBUTED_DEBUG=DETAIL` 将触发用户发出的每个集体调用（直接或间接，如 DDP `allreduce`）上的额外一致性和同步检查。这是通过创建一个包装器进程组来实现的，该包装器进程组包装了由`torch.distributed.init_process_group()`和`torch.distributed.new_group()` API 返回的所有进程组。因此，这些 API 将返回一个包装器进程组，可以像常规进程组一样使用，但在将集体调度到底层进程组之前执行一致性检查。目前，这些检查包括`torch.distributed.monitored_barrier()`，它确保所有等级完成其未完成的集体调用，并报告卡住的等级。接下来，通过确保所有集体函数匹配并使用一致的张量形状来检查集体本身的一致性。如果不是这种情况，应用程序崩溃时将包括详细的错误报告，而不是挂起或无信息的错误消息。例如，考虑以下函数，其中输入形状不匹配到`torch.distributed.all_reduce()`： ```py import torch @@ -2255,11 +2247,11 @@ RuntimeError: Error when verifying shape tensors for collective ALLREDUCE on ran 为了在运行时对调试级别进行细粒度控制，还可以使用函数 `torch.distributed.set_debug_level()`、`torch.distributed.set_debug_level_from_env()` 和 `torch.distributed.get_debug_level()`。 -此外，TORCH_DISTRIBUTED_DEBUG=DETAIL可以与TORCH_SHOW_CPP_STACKTRACES=1结合使用，以在检测到集体不同步时记录整个调用堆栈。这些集体不同步检查将适用于所有使用由[`torch.distributed.init_process_group()`](#torch.distributed.init_process_group "torch.distributed.init_process_group")和[`torch.distributed.new_group()`](#torch.distributed.new_group "torch.distributed.new_group") API创建的进程组支持的`c10d`集体调用的应用程序。 +此外，TORCH_DISTRIBUTED_DEBUG=DETAIL 可以与 TORCH_SHOW_CPP_STACKTRACES=1 结合使用，以在检测到集体不同步时记录整个调用堆栈。这些集体不同步检查将适用于所有使用由`torch.distributed.init_process_group()`和`torch.distributed.new_group()` API 创建的进程组支持的`c10d`集体调用的应用程序。 ## 日志记录 -除了通过[`torch.distributed.monitored_barrier()`](#torch.distributed.monitored_barrier "torch.distributed.monitored_barrier")和`TORCH_DISTRIBUTED_DEBUG`提供显式调试支持外，`torch.distributed`的基础C++库还会在各个级别输出日志消息。这些消息有助于了解分布式训练作业的执行状态，并用于解决诸如网络连接失败等问题。以下矩阵显示了如何通过`TORCH_CPP_LOG_LEVEL`和`TORCH_DISTRIBUTED_DEBUG`环境变量的组合来调整日志级别。 +除了通过`torch.distributed.monitored_barrier()`和`TORCH_DISTRIBUTED_DEBUG`提供显式调试支持外，`torch.distributed`的基础 C++库还会在各个级别输出日志消息。这些消息有助于了解分布式训练作业的执行状态，并用于解决诸如网络连接失败等问题。以下矩阵显示了如何通过`TORCH_CPP_LOG_LEVEL`和`TORCH_DISTRIBUTED_DEBUG`环境变量的组合来调整日志级别。 | `TORCH_CPP_LOG_LEVEL` | `TORCH_DISTRIBUTED_DEBUG` | 有效日志级别 | | --- | --- | --- | @@ -2269,15 +2261,15 @@ RuntimeError: Error when verifying shape tensors for collective ALLREDUCE on ran | `INFO` | `INFO` | 调试 | | `INFO` | `DETAIL` | 跟踪（全称） | -分布式组件引发从RuntimeError派生的自定义异常类型： +分布式组件引发从 RuntimeError 派生的自定义异常类型： + torch.distributed.DistError: 这是所有分布式异常的基本类型。 -+ torch.distributed.DistBackendError: 当发生特定于后端的错误时抛出此异常。例如，如果使用NCCL后端并且用户尝试使用NCCL库不可用的GPU。 ++ torch.distributed.DistBackendError: 当发生特定于后端的错误时抛出此异常。例如，如果使用 NCCL 后端并且用户尝试使用 NCCL 库不可用的 GPU。 + torch.distributed.DistNetworkError: 当网络库遇到错误时抛出此异常（例如：对等方重置连接） -+ torch.distributed.DistStoreError: 当存储遇到错误（例如：TCPStore超时）时抛出此异常 ++ torch.distributed.DistStoreError: 当存储遇到错误（例如：TCPStore 超时）时抛出此异常 ```py class torch.distributed.DistError¶ @@ -2303,14 +2295,14 @@ class torch.distributed.DistStoreError¶ 在分布式存储中发生错误时引发异常 -如果您正在运行单节点训练，可能会方便地在脚本中交互式设置断点。我们提供了一种方便地在单个rank上设置断点的方法： +如果您正在运行单节点训练，可能会方便地在脚本中交互式设置断点。我们提供了一种方便地在单个 rank 上设置断点的方法： ```py torch.distributed.breakpoint(rank=0)¶ ``` -设置断点，但仅在单个rank上。所有其他rank将等待您完成断点后继续。这在底层调用了`breakpoint()`，因此您可以使用正常的工具进行自定义，例如，`PYTHONBREAKPOINT`环境变量。 +设置断点，但仅在单个 rank 上。所有其他 rank 将等待您完成断点后继续。这在底层调用了`breakpoint()`，因此您可以使用正常的工具进行自定义，例如，`PYTHONBREAKPOINT`环境变量。 参数 -**rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 要在其上设置断点的rank。默认值：`0` +**rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 要在其上设置断点的 rank。默认值：`0` diff --git a/totrans/doc22_047.md b/totrans/doc22_047.md index c14421aa..15646697 100644 --- a/totrans/doc22_047.md +++ b/totrans/doc22_047.md @@ -1,8 +1,8 @@ # 通用加入上下文管理器 -> 原文：[https://pytorch.org/docs/stable/distributed.algorithms.join.html](https://pytorch.org/docs/stable/distributed.algorithms.join.html) +> 原文：[`pytorch.org/docs/stable/distributed.algorithms.join.html`](https://pytorch.org/docs/stable/distributed.algorithms.join.html) -通用加入上下文管理器促进了不均匀输入的分布式训练。本页概述了相关类的API：`Join`、`Joinable`和`JoinHook`。有关教程，请参阅[使用加入上下文管理器进行不均匀输入的分布式训练](https://pytorch.org/tutorials/advanced/generic_join.html)。 +通用加入上下文管理器促进了不均匀输入的分布式训练。本页概述了相关类的 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)¶ @@ -10,19 +10,19 @@ class torch.distributed.algorithms.Join(joinables, enable=True, throw_on_early_t 此类定义了通用加入上下文管理器，允许在进程加入后调用自定义钩子。 -这些钩子应该遮蔽未加入进程的集体通信，以防止挂起和出错，并确保算法的正确性。有关钩子定义的详细信息，请参阅[`JoinHook`](#torch.distributed.algorithms.JoinHook "torch.distributed.algorithms.JoinHook")。 +这些钩子应该遮蔽未加入进程的集体通信，以防止挂起和出错，并确保算法的正确性。有关钩子定义的详细信息，请参阅`JoinHook`。 警告 -上下文管理器要求每个参与的[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")在自己的每次迭代集体通信之前调用方法[`notify_join_context()`](#torch.distributed.algorithms.Join.notify_join_context "torch.distributed.algorithms.Join.notify_join_context")以确保正确性。 +上下文管理器要求每个参与的`Joinable`在自己的每次迭代集体通信之前调用方法`notify_join_context()`以确保正确性。 警告 -上下文管理器要求[`JoinHook`](#torch.distributed.algorithms.JoinHook "torch.distributed.algorithms.JoinHook")对象中的所有`process_group`属性都相同。如果有多个[`JoinHook`](#torch.distributed.algorithms.JoinHook "torch.distributed.algorithms.JoinHook")对象，则使用第一个的`device`。进程组和设备信息用于检查未加入的进程，并通知进程在启用`throw_on_early_termination`时抛出异常，两者都使用全局归约。 +上下文管理器要求`JoinHook`对象中的所有`process_group`属性都相同。如果有多个`JoinHook`对象，则使用第一个的`device`。进程组和设备信息用于检查未加入的进程，并通知进程在启用`throw_on_early_termination`时抛出异常，两者都使用全局归约。 参数 -+ **joinables**（*List**[*[*Joinable*](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")*]*) - 参与的[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")对象的列表；它们的钩子按给定顺序迭代。 ++ **joinables**（*List***[*Joinable**]*) - 参与的`Joinable`对象的列表；它们的钩子按给定顺序迭代。 + **enable**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 一个标志，用于启用不均匀输入检测；设置为`False`会禁用上下文管理器的功能，只有在用户知道输入不会不均匀时才应设置（默认值：`True`）。 @@ -62,13 +62,13 @@ static notify_join_context(joinable)¶ 然后，如果`throw_on_early_termination=True`，则检查是否检测到不均匀的输入（即如果一个进程已经加入），如果是，则抛出异常。 -此方法应该在[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")对象的每次迭代集体通信之前调用。例如，在`DistributedDataParallel`的前向传递开始时应调用此方法。 +此方法应该在`Joinable`对象的每次迭代集体通信之前调用。例如，在`DistributedDataParallel`的前向传递开始时应调用此方法。 -只有第一个传递到上下文管理器的[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")对象在此方法中执行集体通信，对于其他对象，此方法为空。 +只有第一个传递到上下文管理器的`Joinable`对象在此方法中执行集体通信，对于其他对象，此方法为空。 参数 -**joinable**（[*Joinable*](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")） - 调用此方法的[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")对象。 +**joinable**（*Joinable*） - 调用此方法的`Joinable`对象。 返回 @@ -80,7 +80,7 @@ class torch.distributed.algorithms.Joinable¶ 这为可加入类定义了一个抽象基类。 -一个可加入的类（从[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")继承）应该实现[`join_hook()`](#torch.distributed.algorithms.Joinable.join_hook "torch.distributed.algorithms.Joinable.join_hook")，它返回一个[`JoinHook`](#torch.distributed.algorithms.JoinHook "torch.distributed.algorithms.JoinHook")实例，另外还应该实现[`join_device()`](#torch.distributed.algorithms.Joinable.join_device "torch.distributed.algorithms.Joinable.join_device")和[`join_process_group()`](#torch.distributed.algorithms.Joinable.join_process_group "torch.distributed.algorithms.Joinable.join_process_group")来分别返回设备和进程组信息。 +一个可加入的类（从`Joinable`继承）应该实现`join_hook()`，它返回一个`JoinHook`实例，另外还应该实现`join_device()`和`join_process_group()`来分别返回设备和进程组信息。 ```py abstract property join_device: device¶ @@ -92,15 +92,15 @@ abstract property join_device: device¶ abstract join_hook(**kwargs)¶ ``` -为给定的[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")返回一个[`JoinHook`](#torch.distributed.algorithms.JoinHook "torch.distributed.algorithms.JoinHook")实例。 +为给定的`Joinable`返回一个`JoinHook`实例。 参数 -**kwargs**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")） - 包含任何关键字参数以在运行时修改加入钩子行为的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")；所有共享相同加入上下文管理器的[`Joinable`](#torch.distributed.algorithms.Joinable "torch.distributed.algorithms.Joinable")实例将被转发相同的`kwargs`值。 +**kwargs**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")） - 包含任何关键字参数以在运行时修改加入钩子行为的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")；所有共享相同加入上下文管理器的`Joinable`实例将被转发相同的`kwargs`值。 返回类型 -[*JoinHook*](#torch.distributed.algorithms.JoinHook "torch.distributed.algorithms.join.JoinHook") +*JoinHook* ```py abstract property join_process_group: Any¶ @@ -116,7 +116,7 @@ class torch.distributed.algorithms.JoinHook¶ 入口点：一个主要的钩子，当存在一个未加入的进程时会被重复调用，以及一个后置钩子，当所有进程都已加入时会被调用一次。 -要为通用加入上下文管理器实现一个加入钩子，需要定义一个从[`JoinHook`](#torch.distributed.algorithms.JoinHook "torch.distributed.algorithms.JoinHook")继承的类，并适当地重写`main_hook()`和`post_hook()`。 +要为通用加入上下文管理器实现一个加入钩子，需要定义一个从`JoinHook`继承的类，并适当地重写`main_hook()`和`post_hook()`。 ```py main_hook()¶ diff --git a/totrans/doc22_048.md b/totrans/doc22_048.md index 532d48dd..3383a860 100644 --- a/totrans/doc22_048.md +++ b/totrans/doc22_048.md @@ -1,43 +1,43 @@ -# Torch分布式弹性 +# Torch 分布式弹性 -> 原文：[https://pytorch.org/docs/stable/distributed.elastic.html](https://pytorch.org/docs/stable/distributed.elastic.html) +> 原文：[`pytorch.org/docs/stable/distributed.elastic.html`](https://pytorch.org/docs/stable/distributed.elastic.html) -使分布式PyTorch具有容错性和弹性。 +使分布式 PyTorch 具有容错性和弹性。 ## 入门 用法 -+ [快速入门](elastic/quickstart.html) ++ 快速入门 -+ [训练脚本](elastic/train_script.html) ++ 训练脚本 -+ [示例](elastic/examples.html) ++ 示例 ## 文档 API -+ [torchrun（弹性启动）](elastic/run.html) ++ torchrun（弹性启动） -+ [弹性代理](elastic/agent.html) ++ 弹性代理 -+ [多进程](elastic/multiprocessing.html) ++ 多进程 -+ [错误传播](elastic/errors.html) ++ 错误传播 -+ [会合](elastic/rendezvous.html) ++ 会合 -+ [过期计时器](elastic/timer.html) ++ 过期计时器 -+ [指标](elastic/metrics.html) ++ 指标 -+ [事件](elastic/events.html) ++ 事件 高级 -+ [定制](elastic/customization.html) ++ 定制 插件 -+ [TorchElastic Kubernetes](elastic/kubernetes.html) ++ TorchElastic Kubernetes diff --git a/totrans/doc22_049.md b/totrans/doc22_049.md index a40e3ff2..9ac081c6 100644 --- a/totrans/doc22_049.md +++ b/totrans/doc22_049.md @@ -1,6 +1,6 @@ # FullyShardedDataParallel -> 原文：[https://pytorch.org/docs/stable/fsdp.html](https://pytorch.org/docs/stable/fsdp.html) +> 原文：[`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)¶ @@ -8,7 +8,7 @@ class torch.distributed.fsdp.FullyShardedDataParallel(module, process_group=None 用于在数据并行工作者之间分片模块参数的包装器。 -这受到[Xu等人](https://arxiv.org/abs/2004.13336)以及[DeepSpeed](https://www.deepspeed.ai/)的ZeRO阶段3的启发。FullyShardedDataParallel通常缩写为FSDP。 +这受到[Xu 等人](https://arxiv.org/abs/2004.13336)以及[DeepSpeed](https://www.deepspeed.ai/)的 ZeRO 阶段 3 的启发。FullyShardedDataParallel 通常缩写为 FSDP。 示例： @@ -26,15 +26,15 @@ class torch.distributed.fsdp.FullyShardedDataParallel(module, process_group=None 警告 -优化器必须在模块被FSDP包装之后初始化，因为FSDP将以一种可能不保留原始参数变量的方式对模块的参数进行分片和转换。因此，先前初始化的优化器可能会对参数有过时的引用。 +优化器必须在模块被 FSDP 包装之后初始化，因为 FSDP 将以一种可能不保留原始参数变量的方式对模块的参数进行分片和转换。因此，先前初始化的优化器可能会对参数有过时的引用。 警告 -如果目标CUDA设备的ID为`dev_id`，则（1）`module`应该已经放置在该设备上，（2）可以使用`torch.cuda.set_device(dev_id)`设置设备，或者（3）应该将`dev_id`传递给`device_id`构造函数参数。此FSDP实例的计算设备将是该目标设备。对于（1）和（3），FSDP初始化始终在GPU上进行。对于（2），FSDP初始化发生在`module`当前的设备上，可能是CPU。 +如果目标 CUDA 设备的 ID 为`dev_id`，则（1）`module`应该已经放置在该设备上，（2）可以使用`torch.cuda.set_device(dev_id)`设置设备，或者（3）应该将`dev_id`传递给`device_id`构造函数参数。此 FSDP 实例的计算设备将是该目标设备。对于（1）和（3），FSDP 初始化始终在 GPU 上进行。对于（2），FSDP 初始化发生在`module`当前的设备上，可能是 CPU。 警告 -在使用CPU卸载时，FSDP当前不支持在`no_sync()`之外支持梯度累积。尝试这样做会产生不正确的结果，因为FSDP将使用新减少的梯度而不是与任何现有梯度累积。 +在使用 CPU 卸载时，FSDP 当前不支持在`no_sync()`之外支持梯度累积。尝试这样做会产生不正确的结果，因为 FSDP 将使用新减少的梯度而不是与任何现有梯度累积。 警告 @@ -42,39 +42,39 @@ class torch.distributed.fsdp.FullyShardedDataParallel(module, process_group=None 警告 -传递`sync_module_states=True`标志需要`module`在GPU上或使用`device_id`参数来指定FSDP将`module`移动到的CUDA设备。这是因为`sync_module_states=True`需要GPU通信。 +传递`sync_module_states=True`标志需要`module`在 GPU 上或使用`device_id`参数来指定 FSDP 将`module`移动到的 CUDA 设备。这是因为`sync_module_states=True`需要 GPU 通信。 警告 -截至PyTorch 1.12，FSDP仅对共享参数提供有限支持（例如，将一个`Linear`层的权重设置为另一个的）。特别是，共享参数的模块必须作为同一FSDP单元的一部分进行包装。如果您的用例需要增强的共享参数支持，请访问[https://github.com/pytorch/pytorch/issues/77724](https://github.com/pytorch/pytorch/issues/77724) +截至 PyTorch 1.12，FSDP 仅对共享参数提供有限支持（例如，将一个`Linear`层的权重设置为另一个的）。特别是，共享参数的模块必须作为同一 FSDP 单元的一部分进行包装。如果您的用例需要增强的共享参数支持，请访问[`github.com/pytorch/pytorch/issues/77724`](https://github.com/pytorch/pytorch/issues/77724) 警告 -FSDP对冻结参数（即设置`param.requires_grad=False`）有一些约束。对于`use_orig_params=False`，每个FSDP实例必须管理所有冻结或所有非冻结的参数。对于`use_orig_params=True`，FSDP支持混合冻结和非冻结，但我们建议不要这样做，因为梯度内存使用量将高于预期（即等同于不冻结这些参数）。这意味着理想情况下，冻结参数应该被隔离到自己的`nn.Module`中，并分别用FSDP包装。 +FSDP 对冻结参数（即设置`param.requires_grad=False`）有一些约束。对于`use_orig_params=False`，每个 FSDP 实例必须管理所有冻结或所有非冻结的参数。对于`use_orig_params=True`，FSDP 支持混合冻结和非冻结，但我们建议不要这样做，因为梯度内存使用量将高于预期（即等同于不冻结这些参数）。这意味着理想情况下，冻结参数应该被隔离到自己的`nn.Module`中，并分别用 FSDP 包装。 注意 -尝试运行包含在FSDP实例中的子模块的前向传递不受支持，将导致错误。这是因为子模块的参数将被分片，但它本身不是FSDP实例，因此其前向传递将不会适当地聚集所有参数。当尝试仅运行编码器-解码器模型的编码器时，可能会发生这种情况，并且编码器未包装在自己的FSDP实例中。要解决此问题，请将子模块包装在自己的FSDP单元中。 +尝试运行包含在 FSDP 实例中的子模块的前向传递不受支持，将导致错误。这是因为子模块的参数将被分片，但它本身不是 FSDP 实例，因此其前向传递将不会适当地聚集所有参数。当尝试仅运行编码器-解码器模型的编码器时，可能会发生这种情况，并且编码器未包装在自己的 FSDP 实例中。要解决此问题，请将子模块包装在自己的 FSDP 单元中。 注意 -FSDP将输入张量移动到GPU计算设备的`forward`方法中，因此用户不需要手动将它们从CPU移动。 +FSDP 将输入张量移动到 GPU 计算设备的`forward`方法中，因此用户不需要手动将它们从 CPU 移动。 警告 -用户不应在前向和后向之间修改参数，而不使用[`summon_full_params()`](#torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params "torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params")上下文，因为修改可能不会持久。此外，对于`use_orig_params=False`，在前向和后向之间访问原始参数可能会引发非法内存访问。 +用户不应在前向和后向之间修改参数，而不使用`summon_full_params()`上下文，因为修改可能不会持久。此外，对于`use_orig_params=False`，在前向和后向之间访问原始参数可能会引发非法内存访问。 警告 -对于`use_orig_params=True`，`ShardingStrategy.SHARD_GRAD_OP`在前向传播后暴露未分片的参数，而不是分片的参数，因为它不释放未分片的参数，不像`ShardingStrategy.FULL_SHARD`。一个注意事项是，由于梯度总是被分片或为`None`，`ShardingStrategy.SHARD_GRAD_OP`在前向传播后不会暴露带有未分片参数的分片梯度。如果要检查梯度，请尝试使用`with_grads=True`调用[`summon_full_params()`](#torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params "torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params")。 +对于`use_orig_params=True`，`ShardingStrategy.SHARD_GRAD_OP`在前向传播后暴露未分片的参数，而不是分片的参数，因为它不释放未分片的参数，不像`ShardingStrategy.FULL_SHARD`。一个注意事项是，由于梯度总是被分片或为`None`，`ShardingStrategy.SHARD_GRAD_OP`在前向传播后不会暴露带有未分片参数的分片梯度。如果要检查梯度，请尝试使用`with_grads=True`调用`summon_full_params()`。 警告 -FSDP在前向和后向计算期间用`torch.Tensor`视图替换托管模块的参数，出于自动求导相关原因。如果您的模块的前向依赖于对参数的保存引用，而不是在每次迭代中重新获取引用，则它将看不到FSDP新创建的视图，并且自动求导将无法正常工作。 +FSDP 在前向和后向计算期间用`torch.Tensor`视图替换托管模块的参数，出于自动求导相关原因。如果您的模块的前向依赖于对参数的保存引用，而不是在每次迭代中重新获取引用，则它将看不到 FSDP 新创建的视图，并且自动求导将无法正常工作。 注意 -使用`limit_all_gathers=True`，您可能会看到FSDP在前向传播中存在一个CPU线程不发出任何内核的间隙。这是有意的，并显示了速率限制器的效果。以这种方式同步CPU线程可以防止为后续全聚合过度分配内存，并且实际上不应延迟GPU内核执行。 +使用`limit_all_gathers=True`，您可能会看到 FSDP 在前向传播中存在一个 CPU 线程不发出任何内核的间隙。这是有意的，并显示了速率限制器的效果。以这种方式同步 CPU 线程可以防止为后续全聚合过度分配内存，并且实际上不应延迟 GPU 内核执行。 注意 @@ -82,17 +82,17 @@ FSDP在前向和后向计算期间用`torch.Tensor`视图替换托管模块的 参数 -+ **module** ([*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")) – 这是要用FSDP包装的模块。 ++ **module** (*nn.Module*) – 这是要用 FSDP 包装的模块。 -+ **process_group** (*可选**[**Union**[**ProcessGroup**,* *Tuple**[**ProcessGroup**,* *ProcessGroup**]**]**]*) – 这是模型被分片的进程组，因此也是FSDP的全聚合和减少散播集体通信所使用的进程组。如果为`None`，则FSDP使用默认进程组。对于混合分片策略，如`ShardingStrategy.HYBRID_SHARD`，用户可以传入一个进程组的元组，分别表示分片和复制的组。如果为`None`，则FSDP为用户构建进程组，以便在节点内进行分片和在节点间进行复制。（默认值：`None`） ++ **process_group** (*可选**[**Union**[**ProcessGroup**,* *Tuple**[**ProcessGroup**,* *ProcessGroup**]**]**]*) – 这是模型被分片的进程组，因此也是 FSDP 的全聚合和减少散播集体通信所使用的进程组。如果为`None`，则 FSDP 使用默认进程组。对于混合分片策略，如`ShardingStrategy.HYBRID_SHARD`，用户可以传入一个进程组的元组，分别表示分片和复制的组。如果为`None`，则 FSDP 为用户构建进程组，以便在节点内进行分片和在节点间进行复制。（默认值：`None`） -+ **sharding_strategy** (*可选**[*[*ShardingStrategy*](#torch.distributed.fsdp.ShardingStrategy "torch.distributed.fsdp.ShardingStrategy")*]*) – 这配置了分片策略，可能会权衡内存节省和通信开销。详细信息请参见[`ShardingStrategy`](#torch.distributed.fsdp.ShardingStrategy "torch.distributed.fsdp.ShardingStrategy")。（默认值：`FULL_SHARD`） ++ **sharding_strategy** (*可选***[*ShardingStrategy**]*) – 这配置了分片策略，可能会权衡内存节省和通信开销。详细信息请参见`ShardingStrategy`。（默认值：`FULL_SHARD`） -+ **cpu_offload** (*可选**[*[*CPUOffload*](#torch.distributed.fsdp.CPUOffload "torch.distributed.fsdp.CPUOffload")*]*) – 这配置了CPU卸载。如果设置为`None`，则不会发生CPU卸载。详细信息请参见[`CPUOffload`](#torch.distributed.fsdp.CPUOffload "torch.distributed.fsdp.CPUOffload")。（默认值：`None`） ++ **cpu_offload** (*可选***[*CPUOffload**]*) – 这配置了 CPU 卸载。如果设置为`None`，则不会发生 CPU 卸载。详细信息请参见`CPUOffload`。（默认值：`None`） -+ **auto_wrap_policy** (*可选**[**Union**[**Callable**[**[*[*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")*,* [*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**,* [*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*]**,* *ModuleWrapPolicy**,* *CustomPolicy**]**]*) – ++ **auto_wrap_policy** (*可选****Union**[**Callable**[**[*[*nn.Module**,* [*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*]**,* [*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*]**,* *ModuleWrapPolicy**,* *CustomPolicy**]**]*) – - 这指定了一个策略，将FSDP应用于`module`的子模块，这对通信和计算重叠至关重要，从而影响性能。如果为`None`，则FSDP仅应用于`module`，用户应手动将FSDP应用于父模块（自下而上进行）。为方便起见，这直接接受`ModuleWrapPolicy`，允许用户指定要包装的模块类（例如变换器块）。否则，这应该是一个可调用对象，接受三个参数`module: nn.Module`、`recurse: bool`和`nonwrapped_numel: int`，并应返回一个`bool`，指定是否应在`recurse=False`时应用FSDP到传入的`module`，或者如果`recurse=True`，遍历应继续到模块的子树。用户可以向可调用对象添加其他参数。`torch.distributed.fsdp.wrap.py`中的`size_based_auto_wrap_policy`提供了一个示例可调用对象，如果其子树中的参数超过100M个元素，则将FSDP应用于模块。我们建议在应用FSDP后打印模型，并根据需要进行调整。 + 这指定了一个策略，将 FSDP 应用于`module`的子模块，这对通信和计算重叠至关重要，从而影响性能。如果为`None`，则 FSDP 仅应用于`module`，用户应手动将 FSDP 应用于父模块（自下而上进行）。为方便起见，这直接接受`ModuleWrapPolicy`，允许用户指定要包装的模块类（例如变换器块）。否则，这应该是一个可调用对象，接受三个参数`module: nn.Module`、`recurse: bool`和`nonwrapped_numel: int`，并应返回一个`bool`，指定是否应在`recurse=False`时应用 FSDP 到传入的`module`，或者如果`recurse=True`，遍历应继续到模块的子树。用户可以向可调用对象添加其他参数。`torch.distributed.fsdp.wrap.py`中的`size_based_auto_wrap_policy`提供了一个示例可调用对象，如果其子树中的参数超过 100M 个元素，则将 FSDP 应用于模块。我们建议在应用 FSDP 后打印模型，并根据需要进行调整。 示例： @@ -109,13 +109,13 @@ FSDP在前向和后向计算期间用`torch.Tensor`视图替换托管模块的 >>> my_auto_wrap_policy = functools.partial(custom_auto_wrap_policy, min_num_params=int(1e5)) ``` -+ **backward_prefetch** (*可选**[*[*BackwardPrefetch*](#torch.distributed.fsdp.BackwardPrefetch "torch.distributed.fsdp.BackwardPrefetch")*]*) – 这配置了所有gather的显式向后预取。如果为`None`，则FSDP不进行向后预取，在向后传递中没有通信和计算重叠。详细信息请参见[`BackwardPrefetch`](#torch.distributed.fsdp.BackwardPrefetch "torch.distributed.fsdp.BackwardPrefetch")。（默认值：`BACKWARD_PRE`） ++ **backward_prefetch** (*可选***[*BackwardPrefetch**]*) – 这配置了所有 gather 的显式向后预取。如果为`None`，则 FSDP 不进行向后预取，在向后传递中没有通信和计算重叠。详细信息请参见`BackwardPrefetch`。（默认值：`BACKWARD_PRE`） -+ **mixed_precision** (*可选**[*[*MixedPrecision*](#torch.distributed.fsdp.MixedPrecision "torch.distributed.fsdp.MixedPrecision")*]*) – 这配置了FSDP的本机混合精度。如果设置为`None`，则不使用混合精度。否则，可以设置参数、缓冲区和梯度减少的数据类型。详细信息请参见[`MixedPrecision`](#torch.distributed.fsdp.MixedPrecision "torch.distributed.fsdp.MixedPrecision")。（默认值：`None`） ++ **mixed_precision** (*可选***[*MixedPrecision**]*) – 这配置了 FSDP 的本机混合精度。如果设置为`None`，则不使用混合精度。否则，可以设置参数、缓冲区和梯度减少的数据类型。详细信息请参见`MixedPrecision`。（默认值：`None`） -+ **ignored_modules** (*可选**[**可迭代**[*[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")*]**]*) – 忽略此实例的参数和子模块的参数和缓冲区的模块。`ignored_modules`中直接的模块都不应该是[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")实例，如果已构建的子模块是[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")实例，并且它们嵌套在此实例下，则不会被忽略。当使用`auto_wrap_policy`时，或者如果参数的分片不是由FSDP管理时，可以使用此参数避免以模块粒度分片特定参数。（默认值：`None`） ++ **ignored_modules** (*可选****可迭代**[*[*torch.nn.Module**]**]*) – 忽略此实例的参数和子模块的参数和缓冲区的模块。`ignored_modules`中直接的模块都不应该是`FullyShardedDataParallel`实例，如果已构建的子模块是`FullyShardedDataParallel`实例，并且它们嵌套在此实例下，则不会被忽略。当使用`auto_wrap_policy`时，或者如果参数的分片不是由 FSDP 管理时，可以使用此参数避免以模块粒度分片特定参数。（默认值：`None`） -+ **param_init_fn** (*可选**[**可调用**[**[*[*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")*]**,* *None**]**]*) – ++ **param_init_fn** (*可选****可调用**[**[*[*nn.Module**]**,* *None**]**]*) – 一个 `Callable[torch.nn.Module] -> None`，指定了当前在元设备上的模块应该如何初始化到实际设备上。从 v1.12 开始，FSDP 通过 `is_meta` 检测在元设备上具有参数或缓冲区的模块，如果指定了 `param_init_fn`，则应用它，否则调用 `nn.Module.reset_parameters()`。对于这两种情况，实现应该 *仅* 初始化模块的参数/缓冲区，而不是其子模块的参数/缓冲区。这是为了避免重新初始化。此外，FSDP 还支持通过 torchdistX 的 `deferred_init()` API 延迟初始化，其中延迟模块通过调用 `param_init_fn`（如果指定）或 torchdistX 的默认 `materialize_module()` 进行初始化。如果指定了 `param_init_fn`，则它将应用于所有元设备模块，这意味着它可能会根据模块类型进行分类。FSDP 在参数展平和分片之前调用初始化函数。 @@ -134,17 +134,17 @@ FSDP在前向和后向计算期间用`torch.Tensor`视图替换托管模块的 >>> fsdp_model = FSDP(module, auto_wrap_policy=size_based_auto_wrap_policy) ``` -+ **device_id**（*Optional**[**Union**[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*torch.device*](tensor_attributes.html#torch.device "torch.device")*]***) – 一个 `int` 或 `torch.device`，指定 FSDP 初始化所在的 CUDA 设备，包括如果需要的话模块初始化和参数分片。如果模块在 CPU 上，则应指定此项以提高初始化速度。如果设置了默认的 CUDA 设备（例如通过 `torch.cuda.set_device`），则用户可以将 `torch.cuda.current_device` 传递给此项。（默认值：`None`） ++ **device_id**（*Optional**[**Union**[*[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* *torch.device**]***) – 一个 `int` 或 `torch.device`，指定 FSDP 初始化所在的 CUDA 设备，包括如果需要的话模块初始化和参数分片。如果模块在 CPU 上，则应指定此项以提高初始化速度。如果设置了默认的 CUDA 设备（例如通过 `torch.cuda.set_device`），则用户可以将 `torch.cuda.current_device` 传递给此项。（默认值：`None`） -+ **sync_module_states**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为 `True`，则每个 FSDP 模块将从排名 0 广播模块参数和缓冲区，以确保它们在各个排名之间复制（为此构造函数增加通信开销）。这可以帮助以内存高效的方式通过 `load_state_dict` 加载 `state_dict` 检查点。请参阅 [`FullStateDictConfig`](#torch.distributed.fsdp.FullStateDictConfig "torch.distributed.fsdp.FullStateDictConfig") 以获取此示例。（默认值：`False`） ++ **sync_module_states**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为 `True`，则每个 FSDP 模块将从排名 0 广播模块参数和缓冲区，以确保它们在各个排名之间复制（为此构造函数增加通信开销）。这可以帮助以内存高效的方式通过 `load_state_dict` 加载 `state_dict` 检查点。请参阅 `FullStateDictConfig` 以获取此示例。（默认值：`False`） + **forward_prefetch**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为 `True`，则 FSDP *明确* 在当前前向计算之前预取下一个前向传递的所有聚集。这仅对 CPU 绑定的工作负载有用，在这种情况下，提前发出下一个所有聚集可能会提高重叠。这仅适用于静态图模型，因为预取遵循第一次迭代的执行顺序。（默认值：`False`） + **limit_all_gathers**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为 `True`，则 FSDP 明确同步 CPU 线程，以确保 GPU 内存使用仅来自 *两个* 连续的 FSDP 实例（当前实例运行计算和下一个实例，其所有聚集都是预取的）。如果为 `False`，则 FSDP 允许 CPU 线程发出所有聚集而无需任何额外的同步。（默认值：`True`）我们通常将此功能称为“速率限制器”。此标志应仅针对具有低内存压力的特定 CPU 绑定工作负载设置为 `False`，在这种情况下，CPU 线程可以积极发出所有内核，而不必担心 GPU 内存使用。 -+ **use_orig_params**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 将此设置为`True`会使FSDP使用`module`的原始参数。FSDP通过`nn.Module.named_parameters()`向用户公开这些原始参数，而不是通过FSDP的内部`FlatParameter`。这意味着优化器步骤在原始参数上运行，从而实现每个原始参数的超参数。FSDP保留原始参数变量，并在未分片和分片形式之间操作它们的数据，其中它们始终是底层未分片或分片`FlatParameter`的视图。根据当前算法，分片形式始终是1D，丢失了原始张量结构。对于给定等级，原始参数可能具有全部、部分或没有数据。在没有数据的情况下，其数据将类似于大小为0的空张量。用户不应编写依赖于给定原始参数在其分片形式中存在哪些数据的程序。`True`是使用`torch.compile()`所必需的。将其设置为`False`通过`nn.Module.named_parameters()`向用户公开FSDP的内部`FlatParameter`。 （默认值：`False`） ++ **use_orig_params**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 将此设置为`True`会使 FSDP 使用`module`的原始参数。FSDP 通过`nn.Module.named_parameters()`向用户公开这些原始参数，而不是通过 FSDP 的内部`FlatParameter`。这意味着优化器步骤在原始参数上运行，从而实现每个原始参数的超参数。FSDP 保留原始参数变量，并在未分片和分片形式之间操作它们的数据，其中它们始终是底层未分片或分片`FlatParameter`的视图。根据当前算法，分片形式始终是 1D，丢失了原始张量结构。对于给定等级，原始参数可能具有全部、部分或没有数据。在没有数据的情况下，其数据将类似于大小为 0 的空张量。用户不应编写依赖于给定原始参数在其分片形式中存在哪些数据的程序。`True`是使用`torch.compile()`所必需的。将其设置为`False`通过`nn.Module.named_parameters()`向用户公开 FSDP 的内部`FlatParameter`。 （默认值：`False`） -+ **ignored_states**（*可选**[**Iterable**[**torch.nn.Parameter**]**]**,* *可选**[**Iterable**[*[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")*]**]*)- 不受此FSDP实例管理的被忽略的参数或模块，这意味着参数未分片，它们的梯度未在等级之间减少。此参数与现有的`ignored_modules`参数统一，我们可能很快会弃用`ignored_modules`。为了向后兼容，我们保留`ignored_states`和`ignored_modules`，但是FSDP只允许其中一个被指定为非`None`。 ++ **ignored_states**（*可选**[**Iterable**[**torch.nn.Parameter**]**]**,* *可选****Iterable**[*[*torch.nn.Module**]**]*)- 不受此 FSDP 实例管理的被忽略的参数或模块，这意味着参数未分片，它们的梯度未在等级之间减少。此参数与现有的`ignored_modules`参数统一，我们可能很快会弃用`ignored_modules`。为了向后兼容，我们保留`ignored_states`和`ignored_modules`，但是 FSDP 只允许其中一个被指定为非`None`。 ```py apply(fn)¶ @@ -152,7 +152,7 @@ apply(fn)¶ 递归地将`fn`应用于每个子模块（由`.children()`返回）以及自身。 -典型用法包括初始化模型的参数（另请参阅[torch.nn.init](nn.init.html#nn-init-doc)）。 +典型用法包括初始化模型的参数（另请参阅 torch.nn.init）。 与`torch.nn.Module.apply`相比，此版本在应用`fn`之前还会收集完整的参数。不应在另一个`summon_full_params`上下文中调用它。 @@ -166,13 +166,13 @@ self 返回类型 -[Module](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module") +Module ```py check_is_root()¶ ``` -检查此实例是否为根FSDP模块。 +检查此实例是否为根 FSDP 模块。 返回类型 @@ -190,7 +190,7 @@ clip_grad_norm_(max_norm, norm_type=2.0)¶ + **max_norm**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")）- 梯度的最大规范 -+ **norm_type**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")）- 使用的p-范数类型。可以是`'inf'`表示无穷范数。 ++ **norm_type**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")）- 使用的 p-范数类型。可以是`'inf'`表示无穷范数。 返回 @@ -198,19 +198,19 @@ clip_grad_norm_(max_norm, norm_type=2.0)¶ 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* 注意 -如果每个FSDP实例都使用`NO_SHARD`，即没有梯度在等级之间分片，则可以直接使用[`torch.nn.utils.clip_grad_norm_()`](generated/torch.nn.utils.clip_grad_norm_.html#torch.nn.utils.clip_grad_norm_ "torch.nn.utils.clip_grad_norm_")。 +如果每个 FSDP 实例都使用`NO_SHARD`，即没有梯度在等级之间分片，则可以直接使用`torch.nn.utils.clip_grad_norm_()`。 注意 -如果至少有一些FSDP实例使用分片策略（即`NO_SHARD`之外的策略），则应使用此方法而不是[`torch.nn.utils.clip_grad_norm_()`](generated/torch.nn.utils.clip_grad_norm_.html#torch.nn.utils.clip_grad_norm_ "torch.nn.utils.clip_grad_norm_")，因为此方法处理了梯度在等级之间分片的事实。 +如果至少有一些 FSDP 实例使用分片策略（即`NO_SHARD`之外的策略），则应使用此方法而不是`torch.nn.utils.clip_grad_norm_()`，因为此方法处理了梯度在等级之间分片的事实。 注意 -返回的总规范将具有PyTorch类型提升语义定义的所有参数/梯度中的“最大”dtype。例如，如果*所有*参数/梯度使用低精度dtype，则返回的规范的dtype将是该低精度dtype，但如果至少存在一个使用FP32的参数/梯度，则返回的规范的dtype将是FP32。 +返回的总规范将具有 PyTorch 类型提升语义定义的所有参数/梯度中的“最大”dtype。例如，如果*所有*参数/梯度使用低精度 dtype，则返回的规范的 dtype 将是该低精度 dtype，但如果至少存在一个使用 FP32 的参数/梯度，则返回的规范的 dtype 将是 FP32。 警告 @@ -222,19 +222,19 @@ static flatten_sharded_optim_state_dict(sharded_optim_state_dict, model, optim) 展平分片的优化器状态字典。 -API类似于[`shard_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict")。唯一的区别是输入的`sharded_optim_state_dict`应该从[`sharded_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.sharded_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.sharded_optim_state_dict")返回。因此，每个秩上都会有全聚合调用以收集`ShardedTensor` s。 +API 类似于`shard_full_optim_state_dict()`。唯一的区别是输入的`sharded_optim_state_dict`应该从`sharded_optim_state_dict()`返回。因此，每个秩上都会有全聚合调用以收集`ShardedTensor` s。 参数 + **sharded_optim_state_dict**（*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]*） - 对应于未展平参数并保存分片优化器状态的优化器状态字典。 -+ **model**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")） - 参考[`shard_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict")。 ++ **model**（*torch.nn.Module*） - 参考`shard_full_optim_state_dict()`。 -+ **optim**（[*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")） - 用于`model`的参数的优化器。 ++ **optim**（*torch.optim.Optimizer*） - 用于`model`的参数的优化器。 返回 -参考[`shard_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict")。 +参考`shard_full_optim_state_dict()`。 返回类型 @@ -244,7 +244,7 @@ API类似于[`shard_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShard forward(*args, **kwargs)¶ ``` -运行包装模块的前向传递，插入FSDP特定的前向和后向分片逻辑。 +运行包装模块的前向传递，插入 FSDP 特定的前向和后向分片逻辑。 返回类型 @@ -254,23 +254,23 @@ forward(*args, **kwargs)¶ static fsdp_modules(module, root_only=False)¶ ``` -返回所有嵌套的FSDP实例。 +返回所有嵌套的 FSDP 实例。 -这可能包括`module`本身，仅在`root_only=True`时包括FSDP根模块。 +这可能包括`module`本身，仅在`root_only=True`时包括 FSDP 根模块。 参数 -+ **module**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")） - 根模块，可能是或可能不是`FSDP`模块。 ++ **module**（*torch.nn.Module*） - 根模块，可能是或可能不是`FSDP`模块。 -+ **root_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 是否仅返回FSDP根模块。 （默认值：`False`） ++ **root_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 是否仅返回 FSDP 根模块。 （默认值：`False`） 返回 -嵌套在输入`module`中的FSDP模块。 +嵌套在输入`module`中的 FSDP 模块。 返回类型 -List[[FullyShardedDataParallel](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")] +List[FullyShardedDataParallel] ```py static full_optim_state_dict(model, optim, optim_input=None, rank0_only=True, group=None)¶ @@ -278,35 +278,35 @@ static full_optim_state_dict(model, optim, optim_input=None, rank0_only=True, gr 返回完整的优化器状态字典。 -在秩0上合并完整的优化器状态，并将其作为[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")返回，遵循[`torch.optim.Optimizer.state_dict()`](generated/torch.optim.Optimizer.state_dict.html#torch.optim.Optimizer.state_dict "torch.optim.Optimizer.state_dict")的约定，即具有键`"state"`和`"param_groups"`。`model`中包含的`FSDP`模块中的展平参数将映射回其未展平参数。 +在秩 0 上合并完整的优化器状态，并将其作为[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")返回，遵循`torch.optim.Optimizer.state_dict()`的约定，即具有键`"state"`和`"param_groups"`。`model`中包含的`FSDP`模块中的展平参数将映射回其未展平参数。 警告 -由于使用集体通信，因此需要在所有秩上调用此函数。但是，如果`rank0_only=True`，则状态字典仅在秩为0时填充，并且所有其他秩返回一个空的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")。 +由于使用集体通信，因此需要在所有秩上调用此函数。但是，如果`rank0_only=True`，则状态字典仅在秩为 0 时填充，并且所有其他秩返回一个空的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")。 警告 -与`torch.optim.Optimizer.state_dict()`不同，此方法使用完整的参数名称作为键，而不是参数ID。 +与`torch.optim.Optimizer.state_dict()`不同，此方法使用完整的参数名称作为键，而不是参数 ID。 注意 -与[`torch.optim.Optimizer.state_dict()`](generated/torch.optim.Optimizer.state_dict.html#torch.optim.Optimizer.state_dict "torch.optim.Optimizer.state_dict")中一样，优化器状态字典中包含的张量不会被克隆，因此可能会出现别名意外。为了最佳实践，考虑立即保存返回的优化器状态字典，例如使用`torch.save()`。 +与`torch.optim.Optimizer.state_dict()`中一样，优化器状态字典中包含的张量不会被克隆，因此可能会出现别名意外。为了最佳实践，考虑立即保存返回的优化器状态字典，例如使用`torch.save()`。 参数 -+ **模型**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module"））- 根模块（可能是或不是[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")实例），其参数被传递给优化器`optim`。 ++ **模型**（*torch.nn.Module*实例），其参数被传递给优化器`optim`。 -+ **optim**（[*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")）- 用于`model`的参数的优化器。 ++ **optim**（*torch.optim.Optimizer*）- 用于`model`的参数的优化器。 + **optim_input**（*Optional**[**Union**[**List**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]**,** *Iterable**[**torch.nn.Parameter**]**]**]*) - 传递给优化器`optim`的输入，表示参数组的[`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")或参数的可迭代对象；如果为`None`，则此方法假定输入为`model.parameters()`。此参数已被弃用，不再需要传递它。 （默认值：`None`） -+ **rank0_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为`True`，则仅在rank 0上保存填充的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")；如果为`False`，则在所有rank上保存。 （默认值：`True`） ++ **rank0_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为`True`，则仅在 rank 0 上保存填充的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")；如果为`False`，则在所有 rank 上保存。 （默认值：`True`） + **group**（*dist.ProcessGroup*）- 模型的进程组或如果使用默认进程组则为`None`。 （默认值：`None`） 返回 -包含`model`原始未扁平化参数的优化器状态和包括“state”和“param_groups”键的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")。如果`rank0_only=True`，则非零rank返回一个空的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")。 +包含`model`原始未扁平化参数的优化器状态和包括“state”和“param_groups”键的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")。如果`rank0_only=True`，则非零 rank 返回一个空的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")。 返回类型 @@ -316,23 +316,23 @@ Dict[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12 static get_state_dict_type(module)¶ ``` -获取根据`module`根模块的FSDP模块的state_dict_type和相应的配置。 +获取根据`module`根模块的 FSDP 模块的 state_dict_type 和相应的配置。 -目标模块不必是FSDP模块。 +目标模块不必是 FSDP 模块。 返回 -包含当前设置的state_dict_type和state_dict / optim_state_dict配置的`StateDictSettings`。 +包含当前设置的 state_dict_type 和 state_dict / optim_state_dict 配置的`StateDictSettings`。 引发 -+ **如果StateDictSettings不同，则会引发AssertionError** - ++ **如果 StateDictSettings 不同，则会引发 AssertionError** - -+ **FSDP子模块不同。** - ++ **FSDP 子模块不同。** - 返回类型 -[*StateDictSettings*](#torch.distributed.fsdp.StateDictSettings "torch.distributed.fsdp.api.StateDictSettings") +*StateDictSettings* ```py property module: Module¶ @@ -346,11 +346,11 @@ named_buffers(*args, **kwargs)¶ 返回一个模块缓冲区的迭代器，同时产生缓冲区的名称和缓冲区本身。 -在[`summon_full_params()`](#torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params "torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params")上下文管理器中，拦截缓冲区名称并删除所有FSDP特定的扁平化缓冲区前缀的出现。 +在`summon_full_params()`上下文管理器中，拦截缓冲区名称并删除所有 FSDP 特定的扁平化缓冲区前缀的出现。 返回类型 -[*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*](tensors.html#torch.Tensor "torch.Tensor")]] +[*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)¶ @@ -358,31 +358,31 @@ named_parameters(*args, **kwargs)¶ 返回一个模块参数的迭代器，同时产生参数的名称和参数本身。 -拦截参数名称，并在[`summon_full_params()`](#torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params "torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params")上下文管理器内部删除所有FSDP特定的扁平化参数前缀的出现。 +拦截参数名称，并在`summon_full_params()`上下文管理器内部删除所有 FSDP 特定的扁平化参数前缀的出现。 返回类型 -[*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*](generated/torch.nn.parameter.Parameter.html#torch.nn.parameter.Parameter "torch.nn.parameter.Parameter")]] +[*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()¶ ``` -禁用FSDP实例之间的梯度同步。 +禁用 FSDP 实例之间的梯度同步。 -在此上下文中，梯度将在模块变量中累积，稍后在退出上下文后的第一个前向-后向传递中进行同步。这应仅用于根FSDP实例，并将递归应用于所有子FSDP实例。 +在此上下文中，梯度将在模块变量中累积，稍后在退出上下文后的第一个前向-后向传递中进行同步。这应仅用于根 FSDP 实例，并将递归应用于所有子 FSDP 实例。 注意 -这可能导致更高的内存使用，因为FSDP将累积完整模型梯度（而不是梯度片段），直到最终同步。 +这可能导致更高的内存使用，因为 FSDP 将累积完整模型梯度（而不是梯度片段），直到最终同步。 注意 -当与CPU卸载一起使用时，在上下文管理器内部梯度不会被卸载到CPU。相反，它们只会在最终同步之后被卸载。 +当与 CPU 卸载一起使用时，在上下文管理器内部梯度不会被卸载到 CPU。相反，它们只会在最终同步之后被卸载。 返回类型 -[*Generator*](https://docs.python.org/3/library/typing.html#typing.Generator "(在Python v3.12中)") +[*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)¶ @@ -392,11 +392,11 @@ static optim_state_dict(model, optim, optim_state_dict=None, group=None)¶ 给定的状态字典可以转换为三种类型之一：1）完整的优化器状态字典，2）分片的优化器状态字典，3）本地的优化器状态字典。 -对于完整的优化器状态字典，所有状态都是未扁平化且未分片的。可以通过[`state_dict_type()`](#torch.distributed.fsdp.FullyShardedDataParallel.state_dict_type "torch.distributed.fsdp.FullyShardedDataParallel.state_dict_type")指定仅Rank0和仅CPU，以避免OOM。 +对于完整的优化器状态字典，所有状态都是未扁平化且未分片的。可以通过`state_dict_type()`指定仅 Rank0 和仅 CPU，以避免 OOM。 -对于分片的优化器状态字典，所有状态都是未扁平化但是分片的。可以通过[`state_dict_type()`](#torch.distributed.fsdp.FullyShardedDataParallel.state_dict_type "torch.distributed.fsdp.FullyShardedDataParallel.state_dict_type")指定仅CPU，以进一步节省内存。 +对于分片的优化器状态字典，所有状态都是未扁平化但是分片的。可以通过`state_dict_type()`指定仅 CPU，以进一步节省内存。 -对于本地state_dict，不会执行任何转换。但是，状态将从nn.Tensor转换为ShardedTensor以表示其分片性质（目前不支持）。 +对于本地 state_dict，不会执行任何转换。但是，状态将从 nn.Tensor 转换为 ShardedTensor 以表示其分片性质（目前不支持）。 示例： @@ -434,29 +434,29 @@ static optim_state_dict(model, optim, optim_state_dict=None, group=None)¶ 参数 -+ **model** ([*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")) – 根模块（可能是或可能不是[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")实例）其参数被传递给优化器`optim`。 ++ **model** (*torch.nn.Module*) – 根模块（可能是或可能不是`FullyShardedDataParallel`实例）其参数被传递给优化器`optim`。 -+ **optim** ([*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")) – 用于`model`参数的优化器。 ++ **optim** (*torch.optim.Optimizer*) – 用于`model`参数的优化器。 -+ **optim_state_dict** (*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*,* *Any**]*) – 要转换的目标优化器状态字典。如果值为None，则将使用optim.state_dict()。（默认值：`None`） ++ **optim_state_dict** (*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* *Any**]*) – 要转换的目标优化器状态字典。如果值为 None，则将使用 optim.state_dict()。（默认值：`None`） + **group** (*dist.ProcessGroup*) – 模型的进程组，参数被分片到该组中，如果使用默认进程组则为`None`。（默认值：`None`） 返回 -包含`model`的优化器状态的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12)")。优化器状态的分片基于`state_dict_type`。 +包含`model`的优化器状态的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12)")。优化器状态的分片基于`state_dict_type`。 返回类型 -Dict[[str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)"), Any] +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)¶ ``` -将优化器状态字典转换为可以加载到与FSDP模型关联的优化器中的格式。 +将优化器状态字典转换为可以加载到与 FSDP 模型关联的优化器中的格式。 -给定通过[`optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.optim_state_dict")转换的`optim_state_dict`，它被转换为可以加载到`optim`的扁平化优化器state_dict，该`optim`是`model`的优化器。`model`必须由FullyShardedDataParallel进行分片。 +给定通过`optim_state_dict()`转换的`optim_state_dict`，它被转换为可以加载到`optim`的扁平化优化器 state_dict，该`optim`是`model`的优化器。`model`必须由 FullyShardedDataParallel 进行分片。 ```py >>> from torch.distributed.fsdp import FullyShardedDataParallel as FSDP @@ -497,15 +497,15 @@ static optim_state_dict_to_load(model, optim, optim_state_dict, is_named_optimiz 参数 -+ **model** ([*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")) – 根模块（可能是或不是[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")实例），其参数传递给了优化器`optim`。 ++ **model** (*torch.nn.Module*) – 根模块（可能是或不是`FullyShardedDataParallel`实例），其参数传递给了优化器`optim`。 -+ **optim** ([*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")) – `model`的参数的优化器。 ++ **optim** (*torch.optim.Optimizer*) – `model`的参数的优化器。 + **optim_state_dict** (*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]*) – 要加载的优化器状态。 -+ **is_named_optimizer** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 这个优化器是NamedOptimizer还是KeyedOptimizer。只有在`optim`是TorchRec的KeyedOptimizer或torch.distributed的NamedOptimizer时才设置为True。 ++ **is_named_optimizer** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 这个优化器是 NamedOptimizer 还是 KeyedOptimizer。只有在`optim`是 TorchRec 的 KeyedOptimizer 或 torch.distributed 的 NamedOptimizer 时才设置为 True。 -+ **load_directly** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果设置为True，则此API在返回结果之前还将调用optim.load_state_dict(result)。否则，用户需要调用`optim.load_state_dict()`（默认值：`False`） ++ **load_directly** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果设置为 True，则此 API 在返回结果之前还将调用 optim.load_state_dict(result)。否则，用户需要调用`optim.load_state_dict()`（默认值：`False`） + **group** (*dist.ProcessGroup*) – 模型的进程组，参数在其中进行分片，如果使用默认进程组，则为`None`。（默认值：`None`） @@ -519,11 +519,11 @@ register_comm_hook(state, hook)¶ 注册通信钩子。 -这是一个增强功能，为用户提供了一个灵活的钩子，他们可以在其中指定FSDP如何在多个工作进程之间聚合梯度。这个钩子可以用于实现几种算法，如[GossipGrad](https://arxiv.org/abs/1803.05880)和涉及不同通信策略的梯度压缩，这些策略用于参数同步，同时使用[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")进行训练。 +这是一个增强功能，为用户提供了一个灵活的钩子，他们可以在其中指定 FSDP 如何在多个工作进程之间聚合梯度。这个钩子可以用于实现几种算法，如[GossipGrad](https://arxiv.org/abs/1803.05880)和涉及不同通信策略的梯度压缩，这些策略用于参数同步，同时使用`FullyShardedDataParallel`进行训练。 警告 -在进行初始前向传递之前，应注册FSDP通信钩子，并且只注册一次。 +在进行初始前向传递之前，应注册 FSDP 通信钩子，并且只注册一次。 参数 @@ -531,7 +531,7 @@ register_comm_hook(state, hook)¶ 传递给钩子以在训练过程中维护任何状态信息。示例包括梯度压缩中的错误反馈，与[GossipGrad](https://arxiv.org/abs/1803.05880)中下一个通信的对等体等。它由每个工作进程本地存储，并由工作进程上的所有梯度张量共享。 -+ **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的可调用函数应处理分片情况的梯度通信。 ++ **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)¶ @@ -539,9 +539,9 @@ static rekey_optim_state_dict(optim_state_dict, optim_state_key_type, model, opt 重新调整优化器状态字典`optim_state_dict`以使用键类型`optim_state_key_type`。 -这可以用于实现具有FSDP实例和没有FSDP实例的模型的优化器状态字典之间的兼容性。 +这可以用于实现具有 FSDP 实例和没有 FSDP 实例的模型的优化器状态字典之间的兼容性。 -重新调整FSDP全优化器状态字典（即从[`full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict")）以使用参数ID，并且可以加载到非包装模型中： +重新调整 FSDP 全优化器状态字典（即从`full_optim_state_dict()`）以使用参数 ID，并且可以加载到非包装模型中： ```py >>> wrapped_model, wrapped_optim = ... @@ -574,9 +574,9 @@ static rekey_optim_state_dict(optim_state_dict, optim_state_key_type, model, opt static scatter_full_optim_state_dict(full_optim_state_dict, model, optim_input=None, optim=None, group=None)¶ ``` -将来自排名0的完整优化器状态字典分散到所有其他排名。 +将来自排名 0 的完整优化器状态字典分散到所有其他排名。 -在每个排名上返回分片的优化器状态字典。返回值与[`shard_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict")相同，在排名0上，第一个参数应该是[`full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict")的返回值。 +在每个排名上返回分片的优化器状态字典。返回值与`shard_full_optim_state_dict()`相同，在排名 0 上，第一个参数应该是`full_optim_state_dict()`的返回值。 示例： @@ -592,17 +592,17 @@ static scatter_full_optim_state_dict(full_optim_state_dict, model, optim_input=N 注意 -[`shard_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict")和[`scatter_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.scatter_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.scatter_full_optim_state_dict")都可以用于获取分片优化器状态字典以进行加载。假设完整的优化器状态字典驻留在CPU内存中，前者要求每个排名在CPU内存中具有完整字典，其中每个排名单独对字典进行分片而无需任何通信，而后者只要求排名0在CPU内存中具有完整字典，其中排名0将每个分片移动到GPU内存（用于NCCL）并适当地将其通信给排名。因此，前者具有更高的总体CPU内存成本，而后者具有更高的通信成本。 +`shard_full_optim_state_dict()`和`scatter_full_optim_state_dict()`都可以用于获取分片优化器状态字典以进行加载。假设完整的优化器状态字典驻留在 CPU 内存中，前者要求每个排名在 CPU 内存中具有完整字典，其中每个排名单独对字典进行分片而无需任何通信，而后者只要求排名 0 在 CPU 内存中具有完整字典，其中排名 0 将每个分片移动到 GPU 内存（用于 NCCL）并适当地将其通信给排名。因此，前者具有更高的总体 CPU 内存成本，而后者具有更高的通信成本。 参数 -+ **full_optim_state_dict** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]*) – 与未扁平化参数对应并保存完整非分片优化器状态的优化器状态字典（如果在排名0上）；在非零排名上忽略该参数。 ++ **full_optim_state_dict** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]*) – 与未扁平化参数对应并保存完整非分片优化器状态的优化器状态字典（如果在排名 0 上）；在非零排名上忽略该参数。 -+ **model**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")）- 根模块（可能是或可能不是[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")实例），其参数对应于`full_optim_state_dict`中的优化器状态。 ++ **model**（*torch.nn.Module*）- 根模块（可能是或可能不是`FullyShardedDataParallel`实例），其参数对应于`full_optim_state_dict`中的优化器状态。 + **optim_input**（*可选**[**Union**[**List**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]**,* *Iterable**[**torch.nn.Parameter**]**]**]*) - 传递给优化器的输入，表示参数组的[`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")或参数的可迭代对象；如果为`None`，则此方法假定输入为`model.parameters()`。此参数已被弃用，不再需要传递它。（默认值：`None`） -+ **optim**（*可选**[*[*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*]*）- 由此方法返回的状态字典将加载的优化器。这是优选的参数，优于`optim_input`。（默认值：`None`） ++ **optim**（*可选***[*torch.optim.Optimizer**]*）- 由此方法返回的状态字典将加载的优化器。这是优选的参数，优于`optim_input`。（默认值：`None`） + **group**（*dist.ProcessGroup*）- 模型的进程组或如果使用默认进程组则为`None`。（默认值：`None`） @@ -618,17 +618,17 @@ Dict[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12 static set_state_dict_type(module, state_dict_type, state_dict_config=None, optim_state_dict_config=None)¶ ``` -设置目标模块的所有后代FSDP模块的`state_dict_type`。 +设置目标模块的所有后代 FSDP 模块的`state_dict_type`。 -还接受（可选）模型和优化器状态字典的配置。目标模块不必是一个FSDP模块。如果目标模块是一个FSDP模块，它的`state_dict_type`也将被更改。 +还接受（可选）模型和优化器状态字典的配置。目标模块不必是一个 FSDP 模块。如果目标模块是一个 FSDP 模块，它的`state_dict_type`也将被更改。 注意 -此API应仅用于顶层（根）模块。 +此 API 应仅用于顶层（根）模块。 注意 -此API使用户能够透明地使用传统的`state_dict` API，在根FSDP模块被另一个`nn.Module`包装的情况下进行模型检查点。例如，以下代码将确保在所有非FSDP实例上调用`state_dict`，同时将分派到FSDP的sharded_state_dict实现： +此 API 使用户能够透明地使用传统的`state_dict` API，在根 FSDP 模块被另一个`nn.Module`包装的情况下进行模型检查点。例如，以下代码将确保在所有非 FSDP 实例上调用`state_dict`，同时将分派到 FSDP 的 sharded_state_dict 实现： 示例： @@ -646,21 +646,21 @@ static set_state_dict_type(module, state_dict_type, state_dict_config=None, opti 参数 -+ **module**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")）- 根模块。 ++ **module**（*torch.nn.Module*）- 根模块。 + **state_dict_type**（*StateDictType*）- 要设置的期望的`state_dict_type`。 -+ **state_dict_config**（*可选**[*[*StateDictConfig*](#torch.distributed.fsdp.StateDictConfig "torch.distributed.fsdp.StateDictConfig")*]*）- 目标`state_dict_type`的配置。 ++ **state_dict_config**（*可选***[*StateDictConfig**]*）- 目标`state_dict_type`的配置。 -+ **optim_state_dict_config**（*可选**[*[*OptimStateDictConfig*](#torch.distributed.fsdp.OptimStateDictConfig "torch.distributed.fsdp.OptimStateDictConfig")*]*）- 优化器状态字典的配置。 ++ **optim_state_dict_config**（*可选***[*OptimStateDictConfig**]*）- 优化器状态字典的配置。 返回值 -包括模块的先前state_dict类型和配置的StateDictSettings。 +包括模块的先前 state_dict 类型和配置的 StateDictSettings。 返回类型 -[*StateDictSettings*](#torch.distributed.fsdp.StateDictSettings "torch.distributed.fsdp.api.StateDictSettings") +*StateDictSettings* ```py static shard_full_optim_state_dict(full_optim_state_dict, model, optim_input=None, optim=None)¶ @@ -668,7 +668,7 @@ static shard_full_optim_state_dict(full_optim_state_dict, model, optim_input=Non 分片完整的优化器状态字典。 -将`full_optim_state_dict`中的状态重新映射为扁平化的参数，而不是未扁平化的参数，并且限制为仅此排名部分的优化器状态。第一个参数应该是[`full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict")的返回值。 +将`full_optim_state_dict`中的状态重新映射为扁平化的参数，而不是未扁平化的参数，并且限制为仅此排名部分的优化器状态。第一个参数应该是`full_optim_state_dict()`的返回值。 示例： @@ -686,17 +686,17 @@ static shard_full_optim_state_dict(full_optim_state_dict, model, optim_input=Non 注意 -[`shard_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict")和[`scatter_full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.scatter_full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.scatter_full_optim_state_dict")都可用于获取分片优化器状态字典以加载。假设完整的优化器状态字典驻留在CPU内存中，前者要求每个排名在CPU内存中具有完整的字典，其中每个排名单独对字典进行分片而无需任何通信，而后者仅要求排名0在CPU内存中具有完整的字典，其中排名0将每个分片移动到GPU内存（用于NCCL）并适当地将其通信给排名。因此，前者具有更高的总体CPU内存成本，而后者具有更高的通信成本。 +`shard_full_optim_state_dict()`和`scatter_full_optim_state_dict()`都可用于获取分片优化器状态字典以加载。假设完整的优化器状态字典驻留在 CPU 内存中，前者要求每个排名在 CPU 内存中具有完整的字典，其中每个排名单独对字典进行分片而无需任何通信，而后者仅要求排名 0 在 CPU 内存中具有完整的字典，其中排名 0 将每个分片移动到 GPU 内存（用于 NCCL）并适当地将其通信给排名。因此，前者具有更高的总体 CPU 内存成本，而后者具有更高的通信成本。 参数 + **full_optim_state_dict**（*字典**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]*) - 与未扁平化参数对应的优化器状态字典，保存完整的非分片优化器状态。 -+ **模型**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")）- 根模块（可能是或不是[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")实例），其参数对应于`full_optim_state_dict`中的优化器状态。 ++ **模型**（*torch.nn.Module*）- 根模块（可能是或不是`FullyShardedDataParallel`实例），其参数对应于`full_optim_state_dict`中的优化器状态。 + **optim_input**（*可选**[**Union**[**List**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]**]**,* *Iterable**[**torch.nn.Parameter**]**]**]*) - 传递给优化器的输入，表示参数组的[`list`](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")或参数的可迭代对象；如果为`None`，则此方法假定输入为`model.parameters()`。此参数已被弃用，不再需要传递它。（默认值：`None`） -+ **optim**（*可选**[*[*torch.optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*]*) - 将由此方法返回的状态字典加载的优化器。这是优选的参数，用于覆盖`optim_input`。（默认值：`None`） ++ **optim**（*可选***[*torch.optim.Optimizer**]*) - 将由此方法返回的状态字典加载的优化器。这是优选的参数，用于覆盖`optim_input`。（默认值：`None`） 返回 @@ -712,9 +712,9 @@ static sharded_optim_state_dict(model, optim, group=None)¶ 以其分片形式返回优化器状态字典。 -API类似于[`full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict")，但此API将所有非零维状态分块为`ShardedTensor`以节省内存。当使用上下文管理器`with state_dict_type(SHARDED_STATE_DICT):`派生模型`state_dict`时，应仅使用此API。 +API 类似于`full_optim_state_dict()`，但此 API 将所有非零维状态分块为`ShardedTensor`以节省内存。当使用上下文管理器`with state_dict_type(SHARDED_STATE_DICT):`派生模型`state_dict`时，应仅使用此 API。 -有关详细用法，请参考[`full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict "torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict")。 +有关详细用法，请参考`full_optim_state_dict()`。 警告 @@ -728,9 +728,9 @@ API类似于[`full_optim_state_dict()`](#torch.distributed.fsdp.FullyShardedData static state_dict_type(module, state_dict_type, state_dict_config=None, optim_state_dict_config=None)¶ ``` -设置目标模块的所有后代FSDP模块的`state_dict_type`。 +设置目标模块的所有后代 FSDP 模块的`state_dict_type`。 -此上下文管理器具有与[`set_state_dict_type()`](#torch.distributed.fsdp.FullyShardedDataParallel.set_state_dict_type "torch.distributed.fsdp.FullyShardedDataParallel.set_state_dict_type")相同的功能。阅读[`set_state_dict_type()`](#torch.distributed.fsdp.FullyShardedDataParallel.set_state_dict_type "torch.distributed.fsdp.FullyShardedDataParallel.set_state_dict_type")的文档以获取详细信息。 +此上下文管理器具有与`set_state_dict_type()`相同的功能。阅读`set_state_dict_type()`的文档以获取详细信息。 示例： @@ -745,29 +745,25 @@ static state_dict_type(module, state_dict_type, state_dict_config=None, optim_st 参数 -+ **module**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module"））- 根模块。 ++ **module**（*torch.nn.Module**]*) - 目标`state_dict_type`的模型`state_dict`配置。 -+ **state_dict_type**（*StateDictType*） - 要设置的期望`state_dict_type`。 - -+ **state_dict_config**（*可选**[*[*StateDictConfig*](#torch.distributed.fsdp.StateDictConfig "torch.distributed.fsdp.StateDictConfig")*]*) - 目标`state_dict_type`的模型`state_dict`配置。 - -+ **optim_state_dict_config**（*可选**[*[*OptimStateDictConfig*](#torch.distributed.fsdp.OptimStateDictConfig "torch.distributed.fsdp.OptimStateDictConfig")*]*) - 目标`state_dict_type`的优化器`state_dict`配置。 ++ **optim_state_dict_config**（*可选***[*OptimStateDictConfig**]*) - 目标`state_dict_type`的优化器`state_dict`配置。 返回类型 -[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在Python v3.12中)") +[*生成器*](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)¶ ``` -使用此上下文管理器为FSDP实例公开完整参数。 +使用此上下文管理器为 FSDP 实例公开完整参数。 -在模型进行前向/反向传播之后，可以用于获取参数以进行额外处理或检查。它可以接受一个非FSDP模块，并将召唤所有包含的FSDP模块以及它们的子模块的完整参数，取决于`recurse`参数。 +在模型进行前向/反向传播之后，可以用于获取参数以进行额外处理或检查。它可以接受一个非 FSDP 模块，并将召唤所有包含的 FSDP 模块以及它们的子模块的完整参数，取决于`recurse`参数。 注意 -这可以在内部FSDP上使用。 +这可以在内部 FSDP 上使用。 注意 @@ -779,11 +775,11 @@ static summon_full_params(module, recurse=True, writeback=True, rank0_only=False 注意 -完整参数可以被修改，但只有对应于本地参数分片的部分将在上下文管理器退出后保留（除非`writeback=False`，在这种情况下更改将被丢弃）。在FSDP不对参数进行分片的情况下，目前仅当`world_size == 1`或`NO_SHARD`配置时，修改将被持久化，无论`writeback`如何。 +完整参数可以被修改，但只有对应于本地参数分片的部分将在上下文管理器退出后保留（除非`writeback=False`，在这种情况下更改将被丢弃）。在 FSDP 不对参数进行分片的情况下，目前仅当`world_size == 1`或`NO_SHARD`配置时，修改将被持久化，无论`writeback`如何。 注意 -此方法适用于本身不是FSDP但可能包含多个独立FSDP单元的模块。在这种情况下，给定的参数将适用于所有包含的FSDP单元。 +此方法适用于本身不是 FSDP 但可能包含多个独立 FSDP 单元的模块。在这种情况下，给定的参数将适用于所有包含的 FSDP 单元。 警告 @@ -791,23 +787,23 @@ static summon_full_params(module, recurse=True, writeback=True, rank0_only=False 警告 -请注意，`offload_to_cpu`和`rank0_only=False`会导致完整参数被冗余地复制到CPU内存中，对于与GPU位于同一台机器上的情况，这可能会带来CPU内存溢出的风险。建议使用`offload_to_cpu`与`rank0_only=True`。 +请注意，`offload_to_cpu`和`rank0_only=False`会导致完整参数被冗余地复制到 CPU 内存中，对于与 GPU 位于同一台机器上的情况，这可能会带来 CPU 内存溢出的风险。建议使用`offload_to_cpu`与`rank0_only=True`。 参数 -+ **recurse**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*) - 递归召唤所有嵌套FSDP实例的参数（默认值：True）。 ++ **recurse**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*) - 递归召唤所有嵌套 FSDP 实例的参数（默认值：True）。 -+ **writeback**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*) - 如果为`False`，则在上下文管理器退出后对参数的修改将被丢弃；禁用此选项可能会稍微更有效（默认值：True） ++ **writeback**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*) - 如果为`False`，则在上下文管理器退出后对参数的修改将被丢弃；禁用此选项可能会稍微更有效（默认值：True） -+ **rank0_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*,* *可选*) - 如果为`True`，则只有全局排名0上的完整参数会被实现。这意味着在上下文中，只有排名0会有完整参数，其他排名将具有分片参数。请注意，在`rank0_only=True`与`writeback=True`一起使用时不受支持，因为模型参数形状在上下文中的不同排名之间会有所不同，对其进行写入可能会导致在退出上下文时跨排名之间的不一致性。 ++ **rank0_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*,* *可选*) - 如果为`True`，则只有全局排名 0 上的完整参数会被实现。这意味着在上下文中，只有排名 0 会有完整参数，其他排名将具有分片参数。请注意，在`rank0_only=True`与`writeback=True`一起使用时不受支持，因为模型参数形状在上下文中的不同排名之间会有所不同，对其进行写入可能会导致在退出上下文时跨排名之间的不一致性。 -+ **offload_to_cpu**（[*布尔*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12版本)")*,* *可选*) – 如果为`True`，完整的参数会被卸载到CPU。请注意，只有在参数被分片时（对于world_size = 1或`NO_SHARD`配置除外），才会发生此卸载。建议使用`offload_to_cpu`与`rank0_only=True`一起使用，以避免将模型参数的冗余副本卸载到相同的CPU内存中。 ++ **offload_to_cpu**（[*布尔*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 版本)")*,* *可选*) – 如果为`True`，完整的参数会被卸载到 CPU。请注意，只有在参数被分片时（对于 world_size = 1 或`NO_SHARD`配置除外），才会发生此卸载。建议使用`offload_to_cpu`与`rank0_only=True`一起使用，以避免将模型参数的冗余副本卸载到相同的 CPU 内存中。 -+ **with_grads**（[*布尔*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12版本)")*,* *可选*) – 如果为`True`，梯度也会与参数一起取消分片。目前，只有在将`use_orig_params=True`传递给FSDP构造函数并将`offload_to_cpu=False`传递给此方法时才支持此功能。（默认值：`False`） ++ **with_grads**（[*布尔*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 版本)")*,* *可选*) – 如果为`True`，梯度也会与参数一起取消分片。目前，只有在将`use_orig_params=True`传递给 FSDP 构造函数并将`offload_to_cpu=False`传递给此方法时才支持此功能。（默认值：`False`） 返回类型 -[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在Python v3.12版本)") +[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在 Python v3.12 版本)") ```py class torch.distributed.fsdp.BackwardPrefetch(value)¶ @@ -817,23 +813,23 @@ class torch.distributed.fsdp.BackwardPrefetch(value)¶ + `BACKWARD_PRE`：这会增加最多的重叠，但也会增加最多的内存使用量。这会在当前一组参数的梯度计算*之前*预取下一组参数。这会重叠*下一个全局聚集*和*当前梯度计算*，在峰值时，它会在内存中保存当前一组参数、下一组参数和当前一组梯度。 -+ `BACKWARD_POST`：这会减少重叠，但需要更少的内存使用量。这会在当前一组参数的梯度计算*之后*预取下一组参数。这会重叠*当前的reduce-scatter*和*下一个梯度计算*，并在为下一组参数分配内存之前释放当前一组参数，仅在内存中保留下一组参数和当前一组梯度。 ++ `BACKWARD_POST`：这会减少重叠，但需要更少的内存使用量。这会在当前一组参数的梯度计算*之后*预取下一组参数。这会重叠*当前的 reduce-scatter*和*下一个梯度计算*，并在为下一组参数分配内存之前释放当前一组参数，仅在内存中保留下一组参数和当前一组梯度。 -+ FSDP的`backward_prefetch`参数接受`None`，这会完全禁用向后预取。这不会重叠，也不会增加内存使用量。总的来说，我们不建议使用这个设置，因为它可能会显著降低吞吐量。 ++ FSDP 的`backward_prefetch`参数接受`None`，这会完全禁用向后预取。这不会重叠，也不会增加内存使用量。总的来说，我们不建议使用这个设置，因为它可能会显著降低吞吐量。 -更多技术背景：对于使用NCCL后端的单个进程组，任何集合，即使从不同流发出，也会争夺相同的每个设备NCCL流，这意味着发出集合的相对顺序对于重叠很重要。两个向后预取值对应不同的发出顺序。 +更多技术背景：对于使用 NCCL 后端的单个进程组，任何集合，即使从不同流发出，也会争夺相同的每个设备 NCCL 流，这意味着发出集合的相对顺序对于重叠很重要。两个向后预取值对应不同的发出顺序。 ```py class torch.distributed.fsdp.ShardingStrategy(value)¶ ``` -这指定了由[`FullyShardedDataParallel`](#torch.distributed.fsdp.FullyShardedDataParallel "torch.distributed.fsdp.FullyShardedDataParallel")用于分布式训练的分片策略。 +这指定了由`FullyShardedDataParallel`用于分布式训练的分片策略。 -+ `FULL_SHARD`：参数、梯度和优化器状态被分片。对于参数，此策略在前向传递之前取消分片（通过全局聚集），在前向传递后重新分片，在向后计算之前取消分片，并在向后计算后重新分片。对于梯度，它在向后计算后同步和分片它们（通过reduce-scatter）。分片的优化器状态在每个秩上本地更新。 ++ `FULL_SHARD`：参数、梯度和优化器状态被分片。对于参数，此策略在前向传递之前取消分片（通过全局聚集），在前向传递后重新分片，在向后计算之前取消分片，并在向后计算后重新分片。对于梯度，它在向后计算后同步和分片它们（通过 reduce-scatter）。分片的优化器状态在每个秩上本地更新。 + `SHARD_GRAD_OP`：梯度和优化器状态在计算过程中被分片，此外，参数在计算之外被分片。对于参数，此策略在前向传递之前取消分片，在前向传递后不再分片，仅在向后计算后重新分片。分片的优化器状态在每个秩上本地更新。在`no_sync()`中，参数在向后计算后不再分片。 -+ `NO_SHARD`：参数、梯度和优化器状态不分片，而是在各个秩之间复制，类似于PyTorch的`DistributedDataParallel`API。对于梯度，此策略在向后计算后同步它们（通过全局归约）。未分片的优化器状态在每个秩上本地更新。 ++ `NO_SHARD`：参数、梯度和优化器状态不分片，而是在各个秩之间复制，类似于 PyTorch 的`DistributedDataParallel`API。对于梯度，此策略在向后计算后同步它们（通过全局归约）。未分片的优化器状态在每个秩上本地更新。 + `HYBRID_SHARD`：在节点内应用`FULL_SHARD`，并在节点之间复制参数。这会减少通信量，因为昂贵的所有收集和减少散射仅在节点内完成，对于中等大小的模型可能更高效。 @@ -843,27 +839,27 @@ class torch.distributed.fsdp.ShardingStrategy(value)¶ 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=(, ))¶ ``` -这配置了FSDP本机混合精度训练。 +这配置了 FSDP 本机混合精度训练。 变量 -+ **param_dtype** (*Optional**[*[*torch.dtype*](tensor_attributes.html#torch.dtype "torch.dtype")*]*) – 这指定了模型参数在前向和反向期间的数据类型，因此也是前向和反向计算的数据类型。在前向和反向之外，*分片*参数保持全精度（例如，用于优化器步骤），并且对于模型检查点，参数始终以全精度保存。（默认值：`None`） ++ **param_dtype** (*Optional***[*torch.dtype**]*) – 这指定了模型参数在前向和反向期间的数据类型，因此也是前向和反向计算的数据类型。在前向和反向之外，*分片*参数保持全精度（例如，用于优化器步骤），并且对于模型检查点，参数始终以全精度保存。（默认值：`None`） -+ **reduce_dtype** (*Optional**[*[*torch.dtype*](tensor_attributes.html#torch.dtype "torch.dtype")*]*) – 这指定了梯度减少的数据类型（即reduce-scatter或all-reduce）。如果这是`None`，但`param_dtype`不是`None`，那么它将采用`param_dtype`的值，仍然以低精度运行梯度减少。这允许与`param_dtype`不同，例如强制梯度减少以全精度运行。（默认值：`None`） ++ **reduce_dtype** (*Optional***[*torch.dtype**]*) – 这指定了梯度减少的数据类型（即 reduce-scatter 或 all-reduce）。如果这是`None`，但`param_dtype`不是`None`，那么它将采用`param_dtype`的值，仍然以低精度运行梯度减少。这允许与`param_dtype`不同，例如强制梯度减少以全精度运行。（默认值：`None`） -+ **buffer_dtype** (*Optional**[*[*torch.dtype*](tensor_attributes.html#torch.dtype "torch.dtype")*]*) – 这指定了缓冲区的数据类型。FSDP不对缓冲区进行分片。相反，FSDP在第一次前向传递中将它们转换为`buffer_dtype`，并在此后保持该数据类型。对于模型检查点，缓冲区以全精度保存，除了`LOCAL_STATE_DICT`。（默认值：`None`） ++ **buffer_dtype** (*Optional***[*torch.dtype**]*) – 这指定了缓冲区的数据类型。FSDP 不对缓冲区进行分片。相反，FSDP 在第一次前向传递中将它们转换为`buffer_dtype`，并在此后保持该数据类型。对于模型检查点，缓冲区以全精度保存，除了`LOCAL_STATE_DICT`。（默认值：`None`） -+ **keep_low_precision_grads** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`False`，则FSDP在反向传递后将梯度向上转换为全精度，以准备进行优化器步骤。如果为`True`，则FSDP保持梯度在用于梯度减少的数据类型中，这可以节省内存，如果使用支持低精度运行的自定义优化器。（默认值：`False`） ++ **keep_low_precision_grads** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`False`，则 FSDP 在反向传递后将梯度向上转换为全精度，以准备进行优化器步骤。如果为`True`，则 FSDP 保持梯度在用于梯度减少的数据类型中，这可以节省内存，如果使用支持低精度运行的自定义优化器。（默认值：`False`） -+ **cast_forward_inputs** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`，则此FSDP模块将其前向参数和kwargs转换为`param_dtype`。这是为了确保前向计算所需的参数和输入数据类型匹配，许多操作都需要。当仅对一些而不是所有FSDP模块应用混合精度时，可能需要将其设置为`True`，在这种情况下，混合精度FSDP子模块需要重新转换其输入。（默认值：`False`） ++ **cast_forward_inputs** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`，则此 FSDP 模块将其前向参数和 kwargs 转换为`param_dtype`。这是为了确保前向计算所需的参数和输入数据类型匹配，许多操作都需要。当仅对一些而不是所有 FSDP 模块应用混合精度时，可能需要将其设置为`True`，在这种情况下，混合精度 FSDP 子模块需要重新转换其输入。（默认值：`False`） -+ **cast_root_forward_inputs** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`，则根FSDP模块将其前向参数和kwargs转换为`param_dtype`，覆盖`cast_forward_inputs`的值。对于非根FSDP模块，这不会做任何事情。（默认值：`True`） ++ **cast_root_forward_inputs** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`，则根 FSDP 模块将其前向参数和 kwargs 转换为`param_dtype`，覆盖`cast_forward_inputs`的值。对于非根 FSDP 模块，这不会做任何事情。（默认值：`True`） -+ **_module_classes_to_ignore** (*Sequence**[**Type**[*[*torch.nn.modules.module.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")*]**]*) – （Sequence[Type[nn.Module]]）：这指定了在使用`auto_wrap_policy`时要忽略的模块类别：这些类别的模块将单独应用FSDP，关闭混合精度（意味着最终的FSDP构造将偏离指定的策略）。如果未指定`auto_wrap_policy`，则这不会做任何事情。此API是实验性的，可能会更改。（默认值：`(_BatchNorm,)`） ++ **_module_classes_to_ignore** (*Sequence****Type**[*[*torch.nn.modules.module.Module**]**]*) – （Sequence[Type[nn.Module]]）：这指定了在使用`auto_wrap_policy`时要忽略的模块类别：这些类别的模块将单独应用 FSDP，关闭混合精度（意味着最终的 FSDP 构造将偏离指定的策略）。如果未指定`auto_wrap_policy`，则这不会做任何事情。此 API 是实验性的，可能会更改。（默认值：`(_BatchNorm,)`） 注意 -此API是实验性的，可能会更改。 +此 API 是实验性的，可能会更改。 注意 @@ -966,7 +962,7 @@ class torch.distributed.fsdp.ShardedStateDictConfig(offload_to_cpu=False, _use_d 警告 -`_use_dtensor`是[`ShardedStateDictConfig`](#torch.distributed.fsdp.ShardedStateDictConfig "torch.distributed.fsdp.ShardedStateDictConfig")的私有字段，由FSDP用于确定状态字典值的类型。用户不应手动修改`_use_dtensor`。 +`_use_dtensor`是`ShardedStateDictConfig`的私有字段，由 FSDP 用于确定状态字典值的类型。用户不应手动修改`_use_dtensor`。 ```py class torch.distributed.fsdp.LocalStateDictConfig(offload_to_cpu: bool = False)¶ @@ -976,11 +972,11 @@ class torch.distributed.fsdp.LocalStateDictConfig(offload_to_cpu: bool = False) class torch.distributed.fsdp.OptimStateDictConfig(offload_to_cpu=True)¶ ``` -`OptimStateDictConfig`是所有`optim_state_dict`配置类的基类。用户应该实例化一个子类（例如`FullOptimStateDictConfig`）以配置由FSDP支持的相应`optim_state_dict`类型的设置。 +`OptimStateDictConfig`是所有`optim_state_dict`配置类的基类。用户应该实例化一个子类（例如`FullOptimStateDictConfig`）以配置由 FSDP 支持的相应`optim_state_dict`类型的设置。 变量 -**offload_to_cpu**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 如果为`True`，则FSDP将状态字典的张量值转移到CPU，如果为`False`，则FSDP将其保留在原始设备上（即GPU，除非启用了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)¶ @@ -988,7 +984,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`） +**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)¶ @@ -998,11 +994,11 @@ class torch.distributed.fsdp.ShardedOptimStateDictConfig(offload_to_cpu=True, _u 变量 -**_use_dtensor**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 如果为`True`，则FSDP将状态字典的值保存为`DTensor`，如果为`False`，则FSDP将其保存为`ShardedTensor`。（默认值：`False`） +**_use_dtensor**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 如果为`True`，则 FSDP 将状态字典的值保存为`DTensor`，如果为`False`，则 FSDP 将其保存为`ShardedTensor`。（默认值：`False`） 警告 -`_use_dtensor`是[`ShardedOptimStateDictConfig`](#torch.distributed.fsdp.ShardedOptimStateDictConfig "torch.distributed.fsdp.ShardedOptimStateDictConfig")的私有字段，由FSDP用于确定状态字典值的类型。用户不应手动修改`_use_dtensor`。 +`_use_dtensor`是`ShardedOptimStateDictConfig`的私有字段，由 FSDP 用于确定状态字典值的类型。用户不应手动修改`_use_dtensor`。 ```py class torch.distributed.fsdp.LocalOptimStateDictConfig(offload_to_cpu: bool = False)¶ diff --git a/totrans/doc22_050.md b/totrans/doc22_050.md index d42bfa58..4ee542f8 100644 --- a/totrans/doc22_050.md +++ b/totrans/doc22_050.md @@ -1,30 +1,30 @@ # 分布式优化器 -> 原文：[https://pytorch.org/docs/stable/distributed.optim.html](https://pytorch.org/docs/stable/distributed.optim.html) +> 原文：[`pytorch.org/docs/stable/distributed.optim.html`](https://pytorch.org/docs/stable/distributed.optim.html) 警告 -在使用CUDA张量时，不支持分布式优化器 +在使用 CUDA 张量时，不支持分布式优化器 -[`torch.distributed.optim`](#module-torch.distributed.optim "torch.distributed.optim") 暴露了DistributedOptimizer，它接受一个远程参数（`RRef`）的列表，并在参数所在的工作节点上本地运行优化器。分布式优化器可以使用任何本地优化器[基类](optim.html#optimizer-algorithms)来在每个工作节点上应用梯度。 +`torch.distributed.optim` 暴露了 DistributedOptimizer，它接受一个远程参数（`RRef`）的列表，并在参数所在的工作节点上本地运行优化器。分布式优化器可以使用任何本地优化器基类来在每个工作节点上应用梯度。 ```py class torch.distributed.optim.DistributedOptimizer(optimizer_class, params_rref, *args, **kwargs)¶ ``` -DistributedOptimizer接受分布在工作节点上的参数的远程引用，并为每个参数本地应用给定的优化器。 +DistributedOptimizer 接受分布在工作节点上的参数的远程引用，并为每个参数本地应用给定的优化器。 -这个类使用[`get_gradients()`](rpc.html#torch.distributed.autograd.get_gradients "torch.distributed.autograd.get_gradients")来检索特定参数的梯度。 +这个类使用`get_gradients()`来检索特定参数的梯度。 -来自同一客户端或不同客户端的对[`step()`](#torch.distributed.optim.DistributedOptimizer.step "torch.distributed.optim.DistributedOptimizer.step")的并发调用将在每个工作节点上串行化 - 因为每个工作节点的优化器一次只能处理一组梯度。但是，不能保证一个客户端一次只执行一个完整的前向-反向-优化器序列。这意味着应用的梯度可能不对应于给定工作节点上执行的最新前向传递。此外，工作节点之间也没有保证的顺序。 +来自同一客户端或不同客户端的对`step()`的并发调用将在每个工作节点上串行化 - 因为每个工作节点的优化器一次只能处理一组梯度。但是，不能保证一个客户端一次只执行一个完整的前向-反向-优化器序列。这意味着应用的梯度可能不对应于给定工作节点上执行的最新前向传递。此外，工作节点之间也没有保证的顺序。 -DistributedOptimizer默认启用了启用了TorchScript的本地优化器，以便在多线程训练（例如分布式模型并行）的情况下，优化器更新不会受到Python全局解释器锁（GIL）的阻塞。目前大多数优化器都启用了这一特性。您也可以按照[教程](https://github.com/pytorch/tutorials/pull/1465)中的步骤为自定义优化器启用TorchScript支持。 +DistributedOptimizer 默认启用了启用了 TorchScript 的本地优化器，以便在多线程训练（例如分布式模型并行）的情况下，优化器更新不会受到 Python 全局解释器锁（GIL）的阻塞。目前大多数优化器都启用了这一特性。您也可以按照[教程](https://github.com/pytorch/tutorials/pull/1465)中的步骤为自定义优化器启用 TorchScript 支持。 参数 -+ **optimizer_class** ([*optim.Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")) – 在每个工作节点上实例化的优化器类。 ++ **optimizer_class** (*optim.Optimizer*) – 在每个工作节点上实例化的优化器类。 -+ **params_rref** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")*[**RRef**]*) – 用于优化的本地或远程参数的RRef列表。 ++ **params_rref** ([*list*](https://docs.python.org/3/library/stdtypes.html#list "(in Python v3.12)")*[**RRef**]*) – 用于优化的本地或远程参数的 RRef 列表。 + **args** – 传递给每个工作节点上优化器构造函数的参数。 @@ -62,23 +62,23 @@ step(context_id)¶ 执行单个优化步骤。 -这将在包含要优化的参数的每个工作节点上调用[`torch.optim.Optimizer.step()`](generated/torch.optim.Optimizer.step.html#torch.optim.Optimizer.step "torch.optim.Optimizer.step")，并将阻塞直到所有工作节点返回。提供的`context_id`将用于检索包含应该应用于参数的梯度的相应[`context`](rpc.html#torch.distributed.autograd.context "torch.distributed.autograd.context")。 +这将在包含要优化的参数的每个工作节点上调用`torch.optim.Optimizer.step()`，并将阻塞直到所有工作节点返回。提供的`context_id`将用于检索包含应该应用于参数的梯度的相应`context`。 参数 -**context_id** – 我们应该运行优化器步骤的自动求导上下文id。 +**context_id** – 我们应该运行优化器步骤的自动求导上下文 id。 ```py class torch.distributed.optim.PostLocalSGDOptimizer(optim, averager)¶ ``` -包装任意[`torch.optim.Optimizer`](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")并运行[后局部SGD](https://arxiv.org/abs/1808.07217)，此优化器在每一步都运行本地优化器。在热身阶段之后，它会定期平均参数，然后应用本地优化器。 +包装任意`torch.optim.Optimizer`并运行[后局部 SGD](https://arxiv.org/abs/1808.07217)，此优化器在每一步都运行本地优化器。在热身阶段之后，它会定期平均参数，然后应用本地优化器。 参数 -+ **optim** ([*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.optimizer.Optimizer")) – 本地优化器。 ++ **optim** (*Optimizer*) – 本地优化器。 -+ **averager** (*ModelAverager*) – 一个模型平均器实例，用于运行后局部SGD算法。 ++ **averager** (*ModelAverager*) – 一个模型平均器实例，用于运行后局部 SGD 算法。 示例: @@ -124,15 +124,15 @@ class torch.distributed.optim.PostLocalSGDOptimizer(optim, averager)¶ load_state_dict(state_dict)¶ ``` -这与[`torch.optim.Optimizer`](optim.html#torch.optim.Optimizer "torch.optim.Optimizer") [`load_state_dict()`](#torch.distributed.optim.PostLocalSGDOptimizer.load_state_dict "torch.distributed.optim.PostLocalSGDOptimizer.load_state_dict")相同，但还将模型平均器的步骤值恢复为提供的`state_dict`中保存的值。 +这与`torch.optim.Optimizer` `load_state_dict()`相同，但还将模型平均器的步骤值恢复为提供的`state_dict`中保存的值。 -如果`state_dict`中没有`"step"`条目，它将引发警告并将模型平均器的步骤初始化为0。 +如果`state_dict`中没有`"step"`条目，它将引发警告并将模型平均器的步骤初始化为 0。 ```py state_dict()¶ ``` -这与[`torch.optim.Optimizer`](optim.html#torch.optim.Optimizer "torch.optim.Optimizer") [`state_dict()`](#torch.distributed.optim.PostLocalSGDOptimizer.state_dict "torch.distributed.optim.PostLocalSGDOptimizer.state_dict")相同，但添加了一个额外的条目来记录模型平均器的步骤到检查点，以确保重新加载不会导致不必要的再次热身。 +这与`torch.optim.Optimizer` `state_dict()`相同，但添加了一个额外的条目来记录模型平均器的步骤到检查点，以确保重新加载不会导致不必要的再次热身。 ```py step()¶ @@ -144,27 +144,27 @@ step()¶ class torch.distributed.optim.ZeroRedundancyOptimizer(params, optimizer_class, process_group=None, parameters_as_bucket_view=False, overlap_with_ddp=False, **defaults)¶ ``` -将任意的[`optim.Optimizer`](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")包装起来，并将其状态在组中分片。 +将任意的`optim.Optimizer`包装起来，并将其状态在组中分片。 共享的方式如[ZeRO](https://arxiv.org/abs/1910.02054)所描述。 -每个rank中的本地优化器实例只负责更新大约`1 / world_size`的参数，因此只需要保留`1 / world_size`的优化器状态。在本地更新参数后，每个rank将向所有其他对等体广播其参数，以保持所有模型副本处于相同状态。`ZeroRedundancyOptimizer`可以与[`torch.nn.parallel.DistributedDataParallel`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")一起使用，以减少每个rank的内存消耗峰值。 +每个 rank 中的本地优化器实例只负责更新大约`1 / world_size`的参数，因此只需要保留`1 / world_size`的优化器状态。在本地更新参数后，每个 rank 将向所有其他对等体广播其参数，以保持所有模型副本处于相同状态。`ZeroRedundancyOptimizer`可以与`torch.nn.parallel.DistributedDataParallel`一起使用，以减少每个 rank 的内存消耗峰值。 -`ZeroRedundancyOptimizer`使用一种排序贪婪算法在每个rank上打包一定数量的参数。每个参数属于单个rank，不会在各个rank之间分割。分区是任意的，可能与参数注册或使用顺序不匹配。 +`ZeroRedundancyOptimizer`使用一种排序贪婪算法在每个 rank 上打包一定数量的参数。每个参数属于单个 rank，不会在各个 rank 之间分割。分区是任意的，可能与参数注册或使用顺序不匹配。 参数 -**params** (`Iterable`) – 一个包含所有参数的`Iterable`，这些参数将在各个rank之间进行分片。 +**params** (`Iterable`) – 一个包含所有参数的`Iterable`，这些参数将在各个 rank 之间进行分片。 关键字参数 + **optimizer_class** (`torch.nn.Optimizer`) – 本地优化器的类。 -+ **process_group** (`ProcessGroup`, optional) – `torch.distributed` `ProcessGroup`（默认值：由[`torch.distributed.init_process_group()`](distributed.html#torch.distributed.init_process_group "torch.distributed.init_process_group")初始化的`dist.group.WORLD`）。 ++ **process_group** (`ProcessGroup`, optional) – `torch.distributed` `ProcessGroup`（默认值：由`torch.distributed.init_process_group()`初始化的`dist.group.WORLD`）。 + **parameters_as_bucket_view** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 如果为`True`，参数将被打包成桶以加快通信速度，并且`param.data`字段指向不同偏移量的桶视图；如果为`False`，每个单独的参数将被单独传输，每个`params.data`保持不变（默认值：`False`）。 -+ **overlap_with_ddp** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 如果为`True`，[`step()`](#torch.distributed.optim.ZeroRedundancyOptimizer.step "torch.distributed.optim.ZeroRedundancyOptimizer.step")将与`DistributedDataParallel`的梯度同步重叠；这需要（1）为`optimizer_class`参数提供一个功能性优化器，或者具有功能等效的优化器，并且（2）注册一个由`ddp_zero_hook.py`中的函数构建的DDP通信钩子；参数被打包成与`DistributedDataParallel`中相匹配的桶，这意味着`parameters_as_bucket_view`参数将被忽略。如果为`False`，[`step()`](#torch.distributed.optim.ZeroRedundancyOptimizer.step "torch.distributed.optim.ZeroRedundancyOptimizer.step")在反向传播后（正常情况下）独立运行。 （默认值：`False`） ++ **overlap_with_ddp** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 如果为`True`，`step()`将与`DistributedDataParallel`的梯度同步重叠；这需要（1）为`optimizer_class`参数提供一个功能性优化器，或者具有功能等效的优化器，并且（2）注册一个由`ddp_zero_hook.py`中的函数构建的 DDP 通信钩子；参数被打包成与`DistributedDataParallel`中相匹配的桶，这意味着`parameters_as_bucket_view`参数将被忽略。如果为`False`，`step()`在反向传播后（正常情况下）独立运行。 （默认值：`False`） + ****defaults** – 任何后续参数，将被转发给本地优化器。 @@ -191,11 +191,11 @@ class torch.distributed.optim.ZeroRedundancyOptimizer(params, optimizer_class, p 警告 -如果传递`overlap_with_ddp=True`，请注意以下事项：鉴于当前实现了与[`ZeroRedundancyOptimizer`](#torch.distributed.optim.ZeroRedundancyOptimizer)重叠的`DistributedDataParallel`的方式，前两个或三个训练迭代不会在优化器步骤中执行参数更新，具体取决于`static_graph=False`或`static_graph=True`。这是因为它需要关于`DistributedDataParallel`使用的梯度桶策略的信息，该信息在第二次前向传递（如果`static_graph=False`）或第三次前向传递（如果`static_graph=True`）之前不会最终确定。为了调整此问题，一个选项是在前面添加虚拟输入。 +如果传递`overlap_with_ddp=True`，请注意以下事项：鉴于当前实现了与`ZeroRedundancyOptimizer`重叠的`DistributedDataParallel`的方式，前两个或三个训练迭代不会在优化器步骤中执行参数更新，具体取决于`static_graph=False`或`static_graph=True`。这是因为它需要关于`DistributedDataParallel`使用的梯度桶策略的信息，该信息在第二次前向传递（如果`static_graph=False`）或第三次前向传递（如果`static_graph=True`）之前不会最终确定。为了调整此问题，一个选项是在前面添加虚拟输入。 警告 -ZeroRedundancyOptimizer是实验性的，可能会发生变化。 +ZeroRedundancyOptimizer 是实验性的，可能会发生变化。 ```py add_param_group(param_group)¶ @@ -225,7 +225,7 @@ consolidate_state_dict(to=0)¶ 引发 -[**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError) - 如果`overlap_with_ddp=True`，并且在此[`ZeroRedundancyOptimizer`](#torch.distributed.optim.ZeroRedundancyOptimizer)实例完全初始化之前调用此方法，这会在`DistributedDataParallel`梯度桶被重建后发生。 +[**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError) - 如果`overlap_with_ddp=True`，并且在此`ZeroRedundancyOptimizer`实例完全初始化之前调用此方法，这会在`DistributedDataParallel`梯度桶被重建后发生。 警告 @@ -241,7 +241,7 @@ property join_device: device¶ join_hook(**kwargs)¶ ``` -返回ZeRO连接钩子。 +返回 ZeRO 连接钩子。 它通过在优化器步骤中模拟集体通信来支持不均匀输入的训练。 @@ -267,11 +267,11 @@ load_state_dict(state_dict)¶ 参数 -**state_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict)） - 优化器状态；应该是从调用[`state_dict()`](#torch.distributed.optim.ZeroRedundancyOptimizer.state_dict)返回的对象。 +**state_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict)） - 优化器状态；应该是从调用`state_dict()`返回的对象。 引发 -[**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError) - 如果`overlap_with_ddp=True`，并且在此[`ZeroRedundancyOptimizer`](#torch.distributed.optim.ZeroRedundancyOptimizer)实例完全初始化之前调用此方法，这会在`DistributedDataParallel`梯度桶被重建后发生。 +[**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError) - 如果`overlap_with_ddp=True`，并且在此`ZeroRedundancyOptimizer`实例完全初始化之前调用此方法，这会在`DistributedDataParallel`梯度桶被重建后发生。 ```py state_dict()¶ @@ -281,7 +281,7 @@ state_dict()¶ 引发 -[**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError "(在 Python v3.12 中)") - 如果 `overlap_with_ddp=True` 并且在此 [`ZeroRedundancyOptimizer`](#torch.distributed.optim.ZeroRedundancyOptimizer "torch.distributed.optim.ZeroRedundancyOptimizer") 实例完全初始化之前调用此方法，这会在 `DistributedDataParallel` 梯度桶重建后发生；或者如果在调用此方法之前没有调用 [`consolidate_state_dict()`](#torch.distributed.optim.ZeroRedundancyOptimizer.consolidate_state_dict "torch.distributed.optim.ZeroRedundancyOptimizer.consolidate_state_dict")。 +[**RuntimeError**](https://docs.python.org/3/library/exceptions.html#RuntimeError "(在 Python v3.12 中)") - 如果 `overlap_with_ddp=True` 并且在此 `ZeroRedundancyOptimizer` 实例完全初始化之前调用此方法，这会在 `DistributedDataParallel` 梯度桶重建后发生；或者如果在调用此方法之前没有调用 `consolidate_state_dict()`。 返回类型 diff --git a/totrans/doc22_051.md b/totrans/doc22_051.md index 47d6ec44..b5130e8e 100644 --- a/totrans/doc22_051.md +++ b/totrans/doc22_051.md @@ -1,12 +1,12 @@ # 张量并行 - torch.distributed.tensor.parallel -> 原文：[https://pytorch.org/docs/stable/distributed.tensor.parallel.html](https://pytorch.org/docs/stable/distributed.tensor.parallel.html) +> 原文：[`pytorch.org/docs/stable/distributed.tensor.parallel.html`](https://pytorch.org/docs/stable/distributed.tensor.parallel.html) -张量并行（TP）建立在PyTorch分布式张量（[DTensor](https://github.com/pytorch/pytorch/blob/main/torch/distributed/_tensor/README.md)）之上，并提供不同的并行化样式：列并行和行并行。 +张量并行（TP）建立在 PyTorch 分布式张量（[DTensor](https://github.com/pytorch/pytorch/blob/main/torch/distributed/_tensor/README.md)）之上，并提供不同的并行化样式：列并行和行并行。 警告 -张量并行API是实验性的，可能会发生变化。 +张量并行 API 是实验性的，可能会发生变化。 使用张量并行并行化您的`nn.Module`的入口点是： @@ -14,23 +14,23 @@ torch.distributed.tensor.parallel.parallelize_module(module, device_mesh, parallelize_plan, tp_mesh_dim=0)¶ ``` -通过根据用户指定的计划并行化模块或子模块来应用PyTorch中的张量并行。 +通过根据用户指定的计划并行化模块或子模块来应用 PyTorch 中的张量并行。 我们根据并行化计划并行化模块或子模块。并行化计划包含`ParallelStyle`，指示用户希望如何并行化模块或子模块。 用户还可以根据模块的完全限定名称（FQN）指定不同的并行样式。 -请注意，`parallelize_module`仅接受1-D的`DeviceMesh`，如果您有2-D或N-D的`DeviceMesh`，请先将DeviceMesh切片为1-D子DeviceMesh，然后将其传递给此API（即`device_mesh["tp"]`） +请注意，`parallelize_module`仅接受 1-D 的`DeviceMesh`，如果您有 2-D 或 N-D 的`DeviceMesh`，请先将 DeviceMesh 切片为 1-D 子 DeviceMesh，然后将其传递给此 API（即`device_mesh["tp"]`） 参数 + **module**（`nn.Module`）- 要并行化的模块。 -+ **device_mesh**（`DeviceMesh`）- 描述DTensor设备网格拓扑的对象。 ++ **device_mesh**（`DeviceMesh`）- 描述 DTensor 设备网格拓扑的对象。 -+ **parallelize_plan**（Union[`ParallelStyle`, Dict[str, `ParallelStyle`]]) – 用于并行化模块的计划。可以是一个包含我们如何为张量并行准备输入/输出的`ParallelStyle`对象，也可以是模块FQN及其对应的`ParallelStyle`对象的字典。 ++ **parallelize_plan**（Union[`ParallelStyle`, Dict[str, `ParallelStyle`]]) – 用于并行化模块的计划。可以是一个包含我们如何为张量并行准备输入/输出的`ParallelStyle`对象，也可以是模块 FQN 及其对应的`ParallelStyle`对象的字典。 -+ **tp_mesh_dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* *已弃用*）- 在其中执行张量并行的`device_mesh`的维度，此字段已弃用，并将在将来删除。如果您有一个2-D或N-D的`DeviceMesh`，请考虑传递device_mesh[“tp”] ++ **tp_mesh_dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* *已弃用*）- 在其中执行张量并行的`device_mesh`的维度，此字段已弃用，并将在将来删除。如果您有一个 2-D 或 N-D 的`DeviceMesh`，请考虑传递 device_mesh[“tp”] 返回 @@ -38,7 +38,7 @@ torch.distributed.tensor.parallel.parallelize_module(module, device_mesh, parall 返回类型 -[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module") +*Module* 示例:: @@ -55,7 +55,7 @@ torch.distributed.tensor.parallel.parallelize_module(module, device_mesh, parall 注意 -对于像Attention、MLP层这样的复杂模块架构，我们建议将不同的ParallelStyles组合在一起（即`ColwiseParallel`和`RowwiseParallel`），并将其作为并行化计划传递，以实现所需的分片计算。 +对于像 Attention、MLP 层这样的复杂模块架构，我们建议将不同的 ParallelStyles 组合在一起（即`ColwiseParallel`和`RowwiseParallel`），并将其作为并行化计划传递，以实现所需的分片计算。 张量并行支持以下并行样式： @@ -63,19 +63,19 @@ torch.distributed.tensor.parallel.parallelize_module(module, device_mesh, parall 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） +以行方式对兼容的 nn.Module 进行分区。目前支持 nn.Linear 和 nn.Embedding。用户可以将其与 RowwiseParallel 组合在一起，以实现更复杂模块的分片（即 MLP、Attention） 关键字参数 -+ **input_layouts**（*Placement**,* *可选*）- 用于nn.Module的输入张量的DTensor布局，用于注释输入张量以成为DTensor。如果未指定，则我们假定输入张量是复制的。 ++ **input_layouts**（*Placement**,* *可选*）- 用于 nn.Module 的输入张量的 DTensor 布局，用于注释输入张量以成为 DTensor。如果未指定，则我们假定输入张量是复制的。 -+ **output_layouts**（*Placement**,* *可选*）- 用于nn.Module输出的DTensor布局，用于确保nn.Module的输出具有用户期望的布局。如果未指定，则输出张量在最后一个维度上进行分片。 ++ **output_layouts**（*Placement**,* *可选*）- 用于 nn.Module 输出的 DTensor 布局，用于确保 nn.Module 的输出具有用户期望的布局。如果未指定，则输出张量在最后一个维度上进行分片。 -+ **use_local_output**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *可选*）- 是否使用本地[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")而不是`DTensor`作为模块输出，默认值为True。 ++ **use_local_output**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *可选*）- 是否使用本地`torch.Tensor`而不是`DTensor`作为模块输出，默认值为 True。 返回 -表示nn.Module的Colwise分片的`ParallelStyle`对象。 +表示 nn.Module 的 Colwise 分片的`ParallelStyle`对象。 示例:: @@ -101,19 +101,19 @@ class torch.distributed.tensor.parallel.ColwiseParallel(*, input_layouts=None, o class torch.distributed.tensor.parallel.RowwiseParallel(*, input_layouts=None, output_layouts=None, use_local_output=True)¶ ``` -将兼容的nn.Module按行划分。目前仅支持nn.Linear。用户可以将其与ColwiseParallel组合，以实现更复杂模块的分片（即MLP，Attention） +将兼容的 nn.Module 按行划分。目前仅支持 nn.Linear。用户可以将其与 ColwiseParallel 组合，以实现更复杂模块的分片（即 MLP，Attention） 关键参数 -+ **input_layouts** (*Placement**,* *optional*) – nn.Module的输入张量的DTensor布局，用于注释输入张量以成为DTensor。如果未指定，我们假定输入张量在最后一个维度上被分片。 ++ **input_layouts** (*Placement**,* *optional*) – nn.Module 的输入张量的 DTensor 布局，用于注释输入张量以成为 DTensor。如果未指定，我们假定输入张量在最后一个维度上被分片。 -+ **output_layouts** (*Placement**,* *optional*) – nn.Module输出的DTensor布局，用于确保nn.Module的输出具有用户期望的布局。如果未指定，则输出张量将被复制。 ++ **output_layouts** (*Placement**,* *optional*) – nn.Module 输出的 DTensor 布局，用于确保 nn.Module 的输出具有用户期望的布局。如果未指定，则输出张量将被复制。 -+ **use_local_output** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否使用本地[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")而不是`DTensor`作为模块输出，默认值为True。 ++ **use_local_output** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否使用本地`torch.Tensor`而不是`DTensor`作为模块输出，默认值为 True。 返回 -代表nn.Module的Rowwise分片的`ParallelStyle`对象。 +代表 nn.Module 的 Rowwise 分片的`ParallelStyle`对象。 示例:: @@ -131,25 +131,25 @@ class torch.distributed.tensor.parallel.RowwiseParallel(*, input_layouts=None, o >>> ... ``` -要简单配置nn.Module的输入和输出以及执行必要的布局重分配，而不将模块参数分发到DTensors，可以在`parallelize_module`的`parallelize_plan`中使用以下类： +要简单配置 nn.Module 的输入和输出以及执行必要的布局重分配，而不将模块参数分发到 DTensors，可以在`parallelize_module`的`parallelize_plan`中使用以下类： ```py 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。 +根据`input_layouts`配置 nn.Module 的输入，根据`desired_input_layouts`执行布局重分配，将 nn.Module 的输入张量转换为 DTensors。 关键参数 -+ **input_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module的输入张量的DTensor布局，用于将输入张量转换为DTensors。如果某些输入不是torch.Tensor或不需要转换为DTensors，则需要指定`None`作为占位符。 ++ **input_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module 的输入张量的 DTensor 布局，用于将输入张量转换为 DTensors。如果某些输入不是 torch.Tensor 或不需要转换为 DTensors，则需要指定`None`作为占位符。 -+ **desired_input_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module输入张量的期望DTensor布局，用于确保nn.Module的输入具有期望的DTensor布局。此参数需要与`input_layouts`具有相同的长度。 ++ **desired_input_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module 输入张量的期望 DTensor 布局，用于确保 nn.Module 的输入具有期望的 DTensor 布局。此参数需要与`input_layouts`具有相同的长度。 -+ **use_local_output** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否使用本地[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")而不是`DTensor`作为模块输入，默认值为False。 ++ **use_local_output** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否使用本地`torch.Tensor`而不是`DTensor`作为模块输入，默认值为 False。 返回 -准备nn.Module输入的分片布局的`ParallelStyle`对象。 +准备 nn.Module 输入的分片布局的`ParallelStyle`对象。 示例:: @@ -174,19 +174,19 @@ class torch.distributed.tensor.parallel.PrepareModuleInput(*, input_layouts, des 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。 +根据`output_layouts`配置 nn.Module 的输出，根据`desired_output_layouts`执行布局重分配，将 nn.Module 的输出张量转换为 DTensors。 关键参数 -+ **output_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module输出张量的DTensor布局，用于将输出张量转换为DTensors（如果它们是[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")）。如果某些输出不是torch.Tensor或不需要转换为DTensors，则需要指定`None`作为占位符。 ++ **output_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module 输出张量的 DTensor 布局，用于将输出张量转换为 DTensors（如果它们是`torch.Tensor`）。如果某些输出不是 torch.Tensor 或不需要转换为 DTensors，则需要指定`None`作为占位符。 -+ **desired_output_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module输出张量的期望DTensor布局，用于确保nn.Module的输出具有期望的DTensor布局。 ++ **desired_output_layouts** (*Union**[**Placement**,* *Tuple**[**Placement**]**]*) – nn.Module 输出张量的期望 DTensor 布局，用于确保 nn.Module 的输出具有期望的 DTensor 布局。 -+ **use_local_output** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否使用本地[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")而不是`DTensor`作为模块输出，默认值为False。 ++ **use_local_output** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否使用本地`torch.Tensor`而不是`DTensor`作为模块输出，默认值为 False。 返回 -准备nn.Module输出的分片布局的`ParallelStyle`对象。 +准备 nn.Module 输出的分片布局的`ParallelStyle`对象。 示例:: @@ -207,4 +207,4 @@ class torch.distributed.tensor.parallel.PrepareModuleOutput(*, output_layouts, d >>> ) ``` -对于Transformer等模型，我们建议用户在`parallelize_plan`中同时使用`ColwiseParallel`和`RowwiseParallel`来实现整个模型的期望分片（即Attention和MLP）。 +对于 Transformer 等模型，我们建议用户在`parallelize_plan`中同时使用`ColwiseParallel`和`RowwiseParallel`来实现整个模型的期望分片（即 Attention 和 MLP）。 diff --git a/totrans/doc22_052.md b/totrans/doc22_052.md index 09c59377..e127978a 100644 --- a/totrans/doc22_052.md +++ b/totrans/doc22_052.md @@ -1,14 +1,14 @@ # 分布式检查点 - torch.distributed.checkpoint -> 原文：[https://pytorch.org/docs/stable/distributed.checkpoint.html](https://pytorch.org/docs/stable/distributed.checkpoint.html) +> 原文：[`pytorch.org/docs/stable/distributed.checkpoint.html`](https://pytorch.org/docs/stable/distributed.checkpoint.html) 分布式检查点（DCP）支持并行从多个排名加载和保存模型。它处理加载时的重分片，使得可以在一个集群拓扑中保存并加载到另一个集群拓扑中。 -DCP与torch.save和torch.load在几个重要方面有所不同： +DCP 与 torch.save 和 torch.load 在几个重要方面有所不同： + 每个检查点会生成多个文件，每个排名至少有一个文件。 -+ 它是就地操作，这意味着模型应该首先分配其数据，DCP将使用该存储空间。 ++ 它是就地操作，这意味着模型应该首先分配其数据，DCP 将使用该存储空间。 加载和保存检查点的入口点如下： @@ -16,33 +16,33 @@ DCP与torch.save和torch.load在几个重要方面有所不同： torch.distributed.checkpoint.load(state_dict, storage_reader, *, process_group=None, coordinator_rank=0, no_dist=False, planner=None)¶ ``` -以SPMD风格加载分布式`state_dict`。 +以 SPMD 风格加载分布式`state_dict`。 -每个排名将尝试读取尽可能少的数据以满足请求的state_dict。在加载`ShardedTensor`或`DTensor`实例时，每个排名只读取其本地分片的数据。 +每个排名将尝试读取尽可能少的数据以满足请求的 state_dict。在加载`ShardedTensor`或`DTensor`实例时，每个排名只读取其本地分片的数据。 -对于每个具有`state_dict`和`load_state_dict`的`Stateful`对象，在尝试反序列化之前，load将首先调用`state_dict`，然后在反序列化完成后调用`load_state_dict`。 +对于每个具有`state_dict`和`load_state_dict`的`Stateful`对象，在尝试反序列化之前，load 将首先调用`state_dict`，然后在反序列化完成后调用`load_state_dict`。 警告 `state_dict`中的所有张量必须在调用此函数之前分配到其目标设备上。 -所有非张量数据都是使用torch.load()加载并在state_dict上进行就地修改的。 +所有非张量数据都是使用 torch.load()加载并在 state_dict 上进行就地修改的。 警告 -用户必须在根模块上调用load_state_dict以确保加载后处理和非张量数据正确传播。 +用户必须在根模块上调用 load_state_dict 以确保加载后处理和非张量数据正确传播。 参数 -+ **state_dict**（*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]*) - 要加载的state_dict。请注意，此state dict将就地更新。 ++ **state_dict**（*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]*) - 要加载的 state_dict。请注意，此 state dict 将就地更新。 -+ **storage_reader**（[*StorageReader*](#torch.distributed.checkpoint.StorageReader "torch.distributed.checkpoint.StorageReader")）- 用于加载数据的StorageReader。 ++ **storage_reader**（*StorageReader*）- 用于加载数据的 StorageReader。 -+ **process_group**（*ProcessGroup*）- 用于跨排同步的ProcessGroup。 ++ **process_group**（*ProcessGroup*）- 用于跨排同步的 ProcessGroup。 -+ **coordinator_rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")）- 用于协调检查点的排名。默认情况下使用rank0。 ++ **coordinator_rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")）- 用于协调检查点的排名。默认情况下使用 rank0。 -+ **no_dist**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为`True`，分布式检查点将不以SPMD风格加载。 （默认值：`False`） ++ **no_dist**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为`True`，分布式检查点将不以 SPMD 风格加载。 （默认值：`False`） 返回 @@ -77,13 +77,13 @@ torch.distributed.checkpoint.load(state_dict, storage_reader, *, process_group=N 注意 -load_state_dict使用集合来协调跨排读取。对于基于NCCL的进程组，对象的内部张量表示必须在通信发生之前移动到GPU设备。在这种情况下，使用的设备由`torch.cuda.current_device()`给出，用户有责任确保设置了这一点，以便每个排名都有一个独立的GPU，通过`torch.cuda.set_device()`。 +load_state_dict 使用集合来协调跨排读取。对于基于 NCCL 的进程组，对象的内部张量表示必须在通信发生之前移动到 GPU 设备。在这种情况下，使用的设备由`torch.cuda.current_device()`给出，用户有责任确保设置了这一点，以便每个排名都有一个独立的 GPU，通过`torch.cuda.set_device()`。 ```py torch.distributed.checkpoint.save(state_dict, storage_writer, *, process_group=None, coordinator_rank=0, no_dist=False, planner=None)¶ ``` -以SPMD风格保存分布式模型。 +以 SPMD 风格保存分布式模型。 此函数与`torch.save()`不同，它处理`ShardedTensor`和`DTensor`，通过让每个排名仅保存其本地分片来实现。 @@ -91,31 +91,31 @@ torch.distributed.checkpoint.save(state_dict, storage_writer, *, process_group=N 警告 -对于保存的state_dicts，不保证在PyTorch版本之间的向后兼容性。 +对于保存的 state_dicts，不保证在 PyTorch 版本之间的向后兼容性。 警告 -如果使用process_group参数，请确保只有其排名调用save_state_dict，并且state_dict中的所有数据都属于它。 +如果使用 process_group 参数，请确保只有其排名调用 save_state_dict，并且 state_dict 中的所有数据都属于它。 注意 -对于FSDP的ShardingStrategy.HYBRID_SHARD保存检查点时，只有一个shard_group应该调用save_state_dict，并且需要传递相应的进程组。 +对于 FSDP 的 ShardingStrategy.HYBRID_SHARD 保存检查点时，只有一个 shard_group 应该调用 save_state_dict，并且需要传递相应的进程组。 注意 -通过传递`no_dist=True`，可以在没有初始化进程组的情况下使用此函数保存state_dict。 +通过传递`no_dist=True`，可以在没有初始化进程组的情况下使用此函数保存 state_dict。 参数 -+ **state_dict**（*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]*) - 要保存的state_dict。 ++ **state_dict**（*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Any**]*) - 要保存的 state_dict。 -+ **storage_writer**（[*StorageWriter*](#torch.distributed.checkpoint.StorageWriter "torch.distributed.checkpoint.StorageWriter")）- 用于执行写操作的StorageWriter实例。 ++ **storage_writer**（*StorageWriter*）- 用于执行写操作的 StorageWriter 实例。 -+ **process_group**（*ProcessGroup*） - 用于跨等级同步的ProcessGroup。 ++ **process_group**（*ProcessGroup*） - 用于跨等级同步的 ProcessGroup。 -+ **coordinator_rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 用于协调检查点的等级。默认情况下使用rank0。 ++ **coordinator_rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 用于协调检查点的等级。默认情况下使用 rank0。 -+ **no_dist**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 如果为`True`，分布式检查点将不以SPMD样式保存。（默认值：`False`） ++ **no_dist**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 如果为`True`，分布式检查点将不以 SPMD 样式保存。（默认值：`False`） 返回 @@ -145,7 +145,7 @@ torch.distributed.checkpoint.save(state_dict, storage_writer, *, process_group=N 注意 -save_state_dict使用集合来协调跨等级的写入。对于基于NCCL的进程组，对象的内部张量表示必须在通信发生之前移动到GPU设备。在这种情况下，使用的设备由`torch.cuda.current_device()`给出，用户有责任确保设置正确，以便每个等级都有独立的GPU，通过`torch.cuda.set_device()`。 +save_state_dict 使用集合来协调跨等级的写入。对于基于 NCCL 的进程组，对象的内部张量表示必须在通信发生之前移动到 GPU 设备。在这种情况下，使用的设备由`torch.cuda.current_device()`给出，用户有责任确保设置正确，以便每个等级都有独立的 GPU，通过`torch.cuda.set_device()`。 ```py torch.distributed.checkpoint.load_state_dict(state_dict, storage_reader, process_group=None, coordinator_rank=0, no_dist=False, planner=None)¶ @@ -163,33 +163,33 @@ torch.distributed.checkpoint.save_state_dict(state_dict, storage_writer, process *元数据* -除了上述入口点外，如下所述的Stateful对象在保存/加载期间提供额外的定制化.. automodule:: torch.distributed.checkpoint.stateful +除了上述入口点外，如下所述的 Stateful 对象在保存/加载期间提供额外的定制化.. automodule:: torch.distributed.checkpoint.stateful ```py class torch.distributed.checkpoint.stateful.Stateful(*args, **kwargs)¶ ``` -可以进行检查点和恢复的具有状态的对象的Stateful协议。 +可以进行检查点和恢复的具有状态的对象的 Stateful 协议。 ```py load_state_dict(state_dict)¶ ``` -从提供的state_dict中恢复对象的状态。 +从提供的 state_dict 中恢复对象的状态。 参数 -**state_dict**（[*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中)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)")*]*) - 要从中恢复的状态字典 +**state_dict**（[*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 中)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)")*]*) - 要从中恢复的状态字典 ```py state_dict()¶ ``` -对象应该将它们的state_dict表示作为字典返回。此函数的输出将被检查点，并稍后在load_state_dict()中恢复。 +对象应该将它们的 state_dict 表示作为字典返回。此函数的输出将被检查点，并稍后在 load_state_dict()中恢复。 警告 -由于恢复检查点的就地性质，此函数在torch.distributed.checkpoint.load期间也被调用。 +由于恢复检查点的就地性质，此函数在 torch.distributed.checkpoint.load 期间也被调用。 返回 @@ -199,9 +199,9 @@ state_dict()¶ 字典 -这个[示例](https://github.com/pytorch/pytorch/blob/main/torch/distributed/checkpoint/examples/fsdp_checkpoint_example.py)展示了如何使用Pytorch分布式检查点保存FSDP模型。 +这个[示例](https://github.com/pytorch/pytorch/blob/main/torch/distributed/checkpoint/examples/fsdp_checkpoint_example.py)展示了如何使用 Pytorch 分布式检查点保存 FSDP 模型。 -以下类型定义了检查点期间使用的IO接口： +以下类型定义了检查点期间使用的 IO 接口： ```py class torch.distributed.checkpoint.StorageReader¶ @@ -209,7 +209,7 @@ class torch.distributed.checkpoint.StorageReader¶ `load_state_dict`用于从存储中读取的接口。 -一个StorageReader实例在分布式检查点中同时充当协调员和跟随者。作为初始化的一部分，告知每个实例其角色。 +一个 StorageReader 实例在分布式检查点中同时充当协调员和跟随者。作为初始化的一部分，告知每个实例其角色。 子类应该期望`load_state_dict`按以下顺序调用： @@ -231,11 +231,11 @@ abstract prepare_global_plan(plans)¶ 此方法仅在协调员实例上调用。 -虽然此方法可以生成完全不同的计划，但推荐的方法是将特定于存储的数据存储在LoadPlan::storage_data中。 +虽然此方法可以生成完全不同的计划，但推荐的方法是将特定于存储的数据存储在 LoadPlan::storage_data 中。 参数 -**plans**（[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")*[*[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.planner.LoadPlan")*]*) - 每个等级一个`LoadPlan`实例的列表。 +**plans**（[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")**[*LoadPlan**]*) - 每个等级一个`LoadPlan`实例的列表。 返回 @@ -243,7 +243,7 @@ abstract prepare_global_plan(plans)¶ 返回类型 -[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")[[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.planner.LoadPlan")] +[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*LoadPlan*] ```py abstract prepare_local_plan(plan)¶ @@ -251,11 +251,11 @@ abstract prepare_local_plan(plan)¶ 执行特定于存储的本地规划。 -虽然此方法可以生成完全不同的计划，但推荐的方法是将特定于存储的数据存储在LoadPlan::storage_data中。 +虽然此方法可以生成完全不同的计划，但推荐的方法是将特定于存储的数据存储在 LoadPlan::storage_data 中。 参数 -**plan**（[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.LoadPlan")） - 使用中的`LoadPlan`的本地计划。 +**plan**（*LoadPlan*） - 使用中的`LoadPlan`的本地计划。 返回 @@ -263,7 +263,7 @@ abstract prepare_local_plan(plan)¶ 返回类型 -[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.planner.LoadPlan") +*LoadPlan* ```py abstract read_data(plan, planner)¶ @@ -271,17 +271,17 @@ abstract read_data(plan, planner)¶ 使用`planner`从`plan`中读取所有项目以解析数据。 -子类应调用`LoadPlanner::load_bytes`将BytesIO对象反序列化到正确的位置。 +子类应调用`LoadPlanner::load_bytes`将 BytesIO 对象反序列化到正确的位置。 子类应调用`LoadPlanner::resolve_tensor`来访问应加载数据的张量。 -StorageLayer有责任正确安排所需的任何跨设备复制。 +StorageLayer 有责任正确安排所需的任何跨设备复制。 参数 -+ **plan**（[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.LoadPlan")） - 要执行的本地计划 ++ **plan**（*LoadPlan*） - 要执行的本地计划 -+ **planner**（[*LoadPlanner*](#torch.distributed.checkpoint.LoadPlanner "torch.distributed.checkpoint.LoadPlanner")） - 用于解析项目的计划器对象。 ++ **planner**（*LoadPlanner*） - 用于解析项目的计划器对象。 返回 @@ -289,7 +289,7 @@ StorageLayer有责任正确安排所需的任何跨设备复制。 返回类型 -[*Future*](futures.html#torch.futures.Future "torch.jit.Future")[无] +*Future*[无] ```py abstract read_metadata()¶ @@ -315,7 +315,7 @@ abstract set_up_storage_reader(metadata, is_coordinator)¶ + **metadata**（*Metadata*） - 要使用的元数据模式。 -+ **is_coordinator**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 此实例是否负责协调检查点。 ++ **is_coordinator**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 此实例是否负责协调检查点。 ```py class torch.distributed.checkpoint.StorageWriter¶ @@ -323,7 +323,7 @@ class torch.distributed.checkpoint.StorageWriter¶ `save_state_dict`用于写入存储的接口。 -一个StorageWriter实例在分布式检查点中充当协调器和跟随者。作为初始化的一部分，告知每个实例其角色。 +一个 StorageWriter 实例在分布式检查点中充当协调器和跟随者。作为初始化的一部分，告知每个实例其角色。 子类应该期望以下调用序列。 @@ -349,7 +349,7 @@ abstract finish(metadata, results)¶ + **metadata**（*Metadata*） - 新检查点的元数据 -+ **results**（[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")*[*[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")*[**WriteResult**]**]*) - 所有秩的WriteResults列表。 ++ **results**（[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")*[*[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")*[**WriteResult**]**]*) - 所有秩的 WriteResults 列表。 返回 @@ -367,11 +367,11 @@ abstract prepare_global_plan(plans)¶ 此方法仅在协调器实例上调用。 -虽然此方法可以生成完全不同的计划，但首选方法是将特定于存储的数据存储在SavePlan::storage_data中。 +虽然此方法可以生成完全不同的计划，但首选方法是将特定于存储的数据存储在 SavePlan::storage_data 中。 参数 -**plans**（[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")*[*[*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.planner.SavePlan")*]*) - `SavePlan`实例列表，每个秩一个。 +**plans**（[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")**[*SavePlan**]*) - `SavePlan`实例列表，每个秩一个。 返回 @@ -379,7 +379,7 @@ abstract prepare_global_plan(plans)¶ 返回类型 -[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")[[*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.planner.SavePlan")] +[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*SavePlan*] ```py abstract prepare_local_plan(plan)¶ @@ -387,11 +387,11 @@ abstract prepare_local_plan(plan)¶ 执行特定于存储的本地规划。 -虽然此方法可以生成完全不同的计划，但推荐的方法是将特定于存储的数据存储在SavePlan::storage_data中。 +虽然此方法可以生成完全不同的计划，但推荐的方法是将特定于存储的数据存储在 SavePlan::storage_data 中。 参数 -**plan**（[*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.SavePlan")） - 使用中的`SavePlanner`中的本地计划。 +**plan**（*SavePlan*） - 使用中的`SavePlanner`中的本地计划。 返回 @@ -399,7 +399,7 @@ abstract prepare_local_plan(plan)¶ 返回类型 -[*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.planner.SavePlan") +*SavePlan* ```py abstract set_up_storage_writer(is_coordinator)¶ @@ -409,7 +409,7 @@ abstract set_up_storage_writer(is_coordinator)¶ 参数 -**is_coordinator**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 此实例是否负责协调检查点。 +**is_coordinator**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 此实例是否负责协调检查点。 ```py abstract write_data(plan, planner)¶ @@ -419,7 +419,7 @@ abstract write_data(plan, planner)¶ 子类应该对计划中的每个项目调用`SavePlanner::resolve_data`以获得写入底层对象的访问权限。 -子类应该懒惰地调用resolve_data，因为它可能会分配内存。对于张量，做出以下假设： +子类应该懒惰地调用 resolve_data，因为它可能会分配内存。对于张量，做出以下假设： + 它们可能位于任何设备上，包括与`WriteItem::tensor_data`不匹配的设备 @@ -427,17 +427,17 @@ abstract write_data(plan, planner)¶ 参数 -+ **plan** ([*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.SavePlan")) – 要执行的保存计划。 ++ **plan** (*SavePlan*) – 要执行的保存计划。 -+ **planner** ([*SavePlanner*](#torch.distributed.checkpoint.SavePlanner "torch.distributed.checkpoint.SavePlanner")) – 用于将项目解析为数据的规划器对象。 ++ **planner** (*SavePlanner*) – 用于将项目解析为数据的规划器对象。 返回 -一个将完成为WriteResult列表的未来 +一个将完成为 WriteResult 列表的未来 返回类型 -[*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")[*WriteResult*]] +*Future*[[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*WriteResult*]] 以下类型定义了检查点期间使用的规划器接口： @@ -445,13 +445,13 @@ abstract write_data(plan, planner)¶ class torch.distributed.checkpoint.LoadPlanner¶ ``` -定义load_state_dict用于规划加载过程的协议的抽象类。 +定义 load_state_dict 用于规划加载过程的协议的抽象类。 -LoadPlanner是可以用于自定义整个加载过程的有状态对象。 +LoadPlanner 是可以用于自定义整个加载过程的有状态对象。 -LoadPlanner充当对state_dict的访问代理，因此对其进行的任何转换都将对整个过程可见。 +LoadPlanner 充当对 state_dict 的访问代理，因此对其进行的任何转换都将对整个过程可见。 -在load_state_dict期间，规划器子类可以期望以下调用序列： +在 load_state_dict 期间，规划器子类可以期望以下调用序列： 1. set_up_planner - 在所有等级上调用。 @@ -459,25 +459,25 @@ LoadPlanner充当对state_dict的访问代理，因此对其进行的任何转 1. create_local_plan - 在所有等级上调用。 - 处理state_dict并生成将发送到全局规划的LoadPlan。 + 处理 state_dict 并生成将发送到全局规划的 LoadPlan。 1. create_global_plan - 仅在协调等级上调用。 - 获取所有等级的LoadPlan并做出任何全局决策。 + 获取所有等级的 LoadPlan 并做出任何全局决策。 1. load_bytes - 在每个等级上多次调用 - 对于state_dict中的每个非张量值，调用一次。 + 对于 state_dict 中的每个非张量值，调用一次。 -1. resolve_tensor和commit_tensor - 在每个等级上多次调用 +1. resolve_tensor 和 commit_tensor - 在每个等级上多次调用 - 它们为state_dict中的每个张量值成对调用。 + 它们为 state_dict 中的每个张量值成对调用。 -建议用户扩展DefaultLoadPlanner而不是直接扩展此接口，因为大多数更改可以通过更改单个方法来表达。 +建议用户扩展 DefaultLoadPlanner 而不是直接扩展此接口，因为大多数更改可以通过更改单个方法来表达。 有两种常见的扩展模式： -重写state_dict。这是扩展加载过程的最简单方法，因为它不需要理解LoadPlan的工作原理。由于加载是就地进行的，因此我们需要保留对原始state_dict的引用，因此我们需要能够就地执行它 +重写 state_dict。这是扩展加载过程的最简单方法，因为它不需要理解 LoadPlan 的工作原理。由于加载是就地进行的，因此我们需要保留对原始 state_dict 的引用，因此我们需要能够就地执行它 ```py >>> class RenamePlanner(DefaultLoadPlanner): @@ -500,7 +500,7 @@ LoadPlanner充当对state_dict的访问代理，因此对其进行的任何转 >>> self.original_state_dict[read_item.dest_index.fqn[4:]] = torch.load(value) ``` -修改resolve_tensor和commit_tensor以处理加载时的转换。 +修改 resolve_tensor 和 commit_tensor 以处理加载时的转换。 ```py >>> class MetaModelMaterialize(DefaultSavePlanner): @@ -516,9 +516,9 @@ LoadPlanner充当对state_dict的访问代理，因此对其进行的任何转 abstract commit_tensor(read_item, tensor)¶ ``` -在StorageReader完成将数据加载到`tensor`后调用一次。 +在 StorageReader 完成将数据加载到`tensor`后调用一次。 -提供的张量与调用`resolve_tensor`返回的相同。如果此LoadPlanner需要在将`tensor`复制回state_dict中的张量之前对其进行后处理，则只需要此方法。 +提供的张量与调用`resolve_tensor`返回的相同。如果此 LoadPlanner 需要在将`tensor`复制回 state_dict 中的张量之前对其进行后处理，则只需要此方法。 张量的内容将遵循其设备同步模型。 @@ -532,29 +532,29 @@ abstract create_global_plan(global_plan)¶ 返回类型 -[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")[[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.planner.LoadPlan")] +[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*LoadPlan*] ```py abstract create_local_plan()¶ ``` -根据set_up_planner提供的state_dict和元数据创建一个LoadPlan。 +根据 set_up_planner 提供的 state_dict 和元数据创建一个 LoadPlan。 。注意：在每个等级上调用。 返回类型 -[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.planner.LoadPlan") +*LoadPlan* ```py abstract finish_plan(central_plan)¶ ``` -接受来自协调员的计划并返回最终的LoadPlan。 +接受来自协调员的计划并返回最终的 LoadPlan。 返回类型 -[*LoadPlan*](#torch.distributed.checkpoint.LoadPlan "torch.distributed.checkpoint.planner.LoadPlan") +*LoadPlan* ```py abstract load_bytes(read_item, value)¶ @@ -562,21 +562,21 @@ abstract load_bytes(read_item, value)¶ 加载由`read_item``和``value`描述的项目。 -这种方法预计会就地修改底层的state_dict。 +这种方法预计会就地修改底层的 state_dict。 -`value`的内容由用于生成正在加载的检查点的SavePlanner定义。 +`value`的内容由用于生成正在加载的检查点的 SavePlanner 定义。 ```py abstract resolve_tensor(read_item)¶ ``` -返回由`read_item`描述的张量，以供StorageReader加载read_item使用。 +返回由`read_item`描述的张量，以供 StorageReader 加载 read_item 使用。 -张量应该与底层state_dict上的张量别名，因为StorageReader将替换其内容。如果由于任何原因这不可能，规划器可以使用`commit_tensor`方法将数据复制回state_dict中的数据。 +张量应该与底层 state_dict 上的张量别名，因为 StorageReader 将替换其内容。如果由于任何原因这不可能，规划器可以使用`commit_tensor`方法将数据复制回 state_dict 中的数据。 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py abstract set_up_planner(state_dict, metadata, is_coordinator)¶ @@ -598,11 +598,11 @@ class torch.distributed.checkpoint.ReadItem(type: torch.distributed.checkpoint.p class torch.distributed.checkpoint.SavePlanner¶ ``` -定义由save_state_dict用于规划保存过程的协议的抽象类。 +定义由 save_state_dict 用于规划保存过程的协议的抽象类。 -SavePlanners是可以用来自定义整个保存过程的有状态对象。 +SavePlanners 是可以用来自定义整个保存过程的有状态对象。 -SavePlanner充当对state_dict的访问代理，因此对其进行的任何转换都将对整个过程可见。 +SavePlanner 充当对 state_dict 的访问代理，因此对其进行的任何转换都将对整个过程可见。 在保存状态字典期间，规划器子类可以期望以下调用序列： @@ -612,11 +612,11 @@ SavePlanner充当对state_dict的访问代理，因此对其进行的任何转 1. create_local_plan - 在所有等级上调用。 - 处理state_dict并生成一个将发送给全局规划的SavePlan。 + 处理 state_dict 并生成一个将发送给全局规划的 SavePlan。 1. create_global_plan - 仅在协调员等级上调用。 - 获取所有等级的SavePlan并做出任何全局决定。 + 获取所有等级的 SavePlan 并做出任何全局决定。 1. finish_plan - 在所有等级上调用。 @@ -624,13 +624,13 @@ SavePlanner充当对state_dict的访问代理，因此对其进行的任何转 1. resolve_data - 在每个等级上多次调用 - 在state_dict上查找存储层要写入的值。 + 在 state_dict 上查找存储层要写入的值。 -建议用户扩展DefaultSavePlanner而不是直接扩展此接口，因为大多数更改可以通过单个方法的更改来表达。 +建议用户扩展 DefaultSavePlanner 而不是直接扩展此接口，因为大多数更改可以通过单个方法的更改来表达。 -有3种常见的扩展模式： +有 3 种常见的扩展模式： -重写state_dict。这是扩展保存过程的最简单方法，因为它不需要理解SavePlan的工作原理的复杂性： +重写 state_dict。这是扩展保存过程的最简单方法，因为它不需要理解 SavePlan 的工作原理的复杂性： ```py >>> class RenamePlanner(DefaultSavePlanner): @@ -699,7 +699,7 @@ abstract create_global_plan(all_plans)¶ 返回类型 -[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.planner.SavePlan")], *Metadata*] +[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[*SavePlan*], *Metadata*] ```py abstract create_local_plan()¶ @@ -707,25 +707,25 @@ abstract create_local_plan()¶ 计算当前等级的保存计划。 -这将被聚合并传递给create_global_plan。规划器特定的数据可以通过SavePlan::planner_data传递。 +这将被聚合并传递给 create_global_plan。规划器特定的数据可以通过 SavePlan::planner_data 传递。 这在所有等级上都会被调用。 返回类型 -[*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.planner.SavePlan") +*SavePlan* ```py abstract finish_plan(new_plan)¶ ``` -合并由create_local_plan创建的计划和create_global_plan的结果。 +合并由 create_local_plan 创建的计划和 create_global_plan 的结果。 这在所有等级上都会被调用。 返回类型 -[*SavePlan*](#torch.distributed.checkpoint.SavePlan "torch.distributed.checkpoint.planner.SavePlan") +*SavePlan* ```py abstract resolve_data(write_item)¶ @@ -735,9 +735,9 @@ abstract resolve_data(write_item)¶ 查找与`write_item`在`state_dict`中关联的对象，并在存储层消耗之前应用任何转换（如序列化）。 -在最终SavePlan中的每个WriteItem中，每个等级多次调用，至少一次。 +在最终 SavePlan 中的每个 WriteItem 中，每个等级多次调用，至少一次。 -此方法应该是幂等的和线程安全的。StorageWriter实现可以根据需要频繁调用它。 +此方法应该是幂等的和线程安全的。StorageWriter 实现可以根据需要频繁调用它。 任何分配内存的转换都应该在调用此方法时懒惰地完成，以减少检查点所需的峰值内存。 @@ -745,7 +745,7 @@ abstract resolve_data(write_item)¶ 返回类型 -[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), *BytesIO*] +[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*Tensor*, *BytesIO*] ```py abstract set_up_planner(state_dict, is_coordinator)¶ @@ -825,7 +825,7 @@ lookup_tensor(index)¶ 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py transform_tensor(read_item, tensor)¶ @@ -859,71 +859,53 @@ ddp_state_dict, ddp_optim_state_dict = get_state_dict(ddp_model, ddp_optim) fsdp 参数 -+ **model**（[*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module"） - 模型的 nn.Module。 ++ **model**（*nn.Module**,* *Iterable***[*Optimizer**]**]*) - 用于优化 `model` 的优化器。 -+ **优化器**（*Union**[**None**,* [*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*,* *Iterable**[*[*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*]**]*) - 用于优化 `model` 的优化器。 ++ **子模块**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*集合*](https://docs.python.org/3/library/typing.html#typing.Set "(在 Python v3.12 中)")**[*模块**]**]*) - 可选[Set[nn.Module]]：仅返回属于子模块的模型参数。 -+ **子模块**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*集合*](https://docs.python.org/3/library/typing.html#typing.Set "(在Python v3.12中)")*[*[*模块*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")*]**]*) - 可选[Set[nn.Module]]：仅返回属于子模块的模型参数。 - -+ **选项**（[*StateDictOptions*](#torch.distributed.checkpoint.state_dict.StateDictOptions "torch.distributed.checkpoint.state_dict.StateDictOptions"）- 控制模型state_dict和优化器state_dict应如何返回的选项。有关详细信息，请参见StateDictOptions。 - -返回 - -包含模型state_dict和优化器state_dict的`元组`。 - -返回类型 - -[*元组*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在Python v3.12中)")[[*字典*](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.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.List "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.Tuple "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.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.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.List "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.Tuple "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.Dict "(在Python v3.12中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)"), ValueType]]]]], [*字典*](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.Union "(在Python v3.12中)")[[*字典*](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.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.List "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.Tuple "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.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.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.List "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.Tuple "(在Python v3.12中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[*DTensor*, *ShardedTensor*, [*张量*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在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.Dict "(在Python v3.12中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)"), ValueType]]]]]]]]] ++ **选项**（*StateDictOptions*")[[*字典*](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.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.List "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.Tuple "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.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.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.List "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.Tuple "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.Dict "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), ValueType]]]]], [*字典*](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.Union "(在 Python v3.12 中)")[[*字典*](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.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.List "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.Tuple "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.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.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.List "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.Tuple "(在 Python v3.12 中)")[[*联合*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*DTensor*, *ShardedTensor*, [*张量*, [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 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.Dict "(在 Python v3.12 中)")[[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), ValueType]]]]]]]]] ```py torch.distributed.checkpoint.state_dict.get_model_state_dict(model, *, submodules=None, options=None)¶ ``` -返回`model`的模型state_dict。 +返回`model`的模型 state_dict。 有关详细用法，请参见`get_state_dict`。 参数 -+ **模型**（[*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")） - 模型的nn.Module。 ++ **模型**（*nn.Module*） - 模型的 nn.Module。 -+ **子模块**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*Set*](https://docs.python.org/3/library/typing.html#typing.Set "(在Python v3.12中)")*[*[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")*]**]*) - 可选[Set[nn.Module]]：仅返回属于子模块的模型参数。 ++ **子模块**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*Set*](https://docs.python.org/3/library/typing.html#typing.Set "(在 Python v3.12 中)")**[*Module**]**]*) - 可选[Set[nn.Module]]：仅返回属于子模块的模型参数。 -+ **选项**（[*StateDictOptions*](#torch.distributed.checkpoint.state_dict.StateDictOptions "torch.distributed.checkpoint.state_dict.StateDictOptions"） - 控制如何返回模型state_dict和优化器state_dict的选项。有关详细信息，请参见StateDictOptions。 - -返回 - -`model`的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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), ValueType]]]]] ++ **选项**（*StateDictOptions*")[[str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), ValueType]]]]] ```py torch.distributed.checkpoint.state_dict.get_optimizer_state_dict(model, optimizers, *, submodules=None, options=None)¶ ``` -返回优化器的组合state_dict。 +返回优化器的组合 state_dict。 查看`get_state_dict`以获取详细用法。 参数 -+ **model** ([*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")) – 要模型的nn.Module。 ++ **model** (*nn.Module*) – 要模型的 nn.Module。 -+ **optimizers** (*Union**[**None**,* [*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*,* *Iterable**[*[*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*]**]*) – 用于优化`model`的优化器。 ++ **optimizers** (*Union****None**,* [*Optimizer**,* *Iterable***[*Optimizer**]**]*) – 用于优化`model`的优化器。 + **子模块**（可选） - Optional[Set[Module]]：仅返回属于子模块的模型参数。 -+ **选项**（StateDictOptions） - 控制模型state_dict和优化器state_dict应如何返回的选项。有关详细信息，请参见StateDictOptions。 ++ **选项**（StateDictOptions） - 控制模型 state_dict 和优化器 state_dict 应如何返回的选项。有关详细信息，请参见 StateDictOptions。 返回 -`optimizers`的state_dict。 +`optimizers`的 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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[[*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), ValueType]]]]], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[*DTensor*, *ShardedTensor*, [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), ValueType]]]]]]]] +[*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[[*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), ValueType]]]]], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*DTensor*, *ShardedTensor*, [*Tensor*, [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")]], [*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)"), ValueType]]]]]]]] ```py torch.distributed.checkpoint.state_dict.set_state_dict(model, optimizers, *, model_state_dict, optim_state_dict, options=None)¶ @@ -935,21 +917,19 @@ torch.distributed.checkpoint.state_dict.set_state_dict(model, optimizers, *, mod 参数 -+ **模型**（[*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module"））- 模型的 nn.Module。 - -+ **optimizers**（*Union**[*[*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer"）*，* *Iterable**[*[*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer"）*]***) - 用于优化 `model` 的优化器。 ++ **模型**（*nn.Module* - 用于优化 `model` 的优化器。 -+ **model_state_dict**（[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*Dict*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")*[*[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")*,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]**]*) – (Union[Dict[nn.Module, Dict[str, ValueType]], Dict[str, ValueType]]): 要加载的模型state_dict。如果`model_state_dict`的键是nn.Module，则该键是`model`的子模块，值应为子模块的state_dict。在加载state_dict时，子模块的前缀将附加到state_dict中。 ++ **model_state_dict**（[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*Dict*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")**[*Module**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]**]*) – (Union[Dict[nn.Module, Dict[str, ValueType]], Dict[str, ValueType]]): 要加载的模型 state_dict。如果`model_state_dict`的键是 nn.Module，则该键是`model`的子模块，值应为子模块的 state_dict。在加载 state_dict 时，子模块的前缀将附加到 state_dict 中。 -+ **optim_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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]*) – OptimizerStateType: 要加载的优化器状态字典。 ++ **optim_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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]*) – OptimizerStateType: 要加载的优化器状态字典。 -+ **options**（[*StateDictOptions*](#torch.distributed.checkpoint.state_dict.StateDictOptions "torch.distributed.checkpoint.state_dict.StateDictOptions")） - 控制如何加载模型state_dict和优化器state_dict的选项。有关详细信息，请参见StateDictOptions。 ++ **options**（*StateDictOptions*） - 控制如何加载模型 state_dict 和优化器 state_dict 的选项。有关详细信息，请参见 StateDictOptions。 返回 -+ **missing_keys**是一个包含模型state_dict中缺失键的str列表。 ++ **missing_keys**是一个包含模型 state_dict 中缺失键的 str 列表。 -+ **unexpected_keys**是一个包含模型state_dict中意外键的str列表。 ++ **unexpected_keys**是一个包含模型 state_dict 中意外键的 str 列表。 返回类型 @@ -959,17 +939,17 @@ torch.distributed.checkpoint.state_dict.set_state_dict(model, optimizers, *, mod torch.distributed.checkpoint.state_dict.set_model_state_dict(model, model_state_dict, *, options=None)¶ ``` -加载模型的state_dict。 +加载模型的 state_dict。 -`get_model_state_dict`的对应项，用于将state_dict设置到模型中。有关详细用法，请参见`set_state_dict`。 +`get_model_state_dict`的对应项，用于将 state_dict 设置到模型中。有关详细用法，请参见`set_state_dict`。 参数 -+ **model**（[*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")） - 模型的nn.Module。 ++ **model**（*nn.Module*） - 模型的 nn.Module。 -+ **model_state_dict**（[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*Dict*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")*[*[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")*,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]**]*) – (Union[Dict[nn.Module, Dict[str, ValueType]], Dict[str, ValueType]]): 要加载的模型state_dict。如果`model_state_dict`的键是nn.Module，则该键是`model`的子模块，值应为子模块的state_dict。在加载state_dict时，子模块的前缀将附加到state_dict中。 ++ **model_state_dict**（[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*Dict*](https://docs.python.org/3/library/typing.html#typing.Dict "(in Python v3.12)")**[*Module**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]**]*) – (Union[Dict[nn.Module, Dict[str, ValueType]], Dict[str, ValueType]]): 要加载的模型 state_dict。如果`model_state_dict`的键是 nn.Module，则该键是`model`的子模块，值应为子模块的 state_dict。在加载 state_dict 时，子模块的前缀将附加到 state_dict 中。 -+ **options**（[*StateDictOptions*](#torch.distributed.checkpoint.state_dict.StateDictOptions "torch.distributed.checkpoint.state_dict.StateDictOptions")） - 控制如何加载模型状态字典和优化器状态字典的选项。有关详细信息，请参见StateDictOptions。 ++ **options**（*StateDictOptions*） - 控制如何加载模型状态字典和优化器状态字典的选项。有关详细信息，请参见 StateDictOptions。 返回 @@ -991,13 +971,13 @@ torch.distributed.checkpoint.state_dict.set_optimizer_state_dict(model, optimize 参数 -+ **model**（[*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")） - 模型的 nn.Module。 ++ **model**（*nn.Module*） - 模型的 nn.Module。 -+ **optimizers**（*Union**[*[*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*,* *Iterable**[*[*Optimizer*](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")*]**]*) - 用于优化`model`的优化器。 ++ **optimizers**（*Union***[*Optimizer**,* *Iterable***[*Optimizer**]**]*) - 用于优化`model`的优化器。 -+ **optim_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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**DTensor**,* *ShardedTensor**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]*) – OptimizerStateType: the optimizer state_dict to load. ++ **optim_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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* [*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")*[*[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")***DTensor**,* *ShardedTensor**,* [*Tensor**,* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]**]**,* [*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)")*,* *ValueType**]**]**]**]**]*) – OptimizerStateType: the optimizer state_dict to load. -+ **options** ([*StateDictOptions*](#torch.distributed.checkpoint.state_dict.StateDictOptions "torch.distributed.checkpoint.state_dict.StateDictOptions")) - 控制如何加载模型state_dict和优化器state_dict的选项。有关详细信息，请参阅StateDictOptions。 ++ **options** (*StateDictOptions*) - 控制如何加载模型 state_dict 和优化器 state_dict 的选项。有关详细信息，请参阅 StateDictOptions。 返回 @@ -1011,14 +991,14 @@ None class torch.distributed.checkpoint.state_dict.StateDictOptions(full_state_dict=False, cpu_offload=False, ignore_frozen_params=False, keep_submodule_prefixes=True, strict=True)¶ ``` -此数据类指定了get_state_dict/set_state_dict的工作方式。 +此数据类指定了 get_state_dict/set_state_dict 的工作方式。 -+ `full_state_dict`: 如果设置为True，则返回的state_dict中的所有张量将被收集。返回的state_dict中不会有ShardedTensor和DTensor。 ++ `full_state_dict`: 如果设置为 True，则返回的 state_dict 中的所有张量将被收集。返回的 state_dict 中不会有 ShardedTensor 和 DTensor。 -+ `cpu_offload`: 将所有张量卸载到CPU。为防止CPU OOM，如果`full_state_dict`也为true，则只有rank0会获取state_dict，所有其他rank将获取空的state_dict。 ++ `cpu_offload`: 将所有张量卸载到 CPU。为防止 CPU OOM，如果`full_state_dict`也为 true，则只有 rank0 会获取 state_dict，所有其他 rank 将获取空的 state_dict。 -+ `ignore_frozen_params`: 如果值为True，则返回的state_dict不会包含任何冻结参数 - `requires_grad`为False。默认值为False。 ++ `ignore_frozen_params`: 如果值为 True，则返回的 state_dict 不会包含任何冻结参数 - `requires_grad`为 False。默认值为 False。 -+ `keep_submodule_prefixes`: 当`submodules`不为None时，此选项指示是否保留state_dict键中的子模块前缀。例如，如果子模块是`module.pretrain`，参数的完整FQN是`pretrain.layer1.weight`。当此选项为True时，返回的state_dict中参数的键将是`pretrain.layer1.weight`。如果选项为False，则键将是`layer1.weight`。请注意，如果`keep_submodule_prefixes`为False，则可能存在冲突的FQN，因此`submodules`中应该只有一个子模块。 ++ `keep_submodule_prefixes`: 当`submodules`不为 None 时，此选项指示是否保留 state_dict 键中的子模块前缀。例如，如果子模块是`module.pretrain`，参数的完整 FQN 是`pretrain.layer1.weight`。当此选项为 True 时，返回的 state_dict 中参数的键将是`pretrain.layer1.weight`。如果选项为 False，则键将是`layer1.weight`。请注意，如果`keep_submodule_prefixes`为 False，则可能存在冲突的 FQN，因此`submodules`中应该只有一个子模块。 -+ `strict`: `set_state_dict` 调用 model.load_state_dict() 时的 `strict` 选项。默认值为False。 ++ `strict`: `set_state_dict` 调用 model.load_state_dict() 时的 `strict` 选项。默认值为 False。 diff --git a/totrans/doc22_053.md b/totrans/doc22_053.md index 248c1ef7..e79dbba6 100644 --- a/totrans/doc22_053.md +++ b/totrans/doc22_053.md @@ -1,20 +1,20 @@ # 概率分布 - torch.distributions -> 原文：[https://pytorch.org/docs/stable/distributions.html](https://pytorch.org/docs/stable/distributions.html) +> 原文：[`pytorch.org/docs/stable/distributions.html`](https://pytorch.org/docs/stable/distributions.html) `distributions`包含可参数化的概率分布和采样函数。这允许构建用于优化的随机计算图和随机梯度估计器。该包通常遵循[TensorFlow Distributions](https://arxiv.org/abs/1711.10604)包的设计。 -无法直接通过随机样本进行反向传播。但是，有两种主要方法可以创建可以通过反向传播的替代函数。这些是得分函数估计器/似然比估计器/REINFORCE和路径导数估计器。REINFORCE通常被视为强化学习中策略梯度方法的基础，而路径导数估计器通常在变分自动编码器中的重参数化技巧中看到。虽然得分函数只需要样本值$f(x)$f(x)，但路径导数需要导数$f'(x)$f′(x)。接下来的部分将讨论强化学习示例中的这两种方法。有关更多详细信息，请参见[使用随机计算图进行梯度估计](https://arxiv.org/abs/1506.05254)。 +无法直接通过随机样本进行反向传播。但是，有两种主要方法可以创建可以通过反向传播的替代函数。这些是得分函数估计器/似然比估计器/REINFORCE 和路径导数估计器。REINFORCE 通常被视为强化学习中策略梯度方法的基础，而路径导数估计器通常在变分自动编码器中的重参数化技巧中看到。虽然得分函数只需要样本值$f(x)$f(x)，但路径导数需要导数$f'(x)$f′(x)。接下来的部分将讨论强化学习示例中的这两种方法。有关更多详细信息，请参见[使用随机计算图进行梯度估计](https://arxiv.org/abs/1506.05254)。 ## 得分函数 -当概率密度函数相对于其参数可微时，我们只需要`sample()`和`log_prob()`来实现REINFORCE： +当概率密度函数相对于其参数可微时，我们只需要`sample()`和`log_prob()`来实现 REINFORCE： $\Delta\theta = \alpha r \frac{\partial\log p(a|\pi^\theta(s))}{\partial\theta}$Δθ=αr∂θ∂logp(a∣πθ(s))​ -其中$\theta$θ是参数，$\alpha$α是学习率，$r$r是奖励，$p(a|\pi^\theta(s))$p(a∣πθ(s))是在状态$s$s中根据策略$\pi^\theta$πθ采取行动$a$a的概率。 +其中$\theta$θ是参数，$\alpha$α是学习率，$r$r 是奖励，$p(a|\pi^\theta(s))$p(a∣πθ(s))是在状态$s$s 中根据策略$\pi^\theta$πθ采取行动$a$a 的概率。 -在实践中，我们会从网络的输出中采样一个动作，在环境中应用此动作，然后使用`log_prob`构建等效的损失函数。请注意，我们使用负号，因为优化器使用梯度下降，而上述规则假定梯度上升。对于分类策略，实现REINFORCE的代码如下： +在实践中，我们会从网络的输出中采样一个动作，在环境中应用此动作，然后使用`log_prob`构建等效的损失函数。请注意，我们使用负号，因为优化器使用梯度下降，而上述规则假定梯度上升。对于分类策略，实现 REINFORCE 的代码如下： ```py probs = policy_network(state) @@ -48,13 +48,13 @@ class torch.distributions.distribution.Distribution(batch_shape=torch.Size([]), 基类：[`object`](https://docs.python.org/3/library/functions.html#object "(in Python v3.12)") -Distribution是概率分布的抽象基类。 +Distribution 是概率分布的抽象基类。 ```py property arg_constraints: Dict[str, Constraint]¶ ``` -返回一个从参数名到应满足该分布每个参数的[`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")对象的字典。不需要出现在此字典中的非张量参数。 +返回一个从参数名到应满足该分布每个参数的`Constraint`对象的字典。不需要出现在此字典中的非张量参数。 ```py property batch_shape: Size¶ @@ -70,11 +70,11 @@ cdf(value)¶ 参数 -**value** ([*张量*](tensors.html#torch.Tensor "torch.Tensor")) – +**value** (*张量*) – 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* ```py entropy()¶ @@ -88,29 +88,29 @@ entropy()¶ 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* ```py enumerate_support(expand=True)¶ ``` -返回包含离散分布支持的所有值的张量。结果将枚举维度0，因此结果的形状将是（基数，）+批形状+事件形状（其中事件形状=（）表示单变量分布）。 +返回包含离散分布支持的所有值的张量。结果将枚举维度 0，因此结果的形状将是（基数，）+批形状+事件形状（其中事件形状=（）表示单变量分布）。 -请注意，这会枚举所有批处理张量[[0, 0]，[1, 1]，…]。使用expand=False，枚举沿dim 0进行，但剩余的批处理维度是单例维度，[[0]，[1]，... +请注意，这会枚举所有批处理张量[[0, 0]，[1, 1]，…]。使用 expand=False，枚举沿 dim 0 进行，但剩余的批处理维度是单例维度，[[0]，[1]，... -要遍历完整的笛卡尔积，请使用itertools.product(m.enumerate_support())。 +要遍历完整的笛卡尔积，请使用 itertools.product(m.enumerate_support())。 参数 -**expand**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 是否扩展支持以匹配分布的批量形状。 +**expand**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 是否扩展支持以匹配分布的批量形状。 返回 -在维度0上迭代的张量。 +在维度 0 上迭代的张量。 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py property event_shape: Size¶ @@ -122,7 +122,7 @@ property event_shape: Size¶ expand(batch_shape, _instance=None)¶ ``` -返回一个新的分布实例（或填充由派生类提供的现有实例），其批量维度扩展到batch_shape。此方法在分布的参数上调用[`expand`](generated/torch.Tensor.expand.html#torch.Tensor.expand "torch.Tensor.expand")。因此，这不会为扩展的分布实例分配新内存。此外，在首次创建实例时，这不会重复任何args检查或参数广播在__init__.py中。 +返回一个新的分布实例（或填充由派生类提供的现有实例），其批量维度扩展到 batch_shape。此方法在分布的参数上调用`expand`。因此，这不会为扩展的分布实例分配新内存。此外，在首次创建实例时，这不会重复任何 args 检查或参数广播在 __init__.py 中。 参数 @@ -132,7 +132,7 @@ expand(batch_shape, _instance=None)¶ 返回 -具有批量维度扩展到batch_size的新分布实例。 +具有批量维度扩展到 batch_size 的新分布实例。 ```py icdf(value)¶ @@ -142,11 +142,11 @@ icdf(value)¶ 参数 -**value**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- +**value**（*Tensor*）- 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py log_prob(value)¶ @@ -156,11 +156,11 @@ log_prob(value)¶ 参数 -**value**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- +**value**（*Tensor*）- 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py property mean: Tensor¶ @@ -182,41 +182,41 @@ perplexity()¶ 返回 -形状为batch_shape的张量。 +形状为 batch_shape 的张量。 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py rsample(sample_shape=torch.Size([]))¶ ``` -生成一个sample_shape形状的重参数化样本或者如果分布参数是批量的，则生成一个sample_shape形状的重参数化样本批次。 +生成一个 sample_shape 形状的重参数化样本或者如果分布参数是批量的，则生成一个 sample_shape 形状的重参数化样本批次。 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py sample(sample_shape=torch.Size([]))¶ ``` -生成一个sample_shape形状的样本或者如果分布参数是批量的，则生成一个sample_shape形状的样本批次。 +生成一个 sample_shape 形状的样本或者如果分布参数是批量的，则生成一个 sample_shape 形状的样本批次。 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py sample_n(n)¶ ``` -生成n个样本或者如果分布参数是批量的，则生成n个样本批次。 +生成 n 个样本或者如果分布参数是批量的，则生成 n 个样本批次。 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* ```py static set_default_validate_args(value)¶ @@ -224,11 +224,11 @@ static set_default_validate_args(value)¶ 设置验证是否启用或禁用。 -默认行为模仿Python的`assert`语句：默认情况下启用验证，但如果Python在优化模式下运行（通过`python -O`），则会禁用验证。验证可能很昂贵，因此一旦模型运行正常，您可能希望禁用它。 +默认行为模仿 Python 的`assert`语句：默认情况下启用验证，但如果 Python 在优化模式下运行（通过`python -O`），则会禁用验证。验证可能很昂贵，因此一旦模型运行正常，您可能希望禁用它。 参数 -**value**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 是否启用验证。 +**value**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 是否启用验证。 ```py property stddev: Tensor¶ @@ -240,7 +240,7 @@ property stddev: Tensor¶ property support: Optional[Any]¶ ``` -返回表示此分布支持的[`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")对象。 +返回表示此分布支持的`Constraint`对象。 ```py property variance: Tensor¶ @@ -254,7 +254,7 @@ property variance: Tensor¶ class torch.distributions.exp_family.ExponentialFamily(batch_shape=torch.Size([]), event_shape=torch.Size([]), validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` 指数族是概率分布的抽象基类，属于指数族，其概率质量/密度函数的形式如下所定义 @@ -264,13 +264,13 @@ $p_{F}(x; \theta) = \exp(\langle t(x), \theta\rangle - F(\theta) + k(x))$pF​(x 注意 -这个类是Distribution类和属于指数族的分布之间的中介，主要用于检查.entropy()和解析KL散度方法的正确性。我们使用这个类来使用AD框架和Bregman散度计算熵和KL散度（感谢：Frank Nielsen和Richard Nock，指数族的熵和交叉熵）。 +这个类是 Distribution 类和属于指数族的分布之间的中介，主要用于检查.entropy()和解析 KL 散度方法的正确性。我们使用这个类来使用 AD 框架和 Bregman 散度计算熵和 KL 散度（感谢：Frank Nielsen 和 Richard Nock，指数族的熵和交叉熵）。 ```py entropy()¶ ``` -使用Bregman散度计算熵的方法。 +使用 Bregman 散度计算熵的方法。 ## 伯努利 @@ -278,11 +278,11 @@ entropy()¶ class torch.distributions.bernoulli.Bernoulli(probs=None, logits=None, validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` -创建一个由[`probs`](#torch.distributions.bernoulli.Bernoulli.probs "torch.distributions.bernoulli.Bernoulli.probs")或[`logits`](#torch.distributions.bernoulli.Bernoulli.logits "torch.distributions.bernoulli.Bernoulli.logits")参数化的伯努利分布（但不能同时使用）。 +创建一个由`probs`或`logits`参数化的伯努利分布（但不能同时使用）。 -样本是二进制（0或1）。它们以概率p取值1，以概率1-p取值0。 +样本是二进制（0 或 1）。它们以概率 p 取值 1，以概率 1-p 取值 0。 示例： @@ -294,9 +294,9 @@ tensor([ 0.]) 参数 -+ **probs**（*Number**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 采样1的概率 ++ **probs**（*Number**,* *Tensor*） - 采样 1 的概率 -+ **logits**（*Number**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 采样1的对数几率 ++ **logits**（*Number**,* *Tensor*） - 采样 1 的对数几率 ```py arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}¶ @@ -360,9 +360,9 @@ property variance¶ class torch.distributions.beta.Beta(concentration1, concentration0, validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` -Beta分布由[`concentration1`](#torch.distributions.beta.Beta.concentration1 "torch.distributions.beta.Beta.concentration1")和[`concentration0`](#torch.distributions.beta.Beta.concentration0 "torch.distributions.beta.Beta.concentration0")参数化。 +Beta 分布由`concentration1`和`concentration0`参数化。 示例： @@ -374,9 +374,9 @@ tensor([ 0.1046]) 参数 -+ **concentration1**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的第一个集中参数（通常称为alpha） ++ **concentration1**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* *Tensor*） - 分布的第一个集中参数（通常称为 alpha） -+ **concentration0**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的第二个集中参数（通常称为beta） ++ **concentration0**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* *Tensor*） - 分布的第二个集中参数（通常称为 beta） ```py arg_constraints = {'concentration0': GreaterThan(lower_bound=0.0), 'concentration1': GreaterThan(lower_bound=0.0)}¶ @@ -432,9 +432,9 @@ property variance¶ class torch.distributions.binomial.Binomial(total_count=1, probs=None, logits=None, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建一个由`total_count`和[`probs`](#torch.distributions.binomial.Binomial.probs "torch.distributions.binomial.Binomial.probs")或[`logits`](#torch.distributions.binomial.Binomial.logits "torch.distributions.binomial.Binomial.logits")参数化的二项式分布（但不能同时使用）。`total_count`必须与[`probs`](#torch.distributions.binomial.Binomial.probs "torch.distributions.binomial.Binomial.probs")/[`logits`](#torch.distributions.binomial.Binomial.logits "torch.distributions.binomial.Binomial.logits")可广播。 +创建一个由`total_count`和`probs`或`logits`参数化的二项式分布（但不能同时使用）。`total_count`必须与`probs`/`logits`可广播。 示例： @@ -451,11 +451,11 @@ tensor([[ 4., 5.], 参数 -+ **total_count**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)") *or* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 伯努利试验的次数 ++ **total_count**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)") *or* *Tensor*） - 伯努利试验的次数 -+ **probs**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 事件概率 ++ **probs**（*Tensor*） - 事件概率 -+ **logits**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 事件对数几率 ++ **logits**（*Tensor*） - 事件对数几率 ```py arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0), 'total_count': IntegerGreaterThan(lower_bound=0)}¶ @@ -519,25 +519,25 @@ property variance¶ class torch.distributions.categorical.Categorical(probs=None, logits=None, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建一个由[`probs`](#torch.distributions.categorical.Categorical.probs "torch.distributions.categorical.Categorical.probs")或[`logits`](#torch.distributions.categorical.Categorical.logits "torch.distributions.categorical.Categorical.logits")参数化的分类分布（但不能同时使用）。 +创建一个由`probs`或`logits`参数化的分类分布（但不能同时使用）。 注意 -它等同于[`torch.multinomial()`](generated/torch.multinomial.html#torch.multinomial "torch.multinomial")从中采样的分布。 +它等同于`torch.multinomial()`从中采样的分布。 -样本是从$\{0, \ldots, K-1\}${0,…,K−1}中的整数，其中K是`probs.size(-1)`。 +样本是从$\{0, \ldots, K-1\}${0,…,K−1}中的整数，其中 K 是`probs.size(-1)`。 -如果probs是1维的，长度为K，每个元素是在该索引处采样类的相对概率。 +如果 probs 是 1 维的，长度为 K，每个元素是在该索引处采样类的相对概率。 -如果probs是N维的，则前N-1维被视为相对概率向量的批处理。 +如果 probs 是 N 维的，则前 N-1 维被视为相对概率向量的批处理。 注意 -probs参数必须是非负的、有限的，并且具有非零总和，它将被归一化为沿着最后一个维度总和为1。[`probs`](#torch.distributions.categorical.Categorical.probs "torch.distributions.categorical.Categorical.probs")将返回这个归一化值。logits参数将被解释为未归一化的对数概率，因此可以是任何实数。同样，它将被归一化，以使得得到的概率沿着最后一个维度总和为1。[`logits`](#torch.distributions.categorical.Categorical.logits "torch.distributions.categorical.Categorical.logits")将返回这个归一化值。 +probs 参数必须是非负的、有限的，并且具有非零总和，它将被归一化为沿着最后一个维度总和为 1。`probs`将返回这个归一化值。logits 参数将被解释为未归一化的对数概率，因此可以是任何实数。同样，它将被归一化，以使得得到的概率沿着最后一个维度总和为 1。`logits`将返回这个归一化值。 -另请参见：[`torch.multinomial()`](generated/torch.multinomial.html#torch.multinomial "torch.multinomial") +另请参见：`torch.multinomial()` 示例： @@ -549,9 +549,9 @@ tensor(3) 参数 -+ **probs**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 事件概率 ++ **probs**（*张量*） - 事件概率 -+ **logits**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 事件对数概率（未归一化） ++ **logits**（*张量*） - 事件对数概率（未归一化） ```py arg_constraints = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}¶ @@ -615,9 +615,9 @@ property variance¶ class torch.distributions.cauchy.Cauchy(loc, scale, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -来自柯西（洛伦兹）分布的样本。具有均值为0的独立正态分布随机变量的比率的分布遵循柯西分布。 +来自柯西（洛伦兹）分布的样本。具有均值为 0 的独立正态分布随机变量的比率的分布遵循柯西分布。 示例： @@ -629,9 +629,9 @@ tensor([ 2.3214]) 参数 -+ **loc**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的模式或中位数。 ++ **loc**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *张量*） - 分布的模式或中位数。 -+ **scale**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 半峰宽。 ++ **scale**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *张量*） - 半峰宽。 ```py arg_constraints = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}¶ @@ -687,9 +687,9 @@ property variance¶ class torch.distributions.chi2.Chi2(df, validate_args=None)¶ ``` -基类：[`Gamma`](#torch.distributions.gamma.Gamma "torch.distributions.gamma.Gamma") +基类：`Gamma` -创建由形状参数[`df`](#torch.distributions.chi2.Chi2.df "torch.distributions.chi2.Chi2.df")参数化的卡方分布。这与`Gamma(alpha=0.5*df, beta=0.5)`完全等效。 +创建由形状参数`df`参数化的卡方分布。这与`Gamma(alpha=0.5*df, beta=0.5)`完全等效。 示例： @@ -701,7 +701,7 @@ tensor([ 0.1046]) 参数 -**df**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的形状参数 +**df**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *张量*） - 分布的形状参数 ```py arg_constraints = {'df': GreaterThan(lower_bound=0.0)}¶ @@ -721,9 +721,9 @@ expand(batch_shape, _instance=None)¶ class torch.distributions.continuous_bernoulli.ContinuousBernoulli(probs=None, logits=None, lims=(0.499, 0.501), validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` -创建由[`probs`](#torch.distributions.continuous_bernoulli.ContinuousBernoulli.probs "torch.distributions.continuous_bernoulli.ContinuousBernoulli.probs")或[`logits`](#torch.distributions.continuous_bernoulli.ContinuousBernoulli.logits "torch.distributions.continuous_bernoulli.ContinuousBernoulli.logits")（但不是两者都有）参数化的连续伯努利分布。 +创建由`probs`或`logits`（但不是两者都有）参数化的连续伯努利分布。 该分布在[0,1]中支持，并由‘probs’（在（0,1）中）或‘logits’（实值）参数化。请注意，与伯努利不同，‘probs’不对应概率，‘logits’不对应对数几率，但由于与伯努利的相似性而使用相同的名称。有关更多详细信息，请参阅[1]。 @@ -737,11 +737,11 @@ tensor([ 0.2538]) 参数 -+ **probs**（*数字*，[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - （0,1）值参数 ++ **probs**（*数字*，*张量*） - （0,1）值参数 -+ **logits**（*数字*，[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 实值参数，其Sigmoid匹配‘probs’ ++ **logits**（*数字*，*张量*） - 实值参数，其 Sigmoid 匹配‘probs’ -[1] 连续伯努利：修复变分自动编码器中的普遍错误，Loaiza-Ganem G和Cunningham JP，NeurIPS 2019。[https://arxiv.org/abs/1907.06845](https://arxiv.org/abs/1907.06845) +[1] 连续伯努利：修复变分自动编码器中的普遍错误，Loaiza-Ganem G 和 Cunningham JP，NeurIPS 2019。[`arxiv.org/abs/1907.06845`](https://arxiv.org/abs/1907.06845) ```py arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}¶ @@ -813,7 +813,7 @@ property variance¶ class torch.distributions.dirichlet.Dirichlet(concentration, validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` 创建由浓度`concentration`参数化的狄利克雷分布。 @@ -827,7 +827,7 @@ tensor([ 0.1046, 0.8954]) 参数 -**concentration**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 分布的集中参数（通常称为alpha） +**concentration**（*Tensor*）– 分布的集中参数（通常称为 alpha） ```py arg_constraints = {'concentration': IndependentConstraint(GreaterThan(lower_bound=0.0), 1)}¶ @@ -875,7 +875,7 @@ property variance¶ class torch.distributions.exponential.Exponential(rate, validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` 创建一个由`rate`参数化的指数分布。 @@ -889,7 +889,7 @@ tensor([ 0.1046]) 参数 -**rate**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– rate = 1 / 分布的比例 +**rate**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *Tensor*）– rate = 1 / 分布的比例 ```py arg_constraints = {'rate': GreaterThan(lower_bound=0.0)}¶ @@ -949,9 +949,9 @@ property variance¶ class torch.distributions.fishersnedecor.FisherSnedecor(df1, df2, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建一个由`df1`和`df2`参数化的Fisher-Snedecor分布。 +创建一个由`df1`和`df2`参数化的 Fisher-Snedecor 分布。 示例： @@ -963,9 +963,9 @@ tensor([ 0.2453]) 参数 -+ **df1**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 自由度参数1 ++ **df1**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *Tensor*）– 自由度参数 1 -+ **df2**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 自由度参数2 ++ **df2**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *Tensor*）– 自由度参数 2 ```py arg_constraints = {'df1': GreaterThan(lower_bound=0.0), 'df2': GreaterThan(lower_bound=0.0)}¶ @@ -1009,9 +1009,9 @@ property variance¶ class torch.distributions.gamma.Gamma(concentration, rate, validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` -创建一个由形状`concentration`和`rate`参数化的Gamma分布。 +创建一个由形状`concentration`和`rate`参数化的 Gamma 分布。 示例： @@ -1023,9 +1023,9 @@ tensor([ 0.1046]) 参数 -+ **concentration**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 分布的形状参数（通常称为alpha） ++ **concentration**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *Tensor*）– 分布的形状参数（通常称为 alpha） -+ **rate**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– rate = 1 / 分布的比例（通常称为beta） ++ **rate**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *Tensor*）– rate = 1 / 分布的比例（通常称为 beta） ```py arg_constraints = {'concentration': GreaterThan(lower_bound=0.0), 'rate': GreaterThan(lower_bound=0.0)}¶ @@ -1077,15 +1077,15 @@ property variance¶ class torch.distributions.geometric.Geometric(probs=None, logits=None, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建一个由[`probs`](#torch.distributions.geometric.Geometric.probs "torch.distributions.geometric.Geometric.probs")参数化的几何分布，其中[`probs`](#torch.distributions.geometric.Geometric.probs "torch.distributions.geometric.Geometric.probs")是伯努利试验成功的概率。 +创建一个由`probs`参数化的几何分布，其中`probs`是伯努利试验成功的概率。 $P(X=k) = (1-p)^{k} p, k = 0, 1, ...$P(X=k)=(1−p)kp,k=0,1,... 注意 -[`torch.distributions.geometric.Geometric()`](#torch.distributions.geometric.Geometric "torch.distributions.geometric.Geometric") $(k+1)$(k+1)次试验是第一次成功，因此在$\{0, 1, \ldots\}${0,1,…}中抽取样本，而[`torch.Tensor.geometric_()`](generated/torch.Tensor.geometric_.html#torch.Tensor.geometric_ "torch.Tensor.geometric_")第k次试验是第一次成功，因此在$\{1, 2, \ldots\}${1,2,…}中抽取样本。 +`torch.distributions.geometric.Geometric()` $(k+1)$(k+1)次试验是第一次成功，因此在$\{0, 1, \ldots\}${0,1,…}中抽取样本，而`torch.Tensor.geometric_()`第 k 次试验是第一次成功，因此在$\{1, 2, \ldots\}${1,2,…}中抽取样本。 示例： @@ -1097,9 +1097,9 @@ tensor([ 2.]) 参数 -+ **probs**（*数字**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 抽样1的概率。必须在范围(0, 1]内。 ++ **probs**（*数字**,* *Tensor*）– 抽样 1 的概率。必须在范围(0, 1]内。 -+ **logits**（*数字**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 抽样1的对数几率。 ++ **logits**（*数字**,* *Tensor*）– 抽样 1 的对数几率。 ```py arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}¶ @@ -1151,9 +1151,9 @@ property variance¶ class torch.distributions.gumbel.Gumbel(loc, scale, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` -从Gumbel分布中抽样。 +从 Gumbel 分布中抽样。 示例： @@ -1165,9 +1165,9 @@ tensor([ 1.0124]) 参数 -+ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 分布的位置参数 ++ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *Tensor*）– 分布的位置参数 -+ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）– 分布的比例参数 ++ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *Tensor*）– 分布的比例参数 ```py arg_constraints: Dict[str, Constraint] = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}¶ @@ -1211,9 +1211,9 @@ property variance¶ class torch.distributions.half_cauchy.HalfCauchy(scale, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` -创建一个由比例参数化的半Cauchy分布，其中： +创建一个由比例参数化的半 Cauchy 分布，其中： ```py X ~ Cauchy(0, scale) @@ -1286,7 +1286,7 @@ property variance¶ class torch.distributions.half_normal.HalfNormal(scale, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` 创建由比例参数化的半正态分布，其中： @@ -1361,11 +1361,11 @@ property variance¶ class torch.distributions.independent.Independent(base_distribution, reinterpreted_batch_ndims, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` 将分布的一些批次维度重新解释为事件维度。 -这主要用于改变[`log_prob()`](#torch.distributions.independent.Independent.log_prob "torch.distributions.independent.Independent.log_prob")结果的形状。例如，为了创建一个与多元正态分布具有相同形状的对角正态分布（因此它们可以互换），您可以： +这主要用于改变`log_prob()`结果的形状。例如，为了创建一个与多元正态分布具有相同形状的对角正态分布（因此它们可以互换），您可以： ```py >>> from torch.distributions.multivariate_normal import MultivariateNormal @@ -1447,9 +1447,9 @@ property variance¶ class torch.distributions.inverse_gamma.InverseGamma(concentration, rate, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` -创建由[`concentration`](#torch.distributions.inverse_gamma.InverseGamma.concentration "torch.distributions.inverse_gamma.InverseGamma.concentration")和[`rate`](#torch.distributions.inverse_gamma.InverseGamma.rate "torch.distributions.inverse_gamma.InverseGamma.rate")参数化的逆伽马分布，其中： +创建由`concentration`和`rate`参数化的逆伽马分布，其中： ```py X ~ Gamma(concentration, rate) @@ -1466,9 +1466,9 @@ tensor([ 1.2953]) 参数 -+ **concentration**（*浮点数*或*张量*）- 分布的形状参数（通常称为alpha） ++ **concentration**（*浮点数*或*张量*）- 分布的形状参数（通常称为 alpha） -+ **rate**（*浮点数*或*张量*）- 分布的比例尺率（通常称为beta的倒数） ++ **rate**（*浮点数*或*张量*）- 分布的比例尺率（通常称为 beta 的倒数） ```py arg_constraints: Dict[str, Constraint] = {'concentration': GreaterThan(lower_bound=0.0), 'rate': GreaterThan(lower_bound=0.0)}¶ @@ -1516,9 +1516,9 @@ property variance¶ class torch.distributions.kumaraswamy.Kumaraswamy(concentration1, concentration0, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` -从Kumaraswamy分布中抽样。 +从 Kumaraswamy 分布中抽样。 示例： @@ -1530,9 +1530,9 @@ tensor([ 0.1729]) 参数 -+ **concentration1**（*浮点数*或*张量*）- 分布的第一个浓度参数（通常称为alpha） ++ **concentration1**（*浮点数*或*张量*）- 分布的第一个浓度参数（通常称为 alpha） -+ **concentration0**（*浮点数*或*张量*）- 分布的第二个浓度参数（通常称为beta） ++ **concentration0**（*浮点数*或*张量*）- 分布的第二个浓度参数（通常称为 beta） ```py arg_constraints: Dict[str, Constraint] = {'concentration0': GreaterThan(lower_bound=0.0), 'concentration1': GreaterThan(lower_bound=0.0)}¶ @@ -1572,16 +1572,16 @@ property variance¶ class torch.distributions.lkj_cholesky.LKJCholesky(dim, concentration=1.0, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -LKJ分布用于相关矩阵的下三角Cholesky因子。该分布由`concentration`参数$\eta$η控制，使得从Cholesky因子生成的相关矩阵$M$的概率与$\det(M)^{\eta - 1}$成正比。因此，当`concentration == 1`时，我们得到一个在相关矩阵的Cholesky因子上均匀分布的分布： +LKJ 分布用于相关矩阵的下三角 Cholesky 因子。该分布由`concentration`参数$\eta$η控制，使得从 Cholesky 因子生成的相关矩阵$M$的概率与$\det(M)^{\eta - 1}$成正比。因此，当`concentration == 1`时，我们得到一个在相关矩阵的 Cholesky 因子上均匀分布的分布： ```py L ~ LKJCholesky(dim, concentration) X = L @ L' ~ LKJCorr(dim, concentration) ``` -请注意，此分布对相关矩阵的Cholesky因子进行采样，而不是相关矩阵本身，因此与[1]中对LKJCorr分布的推导略有不同。对于采样，这使用了[1]第3节中的Onion方法。 +请注意，此分布对相关矩阵的 Cholesky 因子进行采样，而不是相关矩阵本身，因此与[1]中对 LKJCorr 分布的推导略有不同。对于采样，这使用了[1]第 3 节中的 Onion 方法。 示例： @@ -1597,11 +1597,11 @@ tensor([[ 1.0000, 0.0000, 0.0000], + **dimension**（*dim*） - 矩阵的维度 -+ **concentration**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的浓度/形状参数（通常称为eta） ++ **concentration**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的浓度/形状参数（通常称为 eta） **参考** -[1] 基于藤和扩展洋葱方法生成随机相关矩阵（2009年），Daniel Lewandowski，Dorota Kurowicka，Harry Joe。多元分析杂志。100. 10.1016/j.jmva.2009.04.008 +[1] 基于藤和扩展洋葱方法生成随机相关矩阵（2009 年），Daniel Lewandowski，Dorota Kurowicka，Harry Joe。多元分析杂志。100. 10.1016/j.jmva.2009.04.008 ```py arg_constraints = {'concentration': GreaterThan(lower_bound=0.0)}¶ @@ -1629,7 +1629,7 @@ support = CorrCholesky()¶ class torch.distributions.laplace.Laplace(loc, scale, validate_args=None)¶ ``` -基础：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基础：`Distribution` 创建一个由`loc`和`scale`参数化的拉普拉斯分布。 @@ -1643,9 +1643,9 @@ tensor([ 0.1046]) 参数 -+ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的均值 ++ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的均值 -+ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的尺度 ++ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的尺度 ```py arg_constraints = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}¶ @@ -1705,9 +1705,9 @@ property variance¶ class torch.distributions.log_normal.LogNormal(loc, scale, validate_args=None)¶ ``` -基础：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基础：`TransformedDistribution` -创建一个由[`loc`](#torch.distributions.log_normal.LogNormal.loc "torch.distributions.log_normal.LogNormal.loc")和[`scale`](#torch.distributions.log_normal.LogNormal.scale "torch.distributions.log_normal.LogNormal.scale")参数化的对数正态分布，其中： +创建一个由`loc`和`scale`参数化的对数正态分布，其中： ```py X ~ Normal(loc, scale) @@ -1724,9 +1724,9 @@ tensor([ 0.1046]) 参数 -+ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的对数均值 ++ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的对数均值 -+ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 对数分布的标准差 ++ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 对数分布的标准差 ```py arg_constraints: Dict[str, Constraint] = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}¶ @@ -1774,7 +1774,7 @@ property variance¶ class torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal(loc, cov_factor, cov_diag, validate_args=None)¶ ``` -基础：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基础：`Distribution` 创建一个具有由`cov_factor`和`cov_diag`参数化的协方差矩阵低秩形式的多元正态分布： @@ -1792,15 +1792,15 @@ tensor([-0.2102, -0.5429]) 参数 -+ **loc**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 具有形状batch_shape + event_shape的分布均值 ++ **loc**（*Tensor*） - 具有形状 batch_shape + event_shape 的分布均值 -+ **cov_factor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 具有形状batch_shape + event_shape + (rank,)的协方差矩阵低秩形式的因子部分 ++ **cov_factor**（*Tensor*） - 具有形状 batch_shape + event_shape + (rank,)的协方差矩阵低秩形式的因子部分 -+ **cov_diag**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 具有形状batch_shape + event_shape的协方差矩阵低秩形式的对角部分 ++ **cov_diag**（*Tensor*） - 具有形状 batch_shape + event_shape 的协方差矩阵低秩形式的对角部分 注意 -当cov_factor.shape[1] << cov_factor.shape[0]时，通过[Woodbury矩阵恒等式](https://en.wikipedia.org/wiki/Woodbury_matrix_identity)和[矩阵行列式引理](https://en.wikipedia.org/wiki/Matrix_determinant_lemma)避免了协方差矩阵的行列式和逆的计算。由于这些公式，我们只需要计算小尺寸“电容”矩阵的行列式和逆： +当 cov_factor.shape[1] << cov_factor.shape[0]时，通过[Woodbury 矩阵恒等式](https://en.wikipedia.org/wiki/Woodbury_matrix_identity)和[矩阵行列式引理](https://en.wikipedia.org/wiki/Matrix_determinant_lemma)避免了协方差矩阵的行列式和逆的计算。由于这些公式，我们只需要计算小尺寸“电容”矩阵的行列式和逆： ```py capacitance = I + cov_factor.T @ inv(cov_diag) @ cov_factor @@ -1864,9 +1864,9 @@ property variance¶ class torch.distributions.mixture_same_family.MixtureSameFamily(mixture_distribution, component_distribution, validate_args=None)¶ ``` -基础：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基础：`Distribution` -MixtureSameFamily分布实现了一个（批量的）混合分布，其中所有组件来自相同分布类型的不同参数化。它由一个分类“选择分布”（选择k个组件）和一个组件分布参数化，即具有右侧批量形状（等于[k]）的分布，用于索引每个（批量的）组件。 +MixtureSameFamily 分布实现了一个（批量的）混合分布，其中所有组件来自相同分布类型的不同参数化。它由一个分类“选择分布”（选择 k 个组件）和一个组件分布参数化，即具有右侧批量形状（等于[k]）的分布，用于索引每个（批量的）组件。 示例： @@ -1894,9 +1894,9 @@ MixtureSameFamily分布实现了一个（批量的）混合分布，其中所有 参数 -+ **混合分布** - torch.distributions.Categorical-like实例。管理选择组件的概率。类别数量必须与component_distribution的最右边批次维度匹配。必须具有标量batch_shape或与component_distribution.batch_shape[:-1]匹配的batch_shape ++ **混合分布** - torch.distributions.Categorical-like 实例。管理选择组件的概率。类别数量必须与 component_distribution 的最右边批次维度匹配。必须具有标量 batch_shape 或与 component_distribution.batch_shape[:-1]匹配的 batch_shape -+ **component_distribution** - torch.distributions.Distribution-like实例。最右边的批次维度索引组件。 ++ **component_distribution** - torch.distributions.Distribution-like 实例。最右边的批次维度索引组件。 ```py arg_constraints: Dict[str, Constraint] = {}¶ @@ -1948,19 +1948,19 @@ property variance¶ class torch.distributions.multinomial.Multinomial(total_count=1, probs=None, logits=None, validate_args=None)¶ ``` -基类：[`分布`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`分布` -创建由[`total_count`](#torch.distributions.multinomial.Multinomial.total_count "torch.distributions.multinomial.Multinomial.total_count")和[`probs`](#torch.distributions.multinomial.Multinomial.probs "torch.distributions.multinomial.Multinomial.probs")或[`logits`](#torch.distributions.multinomial.Multinomial.logits "torch.distributions.multinomial.Multinomial.logits")（但不能同时）参数化的多项式分布。[`probs`](#torch.distributions.multinomial.Multinomial.probs "torch.distributions.multinomial.Multinomial.probs")的最内部维度索引类别。所有其他维度索引批次。 +创建由`total_count`和`probs`或`logits`（但不能同时）参数化的多项式分布。`probs`的最内部维度索引类别。所有其他维度索引批次。 -请注意，如果仅调用[`log_prob()`](#torch.distributions.multinomial.Multinomial.log_prob "torch.distributions.multinomial.Multinomial.log_prob")，则无需指定[`total_count`](#torch.distributions.multinomial.Multinomial.total_count "torch.distributions.multinomial.Multinomial.total_count")（请参见下面的示例） +请注意，如果仅调用`log_prob()`，则无需指定`total_count`（请参见下面的示例） 注意 -probs参数必须是非负的、有限的，并且具有非零总和，它将被归一化为沿着最后一个维度总和为1。[`probs`](#torch.distributions.multinomial.Multinomial.probs "torch.distributions.multinomial.Multinomial.probs")将返回这个归一化值。logits参数将被解释为未归一化的对数概率，因此可以是任意实数。它也将被归一化，使得最终概率沿着最后一个维度总和为1。[`logits`](#torch.distributions.multinomial.Multinomial.logits "torch.distributions.multinomial.Multinomial.logits")将返回这个归一化值。 +probs 参数必须是非负的、有限的，并且具有非零总和，它将被归一化为沿着最后一个维度总和为 1。`probs`将返回这个归一化值。logits 参数将被解释为未归一化的对数概率，因此可以是任意实数。它也将被归一化，使得最终概率沿着最后一个维度总和为 1。`logits`将返回这个归一化值。 -+ [`sample()`](#torch.distributions.multinomial.Multinomial.sample "torch.distributions.multinomial.Multinomial.sample")需要所有参数和样本的单个共享total_count。 ++ `sample()`需要所有参数和样本的单个共享 total_count。 -+ [`log_prob()`](#torch.distributions.multinomial.Multinomial.log_prob "torch.distributions.multinomial.Multinomial.log_prob")允许每个参数和样本有不同的total_count。 ++ `log_prob()`允许每个参数和样本有不同的 total_count。 示例： @@ -1975,14 +1975,9 @@ tensor([-4.1338]) 参数 -+ **total_count**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 试验次数 ++ **total_count**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 试验次数 -+ **probs**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 事件概率 - -+ **对数**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 事件对数概率（未归一化） - -```py -arg_constraints = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}¶ ++ **probs**（*张量*, 1), 'probs': Simplex()}¶ ``` ```py @@ -2035,11 +2030,11 @@ property variance¶ class torch.distributions.multivariate_normal.MultivariateNormal(loc, covariance_matrix=None, precision_matrix=None, scale_tril=None, validate_args=None)¶ ``` -基类：[`分布`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`分布` 创建由均值向量和协方差矩阵参数化的多元正态（也称为高斯）分布。 -多元正态分布可以通过正定协方差矩阵$\mathbf{\Sigma}$Σ或正定精度矩阵$\mathbf{\Sigma}^{-1}$Σ−1或具有正值对角元素的下三角矩阵$\mathbf{L}$L来参数化，使得$\mathbf{\Sigma} = \mathbf{L}\mathbf{L}^\top$Σ=LL⊤。这个三角矩阵可以通过例如协方差的Cholesky分解获得。 +多元正态分布可以通过正定协方差矩阵$\mathbf{\Sigma}$Σ或正定精度矩阵$\mathbf{\Sigma}^{-1}$Σ−1 或具有正值对角元素的下三角矩阵$\mathbf{L}$L 来参数化，使得$\mathbf{\Sigma} = \mathbf{L}\mathbf{L}^\top$Σ=LL⊤。这个三角矩阵可以通过例如协方差的 Cholesky 分解获得。 示例 @@ -2051,19 +2046,13 @@ tensor([-0.2102, -0.5429]) 参数 -+ **loc**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 分布的均值 - -+ **协方差矩阵**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 正定协方差矩阵 - -+ **精度矩阵**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 正定精度矩阵 - -+ **scale_tril**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 协方差的下三角因子，对角线为正值 ++ **loc**（*张量*） - 协方差的下三角因子，对角线为正值 注意 -只能指定[`covariance_matrix`](#torch.distributions.multivariate_normal.MultivariateNormal.covariance_matrix "torch.distributions.multivariate_normal.MultivariateNormal.covariance_matrix")、[`precision_matrix`](#torch.distributions.multivariate_normal.MultivariateNormal.precision_matrix "torch.distributions.multivariate_normal.MultivariateNormal.precision_matrix")或[`scale_tril`](#torch.distributions.multivariate_normal.MultivariateNormal.scale_tril "torch.distributions.multivariate_normal.MultivariateNormal.scale_tril")中的一个。 +只能指定`covariance_matrix`、`precision_matrix`或`scale_tril`中的一个。 -使用[`scale_tril`](#torch.distributions.multivariate_normal.MultivariateNormal.scale_tril "torch.distributions.multivariate_normal.MultivariateNormal.scale_tril")将更有效：所有计算内部都基于[`scale_tril`](#torch.distributions.multivariate_normal.MultivariateNormal.scale_tril "torch.distributions.multivariate_normal.MultivariateNormal.scale_tril")。如果传递的是[`covariance_matrix`](#torch.distributions.multivariate_normal.MultivariateNormal.covariance_matrix "torch.distributions.multivariate_normal.MultivariateNormal.covariance_matrix")或[`precision_matrix`](#torch.distributions.multivariate_normal.MultivariateNormal.precision_matrix "torch.distributions.multivariate_normal.MultivariateNormal.precision_matrix")，则仅用于使用Cholesky分解计算相应的下三角矩阵。 +使用`scale_tril`将更有效：所有计算内部都基于`scale_tril`。如果传递的是`covariance_matrix`或`precision_matrix`，则仅用于使用 Cholesky 分解计算相应的下三角矩阵。 ```py arg_constraints = {'covariance_matrix': PositiveDefinite(), 'loc': IndependentConstraint(Real(), 1), 'precision_matrix': PositiveDefinite(), 'scale_tril': LowerCholesky()}¶ @@ -2123,17 +2112,17 @@ property variance¶ class torch.distributions.negative_binomial.NegativeBinomial(total_count, probs=None, logits=None, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建一个负二项分布，即在达到`total_count`次失败之前成功独立且相同的伯努利试验次数的分布。每次伯努利试验成功的概率是[`probs`](#torch.distributions.negative_binomial.NegativeBinomial.probs "torch.distributions.negative_binomial.NegativeBinomial.probs")。 +创建一个负二项分布，即在达到`total_count`次失败之前成功独立且相同的伯努利试验次数的分布。每次伯努利试验成功的概率是`probs`。 参数 -+ **total_count**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 非负的负伯努利试验次数，尽管分布仍然适用于实值计数 ++ **total_count**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 非负的负伯努利试验次数，尽管分布仍然适用于实值计数 -+ **probs**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 成功事件的概率在半开区间[0, 1]中 ++ **probs**（*Tensor*） - 成功事件的概率在半开区间[0, 1]中 -+ **logits**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 成功概率的事件对数几率 ++ **logits**（*Tensor*） - 成功概率的事件对数几率 ```py arg_constraints = {'logits': Real(), 'probs': HalfOpenInterval(lower_bound=0.0, upper_bound=1.0), 'total_count': GreaterThanEq(lower_bound=0)}¶ @@ -2185,7 +2174,7 @@ property variance¶ class torch.distributions.normal.Normal(loc, scale, validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` 创建一个由`loc`和`scale`参数化的正态（也称为高斯）分布。 @@ -2199,9 +2188,9 @@ tensor([ 0.1046]) 参数 -+ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的均值（通常称为mu） ++ **loc**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的均值（通常称为 mu） -+ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的标准差（通常称为sigma） ++ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的标准差（通常称为 sigma） ```py arg_constraints = {'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}¶ @@ -2265,17 +2254,17 @@ property variance¶ class torch.distributions.one_hot_categorical.OneHotCategorical(probs=None, logits=None, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建一个由[`probs`](#torch.distributions.one_hot_categorical.OneHotCategorical.probs "torch.distributions.one_hot_categorical.OneHotCategorical.probs")或[`logits`](#torch.distributions.one_hot_categorical.OneHotCategorical.logits "torch.distributions.one_hot_categorical.OneHotCategorical.logits")参数化的一位独热分类分布。 +创建一个由`probs`或`logits`参数化的一位独热分类分布。 样本是大小为`probs.size(-1)`的独热编码向量。 注意 -probs参数必须是非负的、有限的，并且具有非零总和，它将被归一化为沿着最后一个维度总和为1。[`probs`](#torch.distributions.one_hot_categorical.OneHotCategorical.probs "torch.distributions.one_hot_categorical.OneHotCategorical.probs")将返回这个归一化值。logits参数将被解释为未归一化的对数概率，因此可以是任意实数。它也将被归一化，使得最终的概率沿着最后一个维度总和为1。[`logits`](#torch.distributions.one_hot_categorical.OneHotCategorical.logits "torch.distributions.one_hot_categorical.OneHotCategorical.logits")将返回这个归一化值。 +probs 参数必须是非负的、有限的，并且具有非零总和，它将被归一化为沿着最后一个维度总和为 1。`probs`将返回这个归一化值。logits 参数将被解释为未归一化的对数概率，因此可以是任意实数。它也将被归一化，使得最终的概率沿着最后一个维度总和为 1。`logits`将返回这个归一化值。 -另请参阅：`torch.distributions.Categorical()`以获取[`probs`](#torch.distributions.one_hot_categorical.OneHotCategorical.probs "torch.distributions.one_hot_categorical.OneHotCategorical.probs")和[`logits`](#torch.distributions.one_hot_categorical.OneHotCategorical.logits "torch.distributions.one_hot_categorical.OneHotCategorical.logits")的规格。 +另请参阅：`torch.distributions.Categorical()`以获取`probs`和`logits`的规格。 示例： @@ -2287,9 +2276,9 @@ tensor([ 0., 0., 0., 1.]) 参数 -+ **probs**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 事件概率 ++ **probs**（*Tensor*） - 事件概率 -+ **logits**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 事件对数概率（未归一化） ++ **logits**（*Tensor*） - 事件对数概率（未归一化） ```py arg_constraints = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}¶ @@ -2353,9 +2342,9 @@ property variance¶ class torch.distributions.pareto.Pareto(scale, alpha, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` -从Pareto Type 1分布中采样。 +从 Pareto Type 1 分布中采样。 示例： @@ -2367,9 +2356,9 @@ tensor([ 1.5623]) 参数 -+ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的比例参数 ++ **scale**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的比例参数 -+ **alpha**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 分布的形状参数 ++ **alpha**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *或* *Tensor*） - 分布的形状参数 ```py arg_constraints: Dict[str, Constraint] = {'alpha': GreaterThan(lower_bound=0.0), 'scale': GreaterThan(lower_bound=0.0)}¶ @@ -2405,7 +2394,7 @@ property variance¶ class torch.distributions.poisson.Poisson(rate, validate_args=None)¶ ``` -基类：[`ExponentialFamily`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`ExponentialFamily` 创建一个由`rate`参数化的泊松分布，即速率参数。 @@ -2423,7 +2412,7 @@ tensor([ 3.]) 参数 -**rate**（*Number**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 速率参数 +**rate**（*Number**,* *Tensor*） - 速率参数 ```py arg_constraints = {'rate': GreaterThanEq(lower_bound=0.0)}¶ @@ -2463,9 +2452,9 @@ property variance¶ class torch.distributions.relaxed_bernoulli.RelaxedBernoulli(temperature, probs=None, logits=None, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` -创建一个由[`temperature`](#torch.distributions.relaxed_bernoulli.RelaxedBernoulli.temperature "torch.distributions.relaxed_bernoulli.RelaxedBernoulli.temperature")参数化的RelaxedBernoulli分布，以及[`probs`](#torch.distributions.relaxed_bernoulli.RelaxedBernoulli.probs "torch.distributions.relaxed_bernoulli.RelaxedBernoulli.probs")或[`logits`](#torch.distributions.relaxed_bernoulli.RelaxedBernoulli.logits "torch.distributions.relaxed_bernoulli.RelaxedBernoulli.logits")（但不能同时）。这是伯努利分布的松弛版本，因此值在(0, 1)之间，并且具有可重参数化的样本。 +创建一个由`temperature`参数化的 RelaxedBernoulli 分布，以及`probs`或`logits`（但不能同时）。这是伯努利分布的松弛版本，因此值在(0, 1)之间，并且具有可重参数化的样本。 示例： @@ -2478,11 +2467,11 @@ tensor([ 0.2951, 0.3442, 0.8918, 0.9021]) 参数 -+ **temperature**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 松弛温度 ++ **temperature**（*Tensor*） - 松弛温度 -+ **probs**（*Number**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 采样1的概率 ++ **probs**（*Number**,* *Tensor*） - 采样 1 的概率 -+ **logits**（*Number**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 采样1的对数几率 ++ **logits**（*Number**,* *Tensor*） - 采样 1 的对数几率 ```py arg_constraints: Dict[str, Constraint] = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}¶ @@ -2518,23 +2507,23 @@ property temperature¶ class torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli(temperature, probs=None, logits=None, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建由[`probs`](#torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.probs "torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.probs")或[`logits`](#torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.logits "torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.logits")（但不是两者）参数化的LogitRelaxedBernoulli分布，它是RelaxedBernoulli分布的对数几率。 +创建由`probs`或`logits`（但不是两者）参数化的 LogitRelaxedBernoulli 分布，它是 RelaxedBernoulli 分布的对数几率。 样本是在(0, 1)范围内的值的对数。更多细节请参见[1]。 参数 -+ **temperature** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 松弛温度 ++ **temperature** (*Tensor*) – 松弛温度 -+ **probs** (*Number**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 采样1的概率 ++ **probs** (*Number**,* *Tensor*) – 采样 1 的概率 -+ **logits** (*Number**,* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 采样1的对数几率 ++ **logits** (*Number**,* *Tensor*) – 采样 1 的对数几率 -[1] 具体分布：离散随机变量的连续松弛（Maddison等人，2017） +[1] 具体分布：离散随机变量的连续松弛（Maddison 等人，2017） -[2] 使用Gumbel-Softmax的分类重参数化（Jang等人，2017） +[2] 使用 Gumbel-Softmax 的分类重参数化（Jang 等人，2017） ```py arg_constraints = {'logits': Real(), 'probs': Interval(lower_bound=0.0, upper_bound=1.0)}¶ @@ -2574,9 +2563,9 @@ support = Real()¶ class torch.distributions.relaxed_categorical.RelaxedOneHotCategorical(temperature, probs=None, logits=None, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution") +基类：`TransformedDistribution` -创建由[`temperature`](#torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.temperature "torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.temperature")参数化的RelaxedOneHotCategorical分布，并且是由[`probs`](#torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.probs "torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.probs")或[`logits`](#torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.logits "torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.logits")参数化的。这是`OneHotCategorical`分布的松弛版本，因此其样本位于单纯形上，并且可重参数化。 +创建由`temperature`参数化的 RelaxedOneHotCategorical 分布，并且是由`probs`或`logits`参数化的。这是`OneHotCategorical`分布的松弛版本，因此其样本位于单纯形上，并且可重参数化。 示例： @@ -2589,11 +2578,11 @@ tensor([ 0.1294, 0.2324, 0.3859, 0.2523]) 参数 -+ **temperature** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 松弛温度 ++ **temperature** (*Tensor*) – 松弛温度 -+ **probs** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 事件概率 ++ **probs** (*Tensor*) – 事件概率 -+ **logits** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 每个事件的未归一化对数概率 ++ **logits** (*Tensor*) – 每个事件的未归一化对数概率 ```py arg_constraints: Dict[str, Constraint] = {'logits': IndependentConstraint(Real(), 1), 'probs': Simplex()}¶ @@ -2629,9 +2618,9 @@ property temperature¶ class torch.distributions.studentT.StudentT(df, loc=0.0, scale=1.0, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -创建由自由度`df`、均值`loc`和标度`scale`参数化的学生t分布。 +创建由自由度`df`、均值`loc`和标度`scale`参数化的学生 t 分布。 示例： @@ -2643,11 +2632,11 @@ tensor([ 0.1046]) 参数 -+ **df** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 自由度 ++ **df** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* *Tensor*) – 自由度 -+ **loc** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 分布的均值 ++ **loc** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* *Tensor*) – 分布的均值 -+ **scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 分布的标度 ++ **scale** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)") *or* *Tensor*) – 分布的标度 ```py arg_constraints = {'df': GreaterThan(lower_bound=0.0), 'loc': Real(), 'scale': GreaterThan(lower_bound=0.0)}¶ @@ -2695,9 +2684,9 @@ property variance¶ class torch.distributions.transformed_distribution.TransformedDistribution(base_distribution, transforms, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution") +基类：`Distribution` -Distribution类的扩展，将一系列变换应用于基本分布。设f为应用的变换的组合： +Distribution 类的扩展，将一系列变换应用于基本分布。设 f 为应用的变换的组合： ```py X ~ BaseDistribution @@ -2705,9 +2694,9 @@ Y = f(X) ~ TransformedDistribution(BaseDistribution, f) log p(Y) = log p(X) + log |det (dX/dY)| ``` -请注意，[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution")的`.event_shape`是其基本分布和变换的最大形状，因为变换可能在事件之间引入相关性。 +请注意，`TransformedDistribution`的`.event_shape`是其基本分布和变换的最大形状，因为变换可能在事件之间引入相关性。 -使用[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution "torch.distributions.transformed_distribution.TransformedDistribution")的示例： +使用`TransformedDistribution`的示例： ```py # Building a Logistic Distribution @@ -2719,7 +2708,7 @@ transforms = [SigmoidTransform().inv, AffineTransform(loc=a, scale=b)] logistic = TransformedDistribution(base_distribution, transforms) ``` -更多示例，请查看[`Gumbel`](#torch.distributions.gumbel.Gumbel)，[`HalfCauchy`](#torch.distributions.half_cauchy.HalfCauchy)，[`HalfNormal`](#torch.distributions.half_normal.HalfNormal)，[`LogNormal`](#torch.distributions.log_normal.LogNormal)，[`Pareto`](#torch.distributions.pareto.Pareto)，[`Weibull`](#torch.distributions.weibull.Weibull)，[`RelaxedBernoulli`](#torch.distributions.relaxed_bernoulli.RelaxedBernoulli)和[`RelaxedOneHotCategorical`](#torch.distributions.relaxed_categorical.RelaxedOneHotCategorical)的实现。 +更多示例，请查看`Gumbel`，`HalfCauchy`，`HalfNormal`，`LogNormal`，`Pareto`，`Weibull`，`RelaxedBernoulli`和`RelaxedOneHotCategorical`的实现。 ```py arg_constraints: Dict[str, Constraint] = {}¶ @@ -2743,7 +2732,7 @@ property has_rsample¶ icdf(value)¶ ``` -使用transform(s)计算逆累积分布函数，并计算基本分布的得分。 +使用 transform(s)计算逆累积分布函数，并计算基本分布的得分。 ```py log_prob(value)¶ @@ -2755,13 +2744,13 @@ log_prob(value)¶ rsample(sample_shape=torch.Size([]))¶ ``` -生成一个形状为sample_shape的重参数化样本或者如果分布参数是批处理的，则生成一个形状为sample_shape的重参数化样本批次。首先从基本分布中抽样，然后对列表中的每个变换应用transform()。 +生成一个形状为 sample_shape 的重参数化样本或者如果分布参数是批处理的，则生成一个形状为 sample_shape 的重参数化样本批次。首先从基本分布中抽样，然后对列表中的每个变换应用 transform()。 ```py sample(sample_shape=torch.Size([]))¶ ``` -如果分布参数是批处理的，则生成一个形状为sample_shape的样本或者形状为sample_shape的样本批次。首先从基本分布中抽样，然后对列表中的每个变换应用transform()。 +如果分布参数是批处理的，则生成一个形状为 sample_shape 的样本或者形状为 sample_shape 的样本批次。首先从基本分布中抽样，然后对列表中的每个变换应用 transform()。 ```py property support¶ @@ -2773,7 +2762,7 @@ property support¶ class torch.distributions.uniform.Uniform(low, high, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution) +基类：`Distribution` 从半开区间`[low, high)`中生成均匀分布的随机样本。 @@ -2849,11 +2838,11 @@ property variance¶ class torch.distributions.von_mises.VonMises(loc, concentration, validate_args=None)¶ ``` -基类：[`Distribution`](#torch.distributions.distribution.Distribution) +基类：`Distribution` -圆形von Mises分布。 +圆形 von Mises 分布。 -此实现使用极坐标。`loc`和`value`参数可以是任何实数（以便进行无约束优化），但被解释为模2 pi的角度。 +此实现使用极坐标。`loc`和`value`参数可以是任何实数（以便进行无约束优化），但被解释为模 2 pi 的角度。 示例： @@ -2899,9 +2888,9 @@ property mode¶ sample(sample_shape=torch.Size([]))¶ ``` -von Mises分布的抽样算法基于以下论文：D.J. Best和N.I. Fisher，“von Mises分布的高效模拟。”应用统计（1979年）：152-157。 +von Mises 分布的抽样算法基于以下论文：D.J. Best 和 N.I. Fisher，“von Mises 分布的高效模拟。”应用统计（1979 年）：152-157。 -采样始终在内部以双精度进行，以避免在集中值较小时（在单精度约为1e-4时）在_rejection_sample()中出现挂起（请参见问题#88443）。 +采样始终在内部以双精度进行，以避免在集中值较小时（在单精度约为 1e-4 时）在 _rejection_sample()中出现挂起（请参见问题#88443）。 ```py support = Real()¶ @@ -2919,7 +2908,7 @@ property variance¶ class torch.distributions.weibull.Weibull(scale, concentration, validate_args=None)¶ ``` -基类：[`TransformedDistribution`](#torch.distributions.transformed_distribution.TransformedDistribution) +基类：`TransformedDistribution` 从双参数威布尔分布中抽样。 @@ -2935,10 +2924,7 @@ tensor([ 0.4784]) + **scale**（*float*或*Tensor*） - 分布的比例参数（lambda）。 -+ **浓度**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 分布的浓度参数（k/形状）。 - -```py -arg_constraints: Dict[str, Constraint] = {'concentration': GreaterThan(lower_bound=0.0), 'scale': GreaterThan(lower_bound=0.0)}¶ ++ **浓度**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *张量*, 'scale': GreaterThan(lower_bound=0.0)}¶ ``` ```py @@ -2971,9 +2957,9 @@ property variance¶ class torch.distributions.wishart.Wishart(df, covariance_matrix=None, precision_matrix=None, scale_tril=None, validate_args=None)¶ ``` -基类：[`指数族`](#torch.distributions.exp_family.ExponentialFamily "torch.distributions.exp_family.ExponentialFamily") +基类：`指数族` -创建由对称正定矩阵$\Sigma$Σ或其Cholesky分解$\mathbf{\Sigma} = \mathbf{L}\mathbf{L}^\top$Σ=LL⊤参数化的Wishart分布 +创建由对称正定矩阵$\Sigma$Σ或其 Cholesky 分解$\mathbf{\Sigma} = \mathbf{L}\mathbf{L}^\top$Σ=LL⊤参数化的 Wishart 分布 示例 @@ -2985,21 +2971,11 @@ class torch.distributions.wishart.Wishart(df, covariance_matrix=None, precision_ 参数 -+ **df**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 大于（方阵的维数）- 1的实值参数 - -+ **协方差矩阵**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 正定协方差矩阵 - -+ **precision_matrix**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 正定精度矩阵 - -+ **scale_tril**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"） - 协方差的下三角因子，对角线为正值 - -注意 - -只能指定[`covariance_matrix`](#torch.distributions.wishart.Wishart.covariance_matrix "torch.distributions.wishart.Wishart.covariance_matrix")、[`precision_matrix`](#torch.distributions.wishart.Wishart.precision_matrix "torch.distributions.wishart.Wishart.precision_matrix")或[`scale_tril`](#torch.distributions.wishart.Wishart.scale_tril "torch.distributions.wishart.Wishart.scale_tril")中的一个。使用[`scale_tril`](#torch.distributions.wishart.Wishart.scale_tril "torch.distributions.wishart.Wishart.scale_tril")将更有效：所有计算内部都基于[`scale_tril`](#torch.distributions.wishart.Wishart.scale_tril "torch.distributions.wishart.Wishart.scale_tril")。如果传递的是[`covariance_matrix`](#torch.distributions.wishart.Wishart.covariance_matrix "torch.distributions.wishart.Wishart.covariance_matrix")或[`precision_matrix`](#torch.distributions.wishart.Wishart.precision_matrix "torch.distributions.wishart.Wishart.precision_matrix")，则仅用于使用Cholesky分解计算相应的下三角矩阵。‘torch.distributions.LKJCholesky’是受限制的Wishart分布。[1] ++ **df**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *张量*、`precision_matrix`或`scale_tril`中的一个。使用`scale_tril`将更有效：所有计算内部都基于`scale_tril`。如果传递的是`covariance_matrix`或`precision_matrix`，则仅用于使用 Cholesky 分解计算相应的下三角矩阵。‘torch.distributions.LKJCholesky’是受限制的 Wishart 分布。[1] **参考** -[1] 王，Z.，吴，Y.和楚，H.，2018。LKJ分布和受限制的Wishart分布的等价性。[2] 索耶，S.，2007。Wishart分布和逆Wishart抽样。[3] 安德森，T. W.，2003。多元统计分析导论（第3版）。[4] 奥德尔，P. L. & 费夫森，A. H.，1966。生成样本协方差矩阵的数值过程。JASA，61(313)：199-203。[5] 顾，Y.-C. & 布鲁姆菲尔德，P.，2010。在OX中生成具有分数自由度的随机Wishart矩阵。 +[1] 王，Z.，吴，Y.和楚，H.，2018。LKJ 分布和受限制的 Wishart 分布的等价性。[2] 索耶，S.，2007。Wishart 分布和逆 Wishart 抽样。[3] 安德森，T. W.，2003。多元统计分析导论（第 3 版）。[4] 奥德尔，P. L. & 费夫森，A. H.，1966。生成样本协方差矩阵的数值过程。JASA，61(313)：199-203。[5] 顾，Y.-C. & 布鲁姆菲尔德，P.，2010。在 OX 中生成具有分数自由度的随机 Wishart 矩阵。 ```py arg_constraints = {'covariance_matrix': PositiveDefinite(), 'df': GreaterThan(lower_bound=0), 'precision_matrix': PositiveDefinite(), 'scale_tril': LowerCholesky()}¶ @@ -3043,7 +3019,7 @@ rsample(sample_shape=torch.Size([]), max_try_correction=None)¶ 警告 -在某些情况下，基于Bartlett分解的采样算法可能返回奇异矩阵样本。默认情况下会尝试多次纠正奇异样本，但最终可能会返回奇异矩阵样本。奇异样本可能会在.log_prob()中返回-inf值。在这种情况下，用户应验证样本，并修复df的值或根据需要调整.rsample中max_try_correction参数的值。 +在某些情况下，基于 Bartlett 分解的采样算法可能返回奇异矩阵样本。默认情况下会尝试多次纠正奇异样本，但最终可能会返回奇异矩阵样本。奇异样本可能会在.log_prob()中返回-inf 值。在这种情况下，用户应验证样本，并修复 df 的值或根据需要调整.rsample 中 max_try_correction 参数的值。 ```py property scale_tril¶ @@ -3057,33 +3033,19 @@ support = PositiveDefinite()¶ property variance¶ ``` -## KL散度 +## KL 散度 ```py torch.distributions.kl.kl_divergence(p, q)¶ ``` -计算两个分布之间的Kullback-Leibler散度$KL(p \| q)$KL(p∥q)。 +计算两个分布之间的 Kullback-Leibler 散度$KL(p \| q)$KL(p∥q)。 $KL(p \| q) = \int p(x) \log\frac {p(x)} {q(x)} \,dx$KL(p∥q)=∫p(x)logq(x)p(x)​dx 参数 -+ **p**（[*分布*](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution"） - 一个`Distribution`对象。 - -+ **q**（[*分布*](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution"） - 一个`Distribution`对象。 - -返回 - -形状为batch_shape的一批KL散度。 - -返回类型 - -[张量](tensors.html#torch.Tensor "torch.Tensor"） - -引发 - -[**NotImplementedError**](https://docs.python.org/3/library/exceptions.html#NotImplementedError "(in Python v3.12)") - 如果分布类型尚未通过[`register_kl()`](#torch.distributions.kl.register_kl "torch.distributions.kl.register_kl")注册。 ++ **p**（*分布*") - 如果分布类型尚未通过`register_kl()`注册。 KL 散度目前针对以下分布对实现： @@ -3265,7 +3227,7 @@ KL 散度目前针对以下分布对实现： torch.distributions.kl.register_kl(type_p, type_q)¶ ``` -装饰器用于使用[`kl_divergence()`](#torch.distributions.kl.kl_divergence "torch.distributions.kl.kl_divergence")注册成对函数。用法： +装饰器用于使用`kl_divergence()`注册成对函数。用法： ```py @register_kl(Normal, Normal) @@ -3308,17 +3270,17 @@ class torch.distributions.transforms.AffineTransform(loc, scale, event_dim=0, ca 参数 -+ **loc**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") *或* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")） - 位置参数。 ++ **loc**（*Tensor* *或* [*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")） - 位置参数。 -+ **scale**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") *或* [*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")） - 缩放参数。 ++ **scale**（*Tensor* *或* [*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")） - 缩放参数。 -+ **event_dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 事件形状的可选大小。对于一元随机变量，应为零；对于向量分布，应为1；对于矩阵分布，应为2，依此类推。 ++ **event_dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 事件形状的可选大小。对于一元随机变量，应为零；对于向量分布，应为 1；对于矩阵分布，应为 2，依此类推。 ```py class torch.distributions.transforms.CatTransform(tseq, dim=0, lengths=None, cache_size=0)¶ ``` -应用一系列变换tseq，逐个组件地将每个子矩阵在维度dim处的长度为lengths[dim]的变换，以与[`torch.cat()`](generated/torch.cat.html#torch.cat "torch.cat")兼容的方式。 +应用一系列变换 tseq，逐个组件地将每个子矩阵在维度 dim 处的长度为 lengths[dim]的变换，以与`torch.cat()`兼容的方式。 示例： @@ -3338,19 +3300,19 @@ class torch.distributions.transforms.ComposeTransform(parts, cache_size=0)¶ 参数 -+ **parts**（[`Transform`](#torch.distributions.transforms.Transform "torch.distributions.transforms.Transform")列表） - 要组合的变换列表。 ++ **parts**（`Transform`列表） - 要组合的变换列表。 -+ **cache_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 缓存大小。如果为零，则不进行缓存。如果为一，则缓存最新的单个值。仅支持0和1。 ++ **cache_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 缓存大小。如果为零，则不进行缓存。如果为一，则缓存最新的单个值。仅支持 0 和 1。 ```py class torch.distributions.transforms.CorrCholeskyTransform(cache_size=0)¶ ``` -将长度为$D*(D-1)/2$的无约束实向量$x$转换为D维相关矩阵的Cholesky因子。这个Cholesky因子是一个下三角矩阵，对角线为正，每行的欧几里得范数为单位。变换如下进行： +将长度为$D*(D-1)/2$的无约束实向量$x$转换为 D 维相关矩阵的 Cholesky 因子。这个 Cholesky 因子是一个下三角矩阵，对角线为正，每行的欧几里得范数为单位。变换如下进行： -> 1. 首先，我们按行将x转换为下三角矩阵。 +> 1. 首先，我们按行将 x 转换为下三角矩阵。 > 1. -> 1. 对于下三角部分的每一行$X_i$，我们应用类[`StickBreakingTransform`](#torch.distributions.transforms.StickBreakingTransform "torch.distributions.transforms.StickBreakingTransform")的*有符号*版本，将$X_i$转换为单位欧几里得长度向量，步骤如下： - 缩放到区间$(-1, 1)$：$r_i = \tanh(X_i)$。 - 转换为无符号域：$z_i = r_i^2$。 - 应用$si = StickBreakingTransform(z_i)$。 - 转换回有符号域：$y_i = sign(r_i) * \sqrt{s_i}$。 +> 1. 对于下三角部分的每一行$X_i$，我们应用类`StickBreakingTransform`的*有符号*版本，将$X_i$转换为单位欧几里得长度向量，步骤如下： - 缩放到区间$(-1, 1)$：$r_i = \tanh(X_i)$。 - 转换为无符号域：$z_i = r_i²$。 - 应用$si = StickBreakingTransform(z_i)$。 - 转换回有符号域：$y_i = sign(r_i) * \sqrt{s_i}$。 ```py class torch.distributions.transforms.CumulativeDistributionTransform(distribution, cache_size=0)¶ @@ -3360,7 +3322,7 @@ class torch.distributions.transforms.CumulativeDistributionTransform(distributio 参数 -**distribution**（[*Distribution*](#torch.distributions.distribution.Distribution "torch.distributions.distribution.Distribution")） - 要用于变换的累积分布函数的分布。 +**distribution**（*Distribution*） - 要用于变换的累积分布函数的分布。 示例： @@ -3388,9 +3350,9 @@ class torch.distributions.transforms.IndependentTransform(base_transform, reinte 参数 -+ **base_transform**（[`Transform`](#torch.distributions.transforms.Transform "torch.distributions.transforms.Transform")） - 基本变换。 ++ **base_transform**（`Transform`） - 基本变换。 -+ **reinterpreted_batch_ndims**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 要视为相关的额外右侧维度的数量。 ++ **reinterpreted_batch_ndims**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 要视为相关的额外右侧维度的数量。 ```py class torch.distributions.transforms.LowerCholeskyTransform(cache_size=0)¶ @@ -3398,7 +3360,7 @@ class torch.distributions.transforms.LowerCholeskyTransform(cache_size=0)¶ 从无约束矩阵转换为具有非负对角元的下三角矩阵。 -这对于用Cholesky分解参数化正定矩阵非常有用。 +这对于用 Cholesky 分解参数化正定矩阵非常有用。 ```py class torch.distributions.transforms.PositiveDefiniteTransform(cache_size=0)¶ @@ -3418,7 +3380,7 @@ class torch.distributions.transforms.ReshapeTransform(in_shape, out_shape, cache 单位雅可比变换，用于重塑张量的最右侧部分。 -请注意，`in_shape`和`out_shape`必须具有相同数量的元素，就像[`torch.Tensor.reshape()`](generated/torch.Tensor.reshape.html#torch.Tensor.reshape "torch.Tensor.reshape")一样。 +请注意，`in_shape`和`out_shape`必须具有相同数量的元素，就像`torch.Tensor.reshape()`一样。 参数 @@ -3444,9 +3406,9 @@ class torch.distributions.transforms.TanhTransform(cache_size=0)¶ 通过映射$y = \tanh(x)$y=tanh(x)进行变换。 -它等同于`` ComposeTransform([AffineTransform(0., 2.), SigmoidTransform(), AffineTransform(-1., 2.)]) `` 但这可能不是数值稳定的，因此建议改用TanhTransform。 +它等同于`` ComposeTransform([AffineTransform(0., 2.), SigmoidTransform(), AffineTransform(-1., 2.)]) `` 但这可能不是数值稳定的，因此建议改用 TanhTransform。 -请注意，当涉及NaN/Inf值时，应使用cache_size=1。 +请注意，当涉及 NaN/Inf 值时，应使用 cache_size=1。 ```py class torch.distributions.transforms.SoftmaxTransform(cache_size=0)¶ @@ -3454,13 +3416,13 @@ class torch.distributions.transforms.SoftmaxTransform(cache_size=0)¶ 从非约束空间到单纯形的变换，通过$y = \exp(x)$y=exp(x)然后归一化。 -这不是双射的，不能用于HMC。但是这主要是按坐标进行的（除了最终的归一化），因此适用于按坐标优化算法。 +这不是双射的，不能用于 HMC。但是这主要是按坐标进行的（除了最终的归一化），因此适用于按坐标优化算法。 ```py class torch.distributions.transforms.StackTransform(tseq, dim=0, cache_size=0)¶ ``` -将变换序列tseq逐个组件地应用于维度dim中的每个子矩阵的变换函数，以与[`torch.stack()`](generated/torch.stack.html#torch.stack "torch.stack")兼容的方式。 +将变换序列 tseq 逐个组件地应用于维度 dim 中的每个子矩阵的变换函数，以与`torch.stack()`兼容的方式。 示例： @@ -3476,9 +3438,9 @@ class torch.distributions.transforms.StickBreakingTransform(cache_size=0)¶ 通过一个破棍过程，将非约束空间转换为一个额外维度的单纯形。 -这种变换是Dirichlet分布的一个迭代sigmoid变换的结果：第一个logit通过sigmoid变换为第一个概率和其他所有概率，然后过程递归进行。 +这种变换是 Dirichlet 分布的一个迭代 sigmoid 变换的结果：第一个 logit 通过 sigmoid 变换为第一个概率和其他所有概率，然后过程递归进行。 -这是双射的，适用于在HMC中使用；但是它将坐标混合在一起，不太适合优化。 +这是双射的，适用于在 HMC 中使用；但是它将坐标混合在一起，不太适合优化。 ```py class torch.distributions.transforms.Transform(cache_size=0)¶ @@ -3501,27 +3463,27 @@ z = t.inv(y) grad(z.sum(), [y]) # error because z is x ``` -派生类应该实现`_call()`或`_inverse()`中的一个或两个。将bijective=True的派生类还应该实现[`log_abs_det_jacobian()`](#torch.distributions.transforms.Transform.log_abs_det_jacobian "torch.distributions.transforms.Transform.log_abs_det_jacobian")。 +派生类应该实现`_call()`或`_inverse()`中的一个或两个。将 bijective=True 的派生类还应该实现`log_abs_det_jacobian()`。 参数 -**cache_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 缓存的大小。如果为零，则不进行缓存。如果为一，则缓存最新的单个值。仅支持0和1。 +**cache_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 缓存的大小。如果为零，则不进行缓存。如果为一，则缓存最新的单个值。仅支持 0 和 1。 变量 -+ **定义域**（[`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")） - 表示此变换的有效输入的约束。 ++ **定义域**（`Constraint`） - 表示此变换的有效输入的约束。 -+ **值域**（[`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")） - 表示此变换的有效输出的约束，这些输出是逆变换的输入。 ++ **值域**（`Constraint`） - 表示此变换的有效输出的约束，这些输出是逆变换的输入。 + **双射**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 此变换是否是双射。如果变换`t`是双射，则对于每个域中的`x`和值域中的`y`，`t.inv(t(x)) == x`和`t(t.inv(y)) == y`。不是双射的变换应至少保持较弱的伪逆性质`t(t.inv(t(x)) == t(x)`和`t.inv(t(t.inv(y))) == t.inv(y)`。 -+ **符号**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)") *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 对于双射单变量变换，这应该是+1或-1，取决于变换是单调递增还是递减。 ++ **符号**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)") *或* *Tensor*） - 对于双射单变量变换，这应该是+1 或-1，取决于变换是单调递增还是递减。 ```py property inv¶ ``` -返回此变换的逆[`Transform`](#torch.distributions.transforms.Transform "torch.distributions.transforms.Transform")。这应该满足`t.inv.inv is t`。 +返回此变换的逆`Transform`。这应该满足`t.inv.inv is t`。 ```py property sign¶ @@ -3533,7 +3495,7 @@ property sign¶ log_abs_det_jacobian(x, y)¶ ``` -计算给定输入和输出的对数行列式雅可比行列式log |dy/dx|。 +计算给定输入和输出的对数行列式雅可比行列式 log |dy/dx|。 ```py forward_shape(shape)¶ @@ -3615,9 +3577,9 @@ class torch.distributions.constraints.Constraint¶ 变量 -+ **is_discrete** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 约束空间是否是离散的。默认为False。 ++ **is_discrete** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 约束空间是否是离散的。默认为 False。 -+ **event_dim** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 定义事件的最右边维度的数量。[`check()`](#torch.distributions.constraints.Constraint.check "torch.distributions.constraints.Constraint.check")方法在计算有效性时将删除这么多维度。 ++ **event_dim** ([*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 定义事件的最右边维度的数量。`check()`方法在计算有效性时将删除这么多维度。 ```py check(value)¶ @@ -3691,13 +3653,13 @@ torch.distributions.constraints.stack¶ 别名为`_Stack` ## 约束注册[](#module-torch.distributions.constraint_registry "Permalink to this heading") -PyTorch提供了两个全局[`ConstraintRegistry`](#torch.distributions.constraint_registry.ConstraintRegistry "torch.distributions.constraint_registry.ConstraintRegistry")对象，将[`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")对象链接到[`Transform`](#torch.distributions.transforms.Transform "torch.distributions.transforms.Transform")对象。这些对象都输入约束并返回变换，但它们对双射性有不同的保证。 +PyTorch 提供了两个全局`ConstraintRegistry`对象，将`Constraint`对象链接到`Transform`对象。这些对象都输入约束并返回变换，但它们对双射性有不同的保证。 -1. `biject_to(constraint)` 从`constraints.real`查找一个双射的[`Transform`](#torch.distributions.transforms.Transform "torch.distributions.transforms.Transform")到给定的`constraint`。返回的变换保证具有`.bijective = True`，并应实现`.log_abs_det_jacobian()`。 +1. `biject_to(constraint)` 从`constraints.real`查找一个双射的`Transform`到给定的`constraint`。返回的变换保证具有`.bijective = True`，并应实现`.log_abs_det_jacobian()`。 -1. `transform_to(constraint)` 从`constraints.real`查找一个不一定双射的[`Transform`](#torch.distributions.transforms.Transform "torch.distributions.transforms.Transform")到给定的`constraint`。返回的变换不保证实现`.log_abs_det_jacobian()`。 +1. `transform_to(constraint)` 从`constraints.real`查找一个不一定双射的`Transform`到给定的`constraint`。返回的变换不保证实现`.log_abs_det_jacobian()`。 -`transform_to()`注册表对于在概率分布的约束参数上执行无约束优化非常有用，每个分布的`.arg_constraints`字典指示。这些变换通常过度参数化空间以避免旋转；因此，它们更适合于像Adam这样的逐坐标优化算法： +`transform_to()`注册表对于在概率分布的约束参数上执行无约束优化非常有用，每个分布的`.arg_constraints`字典指示。这些变换通常过度参数化空间以避免旋转；因此，它们更适合于像 Adam 这样的逐坐标优化算法： ```py loc = torch.zeros(100, requires_grad=True) @@ -3706,7 +3668,7 @@ scale = transform_to(Normal.arg_constraints['scale'])(unconstrained) loss = -Normal(loc, scale).log_prob(data).sum() ``` -`biject_to()`注册表对于Hamiltonian Monte Carlo很有用，其中来自具有约束`.support`的概率分布的样本在无约束空间中传播，并且算法通常是旋转不变的。 +`biject_to()`注册表对于 Hamiltonian Monte Carlo 很有用，其中来自具有约束`.support`的概率分布的样本在无约束空间中传播，并且算法通常是旋转不变的。 ```py dist = Exponential(rate) @@ -3717,7 +3679,7 @@ potential_energy = -dist.log_prob(sample).sum() 注意 -`transform_to`和`biject_to`不同的一个例子是`constraints.simplex`：`transform_to(constraints.simplex)`返回一个[`SoftmaxTransform`](#torch.distributions.transforms.SoftmaxTransform "torch.distributions.transforms.SoftmaxTransform")，它简单地对其输入进行指数化和归一化；这是一种适用于像SVI这样的算法的廉价且大多数是坐标轴操作。相比之下，`biject_to(constraints.simplex)`返回一个[`StickBreakingTransform`](#torch.distributions.transforms.StickBreakingTransform "torch.distributions.transforms.StickBreakingTransform")，它将其输入映射到一个维度少一的空间；这是一种更昂贵且数值稳定性较差的变换，但对于像HMC这样的算法是必需的。 +`transform_to`和`biject_to`不同的一个例子是`constraints.simplex`：`transform_to(constraints.simplex)`返回一个`SoftmaxTransform`，它简单地对其输入进行指数化和归一化；这是一种适用于像 SVI 这样的算法的廉价且大多数是坐标轴操作。相比之下，`biject_to(constraints.simplex)`返回一个`StickBreakingTransform`，它将其输入映射到一个维度少一的空间；这是一种更昂贵且数值稳定性较差的变换，但对于像 HMC 这样的算法是必需的。 `biject_to`和`transform_to`对象可以通过它们的`.register()`方法扩展用户定义的约束和变换，可以作为单例约束的函数： @@ -3734,7 +3696,7 @@ def my_factory(constraint): return MyTransform(constraint.param1, constraint.param2) ``` -您可以通过创建一个新的[`ConstraintRegistry`](#torch.distributions.constraint_registry.ConstraintRegistry "torch.distributions.constraint_registry.ConstraintRegistry")对象来创建自己的注册表。 +您可以通过创建一个新的`ConstraintRegistry`对象来创建自己的注册表。 ```py class torch.distributions.constraint_registry.ConstraintRegistry¶ @@ -3746,7 +3708,7 @@ class torch.distributions.constraint_registry.ConstraintRegistry¶ register(constraint, factory=None)¶ ``` -在此注册表中注册一个[`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")子类。用法： +在此注册表中注册一个`Constraint`子类。用法： ```py @my_registry.register(MyConstraintClass) @@ -3757,6 +3719,6 @@ def construct_transform(constraint): 参数 -+ **constraint**（[`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")的子类） - [`Constraint`](#torch.distributions.constraints.Constraint "torch.distributions.constraints.Constraint")的子类，或所需类的单例对象。 ++ **constraint**（`Constraint`的子类） - `Constraint`的子类，或所需类的单例对象。 -+ **factory**（*Callable*） - 一个可调用对象，输入一个约束对象并返回一个[`Transform`](#torch.distributions.transforms.Transform "torch.distributions.transforms.Transform")对象。 ++ **factory**（*Callable*） - 一个可调用对象，输入一个约束对象并返回一个`Transform`对象。 diff --git a/totrans/doc22_054.md b/totrans/doc22_054.md index f76ae3db..492b7b80 100644 --- a/totrans/doc22_054.md +++ b/totrans/doc22_054.md @@ -1,6 +1,6 @@ # torch.compiler -> 原文：[https://pytorch.org/docs/stable/torch.compiler.html](https://pytorch.org/docs/stable/torch.compiler.html) +> 原文：[`pytorch.org/docs/stable/torch.compiler.html`](https://pytorch.org/docs/stable/torch.compiler.html) `torch.compiler` 是一个命名空间，通过该命名空间，一些内部编译器方法被公开供用户使用。该命名空间中的主要函数和特性是 `torch.compile`。 @@ -29,7 +29,7 @@ | `torch.compile(m, backend="inductor")` | 使用 TorchInductor 后端。[阅读更多](https://dev-discuss.pytorch.org/t/torchinductor-a-pytorch-native-compiler-with-define-by-run-ir-and-symbolic-shapes/747) | | `torch.compile(m, backend="cudagraphs")` | 使用 CUDA 图形与 AOT Autograd。[阅读更多](https://github.com/pytorch/torchdynamo/pull/757) | | `torch.compile(m, backend="ipex")` | 在 CPU 上使用 IPEX。[阅读更多](https://github.com/intel/intel-extension-for-pytorch) | -| `torch.compile(m, backend="onnxrt")` | 使用 ONNX Runtime 在 CPU/GPU 上进行训练。[阅读更多](onnx_dynamo_onnxruntime_backend.html) | +| `torch.compile(m, backend="onnxrt")` | 使用 ONNX Runtime 在 CPU/GPU 上进行训练。阅读更多 | **仅推理后端** @@ -44,44 +44,44 @@ PyTorch 用户入门 -+ [入门指南](torch.compiler_get_started.html) ++ 入门指南 -+ [torch.compiler API 参考](torch.compiler_api.html) ++ torch.compiler API 参考 -+ [TorchDynamo 用于细粒度跟踪的 API](torch.compiler_fine_grain_apis.html) ++ TorchDynamo 用于细粒度跟踪的 API -+ [AOTInductor：Torch.Export-ed 模型的预编译](torch.compiler_aot_inductor.html) ++ AOTInductor：Torch.Export-ed 模型的预编译 -+ [TorchInductor GPU Profiling](torch.compiler_inductor_profiling.html) ++ TorchInductor GPU Profiling -+ [分析以了解 torch.compile 性能](torch.compiler_profiling_torch_compile.html) ++ 分析以了解 torch.compile 性能 -+ [常见问题解答](torch.compiler_faq.html) ++ 常见问题解答 -+ [PyTorch 2.0 故障排除](torch.compiler_troubleshooting.html) ++ PyTorch 2.0 故障排除 -+ [PyTorch 2.0 性能仪表板](torch.compiler_performance_dashboard.html) ++ PyTorch 2.0 性能仪表板 PyTorch 开发者深入研究 -+ [TorchDynamo 深入研究](torch.compiler_deepdive.html) ++ TorchDynamo 深入研究 -+ [守卫概述](torch.compiler_guards_overview.html) ++ 守卫概述 -+ [动态形状](torch.compiler_dynamic_shapes.html) ++ 动态形状 -+ [PyTorch 2.0 NNModule 支持](torch.compiler_nn_module.html) ++ PyTorch 2.0 NNModule 支持 -+ [后端最佳实践](torch.compiler_best_practices_for_backends.html) ++ 后端最佳实践 -+ [CUDAGraph 树](torch.compiler_cudagraph_trees.html) ++ CUDAGraph 树 -+ [伪张量](torch.compiler_fake_tensor.html) ++ 伪张量 PyTorch 后端供应商操作指南 -+ [自定义后端](torch.compiler_custom_backends.html) ++ 自定义后端 -+ [在 ATen IR 上编写图转换](torch.compiler_transformations.html) ++ 在 ATen IR 上编写图转换 -+ [IRs](torch.compiler_ir.html) ++ IRs diff --git a/totrans/doc22_055.md b/totrans/doc22_055.md index e591dd16..d4ec786e 100644 --- a/totrans/doc22_055.md +++ b/totrans/doc22_055.md @@ -1,35 +1,35 @@ # torch.fft -> 原文：[https://pytorch.org/docs/stable/fft.html](https://pytorch.org/docs/stable/fft.html) +> 原文：[`pytorch.org/docs/stable/fft.html`](https://pytorch.org/docs/stable/fft.html) 离散傅里叶变换和相关函数。 ## 快速傅里叶变换 -| [`fft`](generated/torch.fft.fft.html#torch.fft.fft "torch.fft.fft") | 计算`input`的一维离散傅里叶变换。 | +| `fft` | 计算`input`的一维离散傅里叶变换。 | | --- | --- | -| [`ifft`](generated/torch.fft.ifft.html#torch.fft.ifft "torch.fft.ifft") | 计算`input`的一维逆离散傅里叶变换。 | -| [`fft2`](generated/torch.fft.fft2.html#torch.fft.fft2 "torch.fft.fft2") | 计算`input`的二维离散傅里叶变换。 | -| [`ifft2`](generated/torch.fft.ifft2.html#torch.fft.ifft2 "torch.fft.ifft2") | 计算`input`的二维逆离散傅里叶变换。 | -| [`fftn`](generated/torch.fft.fftn.html#torch.fft.fftn "torch.fft.fftn") | 计算`input`的N维离散傅里叶变换。 | -| [`ifftn`](generated/torch.fft.ifftn.html#torch.fft.ifftn "torch.fft.ifftn") | 计算`input`的N维逆离散傅里叶变换。 | -| [`rfft`](generated/torch.fft.rfft.html#torch.fft.rfft "torch.fft.rfft") | 计算实值`input`的一维傅里叶变换。 | -| [`irfft`](generated/torch.fft.irfft.html#torch.fft.irfft "torch.fft.irfft") | 计算[`rfft()`](generated/torch.fft.rfft.html#torch.fft.rfft "torch.fft.rfft")的逆变换。 | -| [`rfft2`](generated/torch.fft.rfft2.html#torch.fft.rfft2 "torch.fft.rfft2") | 计算实数`input`的二维离散傅里叶变换。 | -| [`irfft2`](generated/torch.fft.irfft2.html#torch.fft.irfft2 "torch.fft.irfft2") | 计算[`rfft2()`](generated/torch.fft.rfft2.html#torch.fft.rfft2 "torch.fft.rfft2")的逆变换。 | -| [`rfftn`](generated/torch.fft.rfftn.html#torch.fft.rfftn "torch.fft.rfftn") | 计算实数`input`的N维离散傅里叶变换。 | -| [`irfftn`](generated/torch.fft.irfftn.html#torch.fft.irfftn "torch.fft.irfftn") | 计算[`rfftn()`](generated/torch.fft.rfftn.html#torch.fft.rfftn "torch.fft.rfftn")的逆变换。 | -| [`hfft`](generated/torch.fft.hfft.html#torch.fft.hfft "torch.fft.hfft") | 计算埃尔米特对称`input`信号的一维离散傅里叶变换。 | -| [`ihfft`](generated/torch.fft.ihfft.html#torch.fft.ihfft "torch.fft.ihfft") | 计算[`hfft()`](generated/torch.fft.hfft.html#torch.fft.hfft "torch.fft.hfft")的逆变换。 | -| [`hfft2`](generated/torch.fft.hfft2.html#torch.fft.hfft2 "torch.fft.hfft2") | 计算埃尔米特对称`input`信号的二维离散傅里叶变换。 | -| [`ihfft2`](generated/torch.fft.ihfft2.html#torch.fft.ihfft2 "torch.fft.ihfft2") | 计算实数`input`的二维逆离散傅里叶变换。 | -| [`hfftn`](generated/torch.fft.hfftn.html#torch.fft.hfftn "torch.fft.hfftn") | 计算埃尔米特对称`input`信号的n维离散傅里叶变换。 | -| [`ihfftn`](generated/torch.fft.ihfftn.html#torch.fft.ihfftn "torch.fft.ihfftn") | 计算实数`input`的N维逆离散傅里叶变换。 | +| `ifft` | 计算`input`的一维逆离散傅里叶变换。 | +| `fft2` | 计算`input`的二维离散傅里叶变换。 | +| `ifft2` | 计算`input`的二维逆离散傅里叶变换。 | +| `fftn` | 计算`input`的 N 维离散傅里叶变换。 | +| `ifftn` | 计算`input`的 N 维逆离散傅里叶变换。 | +| `rfft` | 计算实值`input`的一维傅里叶变换。 | +| `irfft` | 计算`rfft()`的逆变换。 | +| `rfft2` | 计算实数`input`的二维离散傅里叶变换。 | +| `irfft2` | 计算`rfft2()`的逆变换。 | +| `rfftn` | 计算实数`input`的 N 维离散傅里叶变换。 | +| `irfftn` | 计算`rfftn()`的逆变换。 | +| `hfft` | 计算埃尔米特对称`input`信号的一维离散傅里叶变换。 | +| `ihfft` | 计算`hfft()`的逆变换。 | +| `hfft2` | 计算埃尔米特对称`input`信号的二维离散傅里叶变换。 | +| `ihfft2` | 计算实数`input`的二维逆离散傅里叶变换。 | +| `hfftn` | 计算埃尔米特对称`input`信号的 n 维离散傅里叶变换。 | +| `ihfftn` | 计算实数`input`的 N 维逆离散傅里叶变换。 | ## 辅助函数 -| [`fftfreq`](generated/torch.fft.fftfreq.html#torch.fft.fftfreq "torch.fft.fftfreq") | 计算大小为`n`的信号的离散傅里叶变换采样频率。 | +| `fftfreq` | 计算大小为`n`的信号的离散傅里叶变换采样频率。 | | --- | --- | -| [`rfftfreq`](generated/torch.fft.rfftfreq.html#torch.fft.rfftfreq "torch.fft.rfftfreq") | 计算具有大小`n`的信号的[`rfft()`](generated/torch.fft.rfft.html#torch.fft.rfft "torch.fft.rfft")的采样频率。 | -| [`fftshift`](generated/torch.fft.fftshift.html#torch.fft.fftshift "torch.fft.fftshift") | 重新排列n维FFT数据，如[`fftn()`](generated/torch.fft.fftn.html#torch.fft.fftn "torch.fft.fftn")提供的，以使负频率项优先。 | -| [`ifftshift`](生成/torch.fft.ifftshift.html#torch.fft.ifftshift "torch.fft.ifftshift") | [`fftshift()`](生成/torch.fft.fftshift.html#torch.fft.fftshift "torch.fft.fftshift") 的逆操作。 | +| `rfftfreq` | 计算具有大小`n`的信号的`rfft()`的采样频率。 | +| `fftshift` | 重新排列 n 维 FFT 数据，如`fftn()`提供的，以使负频率项优先。 | +| `ifftshift` | `fftshift()` 的逆操作。 | diff --git a/totrans/doc22_056.md b/totrans/doc22_056.md index 6360efae..f6272ac5 100644 --- a/totrans/doc22_056.md +++ b/totrans/doc22_056.md @@ -1,69 +1,69 @@ # torch.func -> 原文：[https://pytorch.org/docs/stable/func.html](https://pytorch.org/docs/stable/func.html) +> 原文：[`pytorch.org/docs/stable/func.html`](https://pytorch.org/docs/stable/func.html) -torch.func，以前称为“functorch”，是PyTorch的[JAX-like](https://github.com/google/jax)可组合函数变换。 +torch.func，以前称为“functorch”，是 PyTorch 的[JAX-like](https://github.com/google/jax)可组合函数变换。 注意 -该库目前处于[测试版](https://pytorch.org/blog/pytorch-feature-classification-changes/#beta)。这意味着功能通常可用（除非另有说明），我们（PyTorch团队）致力于推进该库。但是，API可能会根据用户反馈进行更改，我们对PyTorch操作的覆盖范围不完整。 +该库目前处于[测试版](https://pytorch.org/blog/pytorch-feature-classification-changes/#beta)。这意味着功能通常可用（除非另有说明），我们（PyTorch 团队）致力于推进该库。但是，API 可能会根据用户反馈进行更改，我们对 PyTorch 操作的覆盖范围不完整。 -如果您对API或用例有建议，请打开GitHub问题或联系我们。我们很乐意听听您如何使用库。 +如果您对 API 或用例有建议，请打开 GitHub 问题或联系我们。我们很乐意听听您如何使用库。 ## 什么是可组合的函数变换？[](#what-are-composable-function-transforms "跳转到此标题") + “函数变换”是一个高阶函数，接受一个数值函数并返回一个计算不同量的新函数。 -+ [`torch.func`](func.api.html#module-torch.func "torch.func")具有自动微分变换（`grad(f)`返回一个计算`f`梯度的函数），矢量化/批处理变换（`vmap(f)`返回一个计算输入批次上的`f`的函数）等。 ++ `torch.func`具有自动微分变换（`grad(f)`返回一个计算`f`梯度的函数），矢量化/批处理变换（`vmap(f)`返回一个计算输入批次上的`f`的函数）等。 -+ 这些函数变换可以任意组合。例如，组合`vmap(grad(f))`计算一种称为每样本梯度的量，目前原始PyTorch无法高效计算。 ++ 这些函数变换可以任意组合。例如，组合`vmap(grad(f))`计算一种称为每样本梯度的量，目前原始 PyTorch 无法高效计算。 ## 为什么使用可组合的函数变换？[](#why-composable-function-transforms "跳转到此标题") -目前在PyTorch中有一些棘手的用例： +目前在 PyTorch 中有一些棘手的用例： + 计算每样本梯度（或其他每样本量） + 在单台机器上运行模型集合 -+ 在MAML的内循环中高效批处理任务 ++ 在 MAML 的内循环中高效批处理任务 + 高效计算雅可比矩阵和海森矩阵 + 高效计算批量雅可比矩阵和海森矩阵 -组合[`vmap()`](generated/torch.func.vmap.html#torch.func.vmap "torch.func.vmap")、[`grad()`](generated/torch.func.grad.html#torch.func.grad "torch.func.grad")和[`vjp()`](generated/torch.func.vjp.html#torch.func.vjp "torch.func.vjp")变换使我们能够表达上述内容，而无需为每个设计单独的子系统。这种可组合函数变换的想法来自[JAX框架](https://github.com/google/jax)。 +组合`vmap()`、`grad()`和`vjp()`变换使我们能够表达上述内容，而无需为每个设计单独的子系统。这种可组合函数变换的想法来自[JAX 框架](https://github.com/google/jax)。 ## 阅读更多 -+ [torch.func快速浏览](func.whirlwind_tour.html) ++ torch.func 快速浏览 - + [什么是torch.func？](func.whirlwind_tour.html#what-is-torch-func) + + 什么是 torch.func？ - + [为什么使用可组合的函数变换？](func.whirlwind_tour.html#why-composable-function-transforms) + + 为什么使用可组合的函数变换？ - + [什么是变换？](func.whirlwind_tour.html#what-are-the-transforms) + + 什么是变换？ -+ [torch.func API参考](func.api.html) ++ torch.func API 参考 - + [函数变换](func.api.html#function-transforms) + + 函数变换 - + [与torch.nn.Modules一起工作的实用程序](func.api.html#utilities-for-working-with-torch-nn-modules) + + 与 torch.nn.Modules 一起工作的实用程序 -+ [用户体验限制](func.ux_limitations.html) ++ 用户体验限制 - + [一般限制](func.ux_limitations.html#general-limitations) + + 一般限制 - + [torch.autograd API](func.ux_limitations.html#torch-autograd-apis) + + torch.autograd API - + [vmap限制](func.ux_limitations.html#vmap-limitations) + + vmap 限制 - + [随机性](func.ux_limitations.html#randomness) + + 随机性 -+ [从functorch迁移到torch.func](func.migrating.html) ++ 从 functorch 迁移到 torch.func - + [函数变换](func.migrating.html#function-transforms) + + 函数变换 - + [NN模块实用程序](func.migrating.html#nn-module-utilities) + + NN 模块实用程序 - + [functorch.compile](func.migrating.html#functorch-compile) + + functorch.compile diff --git a/totrans/doc22_057.md b/totrans/doc22_057.md index 29ac7193..e89ea43f 100644 --- a/totrans/doc22_057.md +++ b/totrans/doc22_057.md @@ -1,28 +1,28 @@ # torch.futures -> 原文：[https://pytorch.org/docs/stable/futures.html](https://pytorch.org/docs/stable/futures.html) +> 原文：[`pytorch.org/docs/stable/futures.html`](https://pytorch.org/docs/stable/futures.html) -此软件包提供了一个[`Future`](#torch.futures.Future "torch.futures.Future")类型，封装了异步执行和一组实用函数，以简化对[`Future`](#torch.futures.Future "torch.futures.Future")对象的操作。目前，[`Future`](#torch.futures.Future "torch.futures.Future")类型主要由[分布式RPC框架](rpc.html#distributed-rpc-framework)使用。 +此软件包提供了一个`Future`类型，封装了异步执行和一组实用函数，以简化对`Future`对象的操作。目前，`Future`类型主要由分布式 RPC 框架使用。 ```py class torch.futures.Future(*, devices=None)¶ ``` -封装了对可调用对象的异步执行的`torch._C.Future`的包装器，例如[`rpc_async()`](rpc.html#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")。它还公开了一组API来添加回调函数和设置结果。 +封装了对可调用对象的异步执行的`torch._C.Future`的包装器，例如`rpc_async()`。它还公开了一组 API 来添加回调函数和设置结果。 警告 -GPU支持是一个测试功能，可能会发生变化。 +GPU 支持是一个测试功能，可能会发生变化。 ```py add_done_callback(callback)¶ ``` -将给定的回调函数附加到此`Future`，当`Future`完成时将运行该回调。可以向同一个`Future`添加多个回调，但不能保证它们将以何种顺序执行。回调必须接受一个参数，即对此`Future`的引用。回调函数可以使用[`value()`](#torch.futures.Future.value "torch.futures.Future.value")方法获取值。请注意，如果此`Future`已经完成，给定的回调将内联运行。 +将给定的回调函数附加到此`Future`，当`Future`完成时将运行该回调。可以向同一个`Future`添加多个回调，但不能保证它们将以何种顺序执行。回调必须接受一个参数，即对此`Future`的引用。回调函数可以使用`value()`方法获取值。请注意，如果此`Future`已经完成，给定的回调将内联运行。 -我们建议您使用[`then()`](#torch.futures.Future.then "torch.futures.Future.then")方法，因为它提供了在回调完成后同步的方法。如果您的回调不返回任何内容，`add_done_callback`可能更便宜。但是[`then()`](#torch.futures.Future.then "torch.futures.Future.then")和`add_done_callback`在底层使用相同的回调注册API。 +我们建议您使用`then()`方法，因为它提供了在回调完成后同步的方法。如果您的回调不返回任何内容，`add_done_callback`可能更便宜。但是`then()`和`add_done_callback`在底层使用相同的回调注册 API。 -就GPU张量而言，此方法的行为与[`then()`](#torch.futures.Future.then "torch.futures.Future.then")相同。 +就 GPU 张量而言，此方法的行为与`then()`相同。 参数 @@ -51,7 +51,7 @@ done()¶ 如果此`Future`已完成，则返回`True`。如果`Future`有结果或异常，则已完成。 -如果值包含在GPU上的张量，即使异步内核尚未在设备上完成运行，`Future.done()`将返回`True`，因为在这个阶段结果已经可用，只要执行适当的同步（参见[`wait()`](#torch.futures.Future.wait "torch.futures.Future.wait")）。 +如果值包含在 GPU 上的张量，即使异步内核尚未在设备上完成运行，`Future.done()`将返回`True`，因为在这个阶段结果已经可用，只要执行适当的同步（参见`wait()`）。 返回类型 @@ -61,7 +61,7 @@ done()¶ set_exception(result)¶ ``` -为此`Future`设置异常，这将标记此`Future`为已完成并触发所有附加的回调。请注意，当在此`Future`上调用wait()/value()时，此处设置的异常将内联引发。 +为此`Future`设置异常，这将标记此`Future`为已完成并触发所有附加的回调。请注意，当在此`Future`上调用 wait()/value()时，此处设置的异常将内联引发。 参数 @@ -84,7 +84,7 @@ set_result(result)¶ 设置此`Future`的结果，这将标记此`Future`为已完成并触发所有附加的回调。请注意，`Future`不能被标记为已完成两次。 -如果结果包含驻留在GPU上的张量，即使用于填充这些张量的异步内核尚未在设备上完成运行，也可以调用此方法，前提是在调用此方法时将这些内核排队的流设置为当前流。简而言之，只要在启动这些内核后立即调用此方法，而不需要任何额外的同步，就是安全的，只要在其中不更改流。此方法将在所有相关的当前流上记录事件，并将使用它们来确保所有此`Future`的消费者的适当调度。 +如果结果包含驻留在 GPU 上的张量，即使用于填充这些张量的异步内核尚未在设备上完成运行，也可以调用此方法，前提是在调用此方法时将这些内核排队的流设置为当前流。简而言之，只要在启动这些内核后立即调用此方法，而不需要任何额外的同步，就是安全的，只要在其中不更改流。此方法将在所有相关的当前流上记录事件，并将使用它们来确保所有此`Future`的消费者的适当调度。 参数 @@ -113,11 +113,11 @@ tensor([3., 3.]) then(callback)¶ ``` -将给定的回调函数附加到此`Future`，当`Future`完成时将运行该回调函数。可以向同一个`Future`添加多个回调，但不能保证它们将按照特定顺序执行（要强制执行特定顺序，请考虑链接：`fut.then(cb1).then(cb2)`）。回调函数必须接受一个参数，即对此`Future`的引用。回调函数可以使用[`value()`](#torch.futures.Future.value "torch.futures.Future.value")方法获取值。请注意，如果此`Future`已经完成，给定的回调将立即内联运行。 +将给定的回调函数附加到此`Future`，当`Future`完成时将运行该回调函数。可以向同一个`Future`添加多个回调，但不能保证它们将按照特定顺序执行（要强制执行特定顺序，请考虑链接：`fut.then(cb1).then(cb2)`）。回调函数必须接受一个参数，即对此`Future`的引用。回调函数可以使用`value()`方法获取值。请注意，如果此`Future`已经完成，给定的回调将立即内联运行。 -如果`Future`的值包含驻留在GPU上的张量，回调可能在填充这些张量的异步内核尚未在设备上完成执行时被调用。但是，回调将使用一些专用流（从全局池中获取）作为当前流进行调用，这些流将与这些内核同步。因此，回调在这些张量上执行的任何操作将在内核完成后在设备上调度。换句话说，只要回调不切换流，就可以安全地操作结果而无需任何额外的同步。这类似于[`wait()`](#torch.futures.Future.wait "torch.futures.Future.wait")的非阻塞行为。 +如果`Future`的值包含驻留在 GPU 上的张量，回调可能在填充这些张量的异步内核尚未在设备上完成执行时被调用。但是，回调将使用一些专用流（从全局池中获取）作为当前流进行调用，这些流将与这些内核同步。因此，回调在这些张量上执行的任何操作将在内核完成后在设备上调度。换句话说，只要回调不切换流，就可以安全地操作结果而无需任何额外的同步。这类似于`wait()`的非阻塞行为。 -同样，如果回调返回一个包含驻留在GPU上的张量的值，即使生成这些张量的内核仍在设备上运行，只要回调在执行期间没有更改流，它也可以这样做。如果想要更改流，必须小心地将其重新与原始流同步，即在调用回调时当前的流。 +同样，如果回调返回一个包含驻留在 GPU 上的张量的值，即使生成这些张量的内核仍在设备上运行，只要回调在执行期间没有更改流，它也可以这样做。如果想要更改流，必须小心地将其重新与原始流同步，即在调用回调时当前的流。 参数 @@ -129,11 +129,11 @@ then(callback)¶ 返回类型 -[*Future*](#torch.futures.Future "torch.jit.Future")[*S*] +*Future*[*S*] 注意 -请注意，如果回调函数抛出异常，要么通过原始future完成并调用`fut.wait()`，要么通过回调中的其他代码，`then`返回的future将适当标记为遇到的错误。但是，如果此回调稍后完成其他future，这些future不会被标记为带有错误的已完成状态，用户需要独立处理这些future的完成/等待。 +请注意，如果回调函数抛出异常，要么通过原始 future 完成并调用`fut.wait()`，要么通过回调中的其他代码，`then`返回的 future 将适当标记为遇到的错误。但是，如果此回调稍后完成其他 future，这些 future 不会被标记为带有错误的已完成状态，用户需要独立处理这些 future 的完成/等待。 示例:: @@ -156,15 +156,15 @@ Chained cb done. None value()¶ ``` -获取已完成future的值。 +获取已完成 future 的值。 -此方法应该在调用[`wait()`](#torch.futures.Future.wait "torch.futures.Future.wait")完成后调用，或者在传递给[`then()`](#torch.futures.Future.then "torch.futures.Future.then")的回调函数中调用。在其他情况下，此`Future`可能尚未持有值，调用`value()`可能会失败。 +此方法应该在调用`wait()`完成后调用，或者在传递给`then()`的回调函数中调用。在其他情况下，此`Future`可能尚未持有值，调用`value()`可能会失败。 -如果值包含驻留在GPU上的张量，则此方法将*不*执行任何额外的同步。这应该事先单独完成，通过调用[`wait()`](#torch.futures.Future.wait "torch.futures.Future.wait")（除了在回调中，已经通过[`then()`](#torch.futures.Future.then "torch.futures.Future.then")处理）。 +如果值包含驻留在 GPU 上的张量，则此方法将*不*执行任何额外的同步。这应该事先单独完成，通过调用`wait()`（除了在回调中，已经通过`then()`处理）。 返回值 -此`Future`持有的值。如果创建值的函数（回调或RPC）抛出错误，则此`value()`方法也将抛出错误。 +此`Future`持有的值。如果创建值的函数（回调或 RPC）抛出错误，则此`value()`方法也将抛出错误。 返回类型 @@ -176,11 +176,11 @@ wait()¶ 阻塞，直到此`Future`的值准备就绪。 -如果值包含驻留在GPU上的张量，则会执行与在设备上执行的内核进行的额外同步，这些内核可能是异步填充这些张量。这种同步是非阻塞的，这意味着`wait()`将在当前流中插入必要的指令，以确保在这些流上排队的进一步操作将在异步内核之后正确调度，但是一旦完成，`wait()`将返回，即使这些内核仍在运行。在访问和使用值时不需要进一步的同步，只要不改变流。 +如果值包含驻留在 GPU 上的张量，则会执行与在设备上执行的内核进行的额外同步，这些内核可能是异步填充这些张量。这种同步是非阻塞的，这意味着`wait()`将在当前流中插入必要的指令，以确保在这些流上排队的进一步操作将在异步内核之后正确调度，但是一旦完成，`wait()`将返回，即使这些内核仍在运行。在访问和使用值时不需要进一步的同步，只要不改变流。 返回值 -此`Future`持有的值。如果创建值的函数（回调或RPC）抛出错误，则此`wait`方法也将抛出错误。 +此`Future`持有的值。如果创建值的函数（回调或 RPC）抛出错误，则此`wait`方法也将抛出错误。 返回类型 @@ -190,19 +190,19 @@ wait()¶ torch.futures.collect_all(futures)¶ ``` -将提供的[`Future`](#torch.futures.Future "torch.futures.Future")对象收集到一个单独的组合[`Future`](#torch.futures.Future "torch.futures.Future")中，当所有子Future完成时，该组合Future完成。 +将提供的`Future`对象收集到一个单独的组合`Future`中，当所有子 Future 完成时，该组合 Future 完成。 参数 -**futures**（[*列表*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")）- 一个[`Future`](#torch.futures.Future "torch.futures.Future")对象的列表。 +**futures**（[*列表*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")）- 一个`Future`对象的列表。 返回值 -返回一个[`Future`](#torch.futures.Future "torch.futures.Future")对象到传入Futures的列表。 +返回一个`Future`对象到传入 Futures 的列表。 返回类型 -[*Future*](#torch.futures.Future "torch.jit.Future")[[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")[[*Future*](#torch.futures.Future "torch.jit.Future")]] +*Future*[[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*Future*]] 示例:: @@ -223,16 +223,16 @@ fut1 result = 1 torch.futures.wait_all(futures)¶ ``` -等待所有提供的Futures完成，并返回已完成值的列表。如果任何Future遇到错误，该方法将提前退出并报告错误，不等待其他Futures完成。 +等待所有提供的 Futures 完成，并返回已完成值的列表。如果任何 Future 遇到错误，该方法将提前退出并报告错误，不等待其他 Futures 完成。 参数 -**futures**（[*列表*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")）- 一个[`Future`](#torch.futures.Future "torch.futures.Future")对象的列表。 +**futures**（[*列表*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")）- 一个`Future`对象的列表。 返回值 -已完成的[`Future`](#torch.futures.Future "torch.futures.Future")结果列表。如果任何[`Future`](#torch.futures.Future "torch.futures.Future")上的`wait`抛出错误，此方法将抛出错误。 +已完成的`Future`结果列表。如果任何`Future`上的`wait`抛出错误，此方法将抛出错误。 返回类型 -[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)") +[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)") diff --git a/totrans/doc22_058.md b/totrans/doc22_058.md index 38458413..58214828 100644 --- a/totrans/doc22_058.md +++ b/totrans/doc22_058.md @@ -1,10 +1,10 @@ # torch.fx -> 原文：[https://pytorch.org/docs/stable/fx.html](https://pytorch.org/docs/stable/fx.html) +> 原文：[`pytorch.org/docs/stable/fx.html`](https://pytorch.org/docs/stable/fx.html) ##概述 -FX是开发人员用来转换`nn.Module`实例的工具包。FX由三个主要组件组成：**符号跟踪器**，**中间表示**和**Python代码生成**。这些组件的演示： +FX 是开发人员用来转换`nn.Module`实例的工具包。FX 由三个主要组件组成：**符号跟踪器**，**中间表示**和**Python 代码生成**。这些组件的演示： ```py import torch @@ -30,9 +30,9 @@ print(symbolic_traced.graph) graph(): %x : [num_users=1] = placeholder[target=x] %param : [num_users=1] = get_attr[target=param] - %add : [num_users=1] = call_function[target=operator.add](args = (%x, %param), kwargs = {}) - %linear : [num_users=1] = call_module[target=linear](args = (%add,), kwargs = {}) - %clamp : [num_users=1] = call_method[target=clamp](args = (%linear,), kwargs = {min: 0.0, max: 1.0}) + %add : [num_users=1] = call_functiontarget=operator.add, kwargs = {}) + %linear : [num_users=1] = call_moduletarget=linear, kwargs = {}) + %clamp : [num_users=1] = call_methodtarget=clamp, kwargs = {min: 0.0, max: 1.0}) return clamp """ @@ -48,17 +48,17 @@ def forward(self, x): """ ``` -**符号跟踪器**执行Python代码的“符号执行”。它通过代码传递称为代理的虚拟值。对这些代理的操作被记录下来。有关符号跟踪的更多信息，请参阅[`symbolic_trace()`](#torch.fx.symbolic_trace "torch.fx.symbolic_trace")和[`Tracer`](#torch.fx.Tracer "torch.fx.Tracer")文档。 +**符号跟踪器**执行 Python 代码的“符号执行”。它通过代码传递称为代理的虚拟值。对这些代理的操作被记录下来。有关符号跟踪的更多信息，请参阅`symbolic_trace()`和`Tracer`文档。 -**中间表示**是在符号跟踪期间记录的操作的容器。它包含一系列代表函数输入、调用点（到函数、方法或[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")实例）和返回值的节点。有关IR的更多信息，请参阅[`Graph`](#torch.fx.Graph "torch.fx.Graph")的文档。IR是应用变换的格式。 +**中间表示**是在符号跟踪期间记录的操作的容器。它包含一系列代表函数输入、调用点（到函数、方法或`torch.nn.Module`实例）和返回值的节点。有关 IR 的更多信息，请参阅`Graph`的文档。IR 是应用变换的格式。 -**Python代码生成**是使FX成为Python到Python（或模块到模块）转换工具包的关键。对于每个Graph IR，我们可以创建与Graph语义匹配的有效Python代码。这个功能被封装在[`GraphModule`](#torch.fx.GraphModule "torch.fx.GraphModule")中，它是一个包含[`Graph`](#torch.fx.Graph "torch.fx.Graph")以及从Graph生成的`forward`方法的[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")实例。 +**Python 代码生成**是使 FX 成为 Python 到 Python（或模块到模块）转换工具包的关键。对于每个 Graph IR，我们可以创建与 Graph 语义匹配的有效 Python 代码。这个功能被封装在`GraphModule`中，它是一个包含`Graph`以及从 Graph 生成的`forward`方法的`torch.nn.Module`实例。 -综合起来，这些组件的流水线（符号跟踪->中间表示->变换->Python代码生成）构成了FX的Python到Python转换流水线。此外，这些组件也可以单独使用。例如，符号跟踪可以单独用于捕获代码的一种形式以进行分析（而不是转换）目的。代码生成可用于通过配置文件程序生成模型。FX有许多用途！ +综合起来，这些组件的流水线（符号跟踪->中间表示->变换->Python 代码生成）构成了 FX 的 Python 到 Python 转换流水线。此外，这些组件也可以单独使用。例如，符号跟踪可以单独用于捕获代码的一种形式以进行分析（而不是转换）目的。代码生成可用于通过配置文件程序生成模型。FX 有许多用途！ 在[示例](https://github.com/pytorch/examples/tree/master/fx)存储库中可以找到几个示例变换。##编写变换 -什么是FX变换？基本上，它是一个看起来像这样的函数。 +什么是 FX 变换？基本上，它是一个看起来像这样的函数。 ```py import torch @@ -81,11 +81,11 @@ def transform(m: nn.Module, return torch.fx.GraphModule(m, graph) ``` -您的变换将接受一个[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")，从中获取一个[`Graph`](#torch.fx.Graph "torch.fx.Graph")，进行一些修改，然后返回一个新的[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")。您应该将您的FX变换返回的[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")视为与常规[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")相同-您可以将其传递给另一个FX变换，可以将其传递给TorchScript，或者可以运行它。确保您的FX变换的输入和输出是[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")将允许组合。 +您的变换将接受一个`torch.nn.Module`，从中获取一个`Graph`，进行一些修改，然后返回一个新的`torch.nn.Module`。您应该将您的 FX 变换返回的`torch.nn.Module`视为与常规`torch.nn.Module`相同-您可以将其传递给另一个 FX 变换，可以将其传递给 TorchScript，或者可以运行它。确保您的 FX 变换的输入和输出是`torch.nn.Module`将允许组合。 注意 -也可以修改现有的[`GraphModule`](#torch.fx.GraphModule "torch.fx.GraphModule")而不是创建一个新的，就像这样： +也可以修改现有的`GraphModule`而不是创建一个新的，就像这样： ```py import torch @@ -103,13 +103,13 @@ def transform(m : nn.Module) -> nn.Module: return gm ``` -请注意，您必须调用[`GraphModule.recompile()`](#torch.fx.GraphModule.recompile "torch.fx.GraphModule.recompile")来使生成的`forward()`方法与修改后的[`Graph`](#torch.fx.Graph "torch.fx.Graph")同步。 +请注意，您必须调用`GraphModule.recompile()`来使生成的`forward()`方法与修改后的`Graph`同步。 -给定您传入了一个已经被追踪到一个[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")的[`Graph`](#torch.fx.Graph "torch.fx.Graph")，现在有两种主要方法可以用来构建一个新的[`Graph`](#torch.fx.Graph "torch.fx.Graph")。 +给定您传入了一个已经被追踪到一个`torch.nn.Module`的`Graph`，现在有两种主要方法可以用来构建一个新的`Graph`。 ### 关于图形的快速入门 -关于图形语义的完整处理可以在[`Graph`](#torch.fx.Graph "torch.fx.Graph")文档中找到，但我们将在这里介绍基础知识。[`Graph`](#torch.fx.Graph "torch.fx.Graph")是表示[`GraphModule`](#torch.fx.GraphModule "torch.fx.GraphModule")上的方法的数据结构。这需要的信息是： +关于图形语义的完整处理可以在`Graph`文档中找到，但我们将在这里介绍基础知识。`Graph`是表示`GraphModule`上的方法的数据结构。这需要的信息是： + 方法的输入是什么？ @@ -117,7 +117,7 @@ def transform(m : nn.Module) -> nn.Module: + 方法的输出（即返回）值是什么？ -这三个概念都用[`Node`](#torch.fx.Node "torch.fx.Node")实例表示。让我们通过一个简短的示例来看看我们的意思： +这三个概念都用`Node`实例表示。让我们通过一个简短的示例来看看我们的意思： ```py import torch @@ -139,7 +139,7 @@ gm = torch.fx.symbolic_trace(m) gm.graph.print_tabular() ``` -在这里，我们为演示目的定义了一个模块`MyModule`，实例化它，对其进行符号追踪，然后调用[`Graph.print_tabular()`](#torch.fx.Graph.print_tabular "torch.fx.Graph.print_tabular")方法来打印一个表格，显示这个[`Graph`](#torch.fx.Graph "torch.fx.Graph")的节点： +在这里，我们为演示目的定义了一个模块`MyModule`，实例化它，对其进行符号追踪，然后调用`Graph.print_tabular()`方法来打印一个表格，显示这个`Graph`的节点： > | opcode | name | target | args | kwargs | > | --- | --- | --- | --- | --- | @@ -154,19 +154,19 @@ gm.graph.print_tabular() 我们可以使用这些信息来回答我们上面提出的问题。 -+ 方法的输入是什么？在FX中，方法的输入是通过特殊的`placeholder`节点指定的。在这种情况下，我们有一个带有`target`为`x`的单个`placeholder`节点，这意味着我们有一个名为x的单个（非self）参数。 ++ 方法的输入是什么？在 FX 中，方法的输入是通过特殊的`placeholder`节点指定的。在这种情况下，我们有一个带有`target`为`x`的单个`placeholder`节点，这意味着我们有一个名为 x 的单个（非 self）参数。 -+ 方法内部的操作是什么？`get_attr`、`call_function`、`call_module`和`call_method`节点代表方法中的操作。关于所有这些操作的语义的完整处理可以在[`Node`](#torch.fx.Node "torch.fx.Node")文档中找到。 ++ 方法内部的操作是什么？`get_attr`、`call_function`、`call_module`和`call_method`节点代表方法中的操作。关于所有这些操作的语义的完整处理可以在`Node`文档中找到。 -+ 方法的返回值是什么？在[`Graph`](#torch.fx.Graph "torch.fx.Graph")中，返回值由一个特殊的`output`节点指定。 ++ 方法的返回值是什么？在`Graph`中，返回值由一个特殊的`output`节点指定。 -既然我们现在知道了FX中代码是如何表示的基础知识，我们现在可以探讨如何编辑一个[`Graph`](#torch.fx.Graph "torch.fx.Graph")。 +既然我们现在知道了 FX 中代码是如何表示的基础知识，我们现在可以探讨如何编辑一个`Graph`。 ### 图形操作 #### 直接图形操作 -构建这个新的[`Graph`](#torch.fx.Graph "torch.fx.Graph")的一种方法是直接操作您的旧[`Graph`](#torch.fx.Graph "torch.fx.Graph")。为了帮助这一点，我们可以简单地获取从符号追踪中获得的[`Graph`](#torch.fx.Graph "torch.fx.Graph")并对其进行修改。例如，假设我们希望用[`torch.mul()`](generated/torch.mul.html#torch.mul "torch.mul")调用替换[`torch.add()`](generated/torch.add.html#torch.add "torch.add")调用。 +构建这个新的`Graph`的一种方法是直接操作您的旧`Graph`。为了帮助这一点，我们可以简单地获取从符号追踪中获得的`Graph`并对其进行修改。例如，假设我们希望用`torch.mul()`调用替换`torch.add()`调用。 ```py import torch @@ -197,7 +197,7 @@ def transform(m: torch.nn.Module, return fx.GraphModule(m, graph) ``` -我们还可以进行更复杂的[`Graph`](#torch.fx.Graph "torch.fx.Graph")重写，比如删除或追加节点。为了帮助这些转换，FX有用于转换图形的实用函数，可以在[`Graph`](#torch.fx.Graph "torch.fx.Graph")文档中找到。下面是使用这些API追加`torch.relu()`调用的示例。 +我们还可以进行更复杂的`Graph`重写，比如删除或追加节点。为了帮助这些转换，FX 有用于转换图形的实用函数，可以在`Graph`文档中找到。下面是使用这些 API 追加`torch.relu()`调用的示例。 ```py # Specifies the insertion point. Any nodes added to the @@ -215,9 +215,9 @@ with traced.graph.inserting_after(node): 对于只包含替换的简单转换，您也可以使用[subgraph rewriter.](https://github.com/pytorch/pytorch/blob/main/torch/fx/subgraph_rewriter.py) -#### 使用replace_pattern()进行子图重写 +#### 使用 replace_pattern()进行子图重写 -FX还提供了另一种自动化级别，即在直接图操作之上。[`replace_pattern()`](#torch.fx.replace_pattern "torch.fx.replace_pattern") API本质上是一个用于编辑[`Graph`](#torch.fx.Graph "torch.fx.Graph")的“查找/替换”工具。它允许您指定一个`pattern`和一个`replacement`函数，然后将跟踪这些函数，查找`pattern`图中操作组的实例，并用`replacement`图的副本替换这些实例。这可以帮助大大自动化繁琐的图操作代码，随着转换变得更复杂，这些代码可能变得难以控制。 +FX 还提供了另一种自动化级别，即在直接图操作之上。`replace_pattern()` API 本质上是一个用于编辑`Graph`的“查找/替换”工具。它允许您指定一个`pattern`和一个`replacement`函数，然后将跟踪这些函数，查找`pattern`图中操作组的实例，并用`replacement`图的副本替换这些实例。这可以帮助大大自动化繁琐的图操作代码，随着转换变得更复杂，这些代码可能变得难以控制。 #### 图操作示例[](#graph-manipulation-examples "跳转到此标题") @@ -233,9 +233,9 @@ FX还提供了另一种自动化级别，即在直接图操作之上。[`replace ### 代理/重追踪 -另一种操作[`Graph`](#torch.fx.Graph "torch.fx.Graph")的方法是重用符号跟踪中使用的[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")机制。例如，假设我们想要编写一个将PyTorch函数分解为较小操作的转换。它将每个`F.relu(x)`调用转换为`(x > 0) * x`。一种可能性是执行必要的图重写，将比较和乘法插入到`F.relu`之后，然后清理原始的`F.relu`。但是，我们可以通过使用[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")对象自动记录操作并将其附加到[`Graph`](#torch.fx.Graph "torch.fx.Graph")来自动化此过程。 +另一种操作`Graph`的方法是重用符号跟踪中使用的`Proxy`机制。例如，假设我们想要编写一个将 PyTorch 函数分解为较小操作的转换。它将每个`F.relu(x)`调用转换为`(x > 0) * x`。一种可能性是执行必要的图重写，将比较和乘法插入到`F.relu`之后，然后清理原始的`F.relu`。但是，我们可以通过使用`Proxy`对象自动记录操作并将其附加到`Graph`来自动化此过程。 -要使用此方法，我们编写要插入的操作作为常规PyTorch代码，并使用[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")对象作为参数调用该代码。这些[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")对象将捕获对它们执行的操作，并将它们附加到[`Graph`](#torch.fx.Graph "torch.fx.Graph")。 +要使用此方法，我们编写要插入的操作作为常规 PyTorch 代码，并使用`Proxy`对象作为参数调用该代码。这些`Proxy`对象将捕获对它们执行的操作，并将它们附加到`Graph`。 ```py # Note that this decomposition rule can be read as regular Python @@ -264,7 +264,7 @@ def decompose(model: torch.nn.Module, # to the Graph by symbolically tracing it. proxy_args = [ fx.Proxy(env[x.name], tracer) if isinstance(x, fx.Node) else x for x in node.args] - output_proxy = decomposition_rules[node.target](*proxy_args) + output_proxy = decomposition_rulesnode.target # Operations on `Proxy` always yield new `Proxy`s, and the # return value of our decomposition rule is no exception. @@ -280,13 +280,13 @@ def decompose(model: torch.nn.Module, return fx.GraphModule(model, new_graph) ``` -除了避免显式图操作外，使用[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")还允许您将重写规则指定为本机Python代码。对于需要大量重写规则的转换（如vmap或grad），这通常可以提高规则的可读性和可维护性。请注意，当调用[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")时，我们还传递了一个指向底层变量图的跟踪器。这样做是为了防止图中的操作是n元的情况（例如，add是一个二元运算符），对[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")的调用不会创建多个图跟踪器的实例，这可能导致意外的运行时错误。我们特别推荐在底层运算符不能安全地假定为一元运算符时使用[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")的这种方法。 +除了避免显式图操作外，使用`Proxy`还允许您将重写规则指定为本机 Python 代码。对于需要大量重写规则的转换（如 vmap 或 grad），这通常可以提高规则的可读性和可维护性。请注意，当调用`Proxy`时，我们还传递了一个指向底层变量图的跟踪器。这样做是为了防止图中的操作是 n 元的情况（例如，add 是一个二元运算符），对`Proxy`的调用不会创建多个图跟踪器的实例，这可能导致意外的运行时错误。我们特别推荐在底层运算符不能安全地假定为一元运算符时使用`Proxy`的这种方法。 -关于使用[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")进行[`Graph`](#torch.fx.Graph "torch.fx.Graph")操作的示例可以在[这里](https://github.com/pytorch/examples/blob/master/fx/proxy_based_graph_creation.py)找到。 +关于使用`Proxy`进行`Graph`操作的示例可以在[这里](https://github.com/pytorch/examples/blob/master/fx/proxy_based_graph_creation.py)找到。 ### 解释器模式 -FX中一个有用的代码组织模式是循环遍历[`Graph`](#torch.fx.Graph "torch.fx.Graph")中的所有[`Node`](#torch.fx.Node "torch.fx.Node")并执行它们。这可以用于多种目的，包括通过使用[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")进行回溯来运行时分析流经图中的值或转换代码。例如，假设我们想要运行一个[`GraphModule`](#torch.fx.GraphModule "torch.fx.GraphModule")并在运行时记录节点上的[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")形状和dtype属性。可能看起来像这样： +FX 中一个有用的代码组织模式是循环遍历`Graph`中的所有`Node`并执行它们。这可以用于多种目的，包括通过使用`Proxy`进行回溯来运行时分析流经图中的值或转换代码。例如，假设我们想要运行一个`GraphModule`并在运行时记录节点上的`torch.Tensor`形状和 dtype 属性。可能看起来像这样： ```py import torch @@ -338,7 +338,7 @@ class ShapeProp: kwargs = load_arg(node.kwargs) result = getattr(self_obj, node.target)(*args, **kwargs) elif node.op == 'call_module': - result = self.modules[node.target](*load_arg(node.args), **load_arg(node.kwargs)) + result = self.modulesnode.target, **load_arg(node.kwargs)) # This is the only code specific to shape propagation. # you can delete this `if` branch and this becomes @@ -352,9 +352,9 @@ class ShapeProp: return load_arg(self.graph.result) ``` -正如您所看到的，FX的完整解释器并不复杂，但却非常有用。为了简化使用这种模式，我们提供了[`Interpreter`](#torch.fx.Interpreter "torch.fx.Interpreter")类，它以某种方式包含了上述逻辑，使得解释器执行的某些方面可以通过方法重写来覆盖。 +正如您所看到的，FX 的完整解释器并不复杂，但却非常有用。为了简化使用这种模式，我们提供了`Interpreter`类，它以某种方式包含了上述逻辑，使得解释器执行的某些方面可以通过方法重写来覆盖。 -除了执行操作，我们还可以通过将[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")值通过解释器来生成一个新的Graph。类似地，我们提供了[`Transformer`](#torch.fx.Transformer "torch.fx.Transformer")类来包含这种模式。[`Transformer`](#torch.fx.Transformer "torch.fx.Transformer")的行为类似于[`Interpreter`](#torch.fx.Interpreter "torch.fx.Interpreter")，但是不是调用`run`方法从模块中获取具体的输出值，而是调用[`Transformer.transform()`](#torch.fx.Transformer.transform "torch.fx.Transformer.transform")方法返回一个经过您安装的任何转换规则的新的[`GraphModule`](#torch.fx.GraphModule "torch.fx.GraphModule")。 +除了执行操作，我们还可以通过将`Proxy`值通过解释器来生成一个新的 Graph。类似地，我们提供了`Transformer`类来包含这种模式。`Transformer`的行为类似于`Interpreter`，但是不是调用`run`方法从模块中获取具体的输出值，而是调用`Transformer.transform()`方法返回一个经过您安装的任何转换规则的新的`GraphModule`。 #### 解释器模式的示例[](#examples-of-the-interpreter-pattern "跳转到此标题") @@ -368,15 +368,15 @@ class ShapeProp: 在编写转换时，通常我们的代码不会完全正确。在这种情况下，我们可能需要进行一些调试。关键是要向后工作：首先，检查调用生成的模块的结果以证明或证伪正确性。然后，检查和调试生成的代码。然后，调试导致生成的代码的转换过程。 -如果您对调试器不熟悉，请参阅辅助部分[可用调试器](#available-debuggers)。 +如果您对调试器不熟悉，请参阅辅助部分可用调试器。 ### 转换作者常见的陷阱[](#common-pitfalls-in-transform-authoring "跳转到此标题") -+ 非确定性的`set`迭代顺序。在Python中，`set`数据类型是无序的。例如，使用`set`来包含像`Node`这样的对象集合可能会导致意外的非确定性。一个例子是遍历一组`Node`并将它们插入到`Graph`中。因为`set`数据类型是无序的，输出程序中操作的顺序将是非确定性的，并且可能会在程序调用时发生变化。推荐的替代方案是使用`dict`数据类型，它在Python 3.7（以及cPython 3.6）中是[插入有序的](https://mail.python.org/pipermail/python-dev/2017-December/151283.html)。可以通过将要去重的值存储在`dict`的键中来等效地使用`dict`来代替`set`。 ++ 非确定性的`set`迭代顺序。在 Python 中，`set`数据类型是无序的。例如，使用`set`来包含像`Node`这样的对象集合可能会导致意外的非确定性。一个例子是遍历一组`Node`并将它们插入到`Graph`中。因为`set`数据类型是无序的，输出程序中操作的顺序将是非确定性的，并且可能会在程序调用时发生变化。推荐的替代方案是使用`dict`数据类型，它在 Python 3.7（以及 cPython 3.6）中是[插入有序的](https://mail.python.org/pipermail/python-dev/2017-December/151283.html)。可以通过将要去重的值存储在`dict`的键中来等效地使用`dict`来代替`set`。 ### 检查模块正确性[](#checking-correctness-of-modules "跳转到此标题") -由于大多数深度学习模块的输出由浮点[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")实例组成，检查两个[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")的结果是否等价并不像进行简单的相等性检查那样直接。为了激励这一点，让我们举个例子： +由于大多数深度学习模块的输出由浮点`torch.Tensor`实例组成，检查两个`torch.nn.Module`的结果是否等价并不像进行简单的相等性检查那样直接。为了激励这一点，让我们举个例子： ```py import torch @@ -404,7 +404,7 @@ RuntimeError: Boolean value of Tensor with more than one value is ambiguous """ ``` -在这里，我们尝试使用`==`等号操作符来检查两个深度学习模型的值是否相等。然而，这并不是很明确，因为该操作符返回一个张量而不是布尔值，而且由于浮点值的比较应该使用误差边界（或epsilon）来考虑浮点运算的非交换性（有关更多详细信息，请参见[这里](https://floating-point-gui.de/errors/comparison/)）。我们可以使用`torch.allclose()`来进行近似比较，考虑相对和绝对容差阈值： +在这里，我们尝试使用`==`等号操作符来检查两个深度学习模型的值是否相等。然而，这并不是很明确，因为该操作符返回一个张量而不是布尔值，而且由于浮点值的比较应该使用误差边界（或 epsilon）来考虑浮点运算的非交换性（有关更多详细信息，请参见[这里](https://floating-point-gui.de/errors/comparison/)）。我们可以使用`torch.allclose()`来进行近似比较，考虑相对和绝对容差阈值： ```py assert torch.allclose(resnet18(input_image), transformed_resnet18(input_image)) @@ -414,7 +414,7 @@ assert torch.allclose(resnet18(input_image), transformed_resnet18(input_image)) ### 调试生成的代码 -因为FX在`GraphModule`上生成`forward()`函数，所以使用传统的调试技术如`print`语句或`pdb`并不那么直接。幸运的是，我们有几种技术可以用来调试生成的代码。 +因为 FX 在`GraphModule`上生成`forward()`函数，所以使用传统的调试技术如`print`语句或`pdb`并不那么直接。幸运的是，我们有几种技术可以用来调试生成的代码。 #### 使用`pdb` @@ -485,7 +485,7 @@ post_trace = SubclassM() #### 使用`GraphModule`中的`to_folder`函数 -`GraphModule.to_folder()`是`GraphModule`中的一个方法，允许您将生成的FX代码转储到一个文件夹中。尽管将前向传递复制到代码中通常足够，如[打印生成的代码](#print-the-generated-code)，但使用`to_folder`来检查模块和参数可能更容易。 +`GraphModule.to_folder()`是`GraphModule`中的一个方法，允许您将生成的 FX 代码转储到一个文件夹中。尽管将前向传递复制到代码中通常足够，如打印生成的代码，但使用`to_folder`来检查模块和参数可能更容易。 ```py m = symbolic_trace(M()) @@ -498,7 +498,7 @@ y = Bar() ### 调试转换 -既然我们已经确定一个转换正在创建不正确的代码，现在是时候调试转换本身了。首先，我们将在文档中检查[符号跟踪的限制](#limitations-of-symbolic-tracing)部分。一旦验证了跟踪工作正常，目标就是弄清楚在我们的`GraphModule`转换过程中出了什么问题。在[编写转换](#writing-transformations)中可能会有一个快速答案，但如果没有，有几种方法可以检查我们跟踪的模块： +既然我们已经确定一个转换正在创建不正确的代码，现在是时候调试转换本身了。首先，我们将在文档中检查符号跟踪的限制部分。一旦验证了跟踪工作正常，目标就是弄清楚在我们的`GraphModule`转换过程中出了什么问题。在编写转换中可能会有一个快速答案，但如果没有，有几种方法可以检查我们跟踪的模块： ```py # Sample Module @@ -531,7 +531,7 @@ print(traced.graph) graph(): %x : [num_users=1] = placeholder[target=x] %y : [num_users=1] = placeholder[target=y] - %add : [num_users=1] = call_function[target=operator.add](args = (%x, %y), kwargs = {}) + %add : [num_users=1] = call_functiontarget=operator.add, kwargs = {}) return add """ @@ -578,11 +578,11 @@ print(transformed) ### 可用的调试器 -最常见的Python调试器是[pdb](https://docs.python.org/3/library/pdb.html)。您可以通过在命令行中键入`python -m pdb FILENAME.py`来以`pdb`的“调试模式”启动程序，其中`FILENAME`是您要调试的文件的名称。之后，您可以使用`pdb`[调试器命令](https://docs.python.org/3/library/pdb.html#debugger-commands)逐步浏览正在运行的程序。当您启动`pdb`时设置断点（`b LINE-NUMBER`）是很常见的，然后调用`c`运行程序直到那一点。这样可以避免您必须逐行执行（使用`s`或`n`）以到达您想要检查的代码部分。或者，您可以在要中断的行之前写入`import pdb; pdb.set_trace()`。如果添加了`pdb.set_trace()`，当您运行程序时，它将自动以调试模式启动。 （换句话说，您只需在命令行中键入`python FILENAME.py`，而不是`python -m pdb FILENAME.py`。）运行文件时，您可以通过使用特定命令逐步执行代码并检查程序的内部状态。有许多关于`pdb`的优秀教程在线，包括RealPython的[“使用Pdb进行Python调试”](https://realpython.com/python-debugging-pdb/)。 +最常见的 Python 调试器是[pdb](https://docs.python.org/3/library/pdb.html)。您可以通过在命令行中键入`python -m pdb FILENAME.py`来以`pdb`的“调试模式”启动程序，其中`FILENAME`是您要调试的文件的名称。之后，您可以使用`pdb`[调试器命令](https://docs.python.org/3/library/pdb.html#debugger-commands)逐步浏览正在运行的程序。当您启动`pdb`时设置断点（`b LINE-NUMBER`）是很常见的，然后调用`c`运行程序直到那一点。这样可以避免您必须逐行执行（使用`s`或`n`）以到达您想要检查的代码部分。或者，您可以在要中断的行之前写入`import pdb; pdb.set_trace()`。如果添加了`pdb.set_trace()`，当您运行程序时，它将自动以调试模式启动。 （换句话说，您只需在命令行中键入`python FILENAME.py`，而不是`python -m pdb FILENAME.py`。）运行文件时，您可以通过使用特定命令逐步执行代码并检查程序的内部状态。有许多关于`pdb`的优秀教程在线，包括 RealPython 的[“使用 Pdb 进行 Python 调试”](https://realpython.com/python-debugging-pdb/)。 -像PyCharm或VSCode这样的IDE通常内置了调试器。在您的IDE中，您可以选择要么a）通过在IDE中打开终端窗口（例如在VSCode中选择View → Terminal）使用`pdb`，要么b）使用内置调试器（通常是围绕`pdb`的图形包装器）。## 符号跟踪的限制[](#limitations-of-symbolic-tracing "跳转到此标题的永久链接") +像 PyCharm 或 VSCode 这样的 IDE 通常内置了调试器。在您的 IDE 中，您可以选择要么 a）通过在 IDE 中打开终端窗口（例如在 VSCode 中选择 View → Terminal）使用`pdb`，要么 b）使用内置调试器（通常是围绕`pdb`的图形包装器）。## 符号跟踪的限制[](#limitations-of-symbolic-tracing "跳转到此标题的永久链接") -FX使用一种**符号跟踪**系统（也称为[符号执行](https://en.wikipedia.org/wiki/Symbolic_execution)）来以可转换/可分析的形式捕获程序的语义。该系统是**跟踪**的，因为它执行程序（实际上是一个[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")或函数）以记录操作。它是**符号**的，因为在执行过程中流经程序的数据不是真实数据，而是符号（FX术语中的[`Proxy`](#torch.fx.Proxy "torch.fx.Proxy")）。 +FX 使用一种**符号跟踪**系统（也称为[符号执行](https://en.wikipedia.org/wiki/Symbolic_execution)）来以可转换/可分析的形式捕获程序的语义。该系统是**跟踪**的，因为它执行程序（实际上是一个`torch.nn.Module`或函数）以记录操作。它是**符号**的，因为在执行过程中流经程序的数据不是真实数据，而是符号（FX 术语中的`Proxy`）。 尽管符号跟踪适用于大多数神经网络代码，但它也有一些限制。 @@ -616,7 +616,7 @@ torch.fx.proxy.TraceError: symbolically traced variables cannot be used as input #### 静态控制流 -另一方面，所谓的*静态控制流*是受支持的。静态控制流是循环或`if`语句，其值在调用之间不会改变。通常，在PyTorch程序中，这种控制流是基于超参数对模型架构做出决策的代码。举个具体的例子： +另一方面，所谓的*静态控制流*是受支持的。静态控制流是循环或`if`语句，其值在调用之间不会改变。通常，在 PyTorch 程序中，这种控制流是基于超参数对模型架构做出决策的代码。举个具体的例子： ```py import torch @@ -672,11 +672,11 @@ fx.symbolic_trace(f) # Fails! fx.symbolic_trace(f, concrete_args={'flag': True}) ``` -在真正动态控制流的情况下，包含此代码的程序部分可以被追踪为对方法的调用（参见[使用Tracer类自定义追踪](#customizing-tracing)）或函数的调用（参见[`wrap()`](#torch.fx.wrap "torch.fx.wrap")）而不是通过追踪它们。 +在真正动态控制流的情况下，包含此代码的程序部分可以被追踪为对方法的调用（参见使用 Tracer 类自定义追踪）或函数的调用（参见`wrap()`）而不是通过追踪它们。 ### 非`torch`函数 -FX使用`__torch_function__`作为拦截调用的机制（有关更多信息，请参阅[技术概述](https://github.com/pytorch/pytorch/blob/master/torch/fx/OVERVIEW.md#technical-details)）。一些函数，如内置的Python函数或`math`模块中的函数，不受`__torch_function__`覆盖，但我们仍希望在符号追踪中捕获它们。例如： +FX 使用`__torch_function__`作为拦截调用的机制（有关更多信息，请参阅[技术概述](https://github.com/pytorch/pytorch/blob/master/torch/fx/OVERVIEW.md#technical-details)）。一些函数，如内置的 Python 函数或`math`模块中的函数，不受`__torch_function__`覆盖，但我们仍希望在符号追踪中捕获它们。例如： ```py import torch @@ -703,7 +703,7 @@ RuntimeError: 'len' is not supported in symbolic tracing by default. If you want """ ``` -错误告诉我们内置函数`len`不受支持。我们可以通过使用[`wrap()`](#torch.fx.wrap "torch.fx.wrap") API使这样的函数在追踪中记录为直接调用： +错误告诉我们内置函数`len`不受支持。我们可以通过使用`wrap()` API 使这样的函数在追踪中记录为直接调用： ```py torch.fx.wrap('len') @@ -724,7 +724,7 @@ def forward(self, x): ### 使用`Tracer`类自定义追踪[](#customizing-tracing-with-the-tracer-class "跳转到此标题") -[`Tracer`](#torch.fx.Tracer "torch.fx.Tracer")类是`symbolic_trace`实现的基础类。通过对Tracer进行子类化，可以自定义追踪的行为，如下所示： +`Tracer`类是`symbolic_trace`实现的基础类。通过对 Tracer 进行子类化，可以自定义追踪的行为，如下所示： ```py class MyCustomTracer(torch.fx.Tracer): @@ -778,7 +778,7 @@ def forward(self, x): """ ``` -可以通过覆盖[`Tracer.is_leaf_module()`](#torch.fx.Tracer.is_leaf_module "torch.fx.Tracer.is_leaf_module")来自定义叶子模块的集合。 +可以通过覆盖`Tracer.is_leaf_module()`来自定义叶子模块的集合。 ### 杂项 @@ -802,15 +802,15 @@ def forward(self, x): + 类型注解 - + 支持Python 3风格的类型注解（例如`func(x : torch.Tensor, y : int) -> torch.Tensor`），并且将被符号追踪保留。 + + 支持 Python 3 风格的类型注解（例如`func(x : torch.Tensor, y : int) -> torch.Tensor`），并且将被符号追踪保留。 - + Python 2风格的注释类型注解`# type: (torch.Tensor, int) -> torch.Tensor`目前不受支持。 + + Python 2 风格的注释类型注解`# type: (torch.Tensor, int) -> torch.Tensor`目前不受支持。 + 目前不支持函数内部局部名称的注释。 + 关于`training`标志和子模块的注意事项 - + 当使用像`torch.nn.functional.dropout`这样的函数时，通常会将训练参数作为`self.training`传入。在FX追踪期间，这可能会被固定为一个常量值。 + + 当使用像`torch.nn.functional.dropout`这样的函数时，通常会将训练参数作为`self.training`传入。在 FX 追踪期间，这可能会被固定为一个常量值。 > ```py > import torch @@ -868,13 +868,13 @@ def forward(self, x): > > + 由于这种差异，请考虑将与`training`标志动态交互的模块标记为叶子模块。 -## API参考 +## API 参考 ```py torch.fx.symbolic_trace(root, concrete_args=None)¶ ``` -符号追踪API +符号追踪 API 给定一个`nn.Module`或函数实例`root`，此函数将返回一个通过记录在`root`中追踪到的操作而构建的`GraphModule`。 @@ -890,16 +890,16 @@ def f(a, b): return a*2 ``` -由于存在控制流，FX通常无法追踪到这一点。但是，我们可以使用concrete_args来专门针对b的值进行追踪： +由于存在控制流，FX 通常无法追踪到这一点。但是，我们可以使用 concrete_args 来专门针对 b 的值进行追踪： ```py f = fx.symbolic_trace(f, concrete_args={'b': False}) assert f(3, False) == 6 ``` -请注意，尽管您仍然可以传入不同的b值，但它们将被忽略。 +请注意，尽管您仍然可以传入不同的 b 值，但它们将被忽略。 -我们还可以使用concrete_args来消除函数中的数据结构处理。这将使用pytrees来展平您的输入。为了避免过度特化，传递fx.PH以表示不应特化的值。例如： +我们还可以使用 concrete_args 来消除函数中的数据结构处理。这将使用 pytrees 来展平您的输入。为了避免过度特化，传递 fx.PH 以表示不应特化的值。例如： ```py def f(x): @@ -913,9 +913,9 @@ assert f({'a': 1, 'b': 2, 'c': 4}) == 7 参数 -+ **root**（*Union**[*[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")*,* *Callable**]*) - 要跟踪并转换为图形表示的模块或函数。 ++ **root**（*Union***[*torch.nn.Module**,* *Callable**]*) - 要跟踪并转换为图形表示的模块或函数。 -+ **concrete_args**（*可选**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*,* *any**]**]*) - 要部分特化的输入 ++ **concrete_args**（*可选**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* *any**]**]*) - 要部分特化的输入 返回 @@ -923,17 +923,17 @@ assert f({'a': 1, 'b': 2, 'c': 4}) == 7 返回类型 -[GraphModule](#torch.fx.GraphModule "torch.fx.GraphModule") +GraphModule 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py torch.fx.wrap(fn_or_name)¶ ``` -这个函数可以在模块级别范围内调用，将fn_or_name注册为“叶函数”。 “叶函数”将作为CallFunction节点保留在FX跟踪中，而不是被跟踪通过： +这个函数可以在模块级别范围内调用，将 fn_or_name 注册为“叶函数”。 “叶函数”将作为 CallFunction 节点保留在 FX 跟踪中，而不是被跟踪通过： ```py # foo/bar/baz.py @@ -957,21 +957,21 @@ def my_custom_function(x, y): return x * x + y * y ``` -包装函数可以被视为“叶函数”，类似于“叶模块”的概念，即它们是在FX跟踪中作为调用保留的函数，而不是被跟踪。 +包装函数可以被视为“叶函数”，类似于“叶模块”的概念，即它们是在 FX 跟踪中作为调用保留的函数，而不是被跟踪。 参数 -**fn_or_name**（*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*,* *Callable**]*) - 要在调用时插入到图中的全局函数或名称 +**fn_or_name**（*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* *Callable**]*) - 要在调用时插入到图中的全局函数或名称 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py class torch.fx.GraphModule(*args, **kwargs)¶ ``` -GraphModule是从fx.Graph生成的nn.Module。Graphmodule具有`graph`属性，以及从该`graph`生成的`code`和`forward`属性。 +GraphModule 是从 fx.Graph 生成的 nn.Module。Graphmodule 具有`graph`属性，以及从该`graph`生成的`code`和`forward`属性。 警告 @@ -979,25 +979,25 @@ GraphModule是从fx.Graph生成的nn.Module。Graphmodule具有`graph`属性， 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py __init__(root, graph, class_name='GraphModule')¶ ``` -构建一个GraphModule。 +构建一个 GraphModule。 参数 -+ **root**（*Union**[*[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")*,* *Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*,* *Any**]*) - `root`可以是nn.Module实例或将字符串映射到任何属性类型的字典。如果`root`是一个Module，那么Graph的Nodes的`target`字段中对Module-based对象（通过限定名称）的任何引用将从`root`的Module层次结构中的相应位置复制到GraphModule的模块层次结构中。如果`root`是一个字典，那么在Node的`target`中找到的限定名称将直接在字典的键中查找。字典映射到的对象将被复制到GraphModule的模块层次结构中的适当位置。 ++ **root**（*Union***[*torch.nn.Module**,* *Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* *Any**]*) - `root`可以是 nn.Module 实例或将字符串映射到任何属性类型的字典。如果`root`是一个 Module，那么 Graph 的 Nodes 的`target`字段中对 Module-based 对象（通过限定名称）的任何引用将从`root`的 Module 层次结构中的相应位置复制到 GraphModule 的模块层次结构中。如果`root`是一个字典，那么在 Node 的`target`中找到的限定名称将直接在字典的键中查找。字典映射到的对象将被复制到 GraphModule 的模块层次结构中的适当位置。 -+ **graph**（[*Graph*](#torch.fx.Graph "torch.fx.Graph")） - `graph`包含此GraphModule应用于代码生成的节点 ++ **graph**（*Graph*） - `graph`包含此 GraphModule 应用于代码生成的节点 -+ **class_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - `name`表示此GraphModule的名称，用于调试目的。如果未设置，所有错误消息将报告为源自`GraphModule`。将此设置为`root`的原始名称或在转换上下文中有意义的名称可能有助于。 ++ **class_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - `name`表示此 GraphModule 的名称，用于调试目的。如果未设置，所有错误消息将报告为源自`GraphModule`。将此设置为`root`的原始名称或在转换上下文中有意义的名称可能有助于。 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py add_submodule(target, m)¶ @@ -1005,33 +1005,33 @@ add_submodule(target, m)¶ 将给定的子模块添加到`self`。 -如果它们是`target`的子路径，将安装空的Modules。 +如果它们是`target`的子路径，将安装空的 Modules。 参数 -+ **target**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 新子模块的完全限定字符串名称（请参阅`nn.Module.get_submodule`中的示例，了解如何指定完全限定字符串。） ++ **target**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 新子模块的完全限定字符串名称（请参阅`nn.Module.get_submodule`中的示例，了解如何指定完全限定字符串。） -+ **m**（[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")） - 子模块本身；我们要安装在当前Module中的实际对象 ++ **m**（*Module*） - 子模块本身；我们要安装在当前 Module 中的实际对象 返回 子模块是否可以插入。对于 -为了使此方法返回True，`target`表示的链中的每个对象必须是a)尚不存在，或b)引用`nn.Module`（而不是参数或其他属性） +为了使此方法返回 True，`target`表示的链中的每个对象必须是 a)尚不存在，或 b)引用`nn.Module`（而不是参数或其他属性） 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py property code: str¶ ``` -返回从支持此`GraphModule`的`Graph`生成的Python代码。 +返回从支持此`GraphModule`的`Graph`生成的 Python 代码。 ```py delete_all_unused_submodules()¶ @@ -1039,13 +1039,13 @@ delete_all_unused_submodules()¶ 从`self`中删除所有未使用的子模块。 -如果满足以下任一条件，则将模块视为“已使用”：1. 其子模块已被使用 2. 其forward直接通过`call_module`节点调用 3. 它具有一个从`get_attr`节点使用的非Module属性 +如果满足以下任一条件，则将模块视为“已使用”：1. 其子模块已被使用 2. 其 forward 直接通过`call_module`节点调用 3. 它具有一个从`get_attr`节点使用的非 Module 属性 可以调用此方法来清理`nn.Module`，而无需手动在每个未使用的子模块上调用`delete_submodule`。 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py delete_submodule(target)¶ @@ -1057,7 +1057,7 @@ delete_submodule(target)¶ 参数 -**target**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） – 新子模块的完全限定字符串名称（请参阅`nn.Module.get_submodule`中的示例，了解如何指定完全限定字符串。） +**target**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） – 新子模块的完全限定字符串名称（请参阅`nn.Module.get_submodule`中的示例，了解如何指定完全限定字符串。） 返回 @@ -1067,11 +1067,11 @@ delete_submodule(target)¶ 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py property graph: Graph¶ @@ -1083,11 +1083,11 @@ property graph: Graph¶ print_readable(print_output=True)¶ ``` -返回为当前`GraphModule`及其子`GraphModule`生成的Python代码 +返回为当前`GraphModule`及其子`GraphModule`生成的 Python 代码 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py recompile()¶ @@ -1097,7 +1097,7 @@ recompile()¶ 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 返回类型 @@ -1121,13 +1121,13 @@ to_folder(folder, module_name='FxModule')¶ 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py class torch.fx.Graph(owning_module=None, tracer_cls=None, tracer_extras=None)¶ ``` -`Graph`是FX中间表示中使用的主要数据结构。它由一系列`Node`组成，每个`Node`代表调用点（或其他语法结构）。一起取出的`Node`列表构成一个有效的Python函数。 +`Graph`是 FX 中间表示中使用的主要数据结构。它由一系列`Node`组成，每个`Node`代表调用点（或其他语法结构）。一起取出的`Node`列表构成一个有效的 Python 函数。 例如，以下代码 @@ -1157,19 +1157,19 @@ print(gm.graph) ```py graph(x): %linear_weight : [num_users=1] = self.linear.weight - %add_1 : [num_users=1] = call_function[target=operator.add](args = (%x, %linear_weight), kwargs = {}) - %linear_1 : [num_users=1] = call_module[target=linear](args = (%add_1,), kwargs = {}) - %relu_1 : [num_users=1] = call_method[target=relu](args = (%linear_1,), kwargs = {}) - %sum_1 : [num_users=1] = call_function[target=torch.sum](args = (%relu_1,), kwargs = {dim: -1}) - %topk_1 : [num_users=1] = call_function[target=torch.topk](args = (%sum_1, 3), kwargs = {}) + %add_1 : [num_users=1] = call_functiontarget=operator.add, kwargs = {}) + %linear_1 : [num_users=1] = call_moduletarget=linear, kwargs = {}) + %relu_1 : [num_users=1] = call_methodtarget=relu, kwargs = {}) + %sum_1 : [num_users=1] = call_functiontarget=torch.sum, kwargs = {dim: -1}) + %topk_1 : [num_users=1] = call_functiontarget=torch.topk, kwargs = {}) return topk_1 ``` -有关在`Graph`中表示的操作的语义，请参见[`Node`](#torch.fx.Node "torch.fx.Node")。 +有关在`Graph`中表示的操作的语义，请参见`Node`。 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py __init__(owning_module=None, tracer_cls=None, tracer_extras=None)¶ @@ -1179,23 +1179,23 @@ __init__(owning_module=None, tracer_cls=None, tracer_extras=None)¶ 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py call_function(the_function, args=None, kwargs=None, type_expr=None)¶ ``` -将`call_function` `Node`插入`Graph`。`call_function`节点表示对由`the_function`指定的Python可调用对象的调用。 +将`call_function` `Node`插入`Graph`。`call_function`节点表示对由`the_function`指定的 Python 可调用对象的调用。 参数 -+ **the_function**（*Callable**[**...**,* *Any**]*) – 要调用的函数。可以是任何PyTorch运算符、Python函数或`builtins`或`operator`命名空间的成员。 ++ **the_function**（*Callable**[**...**,* *Any**]*) – 要调用的函数。可以是任何 PyTorch 运算符、Python 函数或`builtins`或`operator`命名空间的成员。 + **args**（*可选**[**Tuple**[**Argument**,* *...**]**]*) – 要传递给调用函数的位置参数。 -+ **kwargs**（*可选**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*,* *Argument**]**]*) – 要传递给调用函数的关键字参数 ++ **kwargs**（*可选**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* *Argument**]**]*) – 要传递给调用函数的关键字参数 -+ **type_expr**（*可选**[**Any**]*) – 一个可选的类型注释，表示此节点的输出将具有的Python类型。 ++ **type_expr**（*可选**[**Any**]*) – 一个可选的类型注释，表示此节点的输出将具有的 Python 类型。 返回 @@ -1203,31 +1203,31 @@ call_function(the_function, args=None, kwargs=None, type_expr=None)¶ 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* 注意 -此方法的插入点和类型表达式规则与[`Graph.create_node()`](#torch.fx.Graph.create_node "torch.fx.Graph.create_node")相同。 +此方法的插入点和类型表达式规则与`Graph.create_node()`相同。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py call_method(method_name, args=None, kwargs=None, type_expr=None)¶ ``` -将`call_method` `Node`插入`Graph`中。`call_method`节点表示在`args`的第0个元素上调用给定方法。 +将`call_method` `Node`插入`Graph`中。`call_method`节点表示在`args`的第 0 个元素上调用给定方法。 参数 -+ **method_name** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")) – 要应用于self参数的方法的名称。例如，如果args[0]是表示`Tensor`的`Node`，则要在该`Tensor`上调用`relu()`，请将`relu`传递给`method_name`。 ++ **method_name** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")) – 要应用于 self 参数的方法的名称。例如，如果 args[0]是表示`Tensor`的`Node`，则要在该`Tensor`上调用`relu()`，请将`relu`传递给`method_name`。 + **args** (*Optional**[**Tuple**[**Argument**,* *...**]**]*) – 要传递给调用方法的位置参数。请注意，这*应该*包括一个`self`参数。 + **kwargs** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Argument**]**]*) – 要传递给调用方法的关键字参数 -+ **type_expr** (*Optional**[**Any**]*) – 一个可选的类型注释，表示此节点的输出将具有的Python类型。 ++ **type_expr** (*Optional**[**Any**]*) – 一个可选的类型注释，表示此节点的输出将具有的 Python 类型。 返回 @@ -1235,21 +1235,21 @@ call_method(method_name, args=None, kwargs=None, type_expr=None)¶ 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* 注意 -此方法的插入点和类型表达式规则与[`Graph.create_node()`](#torch.fx.Graph.create_node "torch.fx.Graph.create_node")相同。 +此方法的插入点和类型表达式规则与`Graph.create_node()`相同。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py call_module(module_name, args=None, kwargs=None, type_expr=None)¶ ``` -将`call_module` `Node`插入`Graph`中。`call_module`节点表示在`Module`层次结构中的`Module`的forward()函数的调用。 +将`call_module` `Node`插入`Graph`中。`call_module`节点表示在`Module`层次结构中的`Module`的 forward()函数的调用。 参数 @@ -1259,7 +1259,7 @@ call_module(module_name, args=None, kwargs=None, type_expr=None)¶ + **kwargs** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Argument**]**]*) – 要传递给调用方法的关键字参数 -+ **type_expr** (*Optional**[**Any**]*) – 一个可选的类型注释，表示此节点的输出将具有的Python类型。 ++ **type_expr** (*Optional**[**Any**]*) – 一个可选的类型注释，表示此节点的输出将具有的 Python 类型。 返回 @@ -1267,21 +1267,21 @@ call_module(module_name, args=None, kwargs=None, type_expr=None)¶ 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* 注意 -此方法的插入点和类型表达式规则与[`Graph.create_node()`](#torch.fx.Graph.create_node "torch.fx.Graph.create_node")相同。 +此方法的插入点和类型表达式规则与`Graph.create_node()`相同。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py create_node(op, target, args=None, kwargs=None, name=None, type_expr=None)¶ ``` -创建一个`Node`并将其添加到当前插入点的`Graph`。请注意，当前插入点可以通过[`Graph.inserting_before()`](#torch.fx.Graph.inserting_before "torch.fx.Graph.inserting_before")和[`Graph.inserting_after()`](#torch.fx.Graph.inserting_after "torch.fx.Graph.inserting_after")进行设置。 +创建一个`Node`并将其添加到当前插入点的`Graph`。请注意，当前插入点可以通过`Graph.inserting_before()`和`Graph.inserting_after()`进行设置。 参数 @@ -1291,9 +1291,9 @@ create_node(op, target, args=None, kwargs=None, name=None, type_expr=None)¶ + **kwargs** (*Optional**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Argument**]**]*) – 此节点的关键字参数 -+ **name** (*Optional**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]*) – `Node`的可选字符串名称。这将影响在Python生成的代码中分配给值的名称。 ++ **name** (*Optional**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]*) – `Node`的可选字符串名称。这将影响在 Python 生成的代码中分配给值的名称。 -+ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的Python类型的可选类型注释。 ++ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的 Python 类型的可选类型注释。 返回 @@ -1301,11 +1301,11 @@ create_node(op, target, args=None, kwargs=None, name=None, type_expr=None)¶ 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py eliminate_dead_code()¶ @@ -1323,7 +1323,7 @@ eliminate_dead_code()¶ 示例： -在消除死代码之前，下面的a = x + 1没有用户，因此可以从图中消除而不产生影响。 +在消除死代码之前，下面的 a = x + 1 没有用户，因此可以从图中消除而不产生影响。 ```py def forward(self, x): @@ -1331,7 +1331,7 @@ def forward(self, x): return x + self.attr_1 ``` -消除死代码后，a = x + 1已被移除，前进的其余部分保留。 +消除死代码后，a = x + 1 已被移除，前进的其余部分保留。 ```py def forward(self, x): @@ -1340,11 +1340,11 @@ def forward(self, x): 警告 -死代码消除具有一些启发式方法，以避免删除具有副作用的节点（请参见Node.is_impure），但总体覆盖率非常差，因此您应该假设除非您知道您的FX图完全由功能操作组成，否则不应调用此方法。 +死代码消除具有一些启发式方法，以避免删除具有副作用的节点（请参见 Node.is_impure），但总体覆盖率非常差，因此您应该假设除非您知道您的 FX 图完全由功能操作组成，否则不应调用此方法。 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py erase_node(to_erase)¶ @@ -1354,11 +1354,11 @@ erase_node(to_erase)¶ 参数 -**to_erase**（[*Node*](#torch.fx.Node "torch.fx.Node")） - 要从`Graph`中删除的`Node`。 +**to_erase**（*Node*） - 要从`Graph`中删除的`Node`。 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py get_attr(qualified_name, type_expr=None)¶ @@ -1370,7 +1370,7 @@ get_attr(qualified_name, type_expr=None)¶ + **qualified_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")） - 要检索的属性的完全限定名称。例如，如果被跟踪的模块有一个名为`foo`的子模块，该子模块有一个名为`bar`的子模块，该子模块有一个名为`baz`的属性，则应将限定名称`foo.bar.baz`作为`qualified_name`传递。 -+ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的Python类型的可选类型注释。 ++ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的 Python 类型的可选类型注释。 返回 @@ -1378,7 +1378,7 @@ get_attr(qualified_name, type_expr=None)¶ 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* 注意 @@ -1386,7 +1386,7 @@ get_attr(qualified_name, type_expr=None)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py graph_copy(g, val_map, return_output_node=False)¶ @@ -1396,9 +1396,9 @@ graph_copy(g, val_map, return_output_node=False)¶ 参数 -+ **g**（[*Graph*](#torch.fx.Graph "torch.fx.Graph")） - 要将节点从中复制到`self`的源图。 ++ **g**（*Graph*） - 要将节点从中复制到`self`的源图。 -+ **val_map**（*Dict**[*[*Node*](#torch.fx.Node "torch.fx.Node")*,* [*Node*](#torch.fx.Node "torch.fx.Node")*]*） - 一个将从`g`中的节点映射到`self`中的节点的映射的字典。请注意，`val_map`可以传入已经具有值的值，以覆盖某些值的复制。 ++ **val_map**（*Dict***[*Node**,* *Node**]*） - 一个将从`g`中的节点映射到`self`中的节点的映射的字典。请注意，`val_map`可以传入已经具有值的值，以覆盖某些值的复制。 返回 @@ -1406,19 +1406,19 @@ graph_copy(g, val_map, return_output_node=False)¶ 返回类型 -[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在Python v3.12中)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)"), …], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)")], [*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中)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)")], [slice](https://docs.python.org/3/library/functions.html#slice "(在Python v3.12中)"), [range](https://docs.python.org/3/library/stdtypes.html#range "(在Python v3.12中)"), [Node](#torch.fx.Node "torch.fx.Node"), [str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)"), [float](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)"), [bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)"), [complex](https://docs.python.org/3/library/functions.html#complex "(在Python v3.12中)"), [*dtype*](tensor_attributes.html#torch.dtype "torch.dtype"), [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [*device*](tensor_attributes.html#torch.device "torch.device"), [*memory_format*](tensor_attributes.html#torch.memory_format "torch.memory_format"), [*layout*](tensor_attributes.html#torch.layout "torch.layout"), *OpOverload*]] +[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12 中)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)"), …], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)")], [*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 中)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)")], [slice](https://docs.python.org/3/library/functions.html#slice "(在 Python v3.12 中)"), [range](https://docs.python.org/3/library/stdtypes.html#range "(在 Python v3.12 中)"), Node, [str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)"), [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)"), [float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)"), [bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)"), [complex](https://docs.python.org/3/library/functions.html#complex "(在 Python v3.12 中)"), *dtype*, *Tensor*, *device*, *memory_format*, *layout*, *OpOverload*]] 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py inserting_after(n=None)¶ ``` -设置create_node和companion方法将插入到图中的位置。 +设置 create_node 和 companion 方法将插入到图中的位置。 -在‘with’语句中使用时，这将临时设置插入点，然后在退出with语句时恢复它： +在‘with’语句中使用时，这将临时设置插入点，然后在退出 with 语句时恢复它： ```py with g.inserting_after(n): @@ -1429,7 +1429,7 @@ g.inserting_after(n) # set the insert point permanently 参数： -> n（可选[节点]）：要插入的节点之前。如果为None，则将在其之后插入 +> n（可选[节点]）：要插入的节点之前。如果为 None，则将在其之后插入 > > 整个图的开始。 @@ -1439,15 +1439,15 @@ g.inserting_after(n) # set the insert point permanently 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py inserting_before(n=None)¶ ``` -设置create_node和companion方法将插入到图中的位置。 +设置 create_node 和 companion 方法将插入到图中的位置。 -在‘with’语句中使用时，这将临时设置插入点，然后在退出with语句时恢复它： +在‘with’语句中使用时，这将临时设置插入点，然后在退出 with 语句时恢复它： ```py with g.inserting_before(n): @@ -1458,7 +1458,7 @@ g.inserting_before(n) # set the insert point permanently 参数： -> n（可选[节点]）：要插入的节点之前。如果为None，则将在其之前插入 +> n（可选[节点]）：要插入的节点之前。如果为 None，则将在其之前插入 > > 整个图的开始。 @@ -1468,23 +1468,23 @@ g.inserting_before(n) # set the insert point permanently 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py lint()¶ ``` -对此图运行各种检查，以确保其形式良好。特别是：-检查节点具有正确的所有权（由此图拥有）-检查节点按拓扑顺序出现-如果此图具有拥有的GraphModule，则检查目标是否存在于该GraphModule中 +对此图运行各种检查，以确保其形式良好。特别是：-检查节点具有正确的所有权（由此图拥有）-检查节点按拓扑顺序出现-如果此图具有拥有的 GraphModule，则检查目标是否存在于该 GraphModule 中 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py node_copy(node, arg_transform=>)¶ ``` -将一个图中的节点复制到另一个图中。`arg_transform`需要将节点图中的参数转换为self图中的参数。例如： +将一个图中的节点复制到另一个图中。`arg_transform`需要将节点图中的参数转换为 self 图中的参数。例如： ```py # Copying all the nodes in `g` into `new_graph` @@ -1497,17 +1497,17 @@ for node in g.nodes: 参数 -+ **node**（[*Node*](#torch.fx.Node "torch.fx.Node")）–要复制到`self`中的节点。 ++ **node**（*Node*）–要复制到`self`中的节点。 -+ **arg_transform**（*Callable**[**[*[*Node*](#torch.fx.Node "torch.fx.Node")*]**,* *Argument**]*) – 一个函数，将节点的`args`和`kwargs`中的`Node`参数转换为`self`中的等效参数。在最简单的情况下，这应该从将原始图中的节点映射到`self`的表中检索值。 ++ **arg_transform**（*Callable****[*[*Node**]**,* *Argument**]*) – 一个函数，将节点的`args`和`kwargs`中的`Node`参数转换为`self`中的等效参数。在最简单的情况下，这应该从将原始图中的节点映射到`self`的表中检索值。 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py property nodes: _node_list¶ @@ -1525,19 +1525,19 @@ property nodes: _node_list¶ on_generate_code(make_transformer)¶ ``` -在生成Python代码时注册一个转换器函数 +在生成 Python 代码时注册一个转换器函数 > 参数： > > make_transformer（Callable[[Optional[TransformCodeFunc]], TransformCodeFunc]）： > -> 返回一个要注册的代码转换器的函数。此函数由on_generate_code调用以获取代码转换器。 +> 返回一个要注册的代码转换器的函数。此函数由 on_generate_code 调用以获取代码转换器。 > -> 此函数还将当前注册的代码转换器（如果没有注册任何内容，则为None）作为其输入，以防不希望覆盖它。这对于链接代码转换器很有用。 +> 此函数还将当前注册的代码转换器（如果没有注册任何内容，则为 None）作为其输入，以防不希望覆盖它。这对于链接代码转换器很有用。 > > 返回： > -> 一个上下文管理器，当在with语句中使用时，自动恢复先前注册的代码转换器。 +> 一个上下文管理器，当在 with 语句中使用时，自动恢复先前注册的代码转换器。 > > 例子： > @@ -1590,19 +1590,19 @@ on_generate_code(make_transformer)¶ 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py output(result, type_expr=None)¶ ``` -将`output` `Node`插入`Graph`。`output`节点表示Python代码中的`return`语句。`result`是应该返回的值。 +将`output` `Node`插入`Graph`。`output`节点表示 Python 代码中的`return`语句。`result`是应该返回的值。 参数 + **result**（*Argument*） - 要返回的值。 -+ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的Python类型的可选类型注释。 ++ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的 Python 类型的可选类型注释。 注意 @@ -1610,25 +1610,25 @@ output(result, type_expr=None)¶ 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py placeholder(name, type_expr=None, default_value)¶ ``` -将`placeholder`节点插入Graph。`placeholder`表示函数输入。 +将`placeholder`节点插入 Graph。`placeholder`表示函数输入。 参数 -+ **name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 输入值的名称。这对应于此`Graph`表示的函数的位置参数的名称。 ++ **name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 输入值的名称。这对应于此`Graph`表示的函数的位置参数的名称。 -+ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的Python类型的可选类型注释。在某些情况下，这是必要的，以便进行正确的代码生成（例如，当函数随后在TorchScript编译中使用时）。 ++ **type_expr**（*Optional**[**Any**]*） - 表示此节点输出的 Python 类型的可选类型注释。在某些情况下，这是必要的，以便进行正确的代码生成（例如，当函数随后在 TorchScript 编译中使用时）。 -+ **default_value**（*Any*） - 此函数参数应该采用的默认值。注意：为了允许None作为默认值，应将inspect.Signature.empty作为此参数传递，以指定该参数没有默认值。 ++ **default_value**（*Any*） - 此函数参数应该采用的默认值。注意：为了允许 None 作为默认值，应将 inspect.Signature.empty 作为此参数传递，以指定该参数没有默认值。 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* 注意 @@ -1636,27 +1636,27 @@ placeholder(name, type_expr=None, default_value)¶ 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py print_tabular()¶ ``` -以表格形式打印图的中间表示。请注意，此API需要安装`tabulate`模块。 +以表格形式打印图的中间表示。请注意，此 API 需要安装`tabulate`模块。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py process_inputs(*args)¶ ``` -处理参数，以便它们可以传递给FX图。 +处理参数，以便它们可以传递给 FX 图。 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py process_outputs(out)¶ @@ -1664,29 +1664,29 @@ process_outputs(out)¶ 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py python_code(root_module, *, verbose=False)¶ ``` -将此`Graph`转换为有效的Python代码。 +将此`Graph`转换为有效的 Python 代码。 参数 -**root_module**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 要查找限定名称目标的根模块的名称。通常为“self”。 +**root_module**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 要查找限定名称目标的根模块的名称。通常为“self”。 返回 -src：表示对象全局名称的Python源代码 globals：src中的全局名称的字典->它们引用的对象。 +src：表示对象全局名称的 Python 源代码 globals：src 中的全局名称的字典->它们引用的对象。 返回类型 -一个PythonCode对象，由两个字段组成 +一个 PythonCode 对象，由两个字段组成 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py set_codegen(codegen)¶ @@ -1694,7 +1694,7 @@ set_codegen(codegen)¶ 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py class torch.fx.Node(graph, name, op, target, args, kwargs, return_type=None)¶ @@ -1736,7 +1736,7 @@ append(x)¶ 参数 -**x** ([*Node*](#torch.fx.Node "torch.fx.Node")) – 要在此节点后放置的节点。必须是同一图中的成员。 +**x** (*Node*) – 要在此节点后放置的节点。必须是同一图中的成员。 注意 @@ -1746,7 +1746,7 @@ append(x)¶ property args: Tuple[Optional[Union[Tuple[Any, ...], List[Any], Dict[str, Any], slice, range, Node, str, int, float, bool, complex, dtype, Tensor, device, memory_format, layout, OpOverload]], ...]¶ ``` -这个 `Node` 的参数元组。参数的解释取决于节点的操作码。查看 [`Node`](#torch.fx.Node "torch.fx.Node") 文档字符串以获取更多信息。 +这个 `Node` 的参数元组。参数的解释取决于节点的操作码。查看 `Node` 文档字符串以获取更多信息。 允许对此属性进行赋值。在赋值时，所有使用和用户的计数都会自动更新。 @@ -1770,15 +1770,15 @@ format_node(placeholder_names=None, maybe_return_typename=None)¶ 如果 1) 我们在内部使用 `format_node` 作为辅助函数 -在`Graph`的`__str__`方法中，以及2）`self`是占位符节点，则返回`None`。否则，返回当前Node的描述性字符串表示。 +在`Graph`的`__str__`方法中，以及 2）`self`是占位符节点，则返回`None`。否则，返回当前 Node 的描述性字符串表示。 返回类型 -[str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)") +[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)") 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py insert_arg(idx, arg)¶ @@ -1788,19 +1788,19 @@ insert_arg(idx, arg)¶ 参数 -+ **idx**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12)")）-要在`self.args`中插入的元素的索引。 ++ **idx**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12)")）-要在`self.args`中插入的元素的索引。 + **arg**（*参数*）-要插入`args`的新参数值 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py is_impure()¶ ``` -返回此操作是否不纯净，即其操作是占位符或输出，或者是不纯净的call_function或call_module。 +返回此操作是否不纯净，即其操作是占位符或输出，或者是不纯净的 call_function 或 call_module。 返回 @@ -1808,17 +1808,17 @@ is_impure()¶ 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12)") 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py property kwargs: Dict[str, Optional[Union[Tuple[Any, ...], List[Any], Dict[str, Any], slice, range, Node, str, int, float, bool, complex, dtype, Tensor, device, memory_format, layout, OpOverload]]]¶ ``` -关键字参数的字典到此`Node`。参数的解释取决于节点的操作码。有关更多信息，请参阅[`Node`](#torch.fx.Node "torch.fx.Node")文档字符串。 +关键字参数的字典到此`Node`。参数的解释取决于节点的操作码。有关更多信息，请参阅`Node`文档字符串。 允许对此属性进行赋值。所有使用和用户的计算都会在分配时自动更新。 @@ -1836,39 +1836,39 @@ property next: Node¶ normalized_arguments(root, arg_types=None, kwarg_types=None, normalize_to_only_use_kwargs=False)¶ ``` -将参数标准化为Python目标的参数。这意味着args/kwargs将与模块/功能的签名匹配，并且如果normalize_to_only_use_kwargs为true，则仅以位置顺序返回kwargs。还填充默认值。不支持仅位置参数或可变参数。 +将参数标准化为 Python 目标的参数。这意味着 args/kwargs 将与模块/功能的签名匹配，并且如果 normalize_to_only_use_kwargs 为 true，则仅以位置顺序返回 kwargs。还填充默认值。不支持仅位置参数或可变参数。 支持模块调用。 -可能需要arg_types和kwarg_types以消除重载。 +可能需要 arg_types 和 kwarg_types 以消除重载。 参数 -+ **root**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")）-要解析模块目标的模块。 ++ **root**（*torch.nn.Module*）-要解析模块目标的模块。 -+ **arg_types**（*可选**[**Tuple**[**Any**]**]*)-args的参数类型元组 ++ **arg_types**（*可选**[**Tuple**[**Any**]**]*)-args 的参数类型元组 -+ **kwarg_types**（*可选**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")*,* *Any**]**]*)-kwargs的参数类型字典 ++ **kwarg_types**（*可选**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")*,* *Any**]**]*)-kwargs 的参数类型字典 -+ **normalize_to_only_use_kwargs**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12)")）-是否规范化为仅使用kwargs。 ++ **normalize_to_only_use_kwargs**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12)")）-是否规范化为仅使用 kwargs。 返回 -返回命名元组ArgsKwargsPair，如果不成功则返回None。 +返回命名元组 ArgsKwargsPair，如果不成功则返回 None。 返回类型 -[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12)")[*ArgsKwargsPair*] +[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12)")[*ArgsKwargsPair*] 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py prepend(x)¶ ``` -在图中的节点列表中的此节点之前插入x。示例： +在图中的节点列表中的此节点之前插入 x。示例： ```py Before: p -> self @@ -1879,11 +1879,11 @@ After: p -> x -> self 参数 -**x**（[*Node*](#torch.fx.Node "torch.fx.Node")）-要在此节点之前放置的节点。必须是同一图的成员。 +**x**（*Node*）-要在此节点之前放置的节点。必须是同一图的成员。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py property prev: Node¶ @@ -1899,15 +1899,15 @@ property prev: Node¶ replace_all_uses_with(replace_with, delete_user_cb=>, *, propagate_meta=False)¶ ``` -用Node`replace_with`替换图中所有`self`的使用。 +用 Node`replace_with`替换图中所有`self`的使用。 参数 -+ **replace_with**（[*Node*](#torch.fx.Node "torch.fx.Node")）-要用`self`替换所有使用的节点。 ++ **replace_with**（*Node*）-要用`self`替换所有使用的节点。 -+ **delete_user_cb**（*可调用*）-用于确定是否应删除self节点的给定用户的回调。 ++ **delete_user_cb**（*可调用*）-用于确定是否应删除 self 节点的给定用户的回调。 -+ **propagate_meta**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12)")）-是否复制原始节点的.meta字段上的所有属性到替换节点。出于安全考虑，只有在替换节点尚未具有现有.meta字段时才能这样做。 ++ **propagate_meta**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12)")）-是否复制原始节点的.meta 字段上的所有属性到替换节点。出于安全考虑，只有在替换节点尚未具有现有.meta 字段时才能这样做。 返回 @@ -1915,11 +1915,11 @@ replace_all_uses_with(replace_with, delete_user_cb=>, *, 返回类型 -[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12)")[[*Node*](#torch.fx.Node "torch.fx.node.Node")] +[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12)")[*Node*] 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py replace_input_with(old_input, new_input)¶ @@ -1929,21 +1929,21 @@ replace_input_with(old_input, new_input)¶ 参数 -+ **old_input**（[*Node*](#torch.fx.Node "torch.fx.Node")）-要替换的旧输入节点。 ++ **old_input**（*Node*）-要替换的旧输入节点。 -+ **new_input**（[*Node*](#torch.fx.Node "torch.fx.Node")）-要替换`old_input`的新输入节点。 ++ **new_input**（*Node*）-要替换`old_input`的新输入节点。 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py property stack_trace: Optional[str]¶ ``` -返回在跟踪期间记录的Python堆栈跟踪，如果有的话。使用fx.Tracer跟踪时，此属性通常由Tracer.create_proxy填充。为了记录跟踪期间的堆栈跟踪以进行调试，可以在Tracer实例上设置record_stack_traces = True。使用dynamo跟踪时，此属性将默认由OutputGraph.create_proxy填充。 +返回在跟踪期间记录的 Python 堆栈跟踪，如果有的话。使用 fx.Tracer 跟踪时，此属性通常由 Tracer.create_proxy 填充。为了记录跟踪期间的堆栈跟踪以进行调试，可以在 Tracer 实例上设置 record_stack_traces = True。使用 dynamo 跟踪时，此属性将默认由 OutputGraph.create_proxy 填充。 -stack_trace将在字符串末尾具有最内部的帧。 +stack_trace 将在字符串末尾具有最内部的帧。 ```py update_arg(idx, arg)¶ @@ -1959,7 +1959,7 @@ update_arg(idx, arg)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py update_kwarg(key, arg)¶ @@ -1975,7 +1975,7 @@ update_kwarg(key, arg)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py class torch.fx.Tracer(autowrap_modules=(math,), autowrap_functions=())¶ @@ -1987,7 +1987,7 @@ class torch.fx.Tracer(autowrap_modules=(math,), autowrap_functions=())¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py call_module(m, forward, args, kwargs)¶ @@ -1997,17 +1997,17 @@ call_module(m, forward, args, kwargs)¶ 默认情况下，行为是检查所调用的模块是否是叶模块，通过`is_leaf_module`。如果是，则在`Graph`中引用`m`发出`call_module`节点。否则，正常调用`Module`，跟踪其`forward`函数中的操作。 -可以重写此方法，例如创建嵌套的跟踪GraphModules，或者在跨`Module`边界跟踪时希望的任何其他行为。 +可以重写此方法，例如创建嵌套的跟踪 GraphModules，或者在跨`Module`边界跟踪时希望的任何其他行为。 参数 -+ **m**（[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")）-正在发出调用的模块 ++ **m**（*Module*）-正在发出调用的模块 -+ **forward**（*可调用*）-要调用的`Module`的forward()方法 ++ **forward**（*可调用*）-要调用的`Module`的 forward()方法 -+ **args**（*元组*）-模块调用站点的args ++ **args**（*元组*）-模块调用站点的 args -+ **kwargs**（*Dict*）-模块调用站点的kwargs ++ **kwargs**（*Dict*）-模块调用站点的 kwargs 返回 @@ -2019,7 +2019,7 @@ call_module(m, forward, args, kwargs)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py create_arg(a)¶ @@ -2031,9 +2031,9 @@ create_arg(a)¶ 1. 遍历集合类型（例如元组、列表、字典）并在元素上递归调用`create_args`。 -1. 给定一个代理对象，返回对底层IR`Node`的引用 +1. 给定一个代理对象，返回对底层 IR`Node`的引用 -1. 给定一个非代理张量对象，发出各种情况的IR： +1. 给定一个非代理张量对象，发出各种情况的 IR： > + 对于参数，发出引用该参数的`get_attr`节点 > + @@ -2051,37 +2051,37 @@ create_arg(a)¶ 返回类型 -[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)"), …], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")], [*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)")], [slice](https://docs.python.org/3/library/functions.html#slice "(in Python v3.12)"), [range](https://docs.python.org/3/library/stdtypes.html#range "(in Python v3.12)"), [Node](#torch.fx.Node "torch.fx.Node"), [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)"), [complex](https://docs.python.org/3/library/functions.html#complex "(in Python v3.12)"), [*dtype*](tensor_attributes.html#torch.dtype "torch.dtype"), [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [*device*](tensor_attributes.html#torch.device "torch.device"), [*memory_format*](tensor_attributes.html#torch.memory_format "torch.memory_format"), [*layout*](tensor_attributes.html#torch.layout "torch.layout"), *OpOverload*]] +[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(in Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(in Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)"), …], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(in Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(in Python v3.12)")], [*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)")], [slice](https://docs.python.org/3/library/functions.html#slice "(in Python v3.12)"), [range](https://docs.python.org/3/library/stdtypes.html#range "(in Python v3.12)"), Node, [str](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)"), [int](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)"), [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)"), [complex](https://docs.python.org/3/library/functions.html#complex "(in Python v3.12)"), *dtype*, *Tensor*, *device*, *memory_format*, *layout*, *OpOverload*]] 注意 -此API的向后兼容性已经得到保证。 +此 API 的向后兼容性已经得到保证。 ```py create_args_for_root(root_fn, is_module, concrete_args=None)¶ ``` -创建与`root`模块的签名对应的`placeholder`节点。此方法审查root的签名并相应地发出这些节点，还支持`*args`和`**kwargs`。 +创建与`root`模块的签名对应的`placeholder`节点。此方法审查 root 的签名并相应地发出这些节点，还支持`*args`和`**kwargs`。 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py create_node(kind, target, args, kwargs, name=None, type_expr=None)¶ ``` -插入一个给定目标、args、kwargs和名称的图节点。 +插入一个给定目标、args、kwargs 和名称的图节点。 可以重写此方法以执行额外的检查、验证或修改用于节点创建的值。例如，可能希望禁止记录原地操作。 注意 -此API的向后兼容性已经得到保证。 +此 API 的向后兼容性已经得到保证。 返回类型 -[*Node*](#torch.fx.Node "torch.fx.node.Node") +*Node* ```py create_proxy(kind, target, args, kwargs, name=None, type_expr=None, proxy_factory_fn=None)¶ @@ -2089,11 +2089,11 @@ create_proxy(kind, target, args, kwargs, name=None, type_expr=None, proxy_factor 从给定的参数创建一个节点，然后返回包装在代理对象中的节点。 -如果kind = `placeholder`，那么我们正在创建一个代表函数参数的节点。如果我们需要编码默认参数，我们使用`args`元组。对于`placeholder`节点，`args`否则为空。 +如果 kind = `placeholder`，那么我们正在创建一个代表函数参数的节点。如果我们需要编码默认参数，我们使用`args`元组。对于`placeholder`节点，`args`否则为空。 注意 -此API的向后兼容性已经得到保证。 +此 API 的向后兼容性已经得到保证。 ```py getattr(attr, attr_val, parameter_proxy_cache)¶ @@ -2115,11 +2115,11 @@ getattr(attr, attr_val, parameter_proxy_cache)¶ 返回 -从getattr调用的返回值。 +从 getattr 调用的返回值。 警告 -此API是实验性的，*不*向后兼容。 +此 API 是实验性的，*不*向后兼容。 ```py is_leaf_module(m, module_qualified_name)¶ @@ -2127,11 +2127,11 @@ is_leaf_module(m, module_qualified_name)¶ 指定给定的`nn.Module`是否是“叶子”模块的方法。 -叶模块是出现在IR中的原子单位，由`call_module`调用引用。默认情况下，PyTorch标准库命名空间（torch.nn）中的模块是叶模块。除非通过此参数另有规定，否则将跟踪所有其他模块，并记录其组成操作。 +叶模块是出现在 IR 中的原子单位，由`call_module`调用引用。默认情况下，PyTorch 标准库命名空间（torch.nn）中的模块是叶模块。除非通过此参数另有规定，否则将跟踪所有其他模块，并记录其组成操作。 参数 -+ **m**（[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")） - 被查询的模块 ++ **m**（*Module*） - 被查询的模块 + **module_qualified_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")） - 此模块的根路径。例如，如果您有一个模块层次结构，其中子模块`foo`包含子模块`bar`，后者包含子模块`baz`，那么该模块将以限定名称`foo.bar.baz`显示在此处。 @@ -2141,7 +2141,7 @@ is_leaf_module(m, module_qualified_name)¶ 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py iter(obj)¶ @@ -2149,11 +2149,11 @@ iter(obj)¶ 当代理对象被迭代时调用，例如 -在控制流中使用时。通常我们不知道该做什么，因为我们不知道代理的值，但是自定义跟踪器可以使用create_node附加更多信息到图节点，并选择返回一个迭代器。 +在控制流中使用时。通常我们不知道该做什么，因为我们不知道代理的值，但是自定义跟踪器可以使用 create_node 附加更多信息到图节点，并选择返回一个迭代器。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 返回类型 @@ -2163,13 +2163,13 @@ iter(obj)¶ keys(obj)¶ ``` -当代理对象调用keys()方法时调用。 +当代理对象调用 keys()方法时调用。 这是在代理上调用**时发生的情况。这应该返回一个迭代器，**应该在您的自定义跟踪器中起作用。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 返回类型 @@ -2191,7 +2191,7 @@ path_of_module(mod)¶ 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py proxy(node)¶ @@ -2199,11 +2199,11 @@ proxy(node)¶ 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 返回类型 -[*Proxy*](#torch.fx.Proxy "torch.fx.proxy.Proxy") +*Proxy* ```py to_bool(obj)¶ @@ -2211,11 +2211,11 @@ to_bool(obj)¶ 当代理对象被转换为布尔值时调用，例如 -在控制流中使用时。通常我们不知道该做什么，因为我们不知道代理的值，但是自定义跟踪器可以使用create_node附加更多信息到图节点，并选择返回一个值。 +在控制流中使用时。通常我们不知道该做什么，因为我们不知道代理的值，但是自定义跟踪器可以使用 create_node 附加更多信息到图节点，并选择返回一个值。 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 返回类型 @@ -2225,13 +2225,13 @@ to_bool(obj)¶ trace(root, concrete_args=None)¶ ``` -跟踪`root`并返回相应的FX`Graph`表示。`root`可以是`nn.Module`实例或Python可调用对象。 +跟踪`root`并返回相应的 FX`Graph`表示。`root`可以是`nn.Module`实例或 Python 可调用对象。 请注意，在此调用之后，`self.root`可能与此处传入的`root`不同。例如，当将自由函数传递给`trace()`时，我们将创建一个`nn.Module`实例用作根，并添加嵌入常量。 参数 -+ **root**（*Union**[*[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")*,* *Callable**]*) - 要跟踪的`Module`或函数。此参数的向后兼容性得到保证。 ++ **root**（*Union***[*Module**,* *Callable**]*) - 要跟踪的`Module`或函数。此参数的向后兼容性得到保证。 + **concrete_args**（*可选**[**Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *any**]**]*) - 不应视为代理的具体参数。此参数是实验性的，不保证向后兼容。 @@ -2241,17 +2241,17 @@ trace(root, concrete_args=None)¶ 返回类型 -[*Graph*](#torch.fx.Graph "torch.fx.graph.Graph") +*Graph* 注意 -此API的向后兼容性得到保证。 +此 API 的向后兼容性得到保证。 ```py class torch.fx.Proxy(node, tracer=None)¶ ``` -`Proxy`对象是`Node`包装器，它们在符号跟踪期间流经程序，并记录它们触及的所有操作（`torch`函数调用，方法调用，运算符）到不断增长的FX图中。 +`Proxy`对象是`Node`包装器，它们在符号跟踪期间流经程序，并记录它们触及的所有操作（`torch`函数调用，方法调用，运算符）到不断增长的 FX 图中。 如果您正在进行图形转换，可以将自己的`Proxy`方法包装在原始`Node`周围，以便您可以使用重载的运算符向`Graph`添加其他内容。 @@ -2264,19 +2264,19 @@ for i in range(self.some_hyperparameter): indexed_item = proxied_value[i] ``` -有关Proxy内部更详细的描述，请查看torch/fx/OVERVIEW.md中的“Proxy”部分 +有关 Proxy 内部更详细的描述，请查看 torch/fx/OVERVIEW.md 中的“Proxy”部分 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py class torch.fx.Interpreter(module, garbage_collect_values=True)¶ ``` -Interpreter逐节点执行FX图。这种模式对于许多事情都很有用，包括编写代码转换以及分析传递。 +Interpreter 逐节点执行 FX 图。这种模式对于许多事情都很有用，包括编写代码转换以及分析传递。 -Interpreter类中的方法可以被重写以自定义执行行为。在调用层次结构方面，可以重写的方法映射如下： +Interpreter 类中的方法可以被重写以自定义执行行为。在调用层次结构方面，可以重写的方法映射如下： ```py run() @@ -2291,7 +2291,7 @@ run() 示例 -假设我们想要交换所有`torch.neg`的实例与`torch.sigmoid`以及反之（包括它们的`Tensor`方法等效）。我们可以像这样子类化Interpreter： +假设我们想要交换所有`torch.neg`的实例与`torch.sigmoid`以及反之（包括它们的`Tensor`方法等效）。我们可以像这样子类化 Interpreter： ```py class NegSigmSwapInterpreter(Interpreter): @@ -2319,13 +2319,13 @@ torch.testing.assert_close(result, torch.neg(input).sigmoid()) 参数 -+ **module**（[*GraphModule*](#torch.fx.GraphModule "torch.fx.GraphModule")）- 要执行的模块 ++ **module**（*GraphModule*）- 要执行的模块 -+ **garbage_collect_values**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 是否在模块执行后删除值。这可以确保执行期间的最佳内存使用。可以禁用此功能，例如，通过查看`Interpreter.env`属性来检查执行中的所有中间值。 ++ **garbage_collect_values**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 是否在模块执行后删除值。这可以确保执行期间的最佳内存使用。可以禁用此功能，例如，通过查看`Interpreter.env`属性来检查执行中的所有中间值。 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py boxed_run(args_list)¶ @@ -2335,7 +2335,7 @@ boxed_run(args_list)¶ 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py call_function(target, args, kwargs)¶ @@ -2353,7 +2353,7 @@ call_function(target, args, kwargs)¶ 返回类型 -[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)") +[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)") 返回 @@ -2361,7 +2361,7 @@ call_function(target, args, kwargs)¶ 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py call_method(target, args, kwargs)¶ @@ -2379,7 +2379,7 @@ call_method(target, args, kwargs)¶ 返回类型 -[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)") +[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)") 返回 @@ -2387,7 +2387,7 @@ call_method(target, args, kwargs)¶ 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 ```py call_module(target, args, kwargs)¶ @@ -2405,7 +2405,7 @@ call_module(target, args, kwargs)¶ 返回类型 -[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)") +[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)") 返回 @@ -2413,7 +2413,7 @@ call_module(target, args, kwargs)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py fetch_args_kwargs_from_env(n)¶ @@ -2423,7 +2423,7 @@ fetch_args_kwargs_from_env(n)¶ 参数 -**n**（[*Node*](#torch.fx.Node "torch.fx.Node")）- 应该获取`args`和`kwargs`的节点。 +**n**（*Node*）- 应该获取`args`和`kwargs`的节点。 返回 @@ -2435,7 +2435,7 @@ Tuple[Tuple, Dict] 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py fetch_attr(target)¶ @@ -2445,7 +2445,7 @@ fetch_attr(target)¶ 参数 -**target**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")）- 要获取的属性的完全限定名称 +**target**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")）- 要获取的属性的完全限定名称 返回 @@ -2457,7 +2457,7 @@ fetch_attr(target)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py get_attr(target, args, kwargs)¶ @@ -2483,7 +2483,7 @@ get_attr(target, args, kwargs)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py map_nodes_to_values(args, n)¶ @@ -2495,15 +2495,15 @@ map_nodes_to_values(args, n)¶ + **args**（*Argument*）- 用于查找具体值的数据结构 -+ **n**（[*Node*](#torch.fx.Node "torch.fx.Node")）- `args`所属的节点。仅用于错误报告。 ++ **n**（*Node*）- `args`所属的节点。仅用于错误报告。 返回类型 -[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12)"), …], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12)")], [*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)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12)")], [slice](https://docs.python.org/3/library/functions.html#slice "(在Python v3.12)"), [range](https://docs.python.org/3/library/stdtypes.html#range "(在Python v3.12)"), [*Node*](#torch.fx.Node "torch.fx.node.Node"), [str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)"), [int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)"), [bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12)"), [complex](https://docs.python.org/3/library/functions.html#complex "(在Python v3.12)"), [*dtype*](tensor_attributes.html#torch.dtype "torch.dtype"), [*Tensor*](tensors.html#torch.Tensor "torch.Tensor"), [*device*](tensor_attributes.html#torch.device "torch.device"), [*memory_format*](tensor_attributes.html#torch.memory_format "torch.memory_format"), [*layout*](tensor_attributes.html#torch.layout "torch.layout"), *OpOverload*]] +[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12)")[[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12)")[[*Tuple*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12)"), …], [*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12)")[[*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12)")], [*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)"), [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12)")], [slice](https://docs.python.org/3/library/functions.html#slice "(在 Python v3.12)"), [range](https://docs.python.org/3/library/stdtypes.html#range "(在 Python v3.12)"), *Node*, [str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)"), [int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12)"), [float](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)"), [bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12)"), [complex](https://docs.python.org/3/library/functions.html#complex "(在 Python v3.12)"), *dtype*, *Tensor*, *device*, *memory_format*, *layout*, *OpOverload*]] 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py output(target, args, kwargs)¶ @@ -2529,13 +2529,13 @@ output(target, args, kwargs)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py placeholder(target, args, kwargs)¶ ``` -执行`placeholder`节点。请注意，这是有状态的：`Interpreter`在传递给`run`的参数上维护一个内部迭代器，此方法在该迭代器上返回next()。 +执行`placeholder`节点。请注意，这是有状态的：`Interpreter`在传递给`run`的参数上维护一个内部迭代器，此方法在该迭代器上返回 next()。 参数 @@ -2555,7 +2555,7 @@ placeholder(target, args, kwargs)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py run(*args, initial_env=None, enable_io_processing=True)¶ @@ -2567,9 +2567,9 @@ run(*args, initial_env=None, enable_io_processing=True)¶ + ***args** – 要运行的模块的参数，按位置顺序排列 -+ **initial_env** (*可选**[**字典**[*[*Node*](#torch.fx.Node "torch.fx.Node")*,* *任何**]***) – 执行的可选起始环境。这是一个将节点映射到任何值的字典。例如，可以用来预先填充某些节点的结果，以便在解释器中仅进行部分评估。 ++ **initial_env** (*可选****字典**[*[*Node**,* *任何**]***) – 执行的可选起始环境。这是一个将节点映射到任何值的字典。例如，可以用来预先填充某些节点的结果，以便在解释器中仅进行部分评估。 -+ **enable_io_processing** ([*布尔*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")) – 如果为真，则在使用它们之前，我们首先使用图的process_inputs和process_outputs函数处理输入和输出。 ++ **enable_io_processing** ([*布尔*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 如果为真，则在使用它们之前，我们首先使用图的 process_inputs 和 process_outputs 函数处理输入和输出。 返回 @@ -2581,17 +2581,17 @@ run(*args, initial_env=None, enable_io_processing=True)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py run_node(n)¶ ``` -运行特定节点`n`并返回结果。根据`node.op`调用占位符、get_attr、call_function、call_method、call_module或输出 +运行特定节点`n`并返回结果。根据`node.op`调用占位符、get_attr、call_function、call_method、call_module 或输出 参数 -**n** ([*Node*](#torch.fx.Node "torch.fx.Node")) – 要执行的节点 +**n** (*Node*) – 要执行的节点 返回 @@ -2603,7 +2603,7 @@ run_node(n)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py class torch.fx.Transformer(module)¶ @@ -2640,11 +2640,11 @@ torch.testing.assert_close(transformed(input), torch.neg(input).sigmoid()) 参数 -**module** ([*GraphModule*](#torch.fx.GraphModule "torch.fx.GraphModule")) – 要转换的`Module`。 +**module** (*GraphModule*) – 要转换的`Module`。 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py call_function(target, args, kwargs)¶ @@ -2652,11 +2652,11 @@ call_function(target, args, kwargs)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 返回类型 -[*任何*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)") +[*任何*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)") ```py call_module(target, args, kwargs)¶ @@ -2664,11 +2664,11 @@ call_module(target, args, kwargs)¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 返回类型 -[*任何*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)") +[*任何*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)") ```py get_attr(target, args, kwargs)¶ @@ -2686,11 +2686,11 @@ get_attr(target, args, kwargs)¶ 返回类型 -[*代理*](#torch.fx.Proxy "torch.fx.proxy.Proxy") +*代理* 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py placeholder(target, args, kwargs)¶ @@ -2708,11 +2708,11 @@ placeholder(target, args, kwargs)¶ 返回类型 -[*代理*](#torch.fx.Proxy "torch.fx.proxy.Proxy") +*代理* 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 ```py transform()¶ @@ -2722,25 +2722,25 @@ transform()¶ 注意 -此API的向后兼容性已得到保证。 +此 API 的向后兼容性已得到保证。 返回类型 -[*GraphModule*](#torch.fx.GraphModule "torch.fx.graph_module.GraphModule") +*GraphModule* ```py torch.fx.replace_pattern(gm, pattern, replacement)¶ ``` -在GraphModule（`gm`）的图中匹配所有可能的非重叠运算符及其数据依赖关系（`pattern`），然后用另一个子图（`replacement`）替换这些匹配的子图。 +在 GraphModule（`gm`）的图中匹配所有可能的非重叠运算符及其数据依赖关系（`pattern`），然后用另一个子图（`replacement`）替换这些匹配的子图。 参数 -+ **gm** ([*GraphModule*](#torch.fx.GraphModule "torch.fx.graph_module.GraphModule")) – 包装要操作的图的GraphModule ++ **gm** (*GraphModule*) – 包装要操作的图的 GraphModule -+ **pattern** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")*[*[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在Python v3.12中)")*,* [*GraphModule*](#torch.fx.GraphModule "torch.fx.graph_module.GraphModule")*]*) – 要在`gm`中匹配以进行替换的子图 ++ **pattern** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*[*[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在 Python v3.12 中)")*,* *GraphModule**]*) – 要在`gm`中匹配以进行替换的子图 -+ **replacement** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")*[*[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在Python v3.12中)")*,* [*GraphModule*](#torch.fx.GraphModule "torch.fx.graph_module.GraphModule")*]*) – 用于替换`pattern`的子图 ++ **replacement** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*[*[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在 Python v3.12 中)")*,* *GraphModule**]*) – 用于替换`pattern`的子图 返回 @@ -2784,13 +2784,13 @@ traced_module = symbolic_trace(M()) subgraph_rewriter.replace_pattern(traced_module, pattern, replacement) ``` -上面的代码将首先在`traced_module`的`forward`方法中匹配`pattern`。模式匹配是基于使用-def关系而不是节点名称的。例如，如果在`pattern`中有`p = torch.cat([a, b])`，则可以在原始`forward`函数中匹配`m = torch.cat([a, b])`，尽管变量名称不同（`p`与`m`）。 +上面的代码将首先在`traced_module`的`forward`方法中匹配`pattern`。模式匹配是基于使用-def 关系而不是节点名称的。例如，如果在`pattern`中有`p = torch.cat([a, b])`，则可以在原始`forward`函数中匹配`m = torch.cat([a, b])`，尽管变量名称不同（`p`与`m`）。 `pattern`中的`return`语句仅基于其值匹配；它可能匹配也可能不匹配较大图中的`return`语句。换句话说，模式不必延伸到较大图的末尾。 -当匹配模式时，它将从较大函数中移除，并被`replacement`替换。如果在较大函数中有多个`pattern`的匹配项，每个不重叠的匹配项将被替换。在匹配重叠的情况下，将替换在重叠匹配集中找到的第一个匹配项。（这里的“第一个”被定义为节点使用-def关系的拓扑排序中的第一个。在大多数情况下，第一个节点是直接在`self`之后出现的参数，而最后一个节点是函数返回的内容。） +当匹配模式时，它将从较大函数中移除，并被`replacement`替换。如果在较大函数中有多个`pattern`的匹配项，每个不重叠的匹配项将被替换。在匹配重叠的情况下，将替换在重叠匹配集中找到的第一个匹配项。（这里的“第一个”被定义为节点使用-def 关系的拓扑排序中的第一个。在大多数情况下，第一个节点是直接在`self`之后出现的参数，而最后一个节点是函数返回的内容。） -一个重要的事情要注意的是`pattern` Callable的参数必须在Callable本身中使用，而`replacement` Callable的参数必须与模式匹配。第一个规则是为什么在上面的代码块中，`forward`函数具有参数`x, w1, w2`，但`pattern`函数只有参数`w1, w2`。`pattern`不使用`x`，所以不应该将`x`指定为参数。作为第二条规则的示例，考虑替换 +一个重要的事情要注意的是`pattern` Callable 的参数必须在 Callable 本身中使用，而`replacement` Callable 的参数必须与模式匹配。第一个规则是为什么在上面的代码块中，`forward`函数具有参数`x, w1, w2`，但`pattern`函数只有参数`w1, w2`。`pattern`不使用`x`，所以不应该将`x`指定为参数。作为第二条规则的示例，考虑替换 ```py def pattern(x, y): @@ -2806,7 +2806,7 @@ def replacement(x, y): 在这种情况下，`replacement`需要与`pattern`（`x`和`y`）具有相同数量的参数，即使`replacement`中没有使用参数`y`。 -调用`subgraph_rewriter.replace_pattern`后，生成的Python代码如下： +调用`subgraph_rewriter.replace_pattern`后，生成的 Python 代码如下： ```py def forward(self, x, w1, w2): @@ -2823,4 +2823,4 @@ def forward(self, x, w1, w2): 注意 -此API的向后兼容性是有保证的。 +此 API 的向后兼容性是有保证的。 diff --git a/totrans/doc22_059.md b/totrans/doc22_059.md index add8de96..ff679b03 100644 --- a/totrans/doc22_059.md +++ b/totrans/doc22_059.md @@ -1,14 +1,14 @@ # torch.hub -> 原文：[https://pytorch.org/docs/stable/hub.html](https://pytorch.org/docs/stable/hub.html) +> 原文：[`pytorch.org/docs/stable/hub.html`](https://pytorch.org/docs/stable/hub.html) -Pytorch Hub是一个旨在促进研究可重现性的预训练模型存储库。 +Pytorch Hub 是一个旨在促进研究可重现性的预训练模型存储库。 ## 发布模型 -Pytorch Hub支持通过添加一个简单的`hubconf.py`文件将预训练模型（模型定义和预训练权重）发布到GitHub存储库； +Pytorch Hub 支持通过添加一个简单的`hubconf.py`文件将预训练模型（模型定义和预训练权重）发布到 GitHub 存储库； -`hubconf.py`可以有多个入口点。每个入口点都定义为一个python函数（例如：您想要发布的预训练模型）。 +`hubconf.py`可以有多个入口点。每个入口点都定义为一个 python 函数（例如：您想要发布的预训练模型）。 ```py def entrypoint_name(*args, **kwargs): @@ -18,7 +18,7 @@ def entrypoint_name(*args, **kwargs): ### 如何实现入口点？ -以下是一个代码片段，如果我们在`pytorch/vision/hubconf.py`中扩展实现，则指定了`resnet18`模型的入口点。在大多数情况下，在`hubconf.py`中导入正确的函数就足够了。这里我们只是想使用扩展版本作为示例来展示它是如何工作的。您可以在[pytorch/vision存储库](https://github.com/pytorch/vision/blob/master/hubconf.py)中看到完整的脚本 +以下是一个代码片段，如果我们在`pytorch/vision/hubconf.py`中扩展实现，则指定了`resnet18`模型的入口点。在大多数情况下，在`hubconf.py`中导入正确的函数就足够了。这里我们只是想使用扩展版本作为示例来展示它是如何工作的。您可以在[pytorch/vision 存储库](https://github.com/pytorch/vision/blob/master/hubconf.py)中看到完整的脚本 ```py dependencies = ['torch'] @@ -43,9 +43,9 @@ def resnet18(pretrained=False, **kwargs): + 入口点函数可以返回一个模型(nn.module)，或者辅助工具，以使用户工作流更顺畅，例如分词器。 -+ 以下划线为前缀的可调用函数被视为助手函数，不会显示在[`torch.hub.list()`](#torch.hub.list "torch.hub.list")中。 ++ 以下划线为前缀的可调用函数被视为助手函数，不会显示在`torch.hub.list()`中。 -+ 预训练权重可以存储在GitHub存储库中，也可以通过[`torch.hub.load_state_dict_from_url()`](#torch.hub.load_state_dict_from_url "torch.hub.load_state_dict_from_url")加载。如果小于2GB，建议将其附加到[项目发布](https://help.github.com/en/articles/distributing-large-binaries)并使用发布中的url。在上面的示例中，`torchvision.models.resnet.resnet18`处理`pretrained`，或者您可以将以下逻辑放在入口点定义中。 ++ 预训练权重可以存储在 GitHub 存储库中，也可以通过`torch.hub.load_state_dict_from_url()`加载。如果小于 2GB，建议将其附加到[项目发布](https://help.github.com/en/articles/distributing-large-binaries)并使用发布中的 url。在上面的示例中，`torchvision.models.resnet.resnet18`处理`pretrained`，或者您可以将以下逻辑放在入口点定义中。 ```py if pretrained: @@ -64,9 +64,9 @@ if pretrained: + 发布的模型应至少在一个分支/标签中。它不能是一个随机提交。 -## 从Hub加载模型 +## 从 Hub 加载模型 -Pytorch Hub提供了方便的API，通过[`torch.hub.list()`](#torch.hub.list "torch.hub.list")来探索hub中所有可用的模型，通过[`torch.hub.help()`](#torch.hub.help "torch.hub.help")显示文档字符串和示例，以及使用[`torch.hub.load()`](#torch.hub.load "torch.hub.load")加载预训练模型。 +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)¶ @@ -76,15 +76,15 @@ torch.hub.list(github, force_reload=False, skip_validation=False, trust_repo=Non 参数 -+ **github**（*str*） - 一个格式为“repo_owner/repo_name[:ref]”的字符串，带有可选的ref（标签或分支）。如果未指定`ref`，则假定默认分支为`main`（如果存在），否则为`master`。示例：‘pytorch/vision:0.10’ ++ **github**（*str*） - 一个格式为“repo_owner/repo_name[:ref]”的字符串，带有可选的 ref（标签或分支）。如果未指定`ref`，则假定默认分支为`main`（如果存在），否则为`master`。示例：‘pytorch/vision:0.10’ + **force_reload**（*bool*，可选） - 是否丢弃现有缓存并强制进行新下载。默认为`False`。 -+ **skip_validation**（*bool*，可选） - 如果为`False`，torchhub将检查由`github`参数指定的分支或提交是否正确属于存储库所有者。这将向GitHub API发出请求；您可以通过设置`GITHUB_TOKEN`环境变量来指定非默认GitHub令牌。默认为`False`。 ++ **skip_validation**（*bool*，可选） - 如果为`False`，torchhub 将检查由`github`参数指定的分支或提交是否正确属于存储库所有者。这将向 GitHub API 发出请求；您可以通过设置`GITHUB_TOKEN`环境变量来指定非默认 GitHub 令牌。默认为`False`。 + **trust_repo**（*bool*，*str*或*None*） - - `"check"`，`True`，`False`或`None`。此参数在v1.12中引入，有助于确保用户仅运行来自他们信任的存储库的代码。 + `"check"`，`True`，`False`或`None`。此参数在 v1.12 中引入，有助于确保用户仅运行来自他们信任的存储库的代码。 + 如果为`False`，将提示用户是否应信任存储库。 @@ -92,9 +92,9 @@ torch.hub.list(github, force_reload=False, skip_validation=False, trust_repo=Non + 如果是`"check"`，则将存储库与缓存中的受信任存储库列表进行检查。如果它不在该列表中，则行为将回退到`trust_repo=False`选项。 - + 如果为`None`：这将引发警告，邀请用户将`trust_repo`设置为`False`、`True`或`"check"`。这仅用于向后兼容，将在v2.0中删除。 + + 如果为`None`：这将引发警告，邀请用户将`trust_repo`设置为`False`、`True`或`"check"`。这仅用于向后兼容，将在 v2.0 中删除。 - 默认值为`None`，最终将在v2.0中更改为`"check"`。 + 默认值为`None`，最终将在 v2.0 中更改为`"check"`。 返回 @@ -102,7 +102,7 @@ torch.hub.list(github, force_reload=False, skip_validation=False, trust_repo=Non 返回类型 -[列表](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)") +[列表](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)") 示例 @@ -118,17 +118,17 @@ torch.hub.help(github, model, force_reload=False, skip_validation=False, trust_r 参数 -+ **github**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")） - 一个格式为的字符串，其中包含可选的ref（标签或分支）。如果未指定`ref`，则假定默认分支为`main`（如果存在），否则为`master`。示例：'pytorch/vision:0.10' ++ **github**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")） - 一个格式为的字符串，其中包含可选的 ref（标签或分支）。如果未指定`ref`，则假定默认分支为`main`（如果存在），否则为`master`。示例：'pytorch/vision:0.10' -+ **model**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")） - 在存储库的`hubconf.py`中定义的入口点名称的字符串 ++ **model**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")） - 在存储库的`hubconf.py`中定义的入口点名称的字符串 -+ **force_reload**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12)")，*可选*） - 是否丢弃现有缓存并强制进行新下载。默认值为`False`。 ++ **force_reload**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12)")，*可选*） - 是否丢弃现有缓存并强制进行新下载。默认值为`False`。 -+ **skip_validation**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")，*可选*） - 如果为`False`，torchhub将检查由`github`参数指定的引用是否正确属于存储库所有者。这将向GitHub API发出请求；您可以通过设置`GITHUB_TOKEN`环境变量来指定非默认GitHub令牌。默认值为`False`。 ++ **skip_validation**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")，*可选*） - 如果为`False`，torchhub 将检查由`github`参数指定的引用是否正确属于存储库所有者。这将向 GitHub API 发出请求；您可以通过设置`GITHUB_TOKEN`环境变量来指定非默认 GitHub 令牌。默认值为`False`。 + **trust_repo**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")，[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")或*None*） - - `"check"`，`True`，`False`或`None`。此参数在v1.12中引入，有助于确保用户仅运行来自他们信任的存储库的代码。 + `"check"`，`True`，`False`或`None`。此参数在 v1.12 中引入，有助于确保用户仅运行来自他们信任的存储库的代码。 + 如果为`False`，将提示用户是否应信任存储库。 @@ -136,9 +136,9 @@ torch.hub.help(github, model, force_reload=False, skip_validation=False, trust_r + 如果是`"check"`，则将存储库与缓存中的受信任存储库列表进行检查。如果它不在该列表中，则行为将回退到`trust_repo=False`选项。 - + 如果为`None`：这将引发警告，邀请用户将`trust_repo`设置为`False`、`True`或`"check"`。这仅用于向后兼容，将在v2.0中删除。 + + 如果为`None`：这将引发警告，邀请用户将`trust_repo`设置为`False`、`True`或`"check"`。这仅用于向后兼容，将在 v2.0 中删除。 - 默认值为`None`，最终将在v2.0中更改为`"check"`。 + 默认值为`None`，最终将在 v2.0 中更改为`"check"`。 示例 @@ -150,45 +150,45 @@ torch.hub.help(github, model, force_reload=False, skip_validation=False, trust_r torch.hub.load(repo_or_dir, model, *args, source='github', trust_repo=None, force_reload=False, verbose=True, skip_validation=False, **kwargs)¶ ``` -从github存储库或本地目录加载模型。 +从 github 存储库或本地目录加载模型。 注意：加载模型是典型用例，但也可用于加载其他对象，如分词器、损失函数等。 -如果`source`是'github'，则预期`repo_or_dir`应为形式为`repo_owner/repo_name[:ref]`的形式，其中包含可选的ref（标签或分支）。 +如果`source`是'github'，则预期`repo_or_dir`应为形式为`repo_owner/repo_name[:ref]`的形式，其中包含可选的 ref（标签或分支）。 如果`source`是'local'，则预期`repo_or_dir`是指向本地目录的路径。 参数 -+ **repo_or_dir**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")） - 如果`source`是'github'，则应对应于格式为`repo_owner/repo_name[:ref]`的github存储库，其中包含可选的ref（标签或分支），例如'pytorch/vision:0.10'。如果未指定`ref`，则假定默认分支为`main`（如果存在），否则为`master`。如果`source`是'local'，则应为指向本地目录的路径。 ++ **repo_or_dir**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")） - 如果`source`是'github'，则应对应于格式为`repo_owner/repo_name[:ref]`的 github 存储库，其中包含可选的 ref（标签或分支），例如'pytorch/vision:0.10'。如果未指定`ref`，则假定默认分支为`main`（如果存在），否则为`master`。如果`source`是'local'，则应为指向本地目录的路径。 -+ - `model`（[str](https://docs.python.org/3/library/stdtypes.html#str)）- 在repo/dir的`hubconf.py`中定义的可调用对象（入口点）的名称。 ++ - `model`（[str](https://docs.python.org/3/library/stdtypes.html#str)）- 在 repo/dir 的`hubconf.py`中定义的可调用对象（入口点）的名称。 -+ - `args`（可选）- 可调用`model`的相应args。 ++ - `args`（可选）- 可调用`model`的相应 args。 + - `source`（[str](https://docs.python.org/3/library/stdtypes.html#str)、可选）- ‘github’或‘local’。指定如何解释`repo_or_dir`。默认为‘github’。 + - `trust_repo`（[bool](https://docs.python.org/3/library/functions.html#bool)、[str](https://docs.python.org/3/library/stdtypes.html#str)或`None`）- - - `"check"`、`True`、`False`或`None`。此参数在v1.12中引入，有助于确保用户仅运行他们信任的repo中的代码。 + - `"check"`、`True`、`False`或`None`。此参数在 v1.12 中引入，有助于确保用户仅运行他们信任的 repo 中的代码。 - + - 如果为`False`，将提示用户是否应信任该repo。 + + - 如果为`False`，将提示用户是否应信任该 repo。 - + - 如果为`True`，将该repo添加到受信任列表中，并在不需要明确确认的情况下加载。 + + - 如果为`True`，将该 repo 添加到受信任列表中，并在不需要明确确认的情况下加载。 - + - 如果为`"check"`，将根据缓存中受信任repo的列表检查该repo。如果它不在该列表中，则行为将回退到`trust_repo=False`选项。 + + - 如果为`"check"`，将根据缓存中受信任 repo 的列表检查该 repo。如果它不在该列表中，则行为将回退到`trust_repo=False`选项。 - + - 如果为`None`：这将引发警告，邀请用户将`trust_repo`设置为`False`、`True`或`"check"`。这仅用于向后兼容，将在v2.0中删除。 + + - 如果为`None`：这将引发警告，邀请用户将`trust_repo`设置为`False`、`True`或`"check"`。这仅用于向后兼容，将在 v2.0 中删除。 - - 默认为`None`，最终将在v2.0中更改为`"check"`。 + - 默认为`None`，最终将在 v2.0 中更改为`"check"`。 -+ - `force_reload`（[bool](https://docs.python.org/3/library/functions.html#bool)、可选）- 是否无条件强制刷新下载github repo。如果`source = 'local'`，则没有任何效果。默认为`False`。 ++ - `force_reload`（[bool](https://docs.python.org/3/library/functions.html#bool)、可选）- 是否无条件强制刷新下载 github repo。如果`source = 'local'`，则没有任何效果。默认为`False`。 + - `verbose`（[bool](https://docs.python.org/3/library/functions.html#bool)、可选）- 如果为`False`，则静音关于命中本地缓存的消息。请注意，无法静音关于首次下载的消息。如果`source = 'local'`，则没有任何效果。默认为`True`。 -+ - `skip_validation`（[bool](https://docs.python.org/3/library/functions.html#bool)、可选）- 如果为`False`，torchhub将检查由`github`参数指定的分支或提交是否正确属于repo所有者。这将向GitHub API发出请求；您可以通过设置`GITHUB_TOKEN`环境变量来指定非默认GitHub令牌。默认为`False`。 ++ - `skip_validation`（[bool](https://docs.python.org/3/library/functions.html#bool)、可选）- 如果为`False`，torchhub 将检查由`github`参数指定的分支或提交是否正确属于 repo 所有者。这将向 GitHub API 发出请求；您可以通过设置`GITHUB_TOKEN`环境变量来指定非默认 GitHub 令牌。默认为`False`。 -+ - `kwargs`（可选）- 可调用`model`的相应kwargs。 ++ - `kwargs`（可选）- 可调用`model`的相应 kwargs。 - 返回 @@ -209,17 +209,17 @@ torch.hub.load(repo_or_dir, model, *args, source='github', trust_repo=None, forc torch.hub.download_url_to_file(url, dst, hash_prefix=None, progress=True)¶ ``` -- 将给定URL处的对象下载到本地路径。 +- 将给定 URL 处的对象下载到本地路径。 - 参数 -+ - `url`（[str](https://docs.python.org/3/library/stdtypes.html#str)）- 要下载的对象的URL ++ - `url`（[str](https://docs.python.org/3/library/stdtypes.html#str)）- 要下载的对象的 URL + - `dst`（[str](https://docs.python.org/3/library/stdtypes.html#str)）- 对象将被保存的完整路径，例如`/tmp/temporary_file` -+ - `hash_prefix`（[str](https://docs.python.org/3/library/stdtypes.html#str)、可选）- 如果不为None，则下载的SHA256文件应以`hash_prefix`开头。默认值：None ++ - `hash_prefix`（[str](https://docs.python.org/3/library/stdtypes.html#str)、可选）- 如果不为 None，则下载的 SHA256 文件应以`hash_prefix`开头。默认值：None -+ - `progress`（[bool](https://docs.python.org/3/library/functions.html#bool)、可选）- 是否在stderr上显示进度条。默认值：True ++ - `progress`（[bool](https://docs.python.org/3/library/functions.html#bool)、可选）- 是否在 stderr 上显示进度条。默认值：True - 示例 @@ -231,27 +231,27 @@ torch.hub.download_url_to_file(url, dst, hash_prefix=None, progress=True)¶ 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序列化对象。 +- 加载给定 URL 处的 Torch 序列化对象。 -- 如果下载的文件是zip文件，它将自动解压缩。 +- 如果下载的文件是 zip 文件，它将自动解压缩。 -- 如果对象已经存在于`model_dir`中，则将其反序列化并返回。`model_dir`的默认值是`/checkpoints`，其中`hub_dir`是由[`get_dir()`](#torch.hub.get_dir)返回的目录。 +- 如果对象已经存在于`model_dir`中，则将其反序列化并返回。`model_dir`的默认值是`/checkpoints`，其中`hub_dir`是由`get_dir()`返回的目录。 - 参数 -+ - `url`（[str](https://docs.python.org/3/library/stdtypes.html#str)）- 要下载的对象的URL ++ - `url`（[str](https://docs.python.org/3/library/stdtypes.html#str)）- 要下载的对象的 URL + - `model_dir`（[str](https://docs.python.org/3/library/stdtypes.html#str)、可选）- 保存对象的目录 -+ **map_location** (*optional*) – 一个函数或指定如何重新映射存储位置的字典（参见torch.load） ++ **map_location** (*optional*) – 一个函数或指定如何重新映射存储位置的字典（参见 torch.load） -+ **progress** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否在stderr上显示进度条。默认值：True ++ **progress** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 是否在 stderr 上显示进度条。默认值：True -+ **check_hash** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 如果为True，则URL的文件名部分应遵循命名约定`filename-.ext`，其中``是文件内容的SHA256哈希的前八位或更多位数字。哈希用于确保唯一名称并验证文件的内容。默认值：False ++ **check_hash** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 如果为 True，则 URL 的文件名部分应遵循命名约定`filename-.ext`，其中``是文件内容的 SHA256 哈希的前八位或更多位数字。哈希用于确保唯一名称并验证文件的内容。默认值：False + **file_name** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *optional*) – 下载文件的名称。如果未设置，将使用`url`中的文件名。 -+ **weights_only** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 如果为True，则仅加载权重，不加载复杂的pickled对象。建议用于不受信任的来源。查看[`load()`](generated/torch.load.html#torch.load "torch.load")获取更多详细信息。 ++ **weights_only** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) – 如果为 True，则仅加载权重，不加载复杂的 pickled 对象。建议用于不受信任的来源。查看`load()`获取更多详细信息。 返回类型 @@ -265,7 +265,7 @@ torch.hub.load_state_dict_from_url(url, model_dir=None, map_location=None, progr ### 运行加载的模型： -请注意，[`torch.hub.load()`](#torch.hub.load "torch.hub.load")中的`*args`和`**kwargs`用于**实例化**模型。加载模型后，如何找出可以对模型执行哪些操作？建议的工作流程是 +请注意，`torch.hub.load()`中的`*args`和`**kwargs`用于**实例化**模型。加载模型后，如何找出可以对模型执行哪些操作？建议的工作流程是 + `dir(model)`查看模型的所有可用方法。 @@ -289,15 +289,15 @@ torch.hub.load_state_dict_from_url(url, model_dir=None, map_location=None, progr torch.hub.get_dir()¶ ``` -获取用于存储下载模型和权重的Torch Hub缓存目录。 +获取用于存储下载模型和权重的 Torch Hub 缓存目录。 -如果未调用[`set_dir()`](#torch.hub.set_dir "torch.hub.set_dir")，默认路径为`$TORCH_HOME/hub`，其中环境变量`$TORCH_HOME`默认为`$XDG_CACHE_HOME/torch`。`$XDG_CACHE_HOME`遵循Linux文件系统布局的X Design Group规范，如果未设置环境变量，则默认值为`~/.cache`。 +如果未调用`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目录。 +可选设置用于保存下载模型和权重的 Torch Hub 目录。 参数 @@ -305,12 +305,12 @@ torch.hub.set_dir(d)¶ ### 缓存逻辑 -默认情况下，加载文件后我们不会清理文件。如果目录由[`get_dir()`](#torch.hub.get_dir "torch.hub.get_dir")返回，则Hub默认使用缓存。 +默认情况下，加载文件后我们不会清理文件。如果目录由`get_dir()`返回，则 Hub 默认使用缓存。 -用户可以通过调用`hub.load(..., force_reload=True)`来强制重新加载。这将删除现有的GitHub文件夹和下载的权重，重新初始化一个新的下载。当更新发布到同一分支时，用户可以跟上最新版本。 +用户可以通过调用`hub.load(..., force_reload=True)`来强制重新加载。这将删除现有的 GitHub 文件夹和下载的权重，重新初始化一个新的下载。当更新发布到同一分支时，用户可以跟上最新版本。 ### 已知限制： -Torch hub的工作方式是将包导入为已安装的包。在Python中导入会引入一些副作用。例如，您可以在Python缓存`sys.modules`和`sys.path_importer_cache`中看到新项目，这是正常的Python行为。这也意味着，如果从不同的存储库导入不同的模型时，如果这些存储库具有相同的子包名称（通常是`model`子包），您可能会遇到导入错误。对于这些类型的导入错误的一种解决方法是从`sys.modules`字典中删除有问题的子包；更多详细信息可以在[此GitHub问题](https://github.com/pytorch/hub/issues/243#issuecomment-942403391)中找到。 +Torch hub 的工作方式是将包导入为已安装的包。在 Python 中导入会引入一些副作用。例如，您可以在 Python 缓存`sys.modules`和`sys.path_importer_cache`中看到新项目，这是正常的 Python 行为。这也意味着，如果从不同的存储库导入不同的模型时，如果这些存储库具有相同的子包名称（通常是`model`子包），您可能会遇到导入错误。对于这些类型的导入错误的一种解决方法是从`sys.modules`字典中删除有问题的子包；更多详细信息可以在[此 GitHub 问题](https://github.com/pytorch/hub/issues/243#issuecomment-942403391)中找到。 -这里值得一提的一个已知限制是：用户**无法**在**同一个Python进程**中加载同一存储库的两个不同分支。这就像在Python中安装两个同名包一样，这是不好的。如果您真的尝试这样做，缓存可能会加入其中并给您带来惊喜。当然，在单独的进程中加载它们是完全可以的。 +这里值得一提的一个已知限制是：用户**无法**在**同一个 Python 进程**中加载同一存储库的两个不同分支。这就像在 Python 中安装两个同名包一样，这是不好的。如果您真的尝试这样做，缓存可能会加入其中并给您带来惊喜。当然，在单独的进程中加载它们是完全可以的。 diff --git a/totrans/doc22_060.md b/totrans/doc22_060.md index a572b72b..1e27953d 100644 --- a/totrans/doc22_060.md +++ b/totrans/doc22_060.md @@ -1,82 +1,82 @@ # TorchScript -> 原文：[https://pytorch.org/docs/stable/jit.html](https://pytorch.org/docs/stable/jit.html) +> 原文：[`pytorch.org/docs/stable/jit.html`](https://pytorch.org/docs/stable/jit.html) -+ [TorchScript语言参考](jit_language_reference_v2.html) ++ TorchScript 语言参考 -+ [创建TorchScript代码](#创建TorchScript代码) ++ 创建 TorchScript 代码 -+ [混合追踪和脚本化](#混合追踪和脚本化) ++ 混合追踪和脚本化 -+ [TorchScript语言](#TorchScript语言) ++ TorchScript 语言 -+ [内置函数和模块](#内置函数和模块) ++ 内置函数和模块 - + [PyTorch函数和模块](#PyTorch函数和模块) + + PyTorch 函数和模块 - + [Python函数和模块](#python函数和模块) + + Python 函数和模块 - + [Python语言参考比较](#Python语言参考比较) + + Python 语言参考比较 -+ [调试](#调试) ++ 调试 - + [用于调试的禁用JIT](#用于调试的禁用JIT) + + 用于调试的禁用 JIT - + [检查代码](#检查代码) + + 检查代码 - + [解释图表](#解释图表) + + 解释图表 - + [追踪器](#追踪器) + + 追踪器 -+ [常见问题解答](#常见问题解答) ++ 常见问题解答 -+ [已知问题](#已知问题) ++ 已知问题 -+ [附录](#附录) ++ 附录 - + [迁移到PyTorch 1.2递归脚本API](#迁移到-pytorch-1-2-递归脚本API) + + 迁移到 PyTorch 1.2 递归脚本 API - + [融合后端](#融合后端) + + 融合后端 - + [参考资料](#参考资料) + + 参考资料 -TorchScript是一种从PyTorch代码创建可序列化和可优化模型的方式。任何TorchScript程序都可以从Python进程中保存并加载到没有Python依赖项的进程中。 +TorchScript 是一种从 PyTorch 代码创建可序列化和可优化模型的方式。任何 TorchScript 程序都可以从 Python 进程中保存并加载到没有 Python 依赖项的进程中。 -我们提供工具，逐步将模型从纯Python程序转换为一个可以独立于Python运行的TorchScript程序，比如在一个独立的C++程序中。这使得可以使用Python中熟悉的工具在PyTorch中训练模型，然后通过TorchScript将模型导出到一个生产环境中，在这个环境中，由于性能和多线程原因，Python程序可能不利。 +我们提供工具，逐步将模型从纯 Python 程序转换为一个可以独立于 Python 运行的 TorchScript 程序，比如在一个独立的 C++程序中。这使得可以使用 Python 中熟悉的工具在 PyTorch 中训练模型，然后通过 TorchScript 将模型导出到一个生产环境中，在这个环境中，由于性能和多线程原因，Python 程序可能不利。 -想要了解TorchScript的初学者，可以参考[介绍TorchScript](https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html)教程。 +想要了解 TorchScript 的初学者，可以参考[介绍 TorchScript](https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html)教程。 -想要了解如何将PyTorch模型转换为TorchScript并在C++中运行的端到端示例，可以参考[在C++中加载PyTorch模型](https://pytorch.org/tutorials/advanced/cpp_export.html)教程。 +想要了解如何将 PyTorch 模型转换为 TorchScript 并在 C++中运行的端到端示例，可以参考[在 C++中加载 PyTorch 模型](https://pytorch.org/tutorials/advanced/cpp_export.html)教程。 -## [创建TorchScript代码](#id4)[](#创建TorchScript代码 "跳转到此标题的永久链接") +## 创建 TorchScript 代码[](#创建 TorchScript 代码 "跳转到此标题的永久链接") -| [`script`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script") | 对函数进行脚本化。 | +| `script` | 对函数进行脚本化。 | | --- | --- | -| [`trace`](generated/torch.jit.trace.html#torch.jit.trace "torch.jit.trace") | 追踪一个函数并返回一个可执行的或[`ScriptFunction`](generated/torch.jit.ScriptFunction.html#torch.jit.ScriptFunction "torch.jit.ScriptFunction")，该函数将使用即时编译进行优化。 | -| [`script_if_tracing`](generated/torch.jit.script_if_tracing.html#torch.jit.script_if_tracing "torch.jit.script_if_tracing") | 当在追踪期间首次调用`fn`时，编译`fn`。 | -| [`trace_module`](generated/torch.jit.trace_module.html#torch.jit.trace_module "torch.jit.trace_module") | 追踪一个模块并返回一个可执行的[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")，该模块将使用即时编译进行优化。 | -| [`fork`](generated/torch.jit.fork.html#torch.jit.fork "torch.jit.fork") | 创建一个执行func的异步任务，并引用此执行结果的值。 | -| [`wait`](generated/torch.jit.wait.html#torch.jit.wait "torch.jit.wait") | 强制完成一个torch.jit.Future[T]异步任务，返回任务的结果。 | -| [`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule") | 用于C++ torch::jit::Module的包装器，具有方法、属性和参数。 | -| [`ScriptFunction`](generated/torch.jit.ScriptFunction.html#torch.jit.ScriptFunction "torch.jit.ScriptFunction") | 与[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")在功能上等效，但表示单个函数，不具有任何属性或参数。 | -| [`freeze`](generated/torch.jit.freeze.html#torch.jit.freeze "torch.jit.freeze") | 冻结 ScriptModule，内联子模块，并将属性作为常量。 | -| [`optimize_for_inference`](generated/torch.jit.optimize_for_inference.html#torch.jit.optimize_for_inference "torch.jit.optimize_for_inference") | 执行一系列优化传递，以优化模型以用于推断目的。 | -| [`enable_onednn_fusion`](generated/torch.jit.enable_onednn_fusion.html#torch.jit.enable_onednn_fusion "torch.jit.enable_onednn_fusion") | 根据启用的参数启用或禁用onednn JIT融合。 | -| [`onednn_fusion_enabled`](generated/torch.jit.onednn_fusion_enabled.html#torch.jit.onednn_fusion_enabled "torch.jit.onednn_fusion_enabled") | 返回 onednn JIT 融合是否已启用。 | -| [`set_fusion_strategy`](generated/torch.jit.set_fusion_strategy.html#torch.jit.set_fusion_strategy "torch.jit.set_fusion_strategy") | 设置在融合过程中可以发生的特化类型和数量。 | -| [`strict_fusion`](generated/torch.jit.strict_fusion.html#torch.jit.strict_fusion "torch.jit.strict_fusion") | 如果推断中没有融合所有节点，或者在训练中没有符号微分，则会出错。 | -| [`save`](generated/torch.jit.save.html#torch.jit.save "torch.jit.save") | 保存此模块的离线版本，以供在单独的进程中使用。 | -| [`load`](generated/torch.jit.load.html#torch.jit.load "torch.jit.load") | 加载之前使用 [`torch.jit.save`](generated/torch.jit.save.html#torch.jit.save "torch.jit.save") 保存的 [`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule") 或 [`ScriptFunction`](generated/torch.jit.ScriptFunction.html#torch.jit.ScriptFunction "torch.jit.ScriptFunction")。 | -| [`ignore`](generated/torch.jit.ignore.html#torch.jit.ignore "torch.jit.ignore") | 此装饰器指示编译器应忽略一个函数或方法，并将其保留为Python函数。 | -| [`unused`](generated/torch.jit.unused.html#torch.jit.unused "torch.jit.unused") | 此装饰器指示编译器应忽略一个函数或方法，并用引发异常替换。 | -| [`interface`](generated/torch.jit.interface.html#torch.jit.interface "torch.jit.interface") | 用于注释不同类型的类或模块的装饰器。 | -| [`isinstance`](generated/torch.jit.isinstance.html#torch.jit.isinstance "torch.jit.isinstance") | 在TorchScript中提供容器类型细化。 | -| [`Attribute`](generated/torch.jit.Attribute.html#torch.jit.Attribute "torch.jit.Attribute") | 此方法是一个传递函数，返回值，主要用于指示TorchScript编译器左侧表达式是具有类型的类实例属性。 | -| [`annotate`](generated/torch.jit.annotate.html#torch.jit.annotate "torch.jit.annotate") | 用于在TorchScript编译器中给出 the_value 的类型。 | - -## [混合跟踪和脚本化](#id5)[](#mixing-tracing-and-scripting "跳转到此标题的永久链接") - -在许多情况下，跟踪或脚本化是将模型转换为TorchScript的更简单方法。跟踪和脚本化可以组合以满足模型的特定要求。 +| `trace` | 追踪一个函数并返回一个可执行的或`ScriptFunction`，该函数将使用即时编译进行优化。 | +| `script_if_tracing` | 当在追踪期间首次调用`fn`时，编译`fn`。 | +| `trace_module` | 追踪一个模块并返回一个可执行的`ScriptModule`，该模块将使用即时编译进行优化。 | +| `fork` | 创建一个执行 func 的异步任务，并引用此执行结果的值。 | +| `wait` | 强制完成一个 torch.jit.Future[T]异步任务，返回任务的结果。 | +| `ScriptModule` | 用于 C++ torch::jit::Module 的包装器，具有方法、属性和参数。 | +| `ScriptFunction` | 与`ScriptModule`在功能上等效，但表示单个函数，不具有任何属性或参数。 | +| `freeze` | 冻结 ScriptModule，内联子模块，并将属性作为常量。 | +| `optimize_for_inference` | 执行一系列优化传递，以优化模型以用于推断目的。 | +| `enable_onednn_fusion` | 根据启用的参数启用或禁用 onednn JIT 融合。 | +| `onednn_fusion_enabled` | 返回 onednn JIT 融合是否已启用。 | +| `set_fusion_strategy` | 设置在融合过程中可以发生的特化类型和数量。 | +| `strict_fusion` | 如果推断中没有融合所有节点，或者在训练中没有符号微分，则会出错。 | +| `save` | 保存此模块的离线版本，以供在单独的进程中使用。 | +| `load` | 加载之前使用 `torch.jit.save` 保存的 `ScriptModule` 或 `ScriptFunction`。 | +| `ignore` | 此装饰器指示编译器应忽略一个函数或方法，并将其保留为 Python 函数。 | +| `unused` | 此装饰器指示编译器应忽略一个函数或方法，并用引发异常替换。 | +| `interface` | 用于注释不同类型的类或模块的装饰器。 | +| `isinstance` | 在 TorchScript 中提供容器类型细化。 | +| `Attribute` | 此方法是一个传递函数，返回值，主要用于指示 TorchScript 编译器左侧表达式是具有类型的类实例属性。 | +| `annotate` | 用于在 TorchScript 编译器中给出 the_value 的类型。 | + +## 混合跟踪和脚本化[](#mixing-tracing-and-scripting "跳转到此标题的永久链接") + +在许多情况下，跟踪或脚本化是将模型转换为 TorchScript 的更简单方法。跟踪和脚本化可以组合以满足模型的特定要求。 脚本函数可以调用跟踪函数。当您需要在一个简单的前馈模型周围使用控制流时，这是特别有用的。例如，序列到序列模型的波束搜索通常会以脚本形式编写，但可以调用使用跟踪生成的编码器模块。 @@ -138,35 +138,35 @@ class MyScriptModule(torch.nn.Module): my_script_module = torch.jit.script(MyScriptModule()) ``` -## [TorchScript语言](#id6) +## TorchScript 语言 -TorchScript是Python的静态类型子集，因此许多Python功能直接适用于TorchScript。有关详细信息，请参阅完整的[TorchScript语言参考](jit_language_reference.html#language-reference)。 +TorchScript 是 Python 的静态类型子集，因此许多 Python 功能直接适用于 TorchScript。有关详细信息，请参阅完整的 TorchScript 语言参考。 -## [内置函数和模块](#id7)[](#built-in-functions-and-modules "跳转到此标题的永久链接") +## 内置函数和模块[](#built-in-functions-and-modules "跳转到此标题的永久链接") -TorchScript支持大多数PyTorch函数和许多Python内置函数。查看[TorchScript内置函数](jit_builtin_functions.html#builtin-functions)以获取支持函数的完整参考。 +TorchScript 支持大多数 PyTorch 函数和许多 Python 内置函数。查看 TorchScript 内置函数以获取支持函数的完整参考。 -### [PyTorch函数和模块](#id8)[](#pytorch-functions-and-modules "跳转到此标题的永久链接") +### PyTorch 函数和模块[](#pytorch-functions-and-modules "跳转到此标题的永久链接") -TorchScript支持PyTorch提供的张量和神经网络函数的子集。Tensor上的大多数方法以及`torch`命名空间中的函数，`torch.nn.functional`中的所有函数以及`torch.nn`中的大多数模块都受TorchScript支持。 +TorchScript 支持 PyTorch 提供的张量和神经网络函数的子集。Tensor 上的大多数方法以及`torch`命名空间中的函数，`torch.nn.functional`中的所有函数以及`torch.nn`中的大多数模块都受 TorchScript 支持。 -请查看[TorchScript不支持的PyTorch构造](jit_unsupported.html#jit-unsupported)以获取不支持的PyTorch函数和模块列表。 +请查看 TorchScript 不支持的 PyTorch 构造以获取不支持的 PyTorch 函数和模块列表。 -### [Python函数和模块](#id9)[](#python-functions-and-modules "跳转到此标题的永久链接") +### Python 函数和模块[](#python-functions-and-modules "跳转到此标题的永久链接") -TorchScript支持Python的许多[内置函数](https://docs.python.org/3/library/functions.html)。[`math`](https://docs.python.org/3/library/math.html#module-math "(在Python v3.12中)")模块也受支持（有关详细信息，请参阅[math模块](jit_builtin_functions.html#math-module)），但不支持其他Python模块（内置或第三方）。 +TorchScript 支持 Python 的许多[内置函数](https://docs.python.org/3/library/functions.html)。[`math`](https://docs.python.org/3/library/math.html#module-math "(在 Python v3.12 中)")模块也受支持（有关详细信息，请参阅 math 模块），但不支持其他 Python 模块（内置或第三方）。 -### [Python语言参考比较](#id10)[](#python-language-reference-comparison "跳转到此标题的永久链接") +### Python 语言参考比较[](#python-language-reference-comparison "跳转到此标题的永久链接") -要查看支持的Python功能的完整列表，请参阅[Python语言参考覆盖范围](jit_python_reference.html#python-language-reference)。 +要查看支持的 Python 功能的完整列表，请参阅 Python 语言参考覆盖范围。 -## [调试](#id11) +## 调试 -### [调试时禁用JIT](#id12)[](#disable-jit-for-debugging "跳转到此标题的永久链接") +### 调试时禁用 JIT[](#disable-jit-for-debugging "跳转到此标题的永久链接") PYTORCH_JIT -设置环境变量`PYTORCH_JIT=0`将禁用所有脚本和跟踪注释。如果您的TorchScript模型中有难以调试的错误，您可以使用此标志强制所有内容都使用本机Python运行。由于使用此标志禁用了TorchScript（脚本和跟踪），您可以使用`pdb`等工具来调试模型代码。例如： +设置环境变量`PYTORCH_JIT=0`将禁用所有脚本和跟踪注释。如果您的 TorchScript 模型中有难以调试的错误，您可以使用此标志强制所有内容都使用本机 Python 运行。由于使用此标志禁用了 TorchScript（脚本和跟踪），您可以使用`pdb`等工具来调试模型代码。例如： ```py @torch.jit.script @@ -184,15 +184,15 @@ traced_fn = torch.jit.trace(fn, (torch.rand(4, 5),)) traced_fn(torch.rand(3, 4)) ``` -使用`pdb`调试此脚本可以正常工作，除非我们调用[`@torch.jit.script`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")函数。我们可以全局禁用JIT，这样我们可以像普通Python函数一样调用[`@torch.jit.script`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")函数而不进行编译。如果上述脚本被称为`disable_jit_example.py`，我们可以这样调用它： +使用`pdb`调试此脚本可以正常工作，除非我们调用`@torch.jit.script`函数。我们可以全局禁用 JIT，这样我们可以像普通 Python 函数一样调用`@torch.jit.script`函数而不进行编译。如果上述脚本被称为`disable_jit_example.py`，我们可以这样调用它： ```py $ PYTORCH_JIT=0 python disable_jit_example.py ``` -我们将能够像普通Python函数一样进入[`@torch.jit.script`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")函数。要禁用特定函数的TorchScript编译器，请参阅[`@torch.jit.ignore`](generated/torch.jit.ignore.html#torch.jit.ignore "torch.jit.ignore")。### [检查代码](#id13)[](#inspecting-code "跳转到此标题的永久链接") +我们将能够像普通 Python 函数一样进入`@torch.jit.script`函数。要禁用特定函数的 TorchScript 编译器，请参阅`@torch.jit.ignore`。### 检查代码[](#inspecting-code "跳转到此标题的永久链接") -TorchScript为所有[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")实例提供了代码漂亮打印机。这个漂亮打印机将脚本方法的代码解释为有效的Python语法。例如： +TorchScript 为所有`ScriptModule`实例提供了代码漂亮打印机。这个漂亮打印机将脚本方法的代码解释为有效的 Python 语法。例如： ```py @torch.jit.script @@ -209,7 +209,7 @@ def foo(len): print(foo.code) ``` -具有单个`forward`方法的[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")将具有一个名为`code`的属性，您可以使用它来检查[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")的代码。如果[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")有多个方法，则需要在方法本身上访问`.code`，而不是模块。我们可以通过访问`.foo.code`来检查名为`foo`的方法的代码，该方法位于[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")上。上面的示例产生了这个输出： +具有单个`forward`方法的`ScriptModule`将具有一个名为`code`的属性，您可以使用它来检查`ScriptModule`的代码。如果`ScriptModule`有多个方法，则需要在方法本身上访问`.code`，而不是模块。我们可以通过访问`.foo.code`来检查名为`foo`的方法的代码，该方法位于`ScriptModule`上。上面的示例产生了这个输出： ```py def foo(len: int) -> Tensor: @@ -224,11 +224,11 @@ def foo(len: int) -> Tensor: return rv0 ``` -这是TorchScript对`forward`方法的代码编译。您可以使用此功能来确保TorchScript（跟踪或脚本化）正确捕获了您的模型代码。### [解释图形](#id14)[](#interpreting-graphs "跳转到此标题的永久链接") +这是 TorchScript 对`forward`方法的代码编译。您可以使用此功能来确保 TorchScript（跟踪或脚本化）正确捕获了您的模型代码。### 解释图形[](#interpreting-graphs "跳转到此标题的永久链接") -TorchScript还具有比代码漂亮打印机更低级别的表示形式，即IR图形。 +TorchScript 还具有比代码漂亮打印机更低级别的表示形式，即 IR 图形。 -TorchScript使用静态单赋值（SSA）中间表示（IR）来表示计算。此格式中的指令包括ATen（PyTorch的C++后端）运算符和其他原始运算符，包括用于循环和条件的控制流运算符。例如： +TorchScript 使用静态单赋值（SSA）中间表示（IR）来表示计算。此格式中的指令包括 ATen（PyTorch 的 C++后端）运算符和其他原始运算符，包括用于循环和条件的控制流运算符。例如： ```py @torch.jit.script @@ -245,7 +245,7 @@ def foo(len): print(foo.graph) ``` -`graph`遵循与[检查代码](#inspecting-code)部分中关于`forward`方法查找的相同规则。 +`graph`遵循与检查代码部分中关于`forward`方法查找的相同规则。 上面的示例脚本产生了以下图形： @@ -280,19 +280,19 @@ graph(%len.1 : int): + `％rv.1：Tensor`表示我们将输出分配给名为`rv.1`的（唯一）值，该值是`Tensor`类型的，我们不知道其具体形状。 -+ `aten::zeros`是运算符（等同于`torch.zeros`），输入列表`（％4，％6，％6，％10，％12）`指定应将哪些作用域内的值作为输入传递。内置函数（如`aten::zeros`）的模式可以在[Builtin Functions](#builtin-functions)中找到。 ++ `aten::zeros`是运算符（等同于`torch.zeros`），输入列表`（％4，％6，％6，％10，％12）`指定应将哪些作用域内的值作为输入传递。内置函数（如`aten::zeros`）的模式可以在 Builtin Functions 中找到。 -+ `＃test.py：9:10`是生成此指令的原始源文件中的位置。在这种情况下，它是一个名为test.py的文件，在第9行，第10个字符处。 ++ `＃test.py：9:10`是生成此指令的原始源文件中的位置。在这种情况下，它是一个名为 test.py 的文件，在第 9 行，第 10 个字符处。 请注意，运算符也可以有关联的`blocks`，即`prim::Loop`和`prim::If`运算符。在图形打印输出中，这些运算符的格式化方式反映了它们等效的源代码形式，以便进行简单的调试。 -可以像下面描述的那样检查图形，以确认由[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")描述的计算是正确的，无论是自动还是手动方式。 +可以像下面描述的那样检查图形，以确认由`ScriptModule`描述的计算是正确的，无论是自动还是手动方式。 -### [跟踪器](#id15) +### 跟踪器 #### 跟踪特殊情况 -存在一些特殊情况，其中给定Python函数/模块的跟踪可能不代表底层代码。这些情况可能包括： +存在一些特殊情况，其中给定 Python 函数/模块的跟踪可能不代表底层代码。这些情况可能包括： + 跟踪依赖于输入（例如张量形状）的控制流 @@ -302,7 +302,7 @@ graph(%len.1 : int): #### 自动跟踪检查 -通过在`torch.jit.trace()` API上使用`check_inputs`来自动捕获跟踪中的许多错误是一种方法。`check_inputs`接受一个输入元组列表，用于重新跟踪计算并验证结果。例如： +通过在`torch.jit.trace()` API 上使用`check_inputs`来自动捕获跟踪中的许多错误是一种方法。`check_inputs`接受一个输入元组列表，用于重新跟踪计算并验证结果。例如： ```py def loop_in_traced_fn(x): @@ -357,7 +357,7 @@ Graph diff: 这条消息告诉我们，当我们首次跟踪它和使用`check_inputs`重新跟踪它时，计算之间存在差异。实际上，在`loop_in_traced_fn`的主体内的循环取决于输入`x`的形状，因此当我们尝试另一个具有不同形状的`x`时，跟踪会有所不同。 -在这种情况下，像这样的数据相关控制流可以使用[`torch.jit.script()`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")来捕获： +在这种情况下，像这样的数据相关控制流可以使用`torch.jit.script()`来捕获： ```py def fn(x): @@ -432,11 +432,11 @@ traced = torch.jit.trace(fill_row_zero, (torch.rand(3, 4),)) print(traced.graph) ``` -## [常见问题](#id16)[](#frequently-asked-questions "跳转到此标题的永久链接") +## 常见问题[](#frequently-asked-questions "跳转到此标题的永久链接") -问：我想在GPU上训练模型，然后在CPU上进行推断。有什么最佳实践吗？ +问：我想在 GPU 上训练模型，然后在 CPU 上进行推断。有什么最佳实践吗？ -> 首先将您的模型从GPU转换为CPU，然后保存，就像这样： +> 首先将您的模型从 GPU 转换为 CPU，然后保存，就像这样： > > ```py > cpu_model = gpu_model.cpu() @@ -459,7 +459,7 @@ print(traced.graph) > > 这是推荐的做法，因为跟踪器可能会在特定设备上看到张量的创建，因此在保存模型之前对模型进行转换可能会产生意外效果。在保存模型之前对模型进行转换可以确保跟踪器具有正确的设备信息。 -问：如何在[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")上存储属性？ +问：如何在`ScriptModule`上存储属性？ > 假设我们有一个模型： > @@ -477,11 +477,11 @@ print(traced.graph) > m = torch.jit.script(Model()) > ``` > -> 如果实例化`Model`，将导致编译错误，因为编译器不知道`x`。有4种方法可以通知编译器[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")上的属性： +> 如果实例化`Model`，将导致编译错误，因为编译器不知道`x`。有 4 种方法可以通知编译器`ScriptModule`上的属性： > > 1. `nn.Parameter` - 包装在`nn.Parameter`中的值将像在`nn.Module`上一样工作 > -> 2. `register_buffer` - 包装在`register_buffer`中的值将像在`nn.Module`上一样工作。这相当于类型为`Tensor`的属性（见4）。 +> 2. `register_buffer` - 包装在`register_buffer`中的值将像在`nn.Module`上一样工作。这相当于类型为`Tensor`的属性（见 4）。 > > 3. 常量 - 将类成员标记为`Final`（或将其添加到类定义级别的名为`__constants__`的列表中）将会将包含的名称标记为常量。常量直接保存在模型的代码中。详细信息请参见内置常量。 > @@ -497,21 +497,21 @@ print(traced.graph) > > + > > + 另一方面，使用模块实例（例如`my_module`）调用`trace`会创建一个新模块，并将参数正确复制到新模块中，因此如果需要，它们可以累积梯度。 > > + -> 要跟踪模块上的特定方法，请参见[`torch.jit.trace_module`](generated/torch.jit.trace_module.html#torch.jit.trace_module "torch.jit.trace_module") +> 要跟踪模块上的特定方法，请参见`torch.jit.trace_module` -## [已知问题](#id17) +## 已知问题 -如果您在TorchScript中使用`Sequential`，则某些`Sequential`子模块的输入可能会被错误地推断为`Tensor`，即使它们已经被注释。标准解决方案是子类化`nn.Sequential`并使用正确类型的输入重新声明`forward`。 +如果您在 TorchScript 中使用`Sequential`，则某些`Sequential`子模块的输入可能会被错误地推断为`Tensor`，即使它们已经被注释。标准解决方案是子类化`nn.Sequential`并使用正确类型的输入重新声明`forward`。 -## [附录](#id18) +## 附录 -### [迁移到PyTorch 1.2递归脚本API](#id19)[](#migrating-to-pytorch-1-2-recursive-scripting-api "跳转到此标题的永久链接") +### 迁移到 PyTorch 1.2 递归脚本 API[](#migrating-to-pytorch-1-2-recursive-scripting-api "跳转到此标题的永久链接") -本节详细介绍了PyTorch 1.2中TorchScript的更改。如果您是TorchScript的新手，可以跳过本节。PyTorch 1.2对TorchScript API进行了两个主要更改。 +本节详细介绍了 PyTorch 1.2 中 TorchScript 的更改。如果您是 TorchScript 的新手，可以跳过本节。PyTorch 1.2 对 TorchScript API 进行了两个主要更改。 -1. [`torch.jit.script`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")现在将尝试递归编译遇到的函数、方法和类。一旦调用`torch.jit.script`，编译就是“opt-out”，而不是“opt-in”。 +1. `torch.jit.script`现在将尝试递归编译遇到的函数、方法和类。一旦调用`torch.jit.script`，编译就是“opt-out”，而不是“opt-in”。 -2. `torch.jit.script(nn_module_instance)`现在是创建[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")的首选方法，而不是继承自`torch.jit.ScriptModule`。这些更改结合在一起，为将您的`nn.Module`转换为[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")提供了一个更简单、更易于使用的API，准备在非Python环境中进行优化和执行。 +2. `torch.jit.script(nn_module_instance)`现在是创建`ScriptModule`的首选方法，而不是继承自`torch.jit.ScriptModule`。这些更改结合在一起，为将您的`nn.Module`转换为`ScriptModule`提供了一个更简单、更易于使用的 API，准备在非 Python 环境中进行优化和执行。 新的用法如下： @@ -538,15 +538,15 @@ my_scripted_model = torch.jit.script(my_model) + 除了从`forward`调用的方法之外，要编译其他方法，请添加`@torch.jit.export`。 -+ 要阻止编译器编译一个方法，请添加[`@torch.jit.ignore`](generated/torch.jit.ignore.html#torch.jit.ignore "torch.jit.ignore")或[`@torch.jit.unused`](generated/torch.jit.unused.html#torch.jit.unused "torch.jit.unused")。`@ignore`保留了 ++ 要阻止编译器编译一个方法，请添加`@torch.jit.ignore`或`@torch.jit.unused`。`@ignore`保留了 -+ 将方法作为对python的调用，并用`@unused`替换它以引发异常。`@ignored`不能被导出；`@unused`可以。 ++ 将方法作为对 python 的调用，并用`@unused`替换它以引发异常。`@ignored`不能被导出；`@unused`可以。 -+ 大多数属性类型可以被推断，因此不需要`torch.jit.Attribute`。对于空容器类型，使用[PEP 526风格](https://www.python.org/dev/peps/pep-0526/#class-and-instance-variable-annotations)的类注释来注释它们的类型。 ++ 大多数属性类型可以被推断，因此不需要`torch.jit.Attribute`。对于空容器类型，使用[PEP 526 风格](https://www.python.org/dev/peps/pep-0526/#class-and-instance-variable-annotations)的类注释来注释它们的类型。 + 常量可以用`Final`类注释标记，而不是将成员名称添加到`__constants__`中。 -+ Python 3类型提示可以用来替代`torch.jit.annotate` ++ Python 3 类型提示可以用来替代`torch.jit.annotate` 由于这些更改，以下项目被视为已弃用，不应出现在新代码中： @@ -564,15 +564,15 @@ my_scripted_model = torch.jit.script(my_model) 警告 -在PyTorch 1.2中，[`@torch.jit.ignore`](generated/torch.jit.ignore.html#torch.jit.ignore "torch.jit.ignore")注解的行为发生了变化。在PyTorch 1.2之前，@ignore装饰器用于使一个函数或方法可以从导出的代码中调用。要恢复此功能，请使用`@torch.jit.unused()`。`@torch.jit.ignore`现在等同于`@torch.jit.ignore(drop=False)`。有关详细信息，请参阅[`@torch.jit.ignore`](generated/torch.jit.ignore.html#torch.jit.ignore "torch.jit.ignore")和[`@torch.jit.unused`](generated/torch.jit.unused.html#torch.jit.unused "torch.jit.unused")。 +在 PyTorch 1.2 中，`@torch.jit.ignore`注解的行为发生了变化。在 PyTorch 1.2 之前，@ignore 装饰器用于使一个函数或方法可以从导出的代码中调用。要恢复此功能，请使用`@torch.jit.unused()`。`@torch.jit.ignore`现在等同于`@torch.jit.ignore(drop=False)`。有关详细信息，请参阅`@torch.jit.ignore`和`@torch.jit.unused`。 -当传递给[`torch.jit.script`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")函数时，`torch.nn.Module`的数据会被复制到一个[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")中，TorchScript编译器会编译该模块。模块的`forward`默认被编译。从`forward`调用的方法会按照它们在`forward`中被使用的顺序进行延迟编译，以及任何`@torch.jit.export`方法。 +当传递给`torch.jit.script`函数时，`torch.nn.Module`的数据会被复制到一个`ScriptModule`中，TorchScript 编译器会编译该模块。模块的`forward`默认被编译。从`forward`调用的方法会按照它们在`forward`中被使用的顺序进行延迟编译，以及任何`@torch.jit.export`方法。 ```py torch.jit.export(fn)¶ ``` -这个装饰器表示`nn.Module`上的一个方法被用作进入[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")的入口点，并且应该被编译。 +这个装饰器表示`nn.Module`上的一个方法被用作进入`ScriptModule`的入口点，并且应该被编译。 `forward`隐式地被假定为入口点，因此不需要这个装饰器。从`forward`调用的函数和方法会被编译器按照它们在`forward`中被看到的顺序编译，因此它们也不需要这个装饰器。 @@ -611,7 +611,7 @@ m = torch.jit.script(MyModule()) #### 函数 -函数没有太大变化，如果需要，可以用[`@torch.jit.ignore`](generated/torch.jit.ignore.html#torch.jit.ignore "torch.jit.ignore")或[`torch.jit.unused`](generated/torch.jit.unused.html#torch.jit.unused "torch.jit.unused")进行装饰。 +函数没有太大变化，如果需要，可以用`@torch.jit.ignore`或`torch.jit.unused`进行装饰。 ```py # Same behavior as pre-PyTorch 1.2 @@ -639,19 +639,19 @@ def some_fn4(): return 2 ``` -#### TorchScript类 +#### TorchScript 类 警告 -TorchScript类支持是实验性的。目前最适合简单的类似记录的类型（考虑带有附加方法的`NamedTuple`）。 +TorchScript 类支持是实验性的。目前最适合简单的类似记录的类型（考虑带有附加方法的`NamedTuple`）。 -用户定义的[TorchScript类](torchscript-class)中的所有内容默认导出，如果需要，函数可以用[`@torch.jit.ignore`](generated/torch.jit.ignore.html#torch.jit.ignore "torch.jit.ignore")进行装饰。 +用户定义的 TorchScript 类中的所有内容默认导出，如果需要，函数可以用`@torch.jit.ignore`进行装饰。 #### 属性 -TorchScript编译器需要知道模块属性的类型。大多数类型可以从成员的值中推断出来。空列表和字典无法推断其类型，必须使用[PEP 526风格](https://www.python.org/dev/peps/pep-0526/#class-and-instance-variable-annotations)的类注释来注释其类型。如果类型无法推断并且没有明确注释，则不会将其添加为结果[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")的属性。 +TorchScript 编译器需要知道模块属性的类型。大多数类型可以从成员的值中推断出来。空列表和字典无法推断其类型，必须使用[PEP 526 风格](https://www.python.org/dev/peps/pep-0526/#class-and-instance-variable-annotations)的类注释来注释其类型。如果类型无法推断并且没有明确注释，则不会将其添加为结果`ScriptModule`的属性。 -旧API： +旧 API： ```py from typing import Dict @@ -666,7 +666,7 @@ class MyModule(torch.jit.ScriptModule): m = MyModule() ``` -新API： +新 API： ```py from typing import Dict @@ -690,9 +690,9 @@ m = torch.jit.script(MyModule()) #### 常量 -`Final`类型构造函数可用于将成员标记为常量。如果成员未标记为常量，则它们将被复制到结果[`ScriptModule`](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit.ScriptModule")作为属性。使用`Final`可以在值已知为固定时进行优化，并提供额外的类型安全性。 +`Final`类型构造函数可用于将成员标记为常量。如果成员未标记为常量，则它们将被复制到结果`ScriptModule`作为属性。使用`Final`可以在值已知为固定时进行优化，并提供额外的类型安全性。 -旧API: +旧 API: ```py class MyModule(torch.jit.ScriptModule): @@ -707,7 +707,7 @@ class MyModule(torch.jit.ScriptModule): m = MyModule() ``` -新API： +新 API： ```py from typing import Final @@ -728,7 +728,7 @@ m = torch.jit.script(MyModule()) #### 变量 -假定容器的类型为`Tensor`且非可选（有关更多信息，请参见默认类型）。以前，使用`torch.jit.annotate`告诉TorchScript编译器应该是什么类型。现在支持Python 3风格的类型提示。 +假定容器的类型为`Tensor`且非可选（有关更多信息，请参见默认类型）。以前，使用`torch.jit.annotate`告诉 TorchScript 编译器应该是什么类型。现在支持 Python 3 风格的类型提示。 ```py import torch @@ -744,12 +744,12 @@ def make_dict(flag: bool): return x, b ``` -### [融合后端](#id20) +### 融合后端 -有几种融合后端可用于优化TorchScript执行。在CPU上的默认融合器是NNC，可以为CPU和GPU执行融合。在GPU上的默认融合器是NVFuser，支持更广泛的运算符，并且已经生成了具有改进吞吐量的内核。有关使用和调试的更多详细信息，请参阅[NVFuser文档](https://github.com/pytorch/pytorch/blob/main/torch/csrc/jit/codegen/cuda/README.md)。 +有几种融合后端可用于优化 TorchScript 执行。在 CPU 上的默认融合器是 NNC，可以为 CPU 和 GPU 执行融合。在 GPU 上的默认融合器是 NVFuser，支持更广泛的运算符，并且已经生成了具有改进吞吐量的内核。有关使用和调试的更多详细信息，请参阅[NVFuser 文档](https://github.com/pytorch/pytorch/blob/main/torch/csrc/jit/codegen/cuda/README.md)。 -### [参考资料](#id21) +### 参考资料 -+ [Python语言参考覆盖](jit_python_reference.html) ++ Python 语言参考覆盖 -+ [TorchScript不支持的PyTorch构造](jit_unsupported.html) ++ TorchScript 不支持的 PyTorch 构造 diff --git a/totrans/doc22_061.md b/totrans/doc22_061.md index 7dcf976f..973a78ac 100644 --- a/totrans/doc22_061.md +++ b/totrans/doc22_061.md @@ -1,83 +1,83 @@ # torch.linalg -> 原文：[https://pytorch.org/docs/stable/linalg.html](https://pytorch.org/docs/stable/linalg.html) +> 原文：[`pytorch.org/docs/stable/linalg.html`](https://pytorch.org/docs/stable/linalg.html) 常见线性代数操作。 -查看[线性代数（torch.linalg）](notes/numerical_accuracy.html#linear-algebra-stability)以获取一些常见的数值边界情况。 +查看线性代数（torch.linalg）以获取一些常见的数值边界情况。 ## 矩阵属性 -| [`norm`](generated/torch.linalg.norm.html#torch.linalg.norm "torch.linalg.norm") | 计算向量或矩阵范数。 | +| `norm` | 计算向量或矩阵范数。 | | --- | --- | -| [`vector_norm`](generated/torch.linalg.vector_norm.html#torch.linalg.vector_norm "torch.linalg.vector_norm") | 计算向量范数。 | -| [`matrix_norm`](generated/torch.linalg.matrix_norm.html#torch.linalg.matrix_norm "torch.linalg.matrix_norm") | 计算矩阵范数。 | -| [`diagonal`](generated/torch.linalg.diagonal.html#torch.linalg.diagonal "torch.linalg.diagonal") | [`torch.diagonal()`](generated/torch.diagonal.html#torch.diagonal "torch.diagonal")的别名，默认参数 `dim1`= -2, `dim2`= -1。 | -| [`det`](generated/torch.linalg.det.html#torch.linalg.det "torch.linalg.det") | 计算方阵的行列式。 | -| [`slogdet`](generated/torch.linalg.slogdet.html#torch.linalg.slogdet "torch.linalg.slogdet") | 计算方阵行列式的符号和自然对数的绝对值。 | -| [`cond`](generated/torch.linalg.cond.html#torch.linalg.cond "torch.linalg.cond") | 计算矩阵相对于矩阵范数的条件数。 | -| [`matrix_rank`](generated/torch.linalg.matrix_rank.html#torch.linalg.matrix_rank "torch.linalg.matrix_rank") | 计算矩阵的数值秩。 | +| `vector_norm` | 计算向量范数。 | +| `matrix_norm` | 计算矩阵范数。 | +| `diagonal` | `torch.diagonal()`的别名，默认参数 `dim1`= -2, `dim2`= -1。 | +| `det` | 计算方阵的行列式。 | +| `slogdet` | 计算方阵行列式的符号和自然对数的绝对值。 | +| `cond` | 计算矩阵相对于矩阵范数的条件数。 | +| `matrix_rank` | 计算矩阵的数值秩。 | ## 分解 -| [`cholesky`](generated/torch.linalg.cholesky.html#torch.linalg.cholesky "torch.linalg.cholesky") | 计算复共轭Hermitian或实对称正定矩阵的Cholesky分解。 | +| `cholesky` | 计算复共轭 Hermitian 或实对称正定矩阵的 Cholesky 分解。 | | --- | --- | -| [`qr`](generated/torch.linalg.qr.html#torch.linalg.qr "torch.linalg.qr") | 计算矩阵的QR分解。 | -| [`lu`](generated/torch.linalg.lu.html#torch.linalg.lu "torch.linalg.lu") | 计算具有部分主元的矩阵LU分解。 | -| [`lu_factor`](generated/torch.linalg.lu_factor.html#torch.linalg.lu_factor "torch.linalg.lu_factor") | 计算具有部分主元的矩阵LU分解的紧凑表示。 | -| [`eig`](generated/torch.linalg.eig.html#torch.linalg.eig "torch.linalg.eig") | 计算方阵的特征值分解（如果存在）。 | -| [`eigvals`](generated/torch.linalg.eigvals.html#torch.linalg.eigvals "torch.linalg.eigvals") | 计算方阵的特征值。 | -| [`eigh`](generated/torch.linalg.eigh.html#torch.linalg.eigh "torch.linalg.eigh") | 计算复共轭Hermitian或实对称矩阵的特征值分解。 | -| [`eigvalsh`](generated/torch.linalg.eigvalsh.html#torch.linalg.eigvalsh "torch.linalg.eigvalsh") | 计算复共轭Hermitian或实对称矩阵的特征值。 | -| [`svd`](generated/torch.linalg.svd.html#torch.linalg.svd "torch.linalg.svd") | 计算矩阵的奇异值分解（SVD）。 | -| [`svdvals`](generated/torch.linalg.svdvals.html#torch.linalg.svdvals "torch.linalg.svdvals") | 计算矩阵的奇异值。 | +| `qr` | 计算矩阵的 QR 分解。 | +| `lu` | 计算具有部分主元的矩阵 LU 分解。 | +| `lu_factor` | 计算具有部分主元的矩阵 LU 分解的紧凑表示。 | +| `eig` | 计算方阵的特征值分解（如果存在）。 | +| `eigvals` | 计算方阵的特征值。 | +| `eigh` | 计算复共轭 Hermitian 或实对称矩阵的特征值分解。 | +| `eigvalsh` | 计算复共轭 Hermitian 或实对称矩阵的特征值。 | +| `svd` | 计算矩阵的奇异值分解（SVD）。 | +| `svdvals` | 计算矩阵的奇异值。 | ## 求解器 -| [`solve`](generated/torch.linalg.solve.html#torch.linalg.solve "torch.linalg.solve") | 计算具有唯一解的方阵线性方程组的解。 | +| `solve` | 计算具有唯一解的方阵线性方程组的解。 | | --- | --- | -| [`solve_triangular`](generated/torch.linalg.solve_triangular.html#torch.linalg.solve_triangular "torch.linalg.solve_triangular") | 计算具有唯一解的三角线性方程组的解。 | -| [`lu_solve`](generated/torch.linalg.lu_solve.html#torch.linalg.lu_solve "torch.linalg.lu_solve") | 在给定LU分解的情况下计算具有唯一解的方阵线性方程组的解。 | +| `solve_triangular` | 计算具有唯一解的三角线性方程组的解。 | +| `lu_solve` | 在给定 LU 分解的情况下计算具有唯一解的方阵线性方程组的解。 | -| [`lstsq`](generated/torch.linalg.lstsq.html#torch.linalg.lstsq "torch.linalg.lstsq") | 计算线性方程组的最小二乘解。 | ## 逆运算 +| `lstsq` | 计算线性方程组的最小二乘解。 | ## 逆运算 -| [`inv`](generated/torch.linalg.inv.html#torch.linalg.inv "torch.linalg.inv") | 计算方阵的逆矩阵（如果存在）。 | +| `inv` | 计算方阵的逆矩阵（如果存在）。 | | --- | --- | -| [`pinv`](generated/torch.linalg.pinv.html#torch.linalg.pinv "torch.linalg.pinv") | 计算矩阵的伪逆（Moore-Penrose 逆）。 | +| `pinv` | 计算矩阵的伪逆（Moore-Penrose 逆）。 | ## 矩阵函数 -| [`matrix_exp`](generated/torch.linalg.matrix_exp.html#torch.linalg.matrix_exp "torch.linalg.matrix_exp") | 计算方阵的矩阵指数。 | +| `matrix_exp` | 计算方阵的矩阵指数。 | | --- | --- | -| [`matrix_power`](generated/torch.linalg.matrix_power.html#torch.linalg.matrix_power "torch.linalg.matrix_power") | 计算整数 n 的方阵的 n 次幂。 | +| `matrix_power` | 计算整数 n 的方阵的 n 次幂。 | ## 矩阵乘积 -| [`cross`](generated/torch.linalg.cross.html#torch.linalg.cross "torch.linalg.cross") | 计算两个三维向量的叉积。 | +| `cross` | 计算两个三维向量的叉积。 | | --- | --- | -| [`matmul`](generated/torch.linalg.matmul.html#torch.linalg.matmul "torch.linalg.matmul") | [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") 的别名 | -| [`vecdot`](generated/torch.linalg.vecdot.html#torch.linalg.vecdot "torch.linalg.vecdot") | 计算沿着维度的两批向量的点积。 | -| [`multi_dot`](generated/torch.linalg.multi_dot.html#torch.linalg.multi_dot "torch.linalg.multi_dot") | 通过重新排列乘法，使得执行最少的算术运算，高效地将两个或多个矩阵相乘。 | -| [`householder_product`](generated/torch.linalg.householder_product.html#torch.linalg.householder_product "torch.linalg.householder_product") | 计算 Householder 矩阵的前 n 列的乘积。 | +| `matmul` | `torch.matmul()` 的别名 | +| `vecdot` | 计算沿着维度的两批向量的点积。 | +| `multi_dot` | 通过重新排列乘法，使得执行最少的算术运算，高效地将两个或多个矩阵相乘。 | +| `householder_product` | 计算 Householder 矩阵的前 n 列的乘积。 | ## 张量操作 -| [`tensorinv`](generated/torch.linalg.tensorinv.html#torch.linalg.tensorinv "torch.linalg.tensorinv") | 计算 [`torch.tensordot()`](generated/torch.tensordot.html#torch.tensordot "torch.tensordot") 的乘法逆。 | +| `tensorinv` | 计算 `torch.tensordot()` 的乘法逆。 | | --- | --- | -| [`tensorsolve`](generated/torch.linalg.tensorsolve.html#torch.linalg.tensorsolve "torch.linalg.tensorsolve") | 计算系统 torch.tensordot(A, X) = B 的解 X。 | +| `tensorsolve` | 计算系统 torch.tensordot(A, X) = B 的解 X。 | ## 其他 -| [`vander`](generated/torch.linalg.vander.html#torch.linalg.vander "torch.linalg.vander") | 生成 Vandermonde 矩阵。 | +| `vander` | 生成 Vandermonde 矩阵。 | | --- | --- | ## 实验性功能 -| [`cholesky_ex`](generated/torch.linalg.cholesky_ex.html#torch.linalg.cholesky_ex "torch.linalg.cholesky_ex") | 计算复 Hermite 或实对称正定矩阵的 Cholesky 分解。 | +| `cholesky_ex` | 计算复 Hermite 或实对称正定矩阵的 Cholesky 分解。 | | --- | --- | -| [`inv_ex`](generated/torch.linalg.inv_ex.html#torch.linalg.inv_ex "torch.linalg.inv_ex") | 计算方阵的逆矩阵（如果可逆）。 | -| [`solve_ex`](generated/torch.linalg.solve_ex.html#torch.linalg.solve_ex "torch.linalg.solve_ex") | [`solve()`](generated/torch.linalg.solve.html#torch.linalg.solve "torch.linalg.solve") 的一个版本，除非 `check_errors`= True，否则不执行错误检查。 | -| [`lu_factor_ex`](generated/torch.linalg.lu_factor_ex.html#torch.linalg.lu_factor_ex "torch.linalg.lu_factor_ex") | 这是 [`lu_factor()`](generated/torch.linalg.lu_factor.html#torch.linalg.lu_factor "torch.linalg.lu_factor") 的一个版本，除非 `check_errors`= True，否则不执行错误检查。 | -| [`ldl_factor`](generated/torch.linalg.ldl_factor.html#torch.linalg.ldl_factor "torch.linalg.ldl_factor") | 计算 Hermite 或对称（可能不定）矩阵的 LDL 分解的紧凑表示。 | -| [`ldl_factor_ex`](generated/torch.linalg.ldl_factor_ex.html#torch.linalg.ldl_factor_ex "torch.linalg.ldl_factor_ex") | 这是 [`ldl_factor()`](generated/torch.linalg.ldl_factor.html#torch.linalg.ldl_factor "torch.linalg.ldl_factor") 的一个版本，除非 `check_errors`= True，否则不执行错误检查。 | -| [`ldl_solve`](generated/torch.linalg.ldl_solve.html#torch.linalg.ldl_solve "torch.linalg.ldl_solve") | 使用 LDL 分解计算线性方程组的解。 | +| `inv_ex` | 计算方阵的逆矩阵（如果可逆）。 | +| `solve_ex` | `solve()` 的一个版本，除非 `check_errors`= True，否则不执行错误检查。 | +| `lu_factor_ex` | 这是 `lu_factor()` 的一个版本，除非 `check_errors`= True，否则不执行错误检查。 | +| `ldl_factor` | 计算 Hermite 或对称（可能不定）矩阵的 LDL 分解的紧凑表示。 | +| `ldl_factor_ex` | 这是 `ldl_factor()` 的一个版本，除非 `check_errors`= True，否则不执行错误检查。 | +| `ldl_solve` | 使用 LDL 分解计算线性方程组的解。 | diff --git a/totrans/doc22_062.md b/totrans/doc22_062.md index deaf5846..685b14be 100644 --- a/totrans/doc22_062.md +++ b/totrans/doc22_062.md @@ -1,12 +1,12 @@ # torch.monitor -> 原文：[https://pytorch.org/docs/stable/monitor.html](https://pytorch.org/docs/stable/monitor.html) +> 原文：[`pytorch.org/docs/stable/monitor.html`](https://pytorch.org/docs/stable/monitor.html) 警告 -此模块是原型版本，其接口和功能可能在未来的PyTorch版本中发生变化而没有警告。 +此模块是原型版本，其接口和功能可能在未来的 PyTorch 版本中发生变化而没有警告。 -`torch.monitor`提供了一个接口，用于从PyTorch记录事件和计数器。 +`torch.monitor`提供了一个接口，用于从 PyTorch 记录事件和计数器。 统计接口旨在用于跟踪定期记录的高级指标，以用于监视系统性能。由于统计数据与特定窗口大小聚合，因此可以从关键循环中记录它们，对性能影响最小。 @@ -14,7 +14,7 @@ 事件处理程序可以注册以处理事件并将其传递给外部事件接收器。 -## API参考 +## API 参考 ```py class torch.monitor.Aggregation¶ @@ -26,27 +26,27 @@ class torch.monitor.Aggregation¶ > VALUE： > -> VALUE返回最后添加的值。 +> VALUE 返回最后添加的值。 > > MEAN： > -> MEAN计算所有添加值的算术平均值。 +> MEAN 计算所有添加值的算术平均值。 > > COUNT： > -> COUNT返回添加值的总数。 +> COUNT 返回添加值的总数。 > > SUM： > -> SUM返回添加值的总和。 +> SUM 返回添加值的总和。 > > MAX： > -> MAX返回添加值的最大值。 +> MAX 返回添加值的最大值。 > > MIN： > -> MIN返回添加值的最小值。 +> MIN 返回添加值的最小值。 ```py property name¶ @@ -56,13 +56,13 @@ property name¶ class torch.monitor.Stat¶ ``` -Stat用于以高效的方式在固定间隔内计算摘要统计信息。Stat每隔`window_size`持续时间记录一次统计信息作为事件。当窗口关闭时，统计信息将通过事件处理程序作为`torch.monitor.Stat`事件记录。 +Stat 用于以高效的方式在固定间隔内计算摘要统计信息。Stat 每隔`window_size`持续时间记录一次统计信息作为事件。当窗口关闭时，统计信息将通过事件处理程序作为`torch.monitor.Stat`事件记录。 -`window_size`应设置为相对较高的值，以避免记录大量事件。例如：60秒。Stat使用毫秒精度。 +`window_size`应设置为相对较高的值，以避免记录大量事件。例如：60 秒。Stat 使用毫秒精度。 如果设置了`max_samples`，则统计数据将通过在发生`max_samples`次添加后丢弃添加调用来限制每个窗口的样本数量。如果未设置，窗口期间的所有`add`调用都将被包括在内。当样本数量可能变化时，这是一个可选字段，使聚合更直接可比较。 -当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¶ @@ -98,13 +98,13 @@ property name¶ class torch.monitor.data_value_t¶ ``` -data_value_t是`str`、`float`、`int`、`bool`之一。 +data_value_t 是`str`、`float`、`int`、`bool`之一。 ```py class torch.monitor.Event¶ ``` -Event表示要记录的特定类型事件。这可以表示每个时代的损失或准确性等高级数据点，或者通过此库提供的统计数据进行更低级别的聚合。 +Event 表示要记录的特定类型事件。这可以表示每个时代的损失或准确性等高级数据点，或者通过此库提供的统计数据进行更低级别的聚合。 所有相同类型的事件应具有相同的名称，以便下游处理程序可以正确处理它们。 @@ -136,13 +136,13 @@ property timestamp¶ class torch.monitor.EventHandlerHandle¶ ``` -EventHandlerHandle是由`register_event_handler`返回的包装类型，用于通过`unregister_event_handler`取消注册处理程序。不能直接初始化。 +EventHandlerHandle 是由`register_event_handler`返回的包装类型，用于通过`unregister_event_handler`取消注册处理程序。不能直接初始化。 ```py torch.monitor.log_event(event: torch._C._monitor.Event) → None¶ ``` -log_event将指定的事件记录到所有已注册的事件处理程序中。由事件处理程序负责将事件记录到相应的事件接收器。 +log_event 将指定的事件记录到所有已注册的事件处理程序中。由事件处理程序负责将事件记录到相应的事件接收器。 如果没有注册事件处理程序，则此方法不执行任何操作。 @@ -150,19 +150,19 @@ log_event将指定的事件记录到所有已注册的事件处理程序中。 torch.monitor.register_event_handler(callback: Callable[[torch._C._monitor.Event], None]) → torch._C._monitor.EventHandlerHandle¶ ``` -register_event_handler注册一个回调，每当通过`log_event`记录事件时都会调用该回调。这些处理程序应避免阻塞主线程，因为这可能会干扰训练，因为它们在`log_event`调用期间运行。 +register_event_handler 注册一个回调，每当通过`log_event`记录事件时都会调用该回调。这些处理程序应避免阻塞主线程，因为这可能会干扰训练，因为它们在`log_event`调用期间运行。 ```py torch.monitor.unregister_event_handler(handler: torch._C._monitor.EventHandlerHandle) → None¶ ``` -unregister_event_handler取消注册在调用`register_event_handler`后返回的`EventHandlerHandle`。完成后，事件处理程序将不再接收事件。 +unregister_event_handler 取消注册在调用`register_event_handler`后返回的`EventHandlerHandle`。完成后，事件处理程序将不再接收事件。 ```py class torch.monitor.TensorboardEventHandler(writer)¶ ``` -TensorboardEventHandler是一个事件处理程序，将已知事件写入提供的SummaryWriter。 +TensorboardEventHandler 是一个事件处理程序，将已知事件写入提供的 SummaryWriter。 目前仅支持作为标量记录的`torch.monitor.Stat`事件。 diff --git a/totrans/doc22_063.md b/totrans/doc22_063.md index 22a9b30a..e809ea09 100644 --- a/totrans/doc22_063.md +++ b/totrans/doc22_063.md @@ -1,20 +1,20 @@ # torch.signal -> 原文：[https://pytorch.org/docs/stable/signal.html](https://pytorch.org/docs/stable/signal.html) +> 原文：[`pytorch.org/docs/stable/signal.html`](https://pytorch.org/docs/stable/signal.html) -torch.signal模块，模仿自SciPy的[signal](https://docs.scipy.org/doc/scipy/reference/signal.html)模块。 +torch.signal 模块，模仿自 SciPy 的[signal](https://docs.scipy.org/doc/scipy/reference/signal.html)模块。 ## torch.signal.windows[](#module-torch.signal.windows "Permalink to this heading") -| [`bartlett`](generated/torch.signal.windows.bartlett.html#torch.signal.windows.bartlett "torch.signal.windows.bartlett") | 计算巴特利特窗口。 | +| `bartlett` | 计算巴特利特窗口。 | | --- | --- | -| [`blackman`](generated/torch.signal.windows.blackman.html#torch.signal.windows.blackman "torch.signal.windows.blackman") | 计算布莱克曼窗口。 | -| [`cosine`](generated/torch.signal.windows.cosine.html#torch.signal.windows.cosine "torch.signal.windows.cosine") | 计算具有简单余弦波形的窗口。 | -| [`exponential`](generated/torch.signal.windows.exponential.html#torch.signal.windows.exponential "torch.signal.windows.exponential") | 计算具有指数波形的窗口。 | -| [`gaussian`](generated/torch.signal.windows.gaussian.html#torch.signal.windows.gaussian "torch.signal.windows.gaussian") | 计算具有高斯波形的窗口。 | -| [`general_cosine`](generated/torch.signal.windows.general_cosine.html#torch.signal.windows.general_cosine "torch.signal.windows.general_cosine") | 计算通用余弦窗口。 | -| [`general_hamming`](generated/torch.signal.windows.general_hamming.html#torch.signal.windows.general_hamming "torch.signal.windows.general_hamming") | 计算通用汉明窗口。 | -| [`hamming`](generated/torch.signal.windows.hamming.html#torch.signal.windows.hamming "torch.signal.windows.hamming") | 计算汉明窗口。 | -| [`hann`](generated/torch.signal.windows.hann.html#torch.signal.windows.hann "torch.signal.windows.hann") | 计算汉宁窗口。 | -| [`kaiser`](generated/torch.signal.windows.kaiser.html#torch.signal.windows.kaiser "torch.signal.windows.kaiser") | 计算凯泽窗口。 | -| [`nuttall`](generated/torch.signal.windows.nuttall.html#torch.signal.windows.nuttall "torch.signal.windows.nuttall") | 根据Nuttall计算最小的4项布莱克曼-哈里斯窗口。 | +| `blackman` | 计算布莱克曼窗口。 | +| `cosine` | 计算具有简单余弦波形的窗口。 | +| `exponential` | 计算具有指数波形的窗口。 | +| `gaussian` | 计算具有高斯波形的窗口。 | +| `general_cosine` | 计算通用余弦窗口。 | +| `general_hamming` | 计算通用汉明窗口。 | +| `hamming` | 计算汉明窗口。 | +| `hann` | 计算汉宁窗口。 | +| `kaiser` | 计算凯泽窗口。 | +| `nuttall` | 根据 Nuttall 计算最小的 4 项布莱克曼-哈里斯窗口。 | diff --git a/totrans/doc22_064.md b/totrans/doc22_064.md index fe8b26e5..2a373917 100644 --- a/totrans/doc22_064.md +++ b/totrans/doc22_064.md @@ -1,8 +1,8 @@ # torch.special -> 原文：[https://pytorch.org/docs/stable/special.html](https://pytorch.org/docs/stable/special.html) +> 原文：[`pytorch.org/docs/stable/special.html`](https://pytorch.org/docs/stable/special.html) -torch.special模块，模仿SciPy的[special](https://docs.scipy.org/doc/scipy/reference/special.html)模块。 +torch.special 模块，模仿 SciPy 的[special](https://docs.scipy.org/doc/scipy/reference/special.html)模块。 ## 函数 @@ -10,7 +10,7 @@ torch.special模块，模仿SciPy的[special](https://docs.scipy.org/doc/scipy/r torch.special.airy_ai(input, *, out=None) → Tensor¶ ``` -Airy函数$\text{Ai}\left(\text{input}\right)$。 +Airy 函数$\text{Ai}\left(\text{input}\right)$。 参数 @@ -58,7 +58,7 @@ $\digamma(x) = \frac{d}{dx} \ln\left(\Gamma\left(x\right)\right) = \frac{\Gamma' 参数 -- 输入张量。在其上计算digamma函数的张量 +- 输入张量。在其上计算 digamma 函数的张量 关键参数 @@ -66,11 +66,11 @@ $\digamma(x) = \frac{d}{dx} \ln\left(\Gamma\left(x\right)\right) = \frac{\Gamma' 注意 -这个函数类似于SciPy的scipy.special.digamma。 +这个函数类似于 SciPy 的 scipy.special.digamma。 注意 -从PyTorch 1.8开始，digamma函数对于0返回-Inf。之前对于0返回NaN。 +从 PyTorch 1.8 开始，digamma 函数对于 0 返回-Inf。之前对于 0 返回 NaN。 示例： @@ -112,7 +112,7 @@ torch.special.erf(input, *, out=None) → Tensor¶ 计算输入的误差函数。误差函数定义如下： -$\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt$ +$\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t²} dt$ 参数 @@ -135,7 +135,7 @@ torch.special.erfc(input, *, out=None) → Tensor¶ 计算输入的互补误差函数。互补误差函数定义如下： -$\mathrm{erfc}(x) = 1 - \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt$ +$\mathrm{erfc}(x) = 1 - \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t²} dt$ 参数 @@ -158,7 +158,7 @@ torch.special.erfcx(input, *, out=None) → Tensor¶ 计算输入的每个元素的缩放互补误差函数。缩放互补误差函数定义如下： -$\mathrm{erfcx}(x) = e^{x^2} \mathrm{erfc}(x)$ +$\mathrm{erfcx}(x) = e^{x²} \mathrm{erfc}(x)$ 参数 @@ -202,7 +202,7 @@ tensor([ 0.0000, 0.4769, -inf]) torch.special.exp2(input, *, out=None) → Tensor¶ ``` -计算输入的以2为底的指数函数。 +计算输入的以 2 为底的指数函数。 $y_{i} = 2^{x_{i}}$ @@ -212,7 +212,7 @@ $y_{i} = 2^{x_{i}}$ 关键参数 -**out**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*，* *可选*）- 输出张量。 +**out**（*张量**，* *可选*）- 输出张量。 示例： @@ -225,17 +225,17 @@ tensor([ 1., 2., 8., 16.]) torch.special.expit(input, *, out=None) → Tensor¶ ``` -计算`input`元素的expit（也称为逻辑Sigmoid函数）。 +计算`input`元素的 expit（也称为逻辑 Sigmoid 函数）。 $\text{out}_{i} = \frac{1}{1 + e^{-\text{input}_{i}}}$ outi​=1+e−inputi​1​ 参数 -**输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")）- 输入张量。 +**输入**（*张量*）- 输入张量。 关键参数 -**out**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*，* *可选*）- 输出张量。 +**out**（*张量**，* *可选*）- 输出张量。 示例： @@ -251,21 +251,21 @@ tensor([ 0.7153, 0.7481, 0.2920, 0.1458]) torch.special.expm1(input, *, out=None) → Tensor¶ ``` -计算`input`元素减1的指数。 +计算`input`元素减 1 的指数。 $y_{i} = e^{x_{i}} - 1$ yi​=exi​−1 注意 -对于较小的x值，此函数提供比exp(x) - 1更高的精度。 +对于较小的 x 值，此函数提供比 exp(x) - 1 更高的精度。 参数 -**输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")）- 输入张量。 +**输入**（*张量*）- 输入张量。 关键参数 -**out**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*，* *可选*）- 输出张量。 +**out**（*张量**，* *可选*）- 输出张量。 示例： @@ -286,23 +286,23 @@ $\text{out}_{i} = \frac{1}{\Gamma(\text{input}_i)} \int_0^{\text{other}_i} t^{\t $\Gamma(\text{input}_i) = \int_0^\infty t^{(\text{input}_i-1)} e^{-t} dt.$ Γ(inputi​)=∫0∞​t(inputi​−1)e−tdt. -有关相关函数，请参见[`torch.special.gammaincc()`](#torch.special.gammaincc "torch.special.gammaincc")和[`torch.special.gammaln()`](#torch.special.gammaln "torch.special.gammaln")。 +有关相关函数，请参见`torch.special.gammaincc()`和`torch.special.gammaln()`。 -支持[广播到公共形状](notes/broadcasting.html#broadcasting-semantics)和浮点输入。 +支持广播到公共形状和浮点输入。 注意 -目前不支持对`input`的反向传播。请在PyTorch的Github上提出问题以请求支持。 +目前不支持对`input`的反向传播。请在 PyTorch 的 Github 上提出问题以请求支持。 参数 -+ **输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")）- 第一个非负输入张量 ++ **输入**（*张量*）- 第一个非负输入张量 -+ **other**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")）- 第二个非负输入张量 ++ **other**（*张量*）- 第二个非负输入张量 关键参数 -**out**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*，* *可选*）- 输出张量。 +**out**（*张量**，* *可选*）- 输出张量。 示例： @@ -328,23 +328,23 @@ $\text{out}_{i} = \frac{1}{\Gamma(\text{input}_i)} \int_{\text{other}_i}^{\infty $\Gamma(\text{input}_i) = \int_0^\infty t^{(\text{input}_i-1)} e^{-t} dt.$ Γ(inputi​)=∫0∞​t(inputi​−1)e−tdt. -有关相关函数，请参见[`torch.special.gammainc()`](#torch.special.gammainc "torch.special.gammainc")和[`torch.special.gammaln()`](#torch.special.gammaln "torch.special.gammaln")。 +有关相关函数，请参见`torch.special.gammainc()`和`torch.special.gammaln()`。 -支持[广播到公共形状](notes/broadcasting.html#broadcasting-semantics)和浮点输入。 +支持广播到公共形状和浮点输入。 注意 -目前不支持对`input`的反向传播。请在PyTorch的Github上提出问题以请求支持。 +目前不支持对`input`的反向传播。请在 PyTorch 的 Github 上提出问题以请求支持。 参数 -+ **输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")）- 第一个非负输入张量 ++ **输入**（*张量*）- 第一个非负输入张量 -+ **other**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")）- 第二个非负输入张量 ++ **other**（*张量*）- 第二个非负输入张量 关键参数 -**out**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*，* *可选*）- 输出张量。 +**out**（*张量**，* *可选*）- 输出张量。 示例： @@ -367,11 +367,11 @@ $\text{out}_{i} = \ln \Gamma(|\text{input}_{i}|)$ outi​=lnΓ(∣inputi​∣) 参数 -**输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")）- 输入张量。 +**输入**（*张量*）- 输入张量。 关键参数 -**out**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*，* *可选*）- 输出张量。 +**out**（*张量**，* *可选*）- 输出张量。 示例： @@ -387,15 +387,15 @@ torch.special.i0(input, *, out=None) → Tensor¶ 计算每个`input`元素的第零阶修正贝塞尔函数（如下所定义）。 -$\text{out}_{i} = I_0(\text{input}_{i}) = \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!)^2}$ +$\text{out}_{i} = I_0(\text{input}_{i}) = \sum_{k=0}^{\infty} \frac{(\text{input}_{i}²/4)^k}{(k!)²}$ 参数 -**input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入张量 +**input**（*Tensor*） - 输入张量 关键参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，*可选） - 输出张量。 +**out**（*Tensor**，*可选） - 输出张量。 示例： @@ -410,15 +410,15 @@ torch.special.i0e(input, *, out=None) → Tensor¶ 计算每个`input`元素的指数缩放的第零阶修正贝塞尔函数（如下所定义）。 -$\text{out}_{i} = \exp(-|x|) * i0(x) = \exp(-|x|) * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!)^2}$ +$\text{out}_{i} = \exp(-|x|) * i0(x) = \exp(-|x|) * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}²/4)^k}{(k!)²}$ 参数 -**input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入张量。 +**input**（*Tensor*） - 输入张量。 关键参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，*可选） - 输出张量。 +**out**（*Tensor**，*可选） - 输出张量。 示例： @@ -433,15 +433,15 @@ torch.special.i1(input, *, out=None) → Tensor¶ 计算每个`input`元素的第一类修正贝塞尔函数（如下所定义）。 -$\text{out}_{i} = \frac{(\text{input}_{i})}{2} * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!) * (k+1)!}$ +$\text{out}_{i} = \frac{(\text{input}_{i})}{2} * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}²/4)^k}{(k!) * (k+1)!}$ 参数 -**input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入张量。 +**input**（*Tensor*） - 输入张量。 关键参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，*可选） - 输出张量。 +**out**（*Tensor**，*可选） - 输出张量。 示例： @@ -456,7 +456,7 @@ torch.special.i1e(input, *, out=None) → Tensor¶ 计算每个`input`元素的指数缩放的第一类修正贝塞尔函数（如下所定义）。 -$\text{out}_{i} = \exp(-|x|) * i1(x) = \exp(-|x|) * \frac{(\text{input}_{i})}{2} * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}^2/4)^k}{(k!) * (k+1)!}$ +$\text{out}_{i} = \exp(-|x|) * i1(x) = \exp(-|x|) * \frac{(\text{input}_{i})}{2} * \sum_{k=0}^{\infty} \frac{(\text{input}_{i}²/4)^k}{(k!) * (k+1)!}$ 参数 @@ -464,7 +464,7 @@ $\text{out}_{i} = \exp(-|x|) * i1(x) = \exp(-|x|) * \frac{(\text{input}_{i})}{2} 关键参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，*可选） - 输出张量。 +**out**（*Tensor**，*可选） - 输出张量。 示例： @@ -477,7 +477,7 @@ tensor([0.0000, 0.2079, 0.2153, 0.1968, 0.1788]) torch.special.log1p(input, *, out=None) → Tensor¶ ``` -[`torch.log1p()`](generated/torch.log1p.html#torch.log1p "torch.log1p")的别名。 +`torch.log1p()`的别名。 ```py torch.special.log_ndtr(input, *, out=None) → Tensor¶ @@ -485,15 +485,15 @@ torch.special.log_ndtr(input, *, out=None) → Tensor¶ 计算标准高斯概率密度函数下面积的对数，从负无穷到`input`，逐元素。 -$\text{log\_ndtr}(x) = \log\left(\frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t^2} dt \right)$ +$\text{log\_ndtr}(x) = \log\left(\frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t²} dt \right)$ 参数 -**input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入张量。 +**input**（*Tensor*） - 输入张量。 关键参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，*可选） - 输出张量。 +**out**（*Tensor**，*可选） - 输出张量。 示例： @@ -506,19 +506,19 @@ tensor([-6.6077 -3.7832 -1.841 -0.6931 -0.1728 -0.023 -0.0014]) torch.special.log_softmax(input, dim, *, dtype=None) → Tensor¶ ``` -计算softmax后跟对数。 +计算 softmax 后跟对数。 -虽然在数学上等价于log(softmax(x))，但分别执行这两个操作会更慢且数值不稳定。此函数计算如下： +虽然在数学上等价于 log(softmax(x))，但分别执行这两个操作会更慢且数值不稳定。此函数计算如下： $\text{log\_softmax}(x_{i}) = \log\left(\frac{\exp(x_i) }{ \sum_j \exp(x_j)} \right)$ 参数 -+ **input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入 ++ **input**（*Tensor*） - 输入 -+ **dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - log_softmax将计算的维度。 ++ **dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - log_softmax 将计算的维度。 -+ **dtype**（[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")，可选） - 返回张量的期望数据类型。如果指定，操作执行前将输入张量转换为`dtype`。这对于防止数据类型溢出很有用。默认值：无。 ++ **dtype**（`torch.dtype`，可选） - 返回张量的期望数据类型。如果指定，操作执行前将输入张量转换为`dtype`。这对于防止数据类型溢出很有用。默认值：无。 示例： @@ -533,19 +533,17 @@ tensor([[-0.6931, -0.6931], torch.special.logit(input, eps=None, *, out=None) → Tensor¶ ``` -返回一个新张量，其中包含`input`元素的logit。当eps不为None时，`input`被夹在[eps, 1 - eps]之间。当eps为None且`input` < 0或`input` > 1时，函数将产生NaN。 +返回一个新张量，其中包含`input`元素的 logit。当 eps 不为 None 时，`input`被夹在[eps, 1 - eps]之间。当 eps 为 None 且`input` < 0 或`input` > 1 时，函数将产生 NaN。 $\begin{align} y_{i} &= \ln(\frac{z_{i}}{1 - z_{i}}) \\ z_{i} &= \begin{cases} x_{i} & \text{if eps is None} \\ \text{eps} & \text{if } x_{i} < \text{eps} \\ x_{i} & \text{if } \text{eps} \leq x_{i} \leq 1 - \text{eps} \\ 1 - \text{eps} & \text{if } x_{i} > 1 - \text{eps} \end{cases} \end{align}$ 参数 -+ **输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"））- 输入张量。 - -+ **eps**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*,* *可选*）- 输入夹紧边界的epsilon。默认值：`None` ++ **输入**（*张量*")*,* *可选*）- 输入夹紧边界的 epsilon。默认值：`None` 关键参数 -**输出**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*）- 输出张量。 +**输出**（*张量**,* *可选*）- 输出张量。 示例: @@ -561,7 +559,7 @@ tensor([-0.9466, 2.6352, 0.6131, -1.7169, 0.6261]) torch.special.logsumexp(input, dim, keepdim=False, *, out=None)¶ ``` -[`torch.logsumexp()`](generated/torch.logsumexp.html#torch.logsumexp "torch.logsumexp")的别名。 +`torch.logsumexp()`的别名。 ```py torch.special.multigammaln(input, p, *, out=None) → Tensor¶ @@ -571,19 +569,17 @@ torch.special.multigammaln(input, p, *, out=None) → Tensor¶ $\log(\Gamma_{p}(a)) = C + \displaystyle \sum_{i=1}^{p} \log\left(\Gamma\left(a - \frac{i - 1}{2}\right)\right)$ -其中$C = \log(\pi) \cdot \frac{p (p - 1)}{4}$，$\Gamma(-)$是Gamma函数。 +其中$C = \log(\pi) \cdot \frac{p (p - 1)}{4}$，$\Gamma(-)$是 Gamma 函数。 所有元素必须大于$\frac{p - 1}{2}$，否则行为未定义。 参数 -+ **输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"））- 计算多元对数伽玛函数的张量 - -+ **p**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 维度的数量 ++ **输入**（*张量*")）- 维度的数量 关键参数 -**输出**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*）- 输出张量。 +**输出**（*张量**,* *可选*）- 输出张量。 示例: @@ -603,15 +599,11 @@ torch.special.ndtr(input, *, out=None) → Tensor¶ 计算标准高斯概率密度函数下的面积，从负无穷积分到`输入`，逐元素计算。 -$\text{ndtr}(x) = \frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t^2} dt$ +$\text{ndtr}(x) = \frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t²} dt$ 参数 -**输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"））- 输入张量。 - -关键参数 - -**输出**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*）- 输出张量。 +**输入**（*张量**,* *可选*）- 输出张量。 示例:: @@ -624,7 +616,7 @@ tensor([0.0013, 0.0228, 0.1587, 0.5000, 0.8413, 0.9772, 0.9987]) torch.special.ndtri(input, *, out=None) → Tensor¶ ``` -计算参数$x$，使得高斯概率密度函数下的面积（从负无穷积分到x）等于`输入`，逐元素计算。 +计算参数$x$，使得高斯概率密度函数下的面积（从负无穷积分到 x）等于`输入`，逐元素计算。 $\text{ndtri}(p) = \sqrt{2}\text{erf}^{-1}(2p - 1)$ @@ -634,11 +626,7 @@ $\text{ndtri}(p) = \sqrt{2}\text{erf}^{-1}(2p - 1)$ 参数 -**输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"））- 输入张量。 - -关键参数 - -**输出**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*）- 输出张量。 +**输入**（*张量**,* *可选*）- 输出张量。 示例:: @@ -651,7 +639,7 @@ tensor([ -inf, -0.6745, 0.0000, 0.6745, inf]) torch.special.polygamma(n, input, *, out=None) → Tensor¶ ``` -计算`输入`上的第$n$阶digamma函数的导数。$n \geq 0$ +计算`输入`上的第$n$阶 digamma 函数的导数。$n \geq 0$ $\psi^{(n)}(x) = \frac{d^{(n)}}{dx^{(n)}} \psi(x)$ @@ -661,13 +649,9 @@ $\psi^{(n)}(x) = \frac{d^{(n)}}{dx^{(n)}} \psi(x)$ 参数 -+ **n**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- polygamma函数的阶数 ++ **n**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- polygamma 函数的阶数 -+ **输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"））- 输入张量。 - -关键参数 - -**输出**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*）- 输出张量。 ++ **输入**（*张量**,* *可选*）- 输出张量。 示例:: @@ -687,13 +671,13 @@ tensor([ -24.8863, -771.4742]) torch.special.psi(input, *, out=None) → Tensor¶ ``` -[`torch.special.digamma()`](#torch.special.digamma "torch.special.digamma")的别名。 +`torch.special.digamma()`的别名。 ```py torch.special.round(input, *, out=None) → Tensor¶ ``` -[`torch.round()`](generated/torch.round.html#torch.round "torch.round")的别名。 +`torch.round()`的别名。 ```py torch.special.scaled_modified_bessel_k0(input, *, out=None) → Tensor¶ @@ -703,11 +687,7 @@ torch.special.scaled_modified_bessel_k0(input, *, out=None) → Tensor¶ 参数 -**输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"））- 输入张量。 - -关键参数 - -**输出**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*）- 输出张量。 +**输入**（*张量**,* *可选*）- 输出张量。 ```py torch.special.scaled_modified_bessel_k1(input, *, out=None) → Tensor¶ @@ -717,27 +697,23 @@ torch.special.scaled_modified_bessel_k1(input, *, out=None) → Tensor¶ 参数 -**输入**（[*张量*](tensors.html#torch.Tensor "torch.Tensor"））- 输入张量。 - -关键字参数 - -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*） - 输出张量。 +**输入**（*张量**,* *可选*） - 输出张量。 ```py torch.special.sinc(input, *, out=None) → Tensor¶ ``` -计算`input`的归一化sinc。 +计算`input`的归一化 sinc。 $\text{out}_{i} = \begin{cases} 1, & \text{if}\ \text{input}_{i}=0 \\ \sin(\pi \text{input}_{i}) / (\pi \text{input}_{i}), & \text{otherwise} \end{cases}$ 参数 -**input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入张量。 +**input**（*Tensor*） - 输入张量。 关键字参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*） - 输出张量。 +**out**（*Tensor**,* *可选*） - 输出张量。 示例:: @@ -753,21 +729,21 @@ tensor([ 0.9186, 0.8631, -0.0259, -0.1300]) torch.special.softmax(input, dim, *, dtype=None) → Tensor¶ ``` -计算softmax函数。 +计算 softmax 函数。 -Softmax定义为： +Softmax 定义为： $\text{Softmax}(x_{i}) = \frac{\exp(x_i)}{\sum_j \exp(x_j)}$ -应用于沿dim的所有切片，并将它们重新缩放，使元素位于范围[0, 1]并总和为1。 +应用于沿 dim 的所有切片，并将它们重新缩放，使元素位于范围[0, 1]并总和为 1。 参数 -+ **input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入 ++ **input**（*Tensor*） - 输入 -+ **dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 将进行softmax计算的维度。 ++ **dim**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 将进行 softmax 计算的维度。 -+ **dtype**（[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")，可选） - 返回张量的期望数据类型。如果指定，操作执行之前将输入张量转换为`dtype`。这对于防止数据类型溢出很有用。默认值：无。 ++ **dtype**（`torch.dtype`，可选） - 返回张量的期望数据类型。如果指定，操作执行之前将输入张量转换为`dtype`。这对于防止数据类型溢出很有用。默认值：无。 示例:: @@ -786,11 +762,11 @@ torch.special.spherical_bessel_j0(input, *, out=None) → Tensor¶ 参数 -**input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 输入张量。 +**input**（*Tensor*） - 输入张量。 关键字参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*） - 输出张量。 +**out**（*Tensor**,* *可选*） - 输出张量。 ```py torch.special.xlog1py(input, other, *, out=None) → Tensor¶ @@ -800,13 +776,13 @@ torch.special.xlog1py(input, other, *, out=None) → Tensor¶ $\text{out}_{i} = \begin{cases} \text{NaN} & \text{if } \text{other}_{i} = \text{NaN} \\ 0 & \text{if } \text{input}_{i} = 0.0 \text{ and } \text{other}_{i} != \text{NaN} \\ \text{input}_{i} * \text{log1p}(\text{other}_{i})& \text{otherwise} \end{cases}$ -类似于SciPy的scipy.special.xlog1py。 +类似于 SciPy 的 scipy.special.xlog1py。 参数 -+ **input**（*Number* *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 乘数 ++ **input**（*Number* *或* *Tensor*） - 乘数 -+ **other**（*Number* *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 参数 ++ **other**（*Number* *或* *Tensor*） - 参数 注意 @@ -814,7 +790,7 @@ $\text{out}_{i} = \begin{cases} \text{NaN} & \text{if } \text{other}_{i} = \text 关键字参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*） - 输出张量。 +**out**（*Tensor**,* *可选*） - 输出张量。 示例： @@ -841,13 +817,13 @@ torch.special.xlogy(input, other, *, out=None) → Tensor¶ $\text{out}_{i} = \begin{cases} \text{NaN} & \text{if } \text{other}_{i} = \text{NaN} \\ 0 & \text{if } \text{input}_{i} = 0.0 \\ \text{input}_{i} * \log{(\text{other}_{i})} & \text{otherwise} \end{cases}$ -类似于SciPy的scipy.special.xlogy。 +类似于 SciPy 的 scipy.special.xlogy。 参数 -+ **input**（*Number* *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 乘数 ++ **input**（*Number* *或* *Tensor*） - 乘数 -+ **other**（*Number* *或* [*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 参数 ++ **other**（*Number* *或* *Tensor*） - 参数 注意 @@ -855,7 +831,7 @@ $\text{out}_{i} = \begin{cases} \text{NaN} & \text{if } \text{other}_{i} = \text 关键字参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*） - 输出张量。 +**out**（*Tensor**,* *可选*） - 输出张量。 示例： @@ -878,23 +854,23 @@ tensor([2.1972, 1.3863, 0.0000]) torch.special.zeta(input, other, *, out=None) → Tensor¶ ``` -逐元素计算Hurwitz zeta函数。 +逐元素计算 Hurwitz zeta 函数。 $\zeta(x, q) = \sum_{k=0}^{\infty} \frac{1}{(k + q)^x}$ 参数 -+ **input**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 与x对应的输入张量。 ++ **input**（*Tensor*） - 与 x 对应的输入张量。 -+ **other**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 与q对应的输入张量。 ++ **other**（*Tensor*） - 与 q 对应的输入张量。 注意 -Riemann zeta函数对应于q = 1的情况 +Riemann zeta 函数对应于 q = 1 的情况 关键字参数 -**out**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* *可选*） - 输出张量。 +**out**（*Tensor**,* *可选*） - 输出张量。 示例:: diff --git a/totrans/doc22_065.md b/totrans/doc22_065.md index 864e5f91..51f5b6b5 100644 --- a/totrans/doc22_065.md +++ b/totrans/doc22_065.md @@ -1,8 +1,8 @@ # torch.overrides -> 原文：[https://pytorch.org/docs/stable/torch.overrides.html](https://pytorch.org/docs/stable/torch.overrides.html) +> 原文：[`pytorch.org/docs/stable/torch.overrides.html`](https://pytorch.org/docs/stable/torch.overrides.html) -此模块公开了各种辅助函数，用于`__torch_function__`协议。有关`__torch_function__`协议的更多详细信息，请参见[扩展torch Python API](notes/extending.html#extending-torch-python)。 +此模块公开了各种辅助函数，用于`__torch_function__`协议。有关`__torch_function__`协议的更多详细信息，请参见扩展 torch Python API。 ## 函数 @@ -14,7 +14,7 @@ torch.overrides.get_ignored_functions()¶ 返回 -一个元组，其中包含在torch API中公开但不能使用`__torch_function__`覆盖的函数。主要是因为这些函数的参数都不是张量或类似张量。 +一个元组，其中包含在 torch API 中公开但不能使用`__torch_function__`覆盖的函数。主要是因为这些函数的参数都不是张量或类似张量。 返回类型 @@ -33,7 +33,7 @@ False torch.overrides.get_overridable_functions()¶ ``` -列出可以通过__torch_function__覆盖的函数 +列出可以通过 __torch_function__ 覆盖的函数 返回 @@ -47,7 +47,7 @@ Dict[Any, List[Callable]] torch.overrides.resolve_name(f)¶ ``` -获取传递给__torch_function__的函数的人类可读字符串名称 +获取传递给 __torch_function__ 的函数的人类可读字符串名称 参数 @@ -55,11 +55,11 @@ torch.overrides.resolve_name(f)¶ 返回 -函数的名称；如果对其进行eval，则应返回输入函数。 +函数的名称；如果对其进行 eval，则应返回输入函数。 返回类型 -[str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)") +[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)") ```py torch.overrides.get_testing_overrides()¶ @@ -69,7 +69,7 @@ torch.overrides.get_testing_overrides()¶ 返回 -一个字典，将PyTorch API中可重写函数映射到具有与真实函数相同签名的lambda函数，这些lambda函数无条件返回-1。这些lambda函数对于测试为定义`__torch_function__`的类型的API覆盖率很有用。 +一个字典，将 PyTorch API 中可重写函数映射到具有与真实函数相同签名的 lambda 函数，这些 lambda 函数无条件返回-1。这些 lambda 函数对于测试为定义`__torch_function__`的类型的 API 覆盖率很有用。 返回类型 @@ -90,17 +90,17 @@ torch.overrides.handle_torch_function(public_api, relevant_args, *args, **kwargs 实现带有`__torch_function__`覆盖的函数。 -请参阅torch::autograd::handle_torch_function，了解C++实现中此函数的等效部分。 +请参阅 torch::autograd::handle_torch_function，了解 C++实现中此函数的等效部分。 参数 -+ **public_api** (*function*) - 最初在公共torch API中调用的函数，如`public_api(*args, **kwargs)`，现在正在检查其参数。 ++ **public_api** (*function*) - 最初在公共 torch API 中调用的函数，如`public_api(*args, **kwargs)`，现在正在检查其参数。 -+ **relevant_args** (*iterable*) - 要检查__torch_function__方法的参数的可迭代对象。 ++ **relevant_args** (*iterable*) - 要检查 __torch_function__ 方法的参数的可迭代对象。 -+ **args** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(在Python v3.12中)")) - 最初传递给`public_api`的任意位置参数。 ++ **args** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(在 Python v3.12 中)")) - 最初传递给`public_api`的任意位置参数。 -+ **kwargs** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(在Python v3.12中)")) - 最初传递给`public_api`的任意关键字参数。 ++ **kwargs** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(在 Python v3.12 中)")) - 最初传递给`public_api`的任意关键字参数。 返回 @@ -108,9 +108,9 @@ torch.overrides.handle_torch_function(public_api, relevant_args, *args, **kwargs 返回类型 -[object](https://docs.python.org/3/library/functions.html#object "(在Python v3.12中)") +[object](https://docs.python.org/3/library/functions.html#object "(在 Python v3.12 中)") -:如果找不到实现，则引发TypeError。: +:如果找不到实现，则引发 TypeError。: 示例 @@ -125,33 +125,33 @@ torch.overrides.handle_torch_function(public_api, relevant_args, *args, **kwargs torch.overrides.has_torch_function()¶ ``` -检查可迭代对象中元素的__torch_function__实现，或者是否启用了__torch_function__模式。将确切的`Tensor`和`Parameter`视为不可分派。使用此功能来保护对[`handle_torch_function()`](#torch.overrides.handle_torch_function "torch.overrides.handle_torch_function")的调用；不要用它来测试某物是否类似于Tensor，而是使用[`is_tensor_like()`](#torch.overrides.is_tensor_like "torch.overrides.is_tensor_like")。:param relevant_args: 要检查__torch_function__方法的可迭代对象或参数。:type relevant_args: iterable +检查可迭代对象中元素的 __torch_function__ 实现，或者是否启用了 __torch_function__ 模式。将确切的`Tensor`和`Parameter`视为不可分派。使用此功能来保护对`handle_torch_function()`的调用；不要用它来测试某物是否类似于 Tensor，而是使用`is_tensor_like()`。:param relevant_args: 要检查 __torch_function__ 方法的可迭代对象或参数。:type relevant_args: iterable 返回 -如果relevant_args的任何元素具有__torch_function__实现，则返回True，否则返回False。 +如果 relevant_args 的任何元素具有 __torch_function__ 实现，则返回 True，否则返回 False。 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") 另请参见 `torch.is_tensor_like` -检查某物是否类似于Tensor，包括确切的`Tensor`。 +检查某物是否类似于 Tensor，包括确切的`Tensor`。 ```py torch.overrides.is_tensor_like(inp)¶ ``` -如果传入的输入是类似于Tensor的，则返回`True`。 +如果传入的输入是类似于 Tensor 的，则返回`True`。 当前，只要输入类型的`__torch_function__`属性存在，就会发生这种情况。 示例 -张量的子类通常是类似于Tensor的。 +张量的子类通常是类似于 Tensor 的。 ```py >>> class SubTensor(torch.Tensor): ... @@ -159,7 +159,7 @@ torch.overrides.is_tensor_like(inp)¶ True ``` -内置或用户类型通常不类似于Tensor。 +内置或用户类型通常不类似于 Tensor。 ```py >>> is_tensor_like(6) @@ -171,7 +171,7 @@ False False ``` -但是，通过实现__torch_function__，它们可以变得类似于Tensor。 +但是，通过实现 __torch_function__，它们可以变得类似于 Tensor。 ```py >>> class TensorLike: @@ -186,7 +186,7 @@ True torch.overrides.is_tensor_method_or_property(func)¶ ``` -如果传入的函数是`torch.Tensor`的方法或属性的处理程序，则返回True，如传入`__torch_function__`。 +如果传入的函数是`torch.Tensor`的方法或属性的处理程序，则返回 True，如传入`__torch_function__`。 注意 @@ -194,7 +194,7 @@ torch.overrides.is_tensor_method_or_property(func)¶ 这可能是必要的，特别是出于以下原因： -1. 方法/属性有时不包含__module__槽。 +1. 方法/属性有时不包含 __module__ 槽。 1. 它们要求第一个传入的参数是`torch.Tensor`的实例。 @@ -209,7 +209,7 @@ False 返回类型 -[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)") +[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)") ```py torch.overrides.wrap_torch_function(dispatcher)¶ @@ -223,7 +223,7 @@ torch.overrides.wrap_torch_function(dispatcher)¶ 注意 -这个装饰器可能会降低代码的性能。通常，将代码表达为一系列支持__torch_function__的函数就足够了。如果您发现自己处于罕见的情况，即如果您正在包装一个低级库，并且还需要它适用于类似张量，那么这个函数是可用的。 +这个装饰器可能会降低代码的性能。通常，将代码表达为一系列支持 __torch_function__ 的函数就足够了。如果您发现自己处于罕见的情况，即如果您正在包装一个低级库，并且还需要它适用于类似张量，那么这个函数是可用的。 示例 diff --git a/totrans/doc22_066.md b/totrans/doc22_066.md index 3d07efec..be34027c 100644 --- a/totrans/doc22_066.md +++ b/totrans/doc22_066.md @@ -1,72 +1,72 @@ # torch.package -> 原文：[https://pytorch.org/docs/stable/package.html](https://pytorch.org/docs/stable/package.html) +> 原文：[`pytorch.org/docs/stable/package.html`](https://pytorch.org/docs/stable/package.html) -`torch.package` 支持创建包含工件和任意PyTorch代码的包。这些包可以保存、共享，用于在以后的日期或不同机器上加载和执行模型，甚至可以使用`torch::deploy`部署到生产环境。 +`torch.package` 支持创建包含工件和任意 PyTorch 代码的包。这些包可以保存、共享，用于在以后的日期或不同机器上加载和执行模型，甚至可以使用`torch::deploy`部署到生产环境。 -本文包含教程、指南、解释和API参考，将帮助您更多地了解`torch.package`及如何使用它。 +本文包含教程、指南、解释和 API 参考，将帮助您更多地了解`torch.package`及如何使用它。 警告 这个模块依赖于不安全的`pickle`模块。只有解包您信任的数据。 -可能构造恶意的pickle数据，将在解包时执行任意代码。永远不要解包可能来自不受信任来源或可能被篡改的数据。 +可能构造恶意的 pickle 数据，将在解包时执行任意代码。永远不要解包可能来自不受信任来源或可能被篡改的数据。 有关`pickle`模块的更多信息，请查看[文档](https://docs.python.org/3/library/pickle.html)。 -+ [教程](#tutorials) ++ 教程 - + [打包您的第一个模型](#packaging-your-first-model) + + 打包您的第一个模型 -+ [我该如何...](#how-do-i) ++ 我该如何... - + [查看包内部内容？](#see-what-is-inside-a-package) + + 查看包内部内容？ - + [查看为什么某个模块被包含为依赖？](#see-why-a-given-module-was-included-as-a-dependency) + + 查看为什么某个模块被包含为依赖？ - + [如何在我的包中包含任意资源并以后访问它们？](#include-arbitrary-resources-with-my-package-and-access-them-later) + + 如何在我的包中包含任意资源并以后访问它们？ - + [自定义类如何打包？](#customize-how-a-class-is-packaged) + + 自定义类如何打包？ + 在我的源代码中测试是否在包内执行？ - + [将代码打补丁到包中？](#patch-code-into-a-package) + + 将代码打补丁到包中？ - + [从打包的代码中访问包内容？](#access-package-contents-from-packaged-code) + + 从打包的代码中访问包内容？ - + [区分打包代码和非打包代码？](#distinguish-between-packaged-code-and-non-packaged-code) + + 区分打包代码和非打包代码？ - + [重新导出导入的对象？](#re-export-an-imported-object) + + 重新导出导入的对象？ - + [打包一个TorchScript模块？](#package-a-torchscript-module) + + 打包一个 TorchScript 模块？ -+ [解释](#explanation) ++ 解释 - + [`torch.package` 格式概述](#torch-package-format-overview) + + `torch.package` 格式概述 - + [`torch.package` 如何找到您代码的依赖](#how-torch-package-finds-your-code-s-dependencies) + + `torch.package` 如何找到您代码的依赖 - + [依赖管理](#dependency-management) + + 依赖管理 - + [`torch.package` 的尖锐边缘](#torch-package-sharp-edges) + + `torch.package` 的尖锐边缘 - + [`torch.package` 如何保持包之间的隔离](#how-torch-package-keeps-packages-isolated-from-each-other) + + `torch.package` 如何保持包之间的隔离 -+ [API参考](#api-reference) ++ API 参考 -## [教程](#id1) +## 教程 -### [打包您的第一个模型](#id2) +### 打包您的第一个模型 -提供了一个指导您打包和解包简单模型的教程[在Colab上](https://colab.research.google.com/drive/1lFZkLyViGfXxB-m3jqlyTQuYToo3XLo-)。完成这个练习后，您将熟悉用于创建和使用Torch包的基本API。 +提供了一个指导您打包和解包简单模型的教程[在 Colab 上](https://colab.research.google.com/drive/1lFZkLyViGfXxB-m3jqlyTQuYToo3XLo-)。完成这个练习后，您将熟悉用于创建和使用 Torch 包的基本 API。 -## [我该如何...](#id3) +## 我该如何... -### [查看包内部内容？](#id4) +### 查看包内部内容？ -#### 将包像ZIP存档一样处理 +#### 将包像 ZIP 存档一样处理 -`torch.package`的容器格式是ZIP，因此任何可以处理标准ZIP文件的工具都可以用于探索内容。与ZIP文件交互的一些常见方法： +`torch.package`的容器格式是 ZIP，因此任何可以处理标准 ZIP 文件的工具都可以用于探索内容。与 ZIP 文件交互的一些常见方法： + `unzip my_package.pt` 将`torch.package`存档解压到磁盘上，您可以自由检查其内容。 @@ -88,7 +88,7 @@ my_package ... ``` -+ Python的`zipfile`模块提供了一种标准的方法来读取和写入ZIP存档内容。 ++ Python 的`zipfile`模块提供了一种标准的方法来读取和写入 ZIP 存档内容。 ```py from zipfile import ZipFile @@ -98,7 +98,7 @@ with ZipFile("my_package.pt") as myzip: myzip.writestr("torchvision/models/resnet.py", new_file_bytes) ``` -+ vim有本地读取ZIP存档的能力。您甚至可以编辑文件并将其`:write`回存档中！ ++ vim 有本地读取 ZIP 存档的能力。您甚至可以编辑文件并将其`:write`回存档中！ ```py # add this to your .vimrc to treat `*.pt` files as zip files @@ -109,9 +109,9 @@ au BufReadCmd *.pt call zip#Browse(expand("")) #### 使用`file_structure()` API -[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter") 提供了一个 `file_structure()` 方法，它将返回一个可打印和可查询的 [`Directory`](#torch.package.Directory "torch.package.Directory") 对象。[`Directory`](#torch.package.Directory "torch.package.Directory") 对象是一个简单的目录结构，您可以用它来探索 `torch.package` 的当前内容。 +`PackageImporter` 提供了一个 `file_structure()` 方法，它将返回一个可打印和可查询的 `Directory` 对象。`Directory` 对象是一个简单的目录结构，您可以用它来探索 `torch.package` 的当前内容。 -[`Directory`](#torch.package.Directory "torch.package.Directory") 对象本身是可以直接打印的，将打印出一个文件树表示。要过滤返回的内容，使用类似glob的 `include` 和 `exclude` 过滤参数。 +`Directory` 对象本身是可以直接打印的，将打印出一个文件树表示。要过滤返回的内容，使用类似 glob 的 `include` 和 `exclude` 过滤参数。 ```py with PackageExporter('my_package.pt') as pe: @@ -150,26 +150,26 @@ print(importer.file_structure()) # will print out all files └── utils.py ``` -您还可以使用 `has_file()` 方法查询 [`Directory`](#torch.package.Directory "torch.package.Directory") 对象。 +您还可以使用 `has_file()` 方法查询 `Directory` 对象。 ```py importer_file_structure = importer.file_structure() found: bool = importer_file_structure.has_file("package_a/subpackage.py") ``` -### [查看为什么一个给定模块被包含为一个依赖项？](#id5)[](#see-why-a-given-module-was-included-as-a-dependency "Permalink to this heading") +### 查看为什么一个给定模块被包含为一个依赖项？[](#see-why-a-given-module-was-included-as-a-dependency "Permalink to this heading") -假设有一个给定的模块 `foo`，您想知道为什么您的 [`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter") 将 `foo` 作为一个依赖项引入。 +假设有一个给定的模块 `foo`，您想知道为什么您的 `PackageExporter` 将 `foo` 作为一个依赖项引入。 -[`PackageExporter.get_rdeps()`](#torch.package.PackageExporter.get_rdeps "torch.package.PackageExporter.get_rdeps") 将返回所有直接依赖于 `foo` 的模块。 +`PackageExporter.get_rdeps()` 将返回所有直接依赖于 `foo` 的模块。 -如果您想查看给定模块 `src` 如何依赖于 `foo`，[`PackageExporter.all_paths()`](#torch.package.PackageExporter.all_paths "torch.package.PackageExporter.all_paths") 方法将返回一个以DOT格式显示的图形，显示 `src` 和 `foo` 之间的所有依赖路径。 +如果您想查看给定模块 `src` 如何依赖于 `foo`，`PackageExporter.all_paths()` 方法将返回一个以 DOT 格式显示的图形，显示 `src` 和 `foo` 之间的所有依赖路径。 -如果您只想查看您的 [`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter") 的整个依赖图，您可以使用 [`PackageExporter.dependency_graph_string()`](#torch.package.PackageExporter.dependency_graph_string "torch.package.PackageExporter.dependency_graph_string")。 +如果您只想查看您的 `PackageExporter` 的整个依赖图，您可以使用 `PackageExporter.dependency_graph_string()`。 -### [如何在我的包中包含任意资源并以后访问它们？](#id6)[](#include-arbitrary-resources-with-my-package-and-access-them-later "Permalink to this heading") +### 如何在我的包中包含任意资源并以后访问它们？[](#include-arbitrary-resources-with-my-package-and-access-them-later "Permalink to this heading") -[`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter") 提供了三种方法，`save_pickle`、`save_text` 和 `save_binary`，允许您将Python对象、文本和二进制数据保存到一个包中。 +`PackageExporter` 提供了三种方法，`save_pickle`、`save_text` 和 `save_binary`，允许您将 Python 对象、文本和二进制数据保存到一个包中。 ```py with torch.PackageExporter("package.pt") as exporter: @@ -179,7 +179,7 @@ with torch.PackageExporter("package.pt") as exporter: exporter.save_binary("raw_data", "binary", my_bytes) ``` -[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter") 提供了名为 `load_pickle`、`load_text` 和 `load_binary` 的补充方法，允许您从一个包中加载Python对象、文本和二进制数据。 +`PackageImporter` 提供了名为 `load_pickle`、`load_text` 和 `load_binary` 的补充方法，允许您从一个包中加载 Python 对象、文本和二进制数据。 ```py importer = torch.PackageImporter("package.pt") @@ -188,9 +188,9 @@ text = importer.load_text("config_stuff", "words.txt") binary = importer.load_binary("raw_data", "binary") ``` -### [如何自定义类的打包方式？](#id7)[](#customize-how-a-class-is-packaged "Permalink to this heading") +### 如何自定义类的打包方式？[](#customize-how-a-class-is-packaged "Permalink to this heading") -`torch.package` 允许自定义类的打包方式。通过在一个类上定义方法 `__reduce_package__` 并定义相应的解包函数来访问这种行为。这类似于为Python的普通pickling过程定义 `__reduce__`。 +`torch.package` 允许自定义类的打包方式。通过在一个类上定义方法 `__reduce_package__` 并定义相应的解包函数来访问这种行为。这类似于为 Python 的普通 pickling 过程定义 `__reduce__`。 步骤： @@ -289,9 +289,9 @@ foo_1 export time: 9857706.650140837 foo_1 import time: 9857706.652698385 ``` -### [在我的源代码中测试是否正在包内执行？](#id8)[](#test-in-my-source-code-whether-or-not-it-is-executing-inside-a-package "Permalink to this heading") +### 在我的源代码中测试是否正在包内执行？[](#test-in-my-source-code-whether-or-not-it-is-executing-inside-a-package "Permalink to this heading") -[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")将在初始化的每个模块上添加属性`__torch_package__`。您的代码可以检查此属性的存在来确定它是否在打包上下文中执行。 +`PackageImporter`将在初始化的每个模块上添加属性`__torch_package__`。您的代码可以检查此属性的存在来确定它是否在打包上下文中执行。 ```py # In foo/bar.py: @@ -308,7 +308,7 @@ else: UserException = UnpackageableException ``` -现在，代码的行为将取决于它是通过Python环境正常导入还是从`torch.package`导入。 +现在，代码的行为将取决于它是通过 Python 环境正常导入还是从`torch.package`导入。 ```py from foo.bar import is_in_package @@ -321,9 +321,9 @@ loaded_module.is_in_package() # True **警告**：通常，根据代码是打包还是未打包而表现不同是不好的实践。这可能导致难以调试的问题，这些问题对您导入代码的方式很敏感。如果您的包打算被广泛使用，请考虑重新组织您的代码，使其无论如何加载都表现相同。 -### [将代码打补丁到包中？](#id9)[](#patch-code-into-a-package "跳转到此标题的永久链接") +### 将代码打补丁到包中？[](#patch-code-into-a-package "跳转到此标题的永久链接") -[`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter")提供了一个`save_source_string()`方法，允许将任意Python源代码保存到您选择的模块中。 +`PackageExporter`提供了一个`save_source_string()`方法，允许将任意 Python 源代码保存到您选择的模块中。 ```py with PackageExporter(f) as exporter: @@ -350,9 +350,9 @@ importer = PackageImporter(f) importer.import_module("my_module.foo").my_function() # prints 'hello world' ``` -### [从打包代码中访问包内容？](#id10)[](#access-package-contents-from-packaged-code "跳转到此标题的永久链接") +### 从打包代码中访问包内容？[](#access-package-contents-from-packaged-code "跳转到此标题的永久链接") -[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")实现了[importlib.resources](https://docs.python.org/3/library/importlib.html#module-importlib.resources) API，用于从包内访问资源。 +`PackageImporter`实现了[importlib.resources](https://docs.python.org/3/library/importlib.html#module-importlib.resources) API，用于从包内访问资源。 ```py with PackageExporter(f) as exporter: @@ -366,7 +366,7 @@ with PackageExporter(f) as exporter: exporter.save_module("bar") ``` -`importlib.resources` API允许从打包代码中访问资源。 +`importlib.resources` API 允许从打包代码中访问资源。 ```py # foo.py: @@ -378,7 +378,7 @@ def get_my_resource(): return importlib.resources.read_text(my_resource, "a.txt") ``` -使用`importlib.resources`是从打包代码中访问包内容的推荐方式，因为它符合Python标准。但是，也可以从打包代码中访问父[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")实例本身。 +使用`importlib.resources`是从打包代码中访问包内容的推荐方式，因为它符合 Python 标准。但是，也可以从打包代码中访问父`PackageImporter`实例本身。 ```py # bar.py: @@ -394,7 +394,7 @@ def get_my_pickle(): return torch_package_importer.load_pickle("my_pickle", "obj.pkl") ``` -### [区分打包代码和非打包代码？](#id11)[](#distinguish-between-packaged-code-and-non-packaged-code "跳转到此标题的永久链接") +### 区分打包代码和非打包代码？[](#distinguish-between-packaged-code-and-non-packaged-code "跳转到此标题的永久链接") 要确定对象的代码是否来自`torch.package`，请使用`torch.package.is_from_package()`函数。注意：如果对象来自包但其定义来自标记为`extern`或`stdlib`的模块，此检查将返回`False`。 @@ -409,9 +409,9 @@ assert is_from_package(obj) assert not is_from_package(txt) # str is from stdlib, so this will return False ``` -### [重新导出已导入的对象？](#id12)[](#re-export-an-imported-object "跳转到此标题的永久链接") +### 重新导出已导入的对象？[](#re-export-an-imported-object "跳转到此标题的永久链接") -重新导出之前由[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")导入的对象，您必须让新的[`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter")知道原始的[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")，以便它可以找到您对象的依赖项的源代码。 +重新导出之前由`PackageImporter`导入的对象，您必须让新的`PackageExporter`知道原始的`PackageImporter`，以便它可以找到您对象的依赖项的源代码。 ```py importer = PackageImporter(f) @@ -422,9 +422,9 @@ with PackageExporter(f2, importer=(importer, sys_importer)) as exporter: exporter.save_pickle("model", "model.pkl", obj) ``` -### [打包TorchScript模块？](#id13)[](#package-a-torchscript-module "跳转到此标题的永久链接") +### 打包 TorchScript 模块？[](#package-a-torchscript-module "跳转到此标题的永久链接") -要打包TorchScript模型，请使用与任何其他对象相同的`save_pickle`和`load_pickle` API。支持保存属性或子模块的TorchScript对象，无需额外工作。 +要打包 TorchScript 模型，请使用与任何其他对象相同的`save_pickle`和`load_pickle` API。支持保存属性或子模块的 TorchScript 对象，无需额外工作。 ```py # save TorchScript just like any other object @@ -437,17 +437,17 @@ loaded_script = importer.load_pickle("res", "script_model.pkl") loaded_mixed = importer.load_pickle("res", "mixed_model.pkl" ``` -## [解释](#id14) +## 解释 -### [`torch.package`格式概述](#id15)[](#torch-package-format-overview "跳转到此标题的永久链接") +### `torch.package`格式概述[](#torch-package-format-overview "跳转到此标题的永久链接") -`torch.package`文件是一个ZIP存档，通常使用`.pt`扩展名。在ZIP存档中，有两种类型的文件： +`torch.package`文件是一个 ZIP 存档，通常使用`.pt`扩展名。在 ZIP 存档中，有两种类型的文件： + 框架文件，放置在`.data/`中。 + 用户文件，即其他所有文件。 -例如，这是一个来自`torchvision`的完全打包的ResNet模型的样子： +例如，这是一个来自`torchvision`的完全打包的 ResNet 模型的样子： ```py resnet @@ -468,7 +468,7 @@ resnet #### 框架文件 -`.data/`目录由torch.package拥有，其内容被视为私有实现细节。`torch.package`格式不对`.data/`的内容做任何保证，但任何更改都将向后兼容（即，新版本的PyTorch始终能够加载旧的`torch.packages`）。 +`.data/`目录由 torch.package 拥有，其内容被视为私有实现细节。`torch.package`格式不对`.data/`的内容做任何保证，但任何更改都将向后兼容（即，新版本的 PyTorch 始终能够加载旧的`torch.packages`）。 目前，`.data/`目录包含以下项目： @@ -489,7 +489,7 @@ resnet #### 用户文件 -存档中的所有其他文件都是用户放置的。布局与Python[常规包](https://docs.python.org/3/reference/import.html#regular-packages)相同。要深入了解Python打包的工作原理，请参考[这篇文章](https://www.python.org/doc/essays/packages/)（它略有过时，因此请通过[Python参考文档](https://docs.python.org/3/library/importlib.html)双重检查实现细节）。 +存档中的所有其他文件都是用户放置的。布局与 Python[常规包](https://docs.python.org/3/reference/import.html#regular-packages)相同。要深入了解 Python 打包的工作原理，请参考[这篇文章](https://www.python.org/doc/essays/packages/)（它略有过时，因此请通过[Python 参考文档](https://docs.python.org/3/library/importlib.html)双重检查实现细节）。 ```py @@ -505,29 +505,29 @@ resnet └── utils.py # torchvision.models.utils ``` -### [如何`torch.package`找到您代码的依赖项](#id16)[](#how-torch-package-finds-your-code-s-dependencies "跳转到此标题") +### 如何`torch.package`找到您代码的依赖项[](#how-torch-package-finds-your-code-s-dependencies "跳转到此标题") #### 分析对象的依赖项[](#analyzing-an-object-s-dependencies "跳转到此标题") -当您发出`save_pickle(obj, ...)`调用时，[`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter")将正常对对象进行pickle。然后，它使用`pickletools`标准库模块来解析pickle字节码。 +当您发出`save_pickle(obj, ...)`调用时，`PackageExporter`将正常对对象进行 pickle。然后，它使用`pickletools`标准库模块来解析 pickle 字节码。 -在pickle中，对象与描述对象类型实现位置的`GLOBAL`操作码一起保存，例如： +在 pickle 中，对象与描述对象类型实现位置的`GLOBAL`操作码一起保存，例如： ```py GLOBAL 'torchvision.models.resnet Resnet` ``` -依赖解析器将收集所有`GLOBAL`操作，并将它们标记为您的pickled对象的依赖项。有关pickling和pickle格式的更多信息，请参考[Python文档](https://docs.python.org/3/library/pickle.html)。 +依赖解析器将收集所有`GLOBAL`操作，并将它们标记为您的 pickled 对象的依赖项。有关 pickling 和 pickle 格式的更多信息，请参考[Python 文档](https://docs.python.org/3/library/pickle.html)。 #### 分析模块的依赖项[](#analyzing-a-module-s-dependencies "跳转到此标题") -当Python模块被识别为依赖项时，`torch.package`会遍历模块的Python AST表示，并查找具有标准形式的导入语句的支持：`from x import y`，`import z`，`from w import v as u`等。当遇到这些导入语句之一时，`torch.package`会将导入的模块注册为依赖项，然后以相同的AST遍历方式解析它们自己。 +当 Python 模块被识别为依赖项时，`torch.package`会遍历模块的 Python AST 表示，并查找具有标准形式的导入语句的支持：`from x import y`，`import z`，`from w import v as u`等。当遇到这些导入语句之一时，`torch.package`会将导入的模块注册为依赖项，然后以相同的 AST 遍历方式解析它们自己。 -**注意**：AST解析对于`__import__(...)`语法有限支持，并且不支持`importlib.import_module`调用。一般来说，您不应该期望`torch.package`能够检测到动态导入。 +**注意**：AST 解析对于`__import__(...)`语法有限支持，并且不支持`importlib.import_module`调用。一般来说，您不应该期望`torch.package`能够检测到动态导入。 -### [依赖管理](#id17)[](#dependency-management "跳转到此标题") +### 依赖管理[](#dependency-management "跳转到此标题") -`torch.package`会自动找到您的代码和对象依赖的Python模块。这个过程称为依赖解析。对于依赖解析器找到的每个模块，您必须指定要执行的*操作*。 +`torch.package`会自动找到您的代码和对象依赖的 Python 模块。这个过程称为依赖解析。对于依赖解析器找到的每个模块，您必须指定要执行的*操作*。 允许的操作是： @@ -543,9 +543,9 @@ GLOBAL 'torchvision.models.resnet Resnet` + 重构：删除或更改代码中的依赖项。 -请注意，操作仅在整个Python模块上定义。无法仅打包模块中的“只是”函数或类并将其余部分留出。这是有意设计的。Python没有为模块中定义的对象提供清晰的边界。依赖组织的唯一定义单元是模块，因此`torch.package`使用它。 +请注意，操作仅在整个 Python 模块上定义。无法仅打包模块中的“只是”函数或类并将其余部分留出。这是有意设计的。Python 没有为模块中定义的对象提供清晰的边界。依赖组织的唯一定义单元是模块，因此`torch.package`使用它。 -使用模式对模块应用操作。模式可以是模块名称（`"foo.bar"`）或通配符（如`"foo.**"`）。您可以使用[`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter")上的方法将模式与操作关联起来，例如： +使用模式对模块应用操作。模式可以是模块名称（`"foo.bar"`）或通配符（如`"foo.**"`）。您可以使用`PackageExporter`上的方法将模式与操作关联起来，例如： ```py my_exporter.intern("torchvision.**") @@ -558,17 +558,17 @@ my_exporter.extern("numpy") 如果一个模块被`intern`，它将被放入包中。 -这个操作是您的模型代码，或者您想要打包的任何相关代码。例如，如果您正在尝试从`torchvision`打包一个ResNet，您将需要`intern`模块torchvision.models.resnet。 +这个操作是您的模型代码，或者您想要打包的任何相关代码。例如，如果您正在尝试从`torchvision`打包一个 ResNet，您将需要`intern`模块 torchvision.models.resnet。 -在包导入时，当您的打包代码尝试导入一个`intern`-ed模块时，PackageImporter将在您的包内查找该模块。如果找不到该模块，将引发错误。这确保了每个[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")与加载环境隔离——即使您的包和加载环境中都有`my_interned_module`，[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")也只会使用您包中的版本。 +在包导入时，当您的打包代码尝试导入一个`intern`-ed 模块时，PackageImporter 将在您的包内查找该模块。如果找不到该模块，将引发错误。这确保了每个`PackageImporter`与加载环境隔离——即使您的包和加载环境中都有`my_interned_module`，`PackageImporter`也只会使用您包中的版本。 -**注意**：只有Python源模块可以被`intern`。其他类型的模块，如C扩展模块和字节码模块，如果您尝试`intern`它们，将引发错误。这些类型的模块需要被`mock`或`extern`。 +**注意**：只有 Python 源模块可以被`intern`。其他类型的模块，如 C 扩展模块和字节码模块，如果您尝试`intern`它们，将引发错误。这些类型的模块需要被`mock`或`extern`。 #### `extern` 如果一个模块被`extern`，它将不会被打包。相反，它将被添加到此包的外部依赖项列表中。您可以在`package_exporter.extern_modules`中找到此列表。 -在包导入时，当打包的代码尝试导入一个`extern`-ed模块时，[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")将使用默认的Python导入器来查找该模块，就好像您执行了`importlib.import_module("my_externed_module")`。如果找不到该模块，将引发错误。 +在包导入时，当打包的代码尝试导入一个`extern`-ed 模块时，`PackageImporter`将使用默认的 Python 导入器来查找该模块，就好像您执行了`importlib.import_module("my_externed_module")`。如果找不到该模块，将引发错误。 通过这种方式，您可以依赖于第三方库，如`numpy`和`scipy`，而无需将它们也打包。 @@ -588,13 +588,13 @@ my_exporter.extern("numpy") **只包含你使用的内容**。不要在你的代码中留下未使用的导入。依赖解析器不够智能，无法判断它们是否确实未使用，并将尝试处理它们。 -**限定您的导入**。例如，不要写import foo然后在后面使用`foo.bar.baz`，最好写`from foo.bar import baz`。这更精确地指定了您的真实依赖项(`foo.bar`)，并让依赖解析器知道您不需要`foo`的全部内容。 +**限定您的导入**。例如，不要写 import foo 然后在后面使用`foo.bar.baz`，最好写`from foo.bar import baz`。这更精确地指定了您的真实依赖项(`foo.bar`)，并让依赖解析器知道您不需要`foo`的全部内容。 **将具有无关功能的大文件拆分为较小的文件**。如果您的`utils`模块包含各种无关功能，任何依赖于`utils`的模块都将需要引入大量无关的依赖项，即使您只需要其中的一小部分。相反，最好定义单一用途的模块，可以独立打包。 #### 模式 -模式允许您使用方便的语法指定模块组。模式的语法和行为遵循Bazel/Buck [glob()](https://docs.bazel.build/versions/master/be/functions.html#glob)。 +模式允许您使用方便的语法指定模块组。模式的语法和行为遵循 Bazel/Buck [glob()](https://docs.bazel.build/versions/master/be/functions.html#glob)。 我们正在尝试匹配的模块称为候选模块。候选模块由一系列由分隔符字符串分隔的段组成，例如`foo.bar.baz`。 @@ -632,19 +632,19 @@ exporter.mock("**", exclude=["torchvision.**"]) 当一个模块可能匹配多个操作时，将采取首先定义的操作。 -### [`torch.package`尖锐边缘](#id18)[](#torch-package-sharp-edges "跳转到此标题") +### `torch.package`尖锐边缘[](#torch-package-sharp-edges "跳转到此标题") #### 避免在您的模块中使用全局状态[](#avoid-global-state-in-your-modules "跳转到此标题") -Python使绑定对象和在模块级别范围运行代码变得非常容易。这通常没问题——毕竟，函数和类是以这种方式绑定到名称的。但是，当您在模块范围定义一个对象以进行突变时，引入可变全局状态时，情况会变得更加复杂。 +Python 使绑定对象和在模块级别范围运行代码变得非常容易。这通常没问题——毕竟，函数和类是以这种方式绑定到名称的。但是，当您在模块范围定义一个对象以进行突变时，引入可变全局状态时，情况会变得更加复杂。 可变全局状态非常有用——它可以减少样板文件，允许向表中开放注册等。但是，除非非常小心地使用，否则在与`torch.package`一起使用时可能会引起复杂性。 -每个[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")为其内容创建一个独立的环境。这很好，因为这意味着我们加载多个包并确保它们彼此隔离，但是当模块以假定共享可变全局状态的方式编写时，此行为可能会导致难以调试的错误。 +每个`PackageImporter`为其内容创建一个独立的环境。这很好，因为这意味着我们加载多个包并确保它们彼此隔离，但是当模块以假定共享可变全局状态的方式编写时，此行为可能会导致难以调试的错误。 #### 类型不在包之间共享，并且加载环境[](#types-are-not-shared-between-packages-and-the-loading-environment "跳转到此标题") -从[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")导入的任何类都将是特定于该导入器的类的版本。例如： +从`PackageImporter`导入的任何类都将是特定于该导入器的类的版本。例如： ```py from foo import MyClass @@ -676,17 +676,17 @@ print(imported_MyClass.__name__) # prints .foo.MyClass + 使类型关系成为类合同的显式部分。例如，您可以添加一个属性标签`self.handler = "handle_me_this_way"`，并让客户端代码检查`handler`的值而不是直接检查类型。 -### [如何使`torch.package`中的包相互隔离](#id19)[](#how-torch-package-keeps-packages-isolated-from-each-other "跳转到此标题的永久链接") +### 如何使`torch.package`中的包相互隔离[](#how-torch-package-keeps-packages-isolated-from-each-other "跳转到此标题的永久链接") -每个[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")实例为其模块和对象创建一个独立的、隔离的环境。包中的模块只能导入其他打包的模块，或标记为`extern`的模块。如果您使用多个[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")实例来加载单个包，您将获得多个独立的环境，它们不会相互交互。 +每个`PackageImporter`实例为其模块和对象创建一个独立的、隔离的环境。包中的模块只能导入其他打包的模块，或标记为`extern`的模块。如果您使用多个`PackageImporter`实例来加载单个包，您将获得多个独立的环境，它们不会相互交互。 -这是通过使用自定义导入器扩展 Python 的导入基础设施来实现的。[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")提供与`importlib`导入器相同的核心 API；即，它实现了`import_module`和`__import__`方法。 +这是通过使用自定义导入器扩展 Python 的导入基础设施来实现的。`PackageImporter`提供与`importlib`导入器相同的核心 API；即，它实现了`import_module`和`__import__`方法。 -当调用[`PackageImporter.import_module()`](#torch.package.PackageImporter.import_module "torch.package.PackageImporter.import_module")时，[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")将构建并返回一个新模块，就像系统导入器一样。但是，[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")会修补返回的模块，以使用`self`（即[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")实例）来满足未来的导入请求，通过在包中查找而不是搜索用户的Python环境。 +当调用`PackageImporter.import_module()`时，`PackageImporter`将构建并返回一个新模块，就像系统导入器一样。但是，`PackageImporter`会修补返回的模块，以使用`self`（即`PackageImporter`实例）来满足未来的导入请求，通过在包中查找而不是搜索用户的 Python 环境。 #### 混淆 -为了避免混淆（“这个`foo.bar`对象是来自我的包还是来自我的Python环境？”），[`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter")通过为导入的所有模块添加*混淆前缀*来篡改它们的`__name__`和`__file__`。 +为了避免混淆（“这个`foo.bar`对象是来自我的包还是来自我的 Python 环境？”），`PackageImporter`通过为导入的所有模块添加*混淆前缀*来篡改它们的`__name__`和`__file__`。 对于`__name__`，类似`torchvision.models.resnet18`的名称变为`.torchvision.models.resnet18`。 @@ -694,7 +694,7 @@ print(imported_MyClass.__name__) # prints .foo.MyClass 名称混淆有助于避免不同包之间模块名称的无意间双关，并通过使堆栈跟踪和打印语句更清晰地显示它们是指向打包代码还是其他内容来帮助您调试。有关混淆的面向开发人员的详细信息，请参阅`torch/package/`中的`mangling.md`。 -## [API 参考](#id20) +## API 参考 ```py class torch.package.PackagingError(dependency_graph, debug=False)¶ @@ -714,13 +714,13 @@ class torch.package.PackageExporter(f, importer=, debug=False)¶ @@ -730,11 +730,11 @@ __init__(f, importer=, debug=False) 参数 -+ **f** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*Path*](https://docs.python.org/3/library/pathlib.html#pathlib.Path "(in Python v3.12)")*,* [*BinaryIO*](https://docs.python.org/3/library/typing.html#typing.BinaryIO "(in Python v3.12)")*]*) – 导出位置。可以是包含文件名的`string`/`Path`对象，也可以是二进制I/O对象。 ++ **f** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* [*Path*](https://docs.python.org/3/library/pathlib.html#pathlib.Path "(in Python v3.12)")*,* [*BinaryIO*](https://docs.python.org/3/library/typing.html#typing.BinaryIO "(in Python v3.12)")*]*) – 导出位置。可以是包含文件名的`string`/`Path`对象，也可以是二进制 I/O 对象。 -+ **importer** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**Importer**,* [*Sequence*](https://docs.python.org/3/library/typing.html#typing.Sequence "(in Python v3.12)")*[**Importer**]**]*) – 如果传递了单个Importer，则使用该Importer搜索模块。如果传递了一系列importers，将从中构建一个`OrderedImporter`。 ++ **importer** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(in Python v3.12)")*[**Importer**,* [*Sequence*](https://docs.python.org/3/library/typing.html#typing.Sequence "(in Python v3.12)")*[**Importer**]**]*) – 如果传递了单个 Importer，则使用该 Importer 搜索模块。如果传递了一系列 importers，将从中构建一个`OrderedImporter`。 -+ **debug** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果设置为True，则将损坏模块的路径添加到PackagingErrors中。 ++ **debug** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果设置为 True，则将损坏模块的路径添加到 PackagingErrors 中。 ```py add_dependency(module_name, dependencies=True)¶ @@ -748,11 +748,11 @@ all_paths(src, dst)¶ 返回子图的点表示 -从src到dst的所有路径。 +从 src 到 dst 的所有路径。 返回 -包含从src到dst的所有路径的点表示。([https://graphviz.org/doc/info/lang.html](https://graphviz.org/doc/info/lang.html)) +包含从 src 到 dst 的所有路径的点表示。([`graphviz.org/doc/info/lang.html`](https://graphviz.org/doc/info/lang.html)) 返回类型 @@ -762,7 +762,7 @@ all_paths(src, dst)¶ close()¶ ``` -将包写入文件系统。[`close()`](#torch.package.PackageExporter.close "torch.package.PackageExporter.close")之后的任何调用现在都是无效的。最好使用资源保护语法： +将包写入文件系统。`close()`之后的任何调用现在都是无效的。最好使用资源保护语法： ```py with PackageExporter("file.zip") as e: @@ -787,11 +787,11 @@ denied_modules()¶ deny(include, *, exclude=())¶ ``` -从包可以导入的模块列表中阻止与给定glob模式匹配的模块名称。如果找到任何匹配的包的依赖项，将引发[`PackagingError`](#torch.package.PackagingError "torch.package.PackagingError")。 +从包可以导入的模块列表中阻止与给定 glob 模式匹配的模块名称。如果找到任何匹配的包的依赖项，将引发`PackagingError`。 参数 -+ **include** (*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)")*]*) – 一个字符串，例如 `"my_package.my_subpackage"`，或者字符串列表，用于指定要外部化的模块的名称。这也可以是一个类似于glob的模式，如[`mock()`](#torch.package.PackageExporter.mock "torch.package.PackageExporter.mock")中所述。 ++ **include** (*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)")*]*) – 一个字符串，例如 `"my_package.my_subpackage"`，或者字符串列表，用于指定要外部化的模块的名称。这也可以是一个类似于 glob 的模式，如`mock()`中所述。 + **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)")*]*) – 一个可选模式，用于排除与包含字符串匹配的某些模式。 @@ -817,25 +817,25 @@ extern(include, *, exclude=(), allow_empty=True)¶ 参数 -+ **包括**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]）- 一个字符串，例如`"my_package.my_subpackage"`，或者是要导出的模块的名称列表。这也可以是一个类似glob的模式，如[`mock()`](#torch.package.PackageExporter.mock "torch.package.PackageExporter.mock")中所述。 ++ **包括**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]）- 一个字符串，例如`"my_package.my_subpackage"`，或者是要导出的模块的名称列表。这也可以是一个类似 glob 的模式，如`mock()`中所述。 -+ **排除**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]）- 一个可选模式，排除一些与包含字符串匹配的模式。 ++ **排除**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]）- 一个可选模式，排除一些与包含字符串匹配的模式。 -+ **allow_empty**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 一个可选标志，指定此调用`extern`方法指定的外部模块是否必须在打包过程中与某个模块匹配。如果添加了一个`allow_empty=False`的外部模块glob模式，并且在任何模块匹配该模式之前调用了[`close()`](#torch.package.PackageExporter.close "torch.package.PackageExporter.close")（显式调用或通过`__exit__`），则会抛出异常。如果`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的模块。 +返回当前所有已经 externed 的模块。 返回 -包含在此包中将被externed的模块的名称列表。 +包含在此包中将被 externed 的模块的名称列表。 返回类型 -[*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中)")] +[*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)¶ @@ -849,17 +849,17 @@ 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中)")] +[*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()¶ ``` -获取一个id。此id保证仅在此包中分配一次。 +获取一个 id。此 id 保证仅在此包中分配一次。 返回类型 -[str](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)") +[str](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)") ```py intern(include, *, exclude=(), allow_empty=True)¶ @@ -869,21 +869,21 @@ intern(include, *, exclude=(), allow_empty=True)¶ 参数 -+ **包括**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]）- 一个字符串，例如“my_package.my_subpackage”，或者是要导出的模块的名称列表。这也可以是一个类似glob的模式，如[`mock()`](#torch.package.PackageExporter.mock "torch.package.PackageExporter.mock")中所述。 ++ **包括**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]）- 一个字符串，例如“my_package.my_subpackage”，或者是要导出的模块的名称列表。这也可以是一个类似 glob 的模式，如`mock()`中所述。 -+ **排除**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]）- 一个可选模式，排除一些与包含字符串匹配的模式。 ++ **排除**（*Union**[**List**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]**,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]）- 一个可选模式，排除一些与包含字符串匹配的模式。 -+ **allow_empty**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 一个可选标志，指定此调用`intern`方法指定的intern模块是否必须在打包过程中与某个模块匹配。如果添加了一个`allow_empty=False`的`intern`模块glob模式，并且在任何模块匹配该模式之前调用了[`close()`](#torch.package.PackageExporter.close "torch.package.PackageExporter.close")（显式调用或通过`__exit__`），则会抛出异常。如果`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的模块。 +返回当前所有已经 interned 的模块。 返回 -包含将在此软件包中intern的模块名称的列表。 +包含将在此软件包中 intern 的模块名称的列表。 返回类型 @@ -899,17 +899,17 @@ mock(include, *, exclude=(), allow_empty=True)¶ + **include**（*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)")*]*) - - 一个字符串，例如`"my_package.my_subpackage"`，或模块名称的字符串列表。字符串也可以是匹配多个模块的glob样式模式字符串。与此模式字符串匹配的任何必需依赖项将自动被模拟。 + 一个字符串，例如`"my_package.my_subpackage"`，或模块名称的字符串列表。字符串也可以是匹配多个模块的 glob 样式模式字符串。与此模式字符串匹配的任何必需依赖项将自动被模拟。 示例： - `'torch.**'` - 匹配`torch`和torch的所有子模块，例如`'torch.nn'`和`'torch.nn.functional'` + `'torch.**'` - 匹配`torch`和 torch 的所有子模块，例如`'torch.nn'`和`'torch.nn.functional'` `'torch.*'` - 匹配`'torch.nn'`或`'torch.functional'`，但不匹配`'torch.nn.functional'` -+ **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)")*]*) - 一个可选模式，用于排除与包含字符串匹配的某些模式。例如 `include='torch.**', exclude='torch.foo'` 将模拟所有torch包，除了`'torch.foo'`，默认值为`[]`。 ++ **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)")*]*) - 一个可选模式，用于排除与包含字符串匹配的某些模式。例如 `include='torch.**', exclude='torch.foo'` 将模拟所有 torch 包，除了`'torch.foo'`，默认值为`[]`。 -+ **allow_empty**（*bool*）- 一个可选标志，指定此调用[`mock()`](#torch.package.PackageExporter.mock "torch.package.PackageExporter.mock")方法指定的模拟实现是否在打包期间必须与某个模块匹配。如果使用`allow_empty=False`添加了一个模拟，并且调用了[`close()`](#torch.package.PackageExporter.close "torch.package.PackageExporter.close")（显式调用或通过`__exit__`），并且该模拟未与要导出的包使用的模块匹配，则会抛出异常。如果`allow_empty=True`，则不会抛出此类异常。 ++ **allow_empty**（*bool*）- 一个可选标志，指定此调用`mock()`方法指定的模拟实现是否在打包期间必须与某个模块匹配。如果使用`allow_empty=False`添加了一个模拟，并且调用了`close()`（显式调用或通过`__exit__`），并且该模拟未与要导出的包使用的模块匹配，则会抛出异常。如果`allow_empty=True`，则不会抛出此类异常。 ```py mocked_modules()¶ @@ -929,9 +929,9 @@ mocked_modules()¶ register_extern_hook(hook)¶ ``` -在导出器上注册一个extern钩子。 +在导出器上注册一个 extern 钩子。 -每次模块与[`extern()`](#torch.package.PackageExporter.extern "torch.package.PackageExporter.extern")模式匹配时都会调用钩子。它应该具有以下签名： +每次模块与`extern()`模式匹配时都会调用钩子。它应该具有以下签名： ```py hook(exporter: PackageExporter, module_name: str) -> None @@ -951,9 +951,9 @@ hook(exporter: PackageExporter, module_name: str) -> None register_intern_hook(hook)¶ ``` -在导出器上注册一个intern钩子。 +在导出器上注册一个 intern 钩子。 -每次模块与[`intern()`](#torch.package.PackageExporter.intern "torch.package.PackageExporter.intern")模式匹配时都会调用钩子。它应该具有以下签名： +每次模块与`intern()`模式匹配时都会调用钩子。它应该具有以下签名： ```py hook(exporter: PackageExporter, module_name: str) -> None @@ -975,7 +975,7 @@ register_mock_hook(hook)¶ 在导出器上注册一个模拟钩子。 -每次模块与[`mock()`](#torch.package.PackageExporter.mock "torch.package.PackageExporter.mock")模式匹配时都会调用钩子。它应该具有以下签名： +每次模块与`mock()`模式匹配时都会调用钩子。它应该具有以下签名： ```py hook(exporter: PackageExporter, module_name: str) -> None @@ -999,11 +999,11 @@ save_binary(package, resource, binary)¶ 参数 -+ **package**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 此资源应该放在的模块包的名称（例如`"my_package.my_subpackage"`）。 ++ **package**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 此资源应该放在的模块包的名称（例如`"my_package.my_subpackage"`）。 -+ **资源**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 用于标识要加载的资源的唯一名称。 ++ **资源**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 用于标识要加载的资源的唯一名称。 -+ **二进制**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 要保存的数据。 ++ **二进制**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 要保存的数据。 ```py save_module(module_name, dependencies=True)¶ @@ -1013,27 +1013,27 @@ save_module(module_name, dependencies=True)¶ 参数 -+ **module_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 例如`my_package.my_subpackage`，将保存代码以提供此包的代码。 ++ **module_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 例如`my_package.my_subpackage`，将保存代码以提供此包的代码。 -+ **依赖项**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，可选） - 如果为`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)¶ ``` -使用pickle将Python对象保存到存档中。相当于[`torch.save()`](generated/torch.save.html#torch.save "torch.save")，但保存到存档而不是独立文件。标准pickle不保存代码，只保存对象。如果`dependencies`为true，则此方法还将扫描pickled对象以确定重建它们所需的模块，并保存相关代码。 +使用 pickle 将 Python 对象保存到存档中。相当于`torch.save()`，但保存到存档而不是独立文件。标准 pickle 不保存代码，只保存对象。如果`dependencies`为 true，则此方法还将扫描 pickled 对象以确定重建它们所需的模块，并保存相关代码。 为了能够保存一个对象，其中`type(obj).__name__`是`my_module.MyObject`，`my_module.MyObject`必须根据`importer`顺序解析为对象的类。当保存先前已打包的对象时，导入程序的`import_module`方法将需要存在于`importer`列表中才能正常工作。 参数 -+ **package**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 此资源应该放在的模块包的名称（例如`"my_package.my_subpackage"`）。 ++ **package**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 此资源应该放在的模块包的名称（例如`"my_package.my_subpackage"`）。 -+ **资源**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 用于标识要加载的资源的唯一名称。 ++ **资源**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 用于标识要加载的资源的唯一名称。 -+ **obj**（*Any*） - 要保存的对象，必须是可picklable的。 ++ **obj**（*Any*） - 要保存的对象，必须是可 picklable 的。 -+ **依赖项**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，可选） - 如果为`True`，我们会扫描源代码以查找依赖项。 ++ **依赖项**（[*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)¶ @@ -1043,11 +1043,11 @@ save_source_file(module_name, file_or_directory, dependencies=True)¶ 参数 -+ **module_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 例如`"my_package.my_subpackage"`，将保存代码以提供此包的代码。 ++ **module_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 例如`"my_package.my_subpackage"`，将保存代码以提供此包的代码。 -+ **file_or_directory**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 文件或代码目录的路径。当目录时，使用[`save_source_file()`](#torch.package.PackageExporter.save_source_file "torch.package.PackageExporter.save_source_file")递归复制目录中的所有python文件。如果文件命名为`"/__init__.py"`，则将代码视为包。 ++ **file_or_directory**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 文件或代码目录的路径。当目录时，使用`save_source_file()`递归复制目录中的所有 python 文件。如果文件命名为`"/__init__.py"`，则将代码视为包。 -+ **依赖项**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，可选） - 如果为`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)¶ @@ -1057,9 +1057,9 @@ save_source_string(module_name, src, is_package=False, dependencies=True)¶ 参数 -+ **module_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 例如`my_package.my_subpackage`，将保存代码以提供此包的代码。 ++ **module_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 例如`my_package.my_subpackage`，将保存代码以提供此包的代码。 -+ **src**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 要保存到此包的Python源代码。 ++ **src**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 要保存到此包的 Python 源代码。 + **is_package**（*bool*，可选）- 如果为`True`，则将此模块视为包。允许包具有子模块（例如`my_package.my_subpackage.my_subsubpackage`），并且资源可以保存在其中。默认为`False`。 @@ -1083,9 +1083,9 @@ save_text(package, resource, text)¶ class torch.package.PackageImporter(file_or_buffer, module_allowed=>)¶ ``` -导入器允许您加载由[`PackageExporter`](#torch.package.PackageExporter "torch.package.PackageExporter")编写的包中的代码。代码以封闭方式加载，使用包中的文件而不是正常的python导入系统。这允许将PyTorch模型代码和数据打包，以便在服务器上运行或在将来用于迁移学习。 +导入器允许您加载由`PackageExporter`编写的包中的代码。代码以封闭方式加载，使用包中的文件而不是正常的 python 导入系统。这允许将 PyTorch 模型代码和数据打包，以便在服务器上运行或在将来用于迁移学习。 -包的导入器确保模块中的代码只能从包内加载，除了在导出期间明确列出为外部模块的模块。zip存档中的`extern_modules`文件列出了包在外部依赖的所有模块。这可以防止“隐式”依赖，其中包在本地运行，因为它正在导入一个本地安装的包，但是当包被复制到另一台机器时会失败。 +包的导入器确保模块中的代码只能从包内加载，除了在导出期间明确列出为外部模块的模块。zip 存档中的`extern_modules`文件列出了包在外部依赖的所有模块。这可以防止“隐式”依赖，其中包在本地运行，因为它正在导入一个本地安装的包，但是当包被复制到另一台机器时会失败。 ```py __init__(file_or_buffer, module_allowed=>)¶ @@ -1107,27 +1107,27 @@ __init__(file_or_buffer, module_allowed=>)¶ file_structure(*, include='**', exclude=())¶ ``` -返回包的zip文件结构表示。 +返回包的 zip 文件结构表示。 参数 -+ **include**（*Union**[**List**[*[*str*]*]**，*[*str*]*]）- 一个可选的字符串，例如`"my_package.my_subpackage"`，或者包含在zip文件表示中的文件名称的可选字符串列表。这也可以是一个类似glob的模式，如[`PackageExporter.mock()`](#torch.package.PackageExporter.mock "torch.package.PackageExporter.mock")中所述。 ++ **include**（*Union**[**List**[*[*str*]*]**，*[*str*]*]）- 一个可选的字符串，例如`"my_package.my_subpackage"`，或者包含在 zip 文件表示中的文件名称的可选字符串列表。这也可以是一个类似 glob 的模式，如`PackageExporter.mock()`中所述。 + **exclude**（*Union**[**List**[*[*str*]*]**，*[*str*]*]）- 一个可选的模式，用于排除与模式匹配的文件。 返回 -[`Directory`](#torch.package.Directory "torch.package.Directory") +`Directory` 返回类型 -[*Directory*](#torch.package.Directory "torch.package.file_structure_representation.Directory") +*Directory* ```py id()¶ ``` -返回内部标识符，torch.package 用于区分 [`PackageImporter`](#torch.package.PackageImporter "torch.package.PackageImporter") 实例。看起来像： +返回内部标识符，torch.package 用于区分 `PackageImporter` 实例。看起来像： ```py @@ -1177,7 +1177,7 @@ load_binary(package, resource)¶ load_pickle(package, resource, map_location=None)¶ ``` -从包中反序列化资源，加载任何需要构造对象的模块，使用 [`import_module()`](#torch.package.PackageImporter.import_module "torch.package.PackageImporter.import_module")。 +从包中反序列化资源，加载任何需要构造对象的模块，使用 `import_module()`。 参数 @@ -1235,13 +1235,13 @@ python_version()¶ class torch.package.Directory(name, is_dir)¶ ``` -文件结构表示。组织为具有其 Directory 子节点列表的 Directory 节点。通过调用 [`PackageImporter.file_structure()`](#torch.package.PackageImporter.file_structure "torch.package.PackageImporter.file_structure") 来创建包的目录。 +文件结构表示。组织为具有其 Directory 子节点列表的 Directory 节点。通过调用 `PackageImporter.file_structure()` 来创建包的目录。 ```py has_file(filename)¶ ``` -检查文件是否存在于 [`Directory`](#torch.package.Directory "torch.package.Directory") 中。 +检查文件是否存在于 `Directory` 中。 参数 @@ -1249,7 +1249,7 @@ has_file(filename)¶ 返回 -如果 [`Directory`](#torch.package.Directory "torch.package.Directory") 包含指定的文件。 +如果 `Directory` 包含指定的文件。 返回类型 diff --git a/totrans/doc22_067.md b/totrans/doc22_067.md index a2a77d08..a335e091 100644 --- a/totrans/doc22_067.md +++ b/totrans/doc22_067.md @@ -1,16 +1,16 @@ # torch.profiler -> 原文：[https://pytorch.org/docs/stable/profiler.html](https://pytorch.org/docs/stable/profiler.html) +> 原文：[`pytorch.org/docs/stable/profiler.html`](https://pytorch.org/docs/stable/profiler.html) ## 概述 -PyTorch Profiler是一个工具，允许在训练和推断过程中收集性能指标。Profiler的上下文管理器API可用于更好地了解哪些模型操作符是最昂贵的，检查它们的输入形状和堆栈跟踪，研究设备内核活动并可视化执行跟踪。 +PyTorch Profiler 是一个工具，允许在训练和推断过程中收集性能指标。Profiler 的上下文管理器 API 可用于更好地了解哪些模型操作符是最昂贵的，检查它们的输入形状和堆栈跟踪，研究设备内核活动并可视化执行跟踪。 注意 -[`torch.autograd`](autograd.html#module-torch.autograd "torch.autograd")模块中的早期版本被视为遗留版本，并将被弃用。 +`torch.autograd`模块中的早期版本被视为遗留版本，并将被弃用。 -## API参考 +## 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)¶ @@ -20,7 +20,7 @@ class torch.profiler._KinetoProfile(*, activities=None, record_shapes=False, pro 参数 -+ **activities**（*可迭代对象*）- 要在分析中使用的活动组（CPU、CUDA）列表，支持的值：`torch.profiler.ProfilerActivity.CPU`、`torch.profiler.ProfilerActivity.CUDA`。默认值：ProfilerActivity.CPU和（如果可用）ProfilerActivity.CUDA。 ++ **activities**（*可迭代对象*）- 要在分析中使用的活动组（CPU、CUDA）列表，支持的值：`torch.profiler.ProfilerActivity.CPU`、`torch.profiler.ProfilerActivity.CUDA`。默认值：ProfilerActivity.CPU 和（如果可用）ProfilerActivity.CUDA。 + **record_shapes**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 保存有关操作符输入形状的信息。 @@ -28,17 +28,17 @@ class torch.profiler._KinetoProfile(*, activities=None, record_shapes=False, pro + **with_stack**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 记录操作的源信息（文件和行号）。 -+ **with_flops**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 使用公式估计特定操作符的FLOPS（矩阵乘法和2D卷积）。 ++ **with_flops**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 使用公式估计特定操作符的 FLOPS（矩阵乘法和 2D 卷积）。 -+ **with_modules**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 记录模块层次结构（包括函数名称），对应于操作的调用堆栈。例如，如果模块A的前向调用的模块B的前向包含一个aten::add操作，则aten::add的模块层次结构是A.B 请注意，此支持目前仅适用于TorchScript模型，而不适用于急切模式模型。 ++ **with_modules**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 记录模块层次结构（包括函数名称），对应于操作的调用堆栈。例如，如果模块 A 的前向调用的模块 B 的前向包含一个 aten::add 操作，则 aten::add 的模块层次结构是 A.B 请注意，此支持目前仅适用于 TorchScript 模型，而不适用于急切模式模型。 -+ **experimental_config**（*_ExperimentalConfig*）- 由像Kineto这样的分析器库使用的一组实验选项。请注意，不保证向后兼容性。 ++ **experimental_config**（*_ExperimentalConfig*）- 由像 Kineto 这样的分析器库使用的一组实验选项。请注意，不保证向后兼容性。 注意 -此API是实验性的，未来可能会更改。 +此 API 是实验性的，未来可能会更改。 -启用形状和堆栈跟踪会导致额外的开销。当指定record_shapes=True时，分析器将暂时保留对张量的引用；这可能进一步阻止依赖引用计数的某些优化，并引入额外的张量副本。 +启用形状和堆栈跟踪会导致额外的开销。当指定 record_shapes=True 时，分析器将暂时保留对张量的引用；这可能进一步阻止依赖引用计数的某些优化，并引入额外的张量副本。 ```py add_metadata(key, value)¶ @@ -50,7 +50,7 @@ add_metadata(key, value)¶ add_metadata_json(key, value)¶ ``` -向跟踪文件中添加具有字符串键和有效json值的用户定义的元数据 +向跟踪文件中添加具有字符串键和有效 json 值的用户定义的元数据 ```py events()¶ @@ -62,21 +62,21 @@ events()¶ export_chrome_trace(path)¶ ``` -以Chrome JSON格式导出收集的跟踪信息。 +以 Chrome JSON 格式导出收集的跟踪信息。 ```py export_memory_timeline(path, device=None)¶ ``` -从收集的树中导出分析器的内存事件信息，用于给定设备，并导出时间线图。使用`export_memory_timeline`有3个可导出的文件，每个文件由`path`的后缀控制。 +从收集的树中导出分析器的内存事件信息，用于给定设备，并导出时间线图。使用`export_memory_timeline`有 3 个可导出的文件，每个文件由`path`的后缀控制。 -+ 要生成HTML兼容的绘图，请使用后缀`.html`，内存时间线图将嵌入到HTML文件中作为PNG文件。 ++ 要生成 HTML 兼容的绘图，请使用后缀`.html`，内存时间线图将嵌入到 HTML 文件中作为 PNG 文件。 -+ 对于由`[times, [sizes by category]]`组成的绘图点，其中`times`是时间戳，`sizes`是每个类别的内存使用量。内存时间线图将保存为JSON（`.json`）或经过gzip压缩的JSON（`.json.gz`），具体取决于后缀。 ++ 对于由`[times, [sizes by category]]`组成的绘图点，其中`times`是时间戳，`sizes`是每个类别的内存使用量。内存时间线图将保存为 JSON（`.json`）或经过 gzip 压缩的 JSON（`.json.gz`），具体取决于后缀。 + 对于原始内存点，请使用后缀`.raw.json.gz`。每个原始内存事件将包括`(时间戳，操作，字节数，类别)`，其中`操作`是`[PREEXISTING, CREATE, INCREMENT_VERSION, DESTROY]`之一，`类别`是`torch.profiler._memory_profiler.Category`中的枚举之一。 -输出：内存时间线以gzipped JSON、JSON或HTML形式编写。 +输出：内存时间线以 gzipped JSON、JSON 或 HTML 形式编写。 ```py export_stacks(path, metric='self_cpu_time_total')¶ @@ -86,15 +86,15 @@ export_stacks(path, metric='self_cpu_time_total')¶ 参数 -+ **path**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 将堆栈文件保存到此位置； ++ **path**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 将堆栈文件保存到此位置； -+ **metric**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 要使用的度量标准：“self_cpu_time_total”或“self_cuda_time_total” ++ **metric**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 要使用的度量标准：“self_cpu_time_total”或“self_cuda_time_total” 注意 -使用FlameGraph工具的示例： +使用 FlameGraph 工具的示例： -+ git clone [https://github.com/brendangregg/FlameGraph](https://github.com/brendangregg/FlameGraph) ++ git clone [`github.com/brendangregg/FlameGraph`](https://github.com/brendangregg/FlameGraph) + cd FlameGraph @@ -108,7 +108,7 @@ key_averages(group_by_input_shape=False, group_by_stack_n=0)¶ 注意 -要使用形状/堆栈功能，请确保在创建分析器上下文管理器时设置record_shapes/with_stack。 +要使用形状/堆栈功能，请确保在创建分析器上下文管理器时设置 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)¶ @@ -118,35 +118,35 @@ class torch.profiler.profile(*, activities=None, schedule=None, on_trace_ready=N 参数 -+ **activities**（*iterable*）- 用于分析的活动组（CPU，CUDA）列表，支持的值：`torch.profiler.ProfilerActivity.CPU`，`torch.profiler.ProfilerActivity.CUDA`。默认值：ProfilerActivity.CPU和（如果可用）ProfilerActivity.CUDA。 ++ **activities**（*iterable*）- 用于分析的活动组（CPU，CUDA）列表，支持的值：`torch.profiler.ProfilerActivity.CPU`，`torch.profiler.ProfilerActivity.CUDA`。默认值：ProfilerActivity.CPU 和（如果可用）ProfilerActivity.CUDA。 + **schedule**（*Callable*）- 接受步骤（int）作为单个参数并返回指定在每个步骤执行的分析器操作的`ProfilerAction`值的可调用对象。 + **on_trace_ready**（*Callable*）- 在分析期间`schedule`返回`ProfilerAction.RECORD_AND_SAVE`时在每个步骤调用的可调用对象。 -+ **record_shapes**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 保存有关运算符输入形状的信息。 ++ **record_shapes**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 保存有关运算符输入形状的信息。 -+ **profile_memory**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 跟踪张量内存分配/释放。 ++ **profile_memory**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 跟踪张量内存分配/释放。 -+ **with_stack**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 记录操作的源信息（文件和行号）。 ++ **with_stack**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 记录操作的源信息（文件和行号）。 -+ **with_flops**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 使用公式估算特定运算符（矩阵乘法和2D卷积）的FLOPs（浮点运算）。 ++ **with_flops**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 使用公式估算特定运算符（矩阵乘法和 2D 卷积）的 FLOPs（浮点运算）。 -+ **with_modules**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 记录与操作的调用堆栈对应的模块层次结构（包括函数名称）。例如，如果模块A的前向调用模块B的前向，其中包含一个aten::add操作，则aten::add的模块层次结构是A.B。请注意，此支持目前仅适用于TorchScript模型，而不适用于急切模式模型。 ++ **with_modules**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 记录与操作的调用堆栈对应的模块层次结构（包括函数名称）。例如，如果模块 A 的前向调用模块 B 的前向，其中包含一个 aten::add 操作，则 aten::add 的模块层次结构是 A.B。请注意，此支持目前仅适用于 TorchScript 模型，而不适用于急切模式模型。 -+ **experimental_config**（*_ExperimentalConfig*）- 用于Kineto库功能的一组实验选项。请注意，不保证向后兼容性。 ++ **experimental_config**（*_ExperimentalConfig*）- 用于 Kineto 库功能的一组实验选项。请注意，不保证向后兼容性。 -+ **use_cuda**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- ++ **use_cuda**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- - 自1.8.1版本起已弃用：请改用`activities`。 + 自 1.8.1 版本起已弃用：请改用`activities`。 注意 -使用[`schedule()`](#torch.profiler.schedule "torch.profiler.schedule")生成可调度的调度。非默认调度在分析长时间训练作业时很有用，并允许用户在训练过程的不同迭代中获取多个跟踪。默认调度仅在上下文管理器的持续时间内连续记录所有事件。 +使用`schedule()`生成可调度的调度。非默认调度在分析长时间训练作业时很有用，并允许用户在训练过程的不同迭代中获取多个跟踪。默认调度仅在上下文管理器的持续时间内连续记录所有事件。 注意 -使用[`tensorboard_trace_handler()`](#torch.profiler.tensorboard_trace_handler "torch.profiler.tensorboard_trace_handler")生成TensorBoard的结果文件： +使用`tensorboard_trace_handler()`生成 TensorBoard 的结果文件： `on_trace_ready=torch.profiler.tensorboard_trace_handler(dir_name)` @@ -154,11 +154,11 @@ class torch.profiler.profile(*, activities=None, schedule=None, on_trace_ready=N `tensorboard --logdir dir_name` -在TensorBoard中查看结果。有关更多信息，请参阅[PyTorch Profiler TensorBoard插件](https://github.com/pytorch/kineto/tree/master/tb_plugin) +在 TensorBoard 中查看结果。有关更多信息，请参阅[PyTorch Profiler TensorBoard 插件](https://github.com/pytorch/kineto/tree/master/tb_plugin) 注意 -启用形状和堆栈跟踪会导致额外的开销。当指定record_shapes=True时，分析器将暂时保留对张量的引用；这可能进一步阻止依赖引用计数的某些优化，并引入额外的张量副本。 +启用形状和堆栈跟踪会导致额外的开销。当指定 record_shapes=True 时，分析器将暂时保留对张量的引用；这可能进一步阻止依赖引用计数的某些优化，并引入额外的张量副本。 示例： @@ -258,15 +258,15 @@ torch.profiler.schedule(*, wait, warmup, active, repeat=0, skip_first=0)¶ torch.profiler.tensorboard_trace_handler(dir_name, worker_name=None, use_gzip=False)¶ ``` -将跟踪文件输出到`dir_name`目录，然后该目录可以直接作为logdir传递给tensorboard。在分布式场景中，`worker_name`应该对每个worker是唯一的，默认情况下将设置为‘[hostname]_[pid]’。 +将跟踪文件输出到`dir_name`目录，然后该目录可以直接作为 logdir 传递给 tensorboard。在分布式场景中，`worker_name`应该对每个 worker 是唯一的，默认情况下将设置为‘[hostname]_[pid]’。 -## 英特尔仪器和跟踪技术APIs[](#intel-instrumentation-and-tracing-technology-apis "跳转到此标题") +## 英特尔仪器和跟踪技术 APIs[](#intel-instrumentation-and-tracing-technology-apis "跳转到此标题") ```py torch.profiler.itt.is_available()¶ ``` -检查ITT功能是否可用 +检查 ITT 功能是否可用 ```py torch.profiler.itt.mark(msg)¶ @@ -276,7 +276,7 @@ torch.profiler.itt.mark(msg)¶ 参数 -**msg** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 与事件关联的ASCII消息。 +**msg** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 与事件关联的 ASCII 消息。 ```py torch.profiler.itt.range_push(msg)¶ @@ -286,7 +286,7 @@ torch.profiler.itt.range_push(msg)¶ 参数 -**msg** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 与范围关联的ASCII消息 +**msg** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 与范围关联的 ASCII 消息 ```py torch.profiler.itt.range_pop()¶ diff --git a/totrans/doc22_068.md b/totrans/doc22_068.md index 6791d214..e54b6bc4 100644 --- a/totrans/doc22_068.md +++ b/totrans/doc22_068.md @@ -1,10 +1,10 @@ # torch.nn.init -> 原文：[https://pytorch.org/docs/stable/nn.init.html](https://pytorch.org/docs/stable/nn.init.html) +> 原文：[`pytorch.org/docs/stable/nn.init.html`](https://pytorch.org/docs/stable/nn.init.html) 警告 -该模块中的所有函数都旨在用于初始化神经网络参数，因此它们都在[`torch.no_grad()`](generated/torch.no_grad.html#torch.no_grad "torch.no_grad")模式下运行，并且不会被autograd考虑。 +该模块中的所有函数都旨在用于初始化神经网络参数，因此它们都在`torch.no_grad()`模式下运行，并且不会被 autograd 考虑。 ```py torch.nn.init.calculate_gain(nonlinearity, param=None)¶ @@ -21,7 +21,7 @@ torch.nn.init.calculate_gain(nonlinearity, param=None)¶ | Sigmoid | $1$1 | | Tanh | $\frac{5}{3}$35​ | | ReLU | $\sqrt{2}$2​ | -| Leaky Relu | $\sqrt{\frac{2}{1 + \text{negative\_slope}^2}}$1+negative_slope22​​ | +| Leaky Relu | $\sqrt{\frac{2}{1 + \text{negative\_slope}²}}$1+negative_slope22​​ | | SELU | $\frac{3}{4}$43​ | 警告 @@ -30,7 +30,7 @@ torch.nn.init.calculate_gain(nonlinearity, param=None)¶ 参数 -+ **nonlinearity** - 非线性函数（nn.functional名称） ++ **nonlinearity** - 非线性函数（nn.functional 名称） + **param** - 非线性函数的可选参数 @@ -50,17 +50,17 @@ $\mathcal{U}(a, b)$U(a,b). 参数 -+ **张量**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 一个n维torch张量 ++ **张量**（*张量*） - 一个 n 维 torch 张量 -+ **a**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 均匀分布的下界 ++ **a**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 均匀分布的下界 -+ **b**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 均匀分布的上界 ++ **b**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 均匀分布的上界 -+ **generator**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12)")*[*[*Generator*](generated/torch.Generator.html#torch.Generator "torch._C.Generator")*]*) - torch生成器用于采样（默认值：无） ++ **generator**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12)")**[*Generator**]*) - torch 生成器用于采样（默认值：无） 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* 示例 @@ -75,21 +75,21 @@ torch.nn.init.normal_(tensor, mean=0.0, std=1.0, generator=None)¶ 用从正态分布中抽取的值填充输入张量。 -$\mathcal{N}(\text{mean}, \text{std}^2)$N(mean,std2). +$\mathcal{N}(\text{mean}, \text{std}²)$N(mean,std2). 参数 -+ **张量**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 一个n维torch张量 ++ **张量**（*张量*） - 一个 n 维 torch 张量 -+ **mean**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 正态分布的均值 ++ **mean**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 正态分布的均值 -+ **std**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 正态分布的标准差 ++ **std**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 正态分布的标准差 -+ **generator**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12)")*[*[*Generator*](generated/torch.Generator.html#torch.Generator "torch._C.Generator")*]*) - torch生成器用于采样（默认值：无） ++ **generator**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12)")**[*Generator**]*) - torch 生成器用于采样（默认值：无） 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* 示例 @@ -106,13 +106,13 @@ torch.nn.init.constant_(tensor, val)¶ 参数 -+ **张量**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 一个n维torch张量 ++ **张量**（*张量*） - 一个 n 维 torch 张量 -+ **val**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 用于填充张量的值 ++ **val**（[*浮点数*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 用于填充张量的值 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* 示例 @@ -125,15 +125,15 @@ torch.nn.init.constant_(tensor, val)¶ torch.nn.init.ones_(tensor)¶ ``` -用标量值1填充输入张量。 +用标量值 1 填充输入张量。 参数 -**张量**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 一个n维torch张量 +**张量**（*张量*） - 一个 n 维 torch 张量 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* 示例 @@ -146,15 +146,15 @@ torch.nn.init.ones_(tensor)¶ torch.nn.init.zeros_(tensor)¶ ``` -用标量值0填充输入张量。 +用标量值 0 填充输入张量。 参数 -**张量**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")） - 一个n维torch张量 +**张量**（*张量*） - 一个 n 维 torch 张量 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* 示例 @@ -167,13 +167,13 @@ torch.nn.init.zeros_(tensor)¶ torch.nn.init.eye_(tensor)¶ ``` -用单位矩阵填充2维输入张量。 +用单位矩阵填充 2 维输入张量。 在线性层中保留输入的身份，尽可能保留多个输入。 参数 -**tensor** - 一个2维torch.Tensor +**tensor** - 一个 2 维 torch.Tensor 示例 @@ -186,13 +186,13 @@ torch.nn.init.eye_(tensor)¶ torch.nn.init.dirac_(tensor, groups=1)¶ ``` -使用Dirac delta函数填充{3, 4, 5}维度的输入张量。 +使用 Dirac delta 函数填充{3, 4, 5}维度的输入张量。 -在卷积层中保留输入的身份，尽可能保留多个输入通道。如果groups>1，则每组通道都保留身份 +在卷积层中保留输入的身份，尽可能保留多个输入通道。如果 groups>1，则每组通道都保留身份 参数 -+ **tensor** - 一个{3, 4, 5}维度的torch.Tensor ++ **tensor** - 一个{3, 4, 5}维度的 torch.Tensor + **groups**（[*int*](https://docs.python.org/3/library/functions.html#int) *，* 可选）- 卷积层中的组数（默认值：1） @@ -209,25 +209,25 @@ torch.nn.init.dirac_(tensor, groups=1)¶ torch.nn.init.xavier_uniform_(tensor, gain=1.0, generator=None)¶ ``` -使用Xavier均匀分布填充输入张量的值。 +使用 Xavier 均匀分布填充输入张量的值。 该方法在《理解深度前馈神经网络训练困难性》- Glorot, X. & Bengio, Y.（2010）中有描述。生成的张量将从$\mathcal{U}(-a, a)$中采样值，其中 $a = \text{gain} \times \sqrt{\frac{6}{\text{fan\_in} + \text{fan\_out}}}$ -也称为Glorot初始化。 +也称为 Glorot 初始化。 参数 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor)）- 一个n维torch.Tensor ++ **tensor**（*Tensor*）- 一个 n 维 torch.Tensor + **gain**（[*float*](https://docs.python.org/3/library/functions.html#float)）- 可选的缩放因子 -+ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional) *[*[*Generator*](generated/torch.Generator.html#torch.Generator)*]*) - 用于采样的torch生成器（默认值：无） ++ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional) **[*Generator**]*) - 用于采样的 torch 生成器（默认值：无） 返回类型 -[*Tensor*](tensors.html#torch.Tensor) +*Tensor* 示例 @@ -240,25 +240,25 @@ $a = \text{gain} \times \sqrt{\frac{6}{\text{fan\_in} + \text{fan\_out}}}$ torch.nn.init.xavier_normal_(tensor, gain=1.0, generator=None)¶ ``` -使用Xavier正态分布填充输入张量的值。 +使用 Xavier 正态分布填充输入张量的值。 -该方法在《理解深度前馈神经网络训练困难性》- Glorot, X. & Bengio, Y.（2010）中有描述。生成的张量将从$\mathcal{N}(0, \text{std}^2)$中采样值，其中 +该方法在《理解深度前馈神经网络训练困难性》- Glorot, X. & Bengio, Y.（2010）中有描述。生成的张量将从$\mathcal{N}(0, \text{std}²)$中采样值，其中 $\text{std} = \text{gain} \times \sqrt{\frac{2}{\text{fan\_in} + \text{fan\_out}}}$ -也称为Glorot初始化。 +也称为 Glorot 初始化。 参数 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor)）- 一个n维torch.Tensor ++ **tensor**（*Tensor*）- 一个 n 维 torch.Tensor + **gain**（[*float*](https://docs.python.org/3/library/functions.html#float)）- 可选的缩放因子 -+ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional) *[*[*Generator*](generated/torch.Generator.html#torch.Generator)*]*) - 用于采样的torch生成器（默认值：无） ++ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional) **[*Generator**]*) - 用于采样的 torch 生成器（默认值：无） 返回类型 -[*Tensor*](tensors.html#torch.Tensor) +*Tensor* 示例 @@ -271,25 +271,25 @@ $\text{std} = \text{gain} \times \sqrt{\frac{2}{\text{fan\_in} + \text{fan\_out} torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu', generator=None)¶ ``` -使用Kaiming均匀分布填充输入张量的值。 +使用 Kaiming 均匀分布填充输入张量的值。 -该方法在《深入研究整流器：超越ImageNet分类的人类级性能》- He, K.等人（2015）中有描述。生成的张量将从$\mathcal{U}(-\text{bound}, \text{bound})$中采样值，其中 +该方法在《深入研究整流器：超越 ImageNet 分类的人类级性能》- He, K.等人（2015）中有描述。生成的张量将从$\mathcal{U}(-\text{bound}, \text{bound})$中采样值，其中 $\text{bound} = \text{gain} \times \sqrt{\frac{3}{\text{fan\_mode}}}$ -也称为He初始化。 +也称为 He 初始化。 参数 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor)）- 一个n维torch.Tensor ++ **tensor**（*Tensor*）- 一个 n 维 torch.Tensor + **a**（[*float*](https://docs.python.org/3/library/functions.html#float)）- 此层后使用的整流器的负斜率（仅与'leaky_relu'一起使用） + **mode**（[*str*](https://docs.python.org/3/library/stdtypes.html#str)）- 要么'fan_in'（默认），要么'fan_out'。选择'fan_in'保留前向传播中权重方差的幅度。选择'fan_out'保留反向传播中的幅度。 -+ **nonlinearity**（[*str*](https://docs.python.org/3/library/stdtypes.html#str)）- 非线性函数（nn.functional名称），建议仅与'relu'或'leaky_relu'一起使用（默认）。 ++ **nonlinearity**（[*str*](https://docs.python.org/3/library/stdtypes.html#str)）- 非线性函数（nn.functional 名称），建议仅与'relu'或'leaky_relu'一起使用（默认）。 -+ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*Generator*](generated/torch.Generator.html#torch.Generator "torch._C.Generator")*]*) - 用于抽样的torch生成器（默认值：无） ++ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")**[*Generator**]*) - 用于抽样的 torch 生成器（默认值：无） 示例 @@ -302,25 +302,25 @@ $\text{bound} = \text{gain} \times \sqrt{\frac{3}{\text{fan\_mode}}}$ torch.nn.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu', generator=None)¶ ``` -用Kaiming正态分布填充输入张量的值。 +用 Kaiming 正态分布填充输入张量的值。 -该方法在Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification - He, K.等人（2015）中有描述。生成的张量将具有从$\mathcal{N}(0, \text{std}^2)$N(0,std2)中抽样的值，其中 +该方法在 Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification - He, K.等人（2015）中有描述。生成的张量将具有从$\mathcal{N}(0, \text{std}²)$N(0,std2)中抽样的值，其中 $\text{std} = \frac{\text{gain}}{\sqrt{\text{fan\_mode}}}$ std=fan_mode​gain​ -也称为He初始化。 +也称为 He 初始化。 参数 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- 一个n维torch.Tensor ++ **tensor**（*Tensor*）- 一个 n 维 torch.Tensor -+ **a**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 在此层后使用的整流器的负斜率（仅与`'leaky_relu'`一起使用） ++ **a**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 在此层后使用的整流器的负斜率（仅与`'leaky_relu'`一起使用） -+ **mode**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- `'fan_in'`（默认）或`'fan_out'`。选择`'fan_in'`保留前向传播中权重方差的幅度。选择`'fan_out'`保留反向传播中的幅度。 ++ **mode**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- `'fan_in'`（默认）或`'fan_out'`。选择`'fan_in'`保留前向传播中权重方差的幅度。选择`'fan_out'`保留反向传播中的幅度。 -+ **nonlinearity**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 非线性函数（nn.functional名称），建议仅与`'relu'`或`'leaky_relu'`一起使用（默认值）。 ++ **nonlinearity**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 非线性函数（nn.functional 名称），建议仅与`'relu'`或`'leaky_relu'`一起使用（默认值）。 -+ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*Generator*](generated/torch.Generator.html#torch.Generator "torch._C.Generator")*]*) - 用于抽样的torch生成器（默认值：无） ++ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")**[*Generator**]*) - 用于抽样的 torch 生成器（默认值：无） 示例 @@ -335,25 +335,25 @@ torch.nn.init.trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0, generator= 用截断正态分布中抽取的值填充输入张量。 -这些值实际上是从正态分布$\mathcal{N}(\text{mean}, \text{std}^2)$N(mean,std2)中抽取的，超出$[a, b]$[a,b]的值会被重新绘制，直到它们在范围内。用于生成随机值的方法在$a \leq \text{mean} \leq b$时效果最佳。 +这些值实际上是从正态分布$\mathcal{N}(\text{mean}, \text{std}²)$N(mean,std2)中抽取的，超出$[a, b]$[a,b]的值会被重新绘制，直到它们在范围内。用于生成随机值的方法在$a \leq \text{mean} \leq b$时效果最佳。 参数 -+ **tensor**（[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")）- 一个n维torch.Tensor ++ **tensor**（*Tensor*）- 一个 n 维 torch.Tensor -+ **mean**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 正态分布的均值 ++ **mean**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 正态分布的均值 -+ **std**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 正态分布的标准差 ++ **std**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 正态分布的标准差 -+ **a**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 最小截断值 ++ **a**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 最小截断值 -+ **b**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 最大截断值 ++ **b**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 最大截断值 -+ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*Generator*](generated/torch.Generator.html#torch.Generator "torch._C.Generator")*]*) - 用于抽样的torch生成器（默认值：无） ++ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")**[*Generator**]*) - 用于抽样的 torch 生成器（默认值：无） 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* 示例 @@ -368,15 +368,15 @@ torch.nn.init.orthogonal_(tensor, gain=1, generator=None)¶ 用（半）正交矩阵填充输入张量。 -在Exact solutions to the nonlinear dynamics of learning in deep linear neural networks - Saxe, A.等人（2013）中有描述。输入张量必须至少有2个维度，对于超过2个维度的张量，尾部维度会被展平。 +在 Exact solutions to the nonlinear dynamics of learning in deep linear neural networks - Saxe, A.等人（2013）中有描述。输入张量必须至少有 2 个维度，对于超过 2 个维度的张量，尾部维度会被展平。 参数 -+ **tensor** - 一个n维torch.Tensor，其中$n \geq 2$ ++ **tensor** - 一个 n 维 torch.Tensor，其中$n \geq 2$ + **gain** - 可选的缩放因子 -+ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*Generator*](generated/torch.Generator.html#torch.Generator "torch._C.Generator")*]*) - 用于抽样的torch生成器（默认值：无） ++ **generator**（[*Optional*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")**[*Generator**]*) - 用于抽样的 torch 生成器（默认值：无） 示例 @@ -389,19 +389,19 @@ torch.nn.init.orthogonal_(tensor, gain=1, generator=None)¶ torch.nn.init.sparse_(tensor, sparsity, std=0.01, generator=None)¶ ``` -将2D输入张量填充为稀疏矩阵。 +将 2D 输入张量填充为稀疏矩阵。 -非零元素将从正态分布$\mathcal{N}(0, 0.01)$N(0,0.01)中抽取，如Deep learning via Hessian-free optimization - Martens, J.（2010）中所述。 +非零元素将从正态分布$\mathcal{N}(0, 0.01)$N(0,0.01)中抽取，如 Deep learning via Hessian-free optimization - Martens, J.（2010）中所述。 参数 -+ **tensor** - 一个n维torch张量 ++ **tensor** - 一个 n 维 torch 张量 + **sparsity** - 每列中要设置为零的元素比例 + **std** - 用于生成非零值的正态分布的标准差 -+ **generator**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*Generator*](generated/torch.Generator.html#torch.Generator "torch._C.Generator")*]*) - 用于采样的torch生成器（默认值：无） ++ **generator**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")**[*Generator**]*) - 用于采样的 torch 生成器（默认值：无） 示例 diff --git a/totrans/doc22_069.md b/totrans/doc22_069.md index 0c320abb..88300c7b 100644 --- a/totrans/doc22_069.md +++ b/totrans/doc22_069.md @@ -1,10 +1,10 @@ # torch.onnx -> 原文：[https://pytorch.org/docs/stable/onnx.html](https://pytorch.org/docs/stable/onnx.html) +> 原文：[`pytorch.org/docs/stable/onnx.html`](https://pytorch.org/docs/stable/onnx.html) ## 概述 -[Open Neural Network eXchange (ONNX)](https://onnx.ai/) 是表示机器学习模型的开放标准格式。`torch.onnx` 模块从本机 PyTorch [`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module") 模型中捕获计算图，并将其转换为 [ONNX 图](https://github.com/onnx/onnx/blob/main/docs/IR.md)。 +[Open Neural Network eXchange (ONNX)](https://onnx.ai/) 是表示机器学习模型的开放标准格式。`torch.onnx` 模块从本机 PyTorch `torch.nn.Module` 模型中捕获计算图，并将其转换为 [ONNX 图](https://github.com/onnx/onnx/blob/main/docs/IR.md)。 导出的模型可以被支持 ONNX 的许多 [运行时](https://onnx.ai/supported-tools.html#deployModel) 使用，包括微软的 [ONNX Runtime](https://www.onnxruntime.ai)。 @@ -18,13 +18,13 @@ TorchDynamo 引擎被用来钩入 Python 的帧评估 API 并动态重写其字 这种方法的主要优势在于，[FX 图](https://pytorch.org/docs/stable/fx.html) 是通过保留模型的动态特性而不是使用传统的静态追踪技术来捕获的。 -[了解基于 TorchDynamo 的 ONNX 导出器](onnx_dynamo.html) +了解基于 TorchDynamo 的 ONNX 导出器 ## 基于 TorchScript 的 ONNX 导出器[](#torchscript-based-onnx-exporter "跳转到此标题") *基于 TorchScript 的 ONNX 导出器自 PyTorch 1.2.0 起可用* -[TorchScript](https://pytorch.org/docs/stable/jit.html) 被利用来追踪（通过 [`torch.jit.trace()`](generated/torch.jit.trace.html#torch.jit.trace "torch.jit.trace")）模型并捕获静态计算图。 +[TorchScript](https://pytorch.org/docs/stable/jit.html) 被利用来追踪（通过 `torch.jit.trace()`）模型并捕获静态计算图。 因此，生成的图有一些限制： @@ -34,9 +34,9 @@ TorchDynamo 引擎被用来钩入 Python 的帧评估 API 并动态重写其字 + 不真正处理动态输入 -为了支持静态追踪的限制，导出器还支持 TorchScript 脚本化（通过 [`torch.jit.script()`](generated/torch.jit.script.html#torch.jit.script "torch.jit.script")），这增加了对数据相关控制流的支持，例如。然而，TorchScript 本身是 Python 语言的一个子集，因此并不支持 Python 中的所有功能，比如原地操作。 +为了支持静态追踪的限制，导出器还支持 TorchScript 脚本化（通过 `torch.jit.script()`），这增加了对数据相关控制流的支持，例如。然而，TorchScript 本身是 Python 语言的一个子集，因此并不支持 Python 中的所有功能，比如原地操作。 -[了解基于 TorchScript 的 ONNX 导出器](onnx_torchscript.html) +了解基于 TorchScript 的 ONNX 导出器 ## 贡献 / 开发 diff --git a/totrans/doc22_070.md b/totrans/doc22_070.md index a6b63ea5..7cbc3a15 100644 --- a/totrans/doc22_070.md +++ b/totrans/doc22_070.md @@ -1,18 +1,18 @@ # torch.optim -> [https://pytorch.org/docs/stable/optim.html](https://pytorch.org/docs/stable/optim.html) +> [`pytorch.org/docs/stable/optim.html`](https://pytorch.org/docs/stable/optim.html) -[`torch.optim`](#module-torch.optim "torch.optim")是一个实现各种优化算法的包。 +`torch.optim`是一个实现各种优化算法的包。 最常用的方法已经得到支持，接口足够通用，以便将来也可以轻松集成更复杂的方法。 ## 如何使用优化器 -要使用[`torch.optim`](#module-torch.optim "torch.optim")，您必须构建一个优化器对象，该对象将保存当前状态，并根据计算出的梯度更新参数。 +要使用`torch.optim`，您必须构建一个优化器对象，该对象将保存当前状态，并根据计算出的梯度更新参数。 ### 构建它 -要构建一个[`Optimizer`](#torch.optim.Optimizer "torch.optim.Optimizer")，您必须给它一个包含要优化的参数（都应该是`Variable`）的可迭代对象。然后，您可以指定特定于优化器的选项，如学习率、权重衰减等。 +要构建一个`Optimizer`，您必须给它一个包含要优化的参数（都应该是`Variable`）的可迭代对象。然后，您可以指定特定于优化器的选项，如学习率、权重衰减等。 示例： @@ -23,7 +23,7 @@ optimizer = optim.Adam([var1, var2], lr=0.0001) ### 每个参数的选项 -[`Optimizer`](#torch.optim.Optimizer "torch.optim.Optimizer")还支持指定每个参数的选项。为此，不要传递`Variable`的可迭代对象，而是传递一个[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")的可迭代对象。每个字典将定义一个单独的参数组，并应包含一个`params`键，其中包含属于该组的参数列表。其他键应与优化器接受的关键字参数匹配，并将用作该组的优化选项。 +`Optimizer`还支持指定每个参数的选项。为此，不要传递`Variable`的可迭代对象，而是传递一个[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")的可迭代对象。每个字典将定义一个单独的参数组，并应包含一个`params`键，其中包含属于该组的参数列表。其他键应与优化器接受的关键字参数匹配，并将用作该组的优化选项。 注意 @@ -42,7 +42,7 @@ optim.SGD([ ### 执行优化步骤[](#taking-an-optimization-step "Permalink to this heading") -所有优化器都实现了一个[`step()`](generated/torch.optim.Optimizer.step.html#torch.optim.Optimizer.step "torch.optim.Optimizer.step")方法，用于更新参数。它可以以两种方式使用： +所有优化器都实现了一个`step()`方法，用于更新参数。它可以以两种方式使用： #### `optimizer.step()` @@ -61,7 +61,7 @@ for input, target in dataset: #### `optimizer.step(closure)` -一些优化算法，如共轭梯度和LBFGS，需要多次重新评估函数，因此您必须传递一个闭包，允许它们重新计算您的模型。闭包应清除梯度，计算损失并返回它。 +一些优化算法，如共轭梯度和 LBFGS，需要多次重新评估函数，因此您必须传递一个闭包，允许它们重新计算您的模型。闭包应清除梯度，计算损失并返回它。 示例： @@ -90,61 +90,61 @@ class torch.optim.Optimizer(params, defaults)¶ 参数 -+ **params**（*可迭代对象*）- 一个包含[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")或[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")的可迭代对象。指定应该优化哪些张量。 ++ **params**（*可迭代对象*）- 一个包含`torch.Tensor`或[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")的可迭代对象。指定应该优化哪些张量。 + **defaults**（[*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)")*]*) - （字典）：包含优化选项的默认值的字典（当参数组未指定它们时使用）。 -| [`Optimizer.add_param_group`](generated/torch.optim.Optimizer.add_param_group.html#torch.optim.Optimizer.add_param_group "torch.optim.Optimizer.add_param_group") | 向[`Optimizer`](#torch.optim.Optimizer "torch.optim.Optimizer")的param_groups中添加一个参数组。 | +| `Optimizer.add_param_group` | 向`Optimizer`的 param_groups 中添加一个参数组。 | | --- | --- | -| [`Optimizer.load_state_dict`](generated/torch.optim.Optimizer.load_state_dict.html#torch.optim.Optimizer.load_state_dict "torch.optim.Optimizer.load_state_dict") | 加载优化器状态。 | -| [`Optimizer.state_dict`](generated/torch.optim.Optimizer.state_dict.html#torch.optim.Optimizer.state_dict "torch.optim.Optimizer.state_dict") | 返回优化器状态的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12中)")。 | -| [`Optimizer.step`](generated/torch.optim.Optimizer.step.html#torch.optim.Optimizer.step "torch.optim.Optimizer.step") | 执行单个优化步骤（参数更新）。 | -| [`Optimizer.zero_grad`](generated/torch.optim.Optimizer.zero_grad.html#torch.optim.Optimizer.zero_grad "torch.optim.Optimizer.zero_grad") | 重置所有优化过的[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")的梯度。 | +| `Optimizer.load_state_dict` | 加载优化器状态。 | +| `Optimizer.state_dict` | 返回优化器状态的[`dict`](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")。 | +| `Optimizer.step` | 执行单个优化步骤（参数更新）。 | +| `Optimizer.zero_grad` | 重置所有优化过的`torch.Tensor`的梯度。 | ## 算法 -| [`Adadelta`](generated/torch.optim.Adadelta.html#torch.optim.Adadelta "torch.optim.Adadelta") | 实现了Adadelta算法。 | +| `Adadelta` | 实现了 Adadelta 算法。 | | --- | --- | -| [`Adagrad`](generated/torch.optim.Adagrad.html#torch.optim.Adagrad "torch.optim.Adagrad") | 实现了Adagrad算法。 | -| [`Adam`](generated/torch.optim.Adam.html#torch.optim.Adam "torch.optim.Adam") | 实现了Adam算法。 | -| [`AdamW`](generated/torch.optim.AdamW.html#torch.optim.AdamW "torch.optim.AdamW") | 实现了AdamW算法。 | -| [`SparseAdam`](generated/torch.optim.SparseAdam.html#torch.optim.SparseAdam "torch.optim.SparseAdam") | SparseAdam 实现了适用于稀疏梯度的掩码版本的Adam算法。 | -| [`Adamax`](generated/torch.optim.Adamax.html#torch.optim.Adamax "torch.optim.Adamax") | 实现了Adamax算法（基于无穷范数的Adam变体）。 | -| [`ASGD`](generated/torch.optim.ASGD.html#torch.optim.ASGD "torch.optim.ASGD") | 实现了平均随机梯度下降算法。 | -| [`LBFGS`](generated/torch.optim.LBFGS.html#torch.optim.LBFGS "torch.optim.LBFGS") | 实现了L-BFGS算法。 | -| [`NAdam`](generated/torch.optim.NAdam.html#torch.optim.NAdam "torch.optim.NAdam") | 实现了NAdam算法。 | -| [`RAdam`](generated/torch.optim.RAdam.html#torch.optim.RAdam "torch.optim.RAdam") | 实现了RAdam算法。 | -| [`RMSprop`](generated/torch.optim.RMSprop.html#torch.optim.RMSprop "torch.optim.RMSprop") | 实现了RMSprop算法。 | -| [`Rprop`](generated/torch.optim.Rprop.html#torch.optim.Rprop "torch.optim.Rprop") | 实现了弹性反向传播算法。 | -| [`SGD`](generated/torch.optim.SGD.html#torch.optim.SGD "torch.optim.SGD") | 实现了随机梯度下降（可选带有动量）。 | +| `Adagrad` | 实现了 Adagrad 算法。 | +| `Adam` | 实现了 Adam 算法。 | +| `AdamW` | 实现了 AdamW 算法。 | +| `SparseAdam` | SparseAdam 实现了适用于稀疏梯度的掩码版本的 Adam 算法。 | +| `Adamax` | 实现了 Adamax 算法（基于无穷范数的 Adam 变体）。 | +| `ASGD` | 实现了平均随机梯度下降算法。 | +| `LBFGS` | 实现了 L-BFGS 算法。 | +| `NAdam` | 实现了 NAdam 算法。 | +| `RAdam` | 实现了 RAdam 算法。 | +| `RMSprop` | 实现了 RMSprop 算法。 | +| `Rprop` | 实现了弹性反向传播算法。 | +| `SGD` | 实现了随机梯度下降（可选带有动量）。 | 我们的许多算法都有各种实现，针对性能、可读性和/或通用性进行了优化，因此如果用户没有指定特定的实现，我们会尝试默认选择当前设备上通常最快的实现。 -我们有3个主要类别的实现：for循环、foreach（多张量）和融合。最直接的实现是对参数进行for循环，并进行大量计算。for循环通常比我们的foreach实现慢，后者将参数组合成多个张量，并一次性运行大量计算，从而节省许多顺序内核调用。我们的一些优化器甚至有更快的融合实现，将大量计算融合成一个内核。我们可以将foreach实现看作是在水平方向融合，将融合实现看作是在此基础上在垂直方向融合。 +我们有 3 个主要类别的实现：for 循环、foreach（多张量）和融合。最直接的实现是对参数进行 for 循环，并进行大量计算。for 循环通常比我们的 foreach 实现慢，后者将参数组合成多个张量，并一次性运行大量计算，从而节省许多顺序内核调用。我们的一些优化器甚至有更快的融合实现，将大量计算融合成一个内核。我们可以将 foreach 实现看作是在水平方向融合，将融合实现看作是在此基础上在垂直方向融合。 -一般来说，这3种实现的性能排序是融合 > foreach > for-loop。因此，在适用的情况下，我们默认选择foreach而不是for-loop。适用的意思是foreach实现可用，用户没有指定任何特定于实现的kwargs（例如，融合，foreach，可微分），并且所有张量都是本地的且在CUDA上。请注意，尽管融合应该比foreach更快，但这些实现是较新的，我们希望在完全切换之前给它们更多的时间来烘烤。您可以尝试它们！ +一般来说，这 3 种实现的性能排序是融合 > foreach > for-loop。因此，在适用的情况下，我们默认选择 foreach 而不是 for-loop。适用的意思是 foreach 实现可用，用户没有指定任何特定于实现的 kwargs（例如，融合，foreach，可微分），并且所有张量都是本地的且在 CUDA 上。请注意，尽管融合应该比 foreach 更快，但这些实现是较新的，我们希望在完全切换之前给它们更多的时间来烘烤。您可以尝试它们！ 下面是一个表格，显示了每种算法的可用和默认实现： -| 算法 | 默认 | 有foreach？ | 有融合？ | +| 算法 | 默认 | 有 foreach？ | 有融合？ | | --- | --- | --- | --- | -| [`Adadelta`](generated/torch.optim.Adadelta.html#torch.optim.Adadelta "torch.optim.Adadelta") | foreach | yes | no | -| [`Adagrad`](generated/torch.optim.Adagrad.html#torch.optim.Adagrad "torch.optim.Adagrad") | foreach | yes | no | -| [`Adam`](generated/torch.optim.Adam.html#torch.optim.Adam "torch.optim.Adam") | foreach | yes | yes | -| [`AdamW`](generated/torch.optim.AdamW.html#torch.optim.AdamW "torch.optim.AdamW") | foreach | yes | yes | -| [`SparseAdam`](generated/torch.optim.SparseAdam.html#torch.optim.SparseAdam "torch.optim.SparseAdam") | for-loop | no | no | -| [`Adamax`](generated/torch.optim.Adamax.html#torch.optim.Adamax "torch.optim.Adamax") | foreach | yes | no | -| [`ASGD`](generated/torch.optim.ASGD.html#torch.optim.ASGD "torch.optim.ASGD") | foreach | yes | no | -| [`LBFGS`](generated/torch.optim.LBFGS.html#torch.optim.LBFGS "torch.optim.LBFGS") | for-loop | no | no | -| [`NAdam`](generated/torch.optim.NAdam.html#torch.optim.NAdam "torch.optim.NAdam") | foreach | yes | no | -| [`RAdam`](generated/torch.optim.RAdam.html#torch.optim.RAdam "torch.optim.RAdam") | foreach | yes | no | -| [`RMSprop`](generated/torch.optim.RMSprop.html#torch.optim.RMSprop "torch.optim.RMSprop") | foreach | yes | no | -| [`Rprop`](generated/torch.optim.Rprop.html#torch.optim.Rprop "torch.optim.Rprop") | foreach | yes | no | -| [`SGD`](generated/torch.optim.SGD.html#torch.optim.SGD "torch.optim.SGD") | foreach | yes | no | +| `Adadelta` | foreach | yes | no | +| `Adagrad` | foreach | yes | no | +| `Adam` | foreach | yes | yes | +| `AdamW` | foreach | yes | yes | +| `SparseAdam` | for-loop | no | no | +| `Adamax` | foreach | yes | no | +| `ASGD` | foreach | yes | no | +| `LBFGS` | for-loop | no | no | +| `NAdam` | foreach | yes | no | +| `RAdam` | foreach | yes | no | +| `RMSprop` | foreach | yes | no | +| `Rprop` | foreach | yes | no | +| `SGD` | foreach | yes | no | ## 如何调整学习率[](#how-to-adjust-learning-rate "Permalink to this heading") -[`torch.optim.lr_scheduler`](#module-torch.optim.lr_scheduler "torch.optim.lr_scheduler") 提供了几种根据周期数调整学习率的方法。[`torch.optim.lr_scheduler.ReduceLROnPlateau`](generated/torch.optim.lr_scheduler.ReduceLROnPlateau.html#torch.optim.lr_scheduler.ReduceLROnPlateau "torch.optim.lr_scheduler.ReduceLROnPlateau") 允许根据一些验证测量动态减少学习率。 +`torch.optim.lr_scheduler` 提供了几种根据周期数调整学习率的方法。`torch.optim.lr_scheduler.ReduceLROnPlateau` 允许根据一些验证测量动态减少学习率。 学习率调度应该在优化器更新之后应用；例如，您应该按照以下方式编写代码： @@ -196,65 +196,65 @@ for epoch in range(20): 警告 -在PyTorch 1.1.0之前，预期应在优化器更新之前调用学习率调度器；1.1.0以一种破坏向后兼容的方式改变了这种行为。如果您在优化器更新之前（调用`scheduler.step()`）使用学习率调度器（调用`optimizer.step()`），这将跳过学习率调度表的第一个值。如果您在升级到PyTorch 1.1.0后无法复现结果，请检查是否在错误的时间调用了`scheduler.step()`。 +在 PyTorch 1.1.0 之前，预期应在优化器更新之前调用学习率调度器；1.1.0 以一种破坏向后兼容的方式改变了这种行为。如果您在优化器更新之前（调用`scheduler.step()`）使用学习率调度器（调用`optimizer.step()`），这将跳过学习率调度表的第一个值。如果您在升级到 PyTorch 1.1.0 后无法复现结果，请检查是否在错误的时间调用了`scheduler.step()`。 -| [`lr_scheduler.LambdaLR`](generated/torch.optim.lr_scheduler.LambdaLR.html#torch.optim.lr_scheduler.LambdaLR "torch.optim.lr_scheduler.LambdaLR") | 将每个参数组的学习率设置为初始学习率乘以给定的函数。 | +| `lr_scheduler.LambdaLR` | 将每个参数组的学习率设置为初始学习率乘以给定的函数。 | | --- | --- | -| [`lr_scheduler.MultiplicativeLR`](generated/torch.optim.lr_scheduler.MultiplicativeLR.html#torch.optim.lr_scheduler.MultiplicativeLR "torch.optim.lr_scheduler.MultiplicativeLR") | 将每个参数组的学习率乘以指定函数中给定的因子。 | -| [`lr_scheduler.StepLR`](generated/torch.optim.lr_scheduler.StepLR.html#torch.optim.lr_scheduler.StepLR "torch.optim.lr_scheduler.StepLR") | 每隔step_size个epoch通过gamma减少每个参数组的学习率。 | -| [`lr_scheduler.MultiStepLR`](generated/torch.optim.lr_scheduler.MultiStepLR.html#torch.optim.lr_scheduler.MultiStepLR "torch.optim.lr_scheduler.MultiStepLR") | 当epoch数达到里程碑之一时，通过gamma减少每个参数组的学习率。 | -| [`lr_scheduler.ConstantLR`](generated/torch.optim.lr_scheduler.ConstantLR.html#torch.optim.lr_scheduler.ConstantLR "torch.optim.lr_scheduler.ConstantLR") | 通过一个小的常数因子逐渐减少每个参数组的学习率，直到epoch数达到预定义的里程碑：total_iters。 | -| [`lr_scheduler.LinearLR`](generated/torch.optim.lr_scheduler.LinearLR.html#torch.optim.lr_scheduler.LinearLR "torch.optim.lr_scheduler.LinearLR") | 通过线性改变小的乘法因子逐渐减少每个参数组的学习率，直到epoch数达到预定义的里程碑：total_iters。 | -| [`lr_scheduler.ExponentialLR`](generated/torch.optim.lr_scheduler.ExponentialLR.html#torch.optim.lr_scheduler.ExponentialLR "torch.optim.lr_scheduler.ExponentialLR") | 每个epoch通过gamma减少每个参数组的学习率。 | -| [`lr_scheduler.PolynomialLR`](generated/torch.optim.lr_scheduler.PolynomialLR.html#torch.optim.lr_scheduler.PolynomialLR "torch.optim.lr_scheduler.PolynomialLR") | 使用给定的total_iters中的多项式函数逐渐减少每个参数组的学习率。 | -| [`lr_scheduler.CosineAnnealingLR`](generated/torch.optim.lr_scheduler.CosineAnnealingLR.html#torch.optim.lr_scheduler.CosineAnnealingLR "torch.optim.lr_scheduler.CosineAnnealingLR") | 使用余弦退火调度设置每个参数组的学习率，其中$ \eta_{max} $设置为初始lr，$ T_{cur} $是自上次SGDR重新启动以来的epoch数： | -| [`lr_scheduler.ChainedScheduler`](generated/torch.optim.lr_scheduler.ChainedScheduler.html#torch.optim.lr_scheduler.ChainedScheduler "torch.optim.lr_scheduler.ChainedScheduler") | 链接学习率调度器列表。 | -| [`lr_scheduler.SequentialLR`](generated/torch.optim.lr_scheduler.SequentialLR.html#torch.optim.lr_scheduler.SequentialLR "torch.optim.lr_scheduler.SequentialLR") | 接收预期在优化过程中按顺序调用的调度器列表和提供确切间隔的里程碑点，以反映在给定epoch时应调用哪个调度器。 | -| [`lr_scheduler.ReduceLROnPlateau`](generated/torch.optim.lr_scheduler.ReduceLROnPlateau.html#torch.optim.lr_scheduler.ReduceLROnPlateau "torch.optim.lr_scheduler.ReduceLROnPlateau") | 当指标停止改善时减少学习率。 | -| [`lr_scheduler.CyclicLR`](generated/torch.optim.lr_scheduler.CyclicLR.html#torch.optim.lr_scheduler.CyclicLR "torch.optim.lr_scheduler.CyclicLR") | 根据循环学习率策略（CLR）设置每个参数组的学习率。 | -| [`lr_scheduler.OneCycleLR`](generated/torch.optim.lr_scheduler.OneCycleLR.html#torch.optim.lr_scheduler.OneCycleLR "torch.optim.lr_scheduler.OneCycleLR") | 根据1cycle学习率策略设置每个参数组的学习率。 | -| [`lr_scheduler.CosineAnnealingWarmRestarts`](generated/torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.html#torch.optim.lr_scheduler.CosineAnnealingWarmRestarts "torch.optim.lr_scheduler.CosineAnnealingWarmRestarts") | 使用余弦退火调度设置每个参数组的学习率，其中$\eta_{max}$设置为初始lr，$T_{cur}$是自上次重启以来的时代数，$T_{i}$是SGDR中两次热重启之间的时代数： | +| `lr_scheduler.MultiplicativeLR` | 将每个参数组的学习率乘以指定函数中给定的因子。 | +| `lr_scheduler.StepLR` | 每隔 step_size 个 epoch 通过 gamma 减少每个参数组的学习率。 | +| `lr_scheduler.MultiStepLR` | 当 epoch 数达到里程碑之一时，通过 gamma 减少每个参数组的学习率。 | +| `lr_scheduler.ConstantLR` | 通过一个小的常数因子逐渐减少每个参数组的学习率，直到 epoch 数达到预定义的里程碑：total_iters。 | +| `lr_scheduler.LinearLR` | 通过线性改变小的乘法因子逐渐减少每个参数组的学习率，直到 epoch 数达到预定义的里程碑：total_iters。 | +| `lr_scheduler.ExponentialLR` | 每个 epoch 通过 gamma 减少每个参数组的学习率。 | +| `lr_scheduler.PolynomialLR` | 使用给定的 total_iters 中的多项式函数逐渐减少每个参数组的学习率。 | +| `lr_scheduler.CosineAnnealingLR` | 使用余弦退火调度设置每个参数组的学习率，其中$ \eta_{max} $设置为初始 lr，$ T_{cur} $是自上次 SGDR 重新启动以来的 epoch 数： | +| `lr_scheduler.ChainedScheduler` | 链接学习率调度器列表。 | +| `lr_scheduler.SequentialLR` | 接收预期在优化过程中按顺序调用的调度器列表和提供确切间隔的里程碑点，以反映在给定 epoch 时应调用哪个调度器。 | +| `lr_scheduler.ReduceLROnPlateau` | 当指标停止改善时减少学习率。 | +| `lr_scheduler.CyclicLR` | 根据循环学习率策略（CLR）设置每个参数组的学习率。 | +| `lr_scheduler.OneCycleLR` | 根据 1cycle 学习率策略设置每个参数组的学习率。 | +| `lr_scheduler.CosineAnnealingWarmRestarts` | 使用余弦退火调度设置每个参数组的学习率，其中$\eta_{max}$设置为初始 lr，$T_{cur}$是自上次重启以来的时代数，$T_{i}$是 SGDR 中两次热重启之间的时代数： | -## 权重平均（SWA和EMA）[](#weight-averaging-swa-and-ema "跳转到此标题的永久链接") +## 权重平均（SWA 和 EMA）[](#weight-averaging-swa-and-ema "跳转到此标题的永久链接") -[`torch.optim.swa_utils`](#module-torch.optim.swa_utils "torch.optim.swa_utils")实现了随机权重平均（SWA）和指数移动平均（EMA）。特别是，`torch.optim.swa_utils.AveragedModel`类实现了SWA和EMA模型，`torch.optim.swa_utils.SWALR`实现了SWA学习率调度程序，`torch.optim.swa_utils.update_bn()`是一个实用函数，用于在训练结束时更新SWA/EMA批归一化统计数据。 +`torch.optim.swa_utils`实现了随机权重平均（SWA）和指数移动平均（EMA）。特别是，`torch.optim.swa_utils.AveragedModel`类实现了 SWA 和 EMA 模型，`torch.optim.swa_utils.SWALR`实现了 SWA 学习率调度程序，`torch.optim.swa_utils.update_bn()`是一个实用函数，用于在训练结束时更新 SWA/EMA 批归一化统计数据。 -SWA已经在[Averaging Weights Leads to Wider Optima and Better Generalization](https://arxiv.org/abs/1803.05407)中提出。 +SWA 已经在[Averaging Weights Leads to Wider Optima and Better Generalization](https://arxiv.org/abs/1803.05407)中提出。 -EMA是一种广泛知晓的技术，通过减少所需的权重更新次数来减少训练时间。它是[Polyak平均](https://paperswithcode.com/method/polyak-averaging)的一种变体，但是使用指数权重而不是在迭代中使用相等权重。 +EMA 是一种广泛知晓的技术，通过减少所需的权重更新次数来减少训练时间。它是[Polyak 平均](https://paperswithcode.com/method/polyak-averaging)的一种变体，但是使用指数权重而不是在迭代中使用相等权重。 ### 构建平均模型[](#constructing-averaged-models "跳转到此标题的永久链接") -AveragedModel类用于计算SWA或EMA模型的权重。 +AveragedModel 类用于计算 SWA 或 EMA 模型的权重。 -您可以通过运行以下命令创建一个SWA平均模型： +您可以通过运行以下命令创建一个 SWA 平均模型： ```py >>> averaged_model = AveragedModel(model) ``` -通过指定`multi_avg_fn`参数来构建EMA模型，如下所示： +通过指定`multi_avg_fn`参数来构建 EMA 模型，如下所示： ```py >>> decay = 0.999 >>> averaged_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(decay)) ``` -衰减是一个介于0和1之间的参数，控制平均参数衰减的速度。如果未提供给`get_ema_multi_avg_fn`，则默认值为0.999。 +衰减是一个介于 0 和 1 之间的参数，控制平均参数衰减的速度。如果未提供给`get_ema_multi_avg_fn`，则默认值为 0.999。 -`get_ema_multi_avg_fn`返回一个函数，该函数将以下EMA方程应用于权重： +`get_ema_multi_avg_fn`返回一个函数，该函数将以下 EMA 方程应用于权重： $W^\textrm{EMA}_{t+1} = \alpha W^\textrm{EMA}_{t} + (1 - \alpha) W^\textrm{model}_t$ -其中alpha是EMA衰减。 +其中 alpha 是 EMA 衰减。 -在这里，模型`model`可以是任意[`torch.nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")对象。`averaged_model`将跟踪`model`的参数的运行平均值。要更新这些平均值，您应该在optimizer.step()之后使用`update_parameters()`函数： +在这里，模型`model`可以是任意`torch.nn.Module`对象。`averaged_model`将跟踪`model`的参数的运行平均值。要更新这些平均值，您应该在 optimizer.step()之后使用`update_parameters()`函数： ```py >>> averaged_model.update_parameters(model) ``` -对于SWA和EMA，这个调用通常在optimizer `step()`之后立即执行。在SWA的情况下，通常在训练开始时跳过一些步骤。 +对于 SWA 和 EMA，这个调用通常在 optimizer `step()`之后立即执行。在 SWA 的情况下，通常在训练开始时跳过一些步骤。 ### 自定义平均策略[](#custom-averaging-strategies "跳转到此标题的永久链接") @@ -278,9 +278,9 @@ $W^\textrm{EMA}_{t+1} = \alpha W^\textrm{EMA}_{t} + (1 - \alpha) W^\textrm{model >>> ema_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(0.9)) ``` -### SWA学习率调度[](#swa-learning-rate-schedules "跳转到此标题的永久链接") +### SWA 学习率调度[](#swa-learning-rate-schedules "跳转到此标题的永久链接") -通常，在SWA中，学习率设置为一个较高的恒定值。`SWALR`是一个学习率调度程序，它将学习率退火到一个固定值，然后保持恒定。例如，以下代码创建一个调度程序，它在每个参数组内将学习率从初始值线性退火到0.05，共5个时期： +通常，在 SWA 中，学习率设置为一个较高的恒定值。`SWALR`是一个学习率调度程序，它将学习率退火到一个固定值，然后保持恒定。例如，以下代码创建一个调度程序，它在每个参数组内将学习率从初始值线性退火到 0.05，共 5 个时期： ```py >>> swa_scheduler = torch.optim.swa_utils.SWALR(optimizer, \ @@ -291,7 +291,7 @@ $W^\textrm{EMA}_{t+1} = \alpha W^\textrm{EMA}_{t} + (1 - \alpha) W^\textrm{model ### 处理批归一化[](#taking-care-of-batch-normalization "Permalink to this heading") -`update_bn()`是一个实用函数，允许在训练结束时计算给定数据加载器`loader`上SWA模型的批归一化统计信息： +`update_bn()`是一个实用函数，允许在训练结束时计算给定数据加载器`loader`上 SWA 模型的批归一化统计信息： ```py >>> torch.optim.swa_utils.update_bn(loader, swa_model) @@ -305,7 +305,7 @@ $W^\textrm{EMA}_{t+1} = \alpha W^\textrm{EMA}_{t} + (1 - \alpha) W^\textrm{model ### 将所有内容放在一起：SWA[](#putting-it-all-together-swa "Permalink to this heading") -在下面的示例中，`swa_model`是累积权重平均值的SWA模型。我们总共训练模型300个时期，并切换到SWA学习率计划，并开始在第160个时期收集参数的SWA平均值： +在下面的示例中，`swa_model`是累积权重平均值的 SWA 模型。我们总共训练模型 300 个时期，并切换到 SWA 学习率计划，并开始在第 160 个时期收集参数的 SWA 平均值： ```py >>> loader, optimizer, model, loss_fn = ... @@ -333,7 +333,7 @@ $W^\textrm{EMA}_{t+1} = \alpha W^\textrm{EMA}_{t} + (1 - \alpha) W^\textrm{model ### 将所有内容放在一起：EMA[](#putting-it-all-together-ema "Permalink to this heading") -在下面的示例中，`ema_model`是EMA模型，它累积权重的指数衰减平均值，衰减率为0.999。我们总共训练模型300个时期，并立即开始收集EMA平均值。 +在下面的示例中，`ema_model`是 EMA 模型，它累积权重的指数衰减平均值，衰减率为 0.999。我们总共训练模型 300 个时期，并立即开始收集 EMA 平均值。 ```py >>> loader, optimizer, model, loss_fn = ... diff --git a/totrans/doc22_071.md b/totrans/doc22_071.md index 1442455c..82c55993 100644 --- a/totrans/doc22_071.md +++ b/totrans/doc22_071.md @@ -1,14 +1,14 @@ -# [https://pytorch.org/docs/stable/complex_numbers.html](https://pytorch.org/docs/stable/complex_numbers.html) +# [`pytorch.org/docs/stable/complex_numbers.html`](https://pytorch.org/docs/stable/complex_numbers.html) > 复数 -复数是可以用形式$a + bj$a+bj表示的数，其中a和b是实数，*j*称为虚数单位，满足方程$j^2 = -1$j2=−1。复数在数学和工程中经常出现，特别是在信号处理等主题中。传统上，许多用户和库（例如TorchAudio）通过使用形状为$(..., 2)$(...,2)的浮点张量来处理复数，其中最后一个维度包含实部和虚部值。 +复数是可以用形式$a + bj$a+bj 表示的数，其中 a 和 b 是实数，*j*称为虚数单位，满足方程$j² = -1$j2=−1。复数在数学和工程中经常出现，特别是在信号处理等主题中。传统上，许多用户和库（例如 TorchAudio）通过使用形状为$(..., 2)$(...,2)的浮点张量来处理复数，其中最后一个维度包含实部和虚部值。 -复数dtype的张量在处理复数时提供更自然的用户体验。对复数张量的操作（例如[`torch.mv()`](generated/torch.mv.html#torch.mv "torch.mv")、[`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul")）可能比在模拟它们的浮点张量上的操作更快速、更节省内存。PyTorch中涉及复数的操作经过优化，使用矢量化汇编指令和专门的内核（例如LAPACK、cuBlas）。 +复数 dtype 的张量在处理复数时提供更自然的用户体验。对复数张量的操作（例如`torch.mv()`、`torch.matmul()`）可能比在模拟它们的浮点张量上的操作更快速、更节省内存。PyTorch 中涉及复数的操作经过优化，使用矢量化汇编指令和专门的内核（例如 LAPACK、cuBlas）。 注意 -在[torch.fft模块](https://pytorch.org/docs/stable/fft.html#torch-fft)中的频谱操作支持本机复数张量。 +在[torch.fft 模块](https://pytorch.org/docs/stable/fft.html#torch-fft)中的频谱操作支持本机复数张量。 警告 @@ -16,7 +16,7 @@ ## 创建复数张量 -我们支持两种复数dtype：torch.cfloat和torch.cdouble +我们支持两种复数 dtype：torch.cfloat 和 torch.cdouble ```py >>> x = torch.randn(2,2, dtype=torch.cfloat) @@ -27,13 +27,13 @@ tensor([[-0.4621-0.0303j, -0.2438-0.5874j], 注意 -复数张量的默认dtype由默认浮点dtype确定。如果默认浮点dtype是torch.float64，则推断复数的dtype为torch.complex128，否则假定为torch.complex64。 +复数张量的默认 dtype 由默认浮点 dtype 确定。如果默认浮点 dtype 是 torch.float64，则推断复数的 dtype 为 torch.complex128，否则假定为 torch.complex64。 -除了[`torch.linspace()`](generated/torch.linspace.html#torch.linspace "torch.linspace")、[`torch.logspace()`](generated/torch.logspace.html#torch.logspace "torch.logspace")和[`torch.arange()`](generated/torch.arange.html#torch.arange "torch.arange")之外的所有工厂函数都支持复数张量。 +除了`torch.linspace()`、`torch.logspace()`和`torch.arange()`之外的所有工厂函数都支持复数张量。 ## 从旧表示形式过渡[](#transition-from-the-old-representation "Permalink to this heading") -目前通过使用形状为$(..., 2)$(...,2)的实数张量绕过缺少复数张量的用户可以轻松地在其代码中使用复数张量切换，使用[`torch.view_as_complex()`](generated/torch.view_as_complex.html#torch.view_as_complex "torch.view_as_complex")和[`torch.view_as_real()`](generated/torch.view_as_real.html#torch.view_as_real "torch.view_as_real")。请注意，这些函数不执行任何复制操作，返回输入张量的视图。 +目前通过使用形状为$(..., 2)$(...,2)的实数张量绕过缺少复数张量的用户可以轻松地在其代码中使用复数张量切换，使用`torch.view_as_complex()`和`torch.view_as_real()`。请注意，这些函数不执行任何复制操作，返回输入张量的视图。 ```py >>> x = torch.randn(3, 2) @@ -50,13 +50,13 @@ tensor([[ 0.6125, -0.1681], [-0.0861, -0.7981]]) ``` -## 访问real和imag +## 访问 real 和 imag 可以使用`real`和`imag`访问复数张量的实部和虚部值。 注意 -访问real和imag属性不会分配任何内存，并且对real和imag张量的原位更新将更新原始复数张量。此外，返回的real和imag张量不是连续的。 +访问 real 和 imag 属性不会分配任何内存，并且对 real 和 imag 张量的原位更新将更新原始复数张量。此外，返回的 real 和 imag 张量不是连续的。 ```py >>> y.real @@ -74,7 +74,7 @@ tensor([ 1.2250-0.1681j, -0.7546+1.3487j, -0.1722-0.7981j]) ## 角度和绝对值 -可以使用[`torch.angle()`](generated/torch.angle.html#torch.angle "torch.angle")和[`torch.abs()`](generated/torch.abs.html#torch.abs "torch.abs")计算复数张量的角度和绝对值。 +可以使用`torch.angle()`和`torch.abs()`计算复数张量的角度和绝对值。 ```py >>> x1=torch.tensor([3j, 4+4j]) @@ -86,7 +86,7 @@ tensor([1.5708, 0.7854]) ## 线性代数 -许多线性代数操作，如[`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul")、[`torch.linalg.svd()`](generated/torch.linalg.svd.html#torch.linalg.svd "torch.linalg.svd")、[`torch.linalg.solve()`](generated/torch.linalg.solve.html#torch.linalg.solve "torch.linalg.solve")等，支持复数。如果您想请求我们目前不支持的操作，请[搜索](https://github.com/pytorch/pytorch/issues?q=is%3Aissue+is%3Aopen+complex)是否已经提交了问题，如果没有，请[提交一个](https://github.com/pytorch/pytorch/issues/new/choose)。 +许多线性代数操作，如`torch.matmul()`、`torch.linalg.svd()`、`torch.linalg.solve()`等，支持复数。如果您想请求我们目前不支持的操作，请[搜索](https://github.com/pytorch/pytorch/issues?q=is%3Aissue+is%3Aopen+complex)是否已经提交了问题，如果没有，请[提交一个](https://github.com/pytorch/pytorch/issues/new/choose)。 ## 序列化 @@ -100,7 +100,7 @@ tensor([ 0.6125-0.1681j, -0.3773+1.3487j, -0.0861-0.7981j]) ## 自动求导 -PyTorch支持复杂张量的自动求导。计算的梯度是共轭Wirtinger导数，其负值恰好是梯度下降算法中使用的最陡下降方向。因此，所有现有的优化器都可以直接与复杂参数一起使用。更多详情，请查看说明[复数的自动求导](notes/autograd.html#complex-autograd-doc)。 +PyTorch 支持复杂张量的自动求导。计算的梯度是共轭 Wirtinger 导数，其负值恰好是梯度下降算法中使用的最陡下降方向。因此，所有现有的优化器都可以直接与复杂参数一起使用。更多详情，请查看说明复数的自动求导。 我们不完全支持以下子系统： diff --git a/totrans/doc22_072.md b/totrans/doc22_072.md index a22532c6..f48123a0 100644 --- a/totrans/doc22_072.md +++ b/totrans/doc22_072.md @@ -1,24 +1,24 @@ -# DDP通信钩子 +# DDP 通信钩子 -> 原文：[https://pytorch.org/docs/stable/ddp_comm_hooks.html](https://pytorch.org/docs/stable/ddp_comm_hooks.html) +> 原文：[`pytorch.org/docs/stable/ddp_comm_hooks.html`](https://pytorch.org/docs/stable/ddp_comm_hooks.html) -DDP通信钩子是一个通用接口，通过覆盖[DistributedDataParallel](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.)中的基本allreduce来控制如何在工作进程之间通信梯度。提供了一些内置的通信钩子，用户可以轻松应用其中任何一个来优化通信。此外，该钩子接口还可以支持用户定义的通信策略，以满足更高级的用例需求。 +DDP 通信钩子是一个通用接口，通过覆盖[DistributedDataParallel](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.)中的基本 allreduce 来控制如何在工作进程之间通信梯度。提供了一些内置的通信钩子，用户可以轻松应用其中任何一个来优化通信。此外，该钩子接口还可以支持用户定义的通信策略，以满足更高级的用例需求。 ## 如何使用通信钩子？[](#how-to-use-a-communication-hook "跳转到此标题的永久链接") -要使用通信钩子，用户只需在训练循环之前让DDP模型注册钩子，如下所示。 +要使用通信钩子，用户只需在训练循环之前让 DDP 模型注册钩子，如下所示。 -[`torch.nn.parallel.DistributedDataParallel.register_comm_hook()`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel.register_comm_hook "torch.nn.parallel.DistributedDataParallel.register_comm_hook") +`torch.nn.parallel.DistributedDataParallel.register_comm_hook()` ## 通信钩子操作的是什么？[](#what-does-a-communication-hook-operate-on "跳转到此标题的永久链接") -通信钩子提供了一种灵活的方式来allreduce梯度。因此，它主要在每个副本上的梯度上操作，然后进行allreduce，这些梯度被分桶以增加通信和计算之间的重叠。特别地，[`torch.distributed.GradBucket`](#torch.distributed.GradBucket "torch.distributed.GradBucket")表示要进行allreduce的梯度张量的一个桶。 +通信钩子提供了一种灵活的方式来 allreduce 梯度。因此，它主要在每个副本上的梯度上操作，然后进行 allreduce，这些梯度被分桶以增加通信和计算之间的重叠。特别地，`torch.distributed.GradBucket`表示要进行 allreduce 的梯度张量的一个桶。 ```py class torch.distributed.GradBucket¶ ``` -这个类主要将一个扁平化的梯度张量（由[`buffer()`](#torch.distributed.GradBucket.buffer "torch.distributed.GradBucket.buffer")返回）传递给DDP通信钩子。这个张量可以进一步分解为此桶中每个参数张量的列表（由`get_per_parameter_tensors()`返回），以应用逐层操作。 +这个类主要将一个扁平化的梯度张量（由`buffer()`返回）传递给 DDP 通信钩子。这个张量可以进一步分解为此桶中每个参数张量的列表（由`get_per_parameter_tensors()`返回），以应用逐层操作。 ```py torch.distributed.GradBucket.index(self: torch._C._distributed_c10d.GradBucket) → int¶ @@ -38,7 +38,7 @@ torch.distributed.GradBucket.buffer(self: torch._C._distributed_c10d.GradBucket) 返回值 -一个扁平化的1D `torch.Tensor` 缓冲区，可以进一步分解为此桶中每个参数张量的列表。 +一个扁平化的 1D `torch.Tensor` 缓冲区，可以进一步分解为此桶中每个参数张量的列表。 ```py torch.distributed.GradBucket.gradients(self: torch._C._distributed_c10d.GradBucket) → List[torch.Tensor]¶ @@ -54,7 +54,7 @@ torch.distributed.GradBucket.is_last(self: torch._C._distributed_c10d.GradBucket 返回值 -这个桶是否是迭代中最后一个要进行allreduce的桶。这也意味着这个桶对应于前向传播中的前几层。 +这个桶是否是迭代中最后一个要进行 allreduce 的桶。这也意味着这个桶对应于前向传播中的前几层。 ```py torch.distributed.GradBucket.set_buffer(self: torch._C._distributed_c10d.GradBucket, buffer: torch.Tensor) → None¶ @@ -72,13 +72,13 @@ torch.distributed.GradBucket.parameters(self: torch._C._distributed_c10d.GradBuc ## 默认通信钩子[](#default-communication-hooks "跳转到此标题的永久链接") -默认通信钩子是简单的**无状态**钩子，因此`register_comm_hook`中的输入状态要么是一个进程组，要么是`None`。输入`bucket`是一个[`torch.distributed.GradBucket`](#torch.distributed.GradBucket "torch.distributed.GradBucket")对象。 +默认通信钩子是简单的**无状态**钩子，因此`register_comm_hook`中的输入状态要么是一个进程组，要么是`None`。输入`bucket`是一个`torch.distributed.GradBucket`对象。 ```py torch.distributed.algorithms.ddp_comm_hooks.default_hooks.allreduce_hook(process_group, bucket)¶ ``` -这个DDP通信钩子只是使用`GradBucket`张量调用`allreduce`。一旦梯度张量在所有工作进程中聚合，它的`then`回调会取平均值并返回结果。如果用户注册了这个钩子，DDP的结果预计与未注册钩子的情况相同。因此，这不会改变DDP的行为，用户可以将其用作参考或修改此钩子以记录有用信息或其他目的，同时不影响DDP的行为。 +这个 DDP 通信钩子只是使用`GradBucket`张量调用`allreduce`。一旦梯度张量在所有工作进程中聚合，它的`then`回调会取平均值并返回结果。如果用户注册了这个钩子，DDP 的结果预计与未注册钩子的情况相同。因此，这不会改变 DDP 的行为，用户可以将其用作参考或修改此钩子以记录有用信息或其他目的，同时不影响 DDP 的行为。 示例:: @@ -88,13 +88,13 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.allreduce_hook(process 返回类型 -[*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")] +*Future*[*Tensor*] ```py torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook(process_group, bucket)¶ ``` -这个DDP通信钩子实现了一种简单的梯度压缩方法，将`GradBucket`张量转换为半精度浮点格式（`torch.float16`），然后将其除以进程组大小。它对这些`float16`梯度张量进行全局归约。一旦压缩的梯度张量全部归约，链式回调`decompress`将其转换回输入数据类型（如`float32`）。 +这个 DDP 通信钩子实现了一种简单的梯度压缩方法，将`GradBucket`张量转换为半精度浮点格式（`torch.float16`），然后将其除以进程组大小。它对这些`float16`梯度张量进行全局归约。一旦压缩的梯度张量全部归约，链式回调`decompress`将其转换回输入数据类型（如`float32`）。 示例:: @@ -104,15 +104,15 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook(pro 返回类型 -[*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")] +*Future*[*Tensor*] ```py torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook(process_group, bucket)¶ ``` -警告：此API是实验性的，需要NCCL版本高于2.9.6。 +警告：此 API 是实验性的，需要 NCCL 版本高于 2.9.6。 -这个DDP通信钩子实现了一种简单的梯度压缩方法，将`GradBucket`张量转换为半精度[Brain浮点格式](https://en.wikipedia.org/wiki/Bfloat16_floating-point_format) (`torch.bfloat16`)，然后将其除以进程组大小。它对这些`bfloat16`梯度张量进行全局归约。一旦压缩的梯度张量全部归约，链式回调`decompress`将其转换回输入数据类型（如`float32`）。 +这个 DDP 通信钩子实现了一种简单的梯度压缩方法，将`GradBucket`张量转换为半精度[Brain 浮点格式](https://en.wikipedia.org/wiki/Bfloat16_floating-point_format) (`torch.bfloat16`)，然后将其除以进程组大小。它对这些`bfloat16`梯度张量进行全局归约。一旦压缩的梯度张量全部归约，链式回调`decompress`将其转换回输入数据类型（如`float32`）。 示例:: @@ -122,15 +122,15 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook(pro 返回类型 -[*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")] +*Future*[*Tensor*] -此外，提供了一个通信钩子包装器，支持[`fp16_compress_hook()`](#torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook "torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook")或[`bf16_compress_hook()`](#torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook "torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook")作为一个包装器，可以与其他通信钩子组合使用。 +此外，提供了一个通信钩子包装器，支持`fp16_compress_hook()`或`bf16_compress_hook()`作为一个包装器，可以与其他通信钩子组合使用。 ```py torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_wrapper(hook)¶ ``` -这个包装器将给定DDP通信钩子的输入梯度张量转换为半精度浮点格式（`torch.float16`），并将给定钩子的结果张量转换回输入数据类型，如`float32`。 +这个包装器将给定 DDP 通信钩子的输入梯度张量转换为半精度浮点格式（`torch.float16`），并将给定钩子的结果张量转换回输入数据类型，如`float32`。 因此，`fp16_compress_hook`等同于`fp16_compress_wrapper(allreduce_hook)`。 @@ -143,15 +143,15 @@ 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*](#torch.distributed.GradBucket "torch._C._distributed_c10d.GradBucket")], [*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")]] +[*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)¶ ``` -警告：此API是实验性的，需要NCCL版本高于2.9.6。 +警告：此 API 是实验性的，需要 NCCL 版本高于 2.9.6。 -这个包装器将给定DDP通信钩子的输入梯度张量转换为半精度Brain浮点格式 `_（`torch.bfloat16`），并将给定钩子的结果张量转换回输入数据类型，如`float32`。 +这个包装器将给定 DDP 通信钩子的输入梯度张量转换为半精度 Brain 浮点格式 `_（`torch.bfloat16`），并将给定钩子的结果张量转换回输入数据类型，如`float32`。 因此，`bf16_compress_hook`等同于`bf16_compress_wrapper(allreduce_hook)`。 @@ -164,13 +164,13 @@ torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_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*](#torch.distributed.GradBucket "torch._C._distributed_c10d.GradBucket")], [*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")]] +[*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*]] -## PowerSGD通信钩子[](#powersgd-communication-hook "跳转到此标题") +## PowerSGD 通信钩子[](#powersgd-communication-hook "跳转到此标题") -PowerSGD（[Vogels等人，NeurIPS 2019](https://arxiv.org/abs/1905.13727)）是一种梯度压缩算法，可以提供非常高的压缩率，并加速带宽受限的分布式训练。该算法需要维护一些超参数和内部状态。因此，PowerSGD通信钩子是一个**有状态**的钩子，用户需要提供以下定义的状态对象。 +PowerSGD（[Vogels 等人，NeurIPS 2019](https://arxiv.org/abs/1905.13727)）是一种梯度压缩算法，可以提供非常高的压缩率，并加速带宽受限的分布式训练。该算法需要维护一些超参数和内部状态。因此，PowerSGD 通信钩子是一个**有状态**的钩子，用户需要提供以下定义的状态对象。 -### PowerSGD状态 +### 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)¶ @@ -210,49 +210,49 @@ PowerSGD 通常需要额外的内存，大小与模型梯度相同，以启用 警告 -PowerSGD钩子可能与[Apex自动混合精度包](https://github.com/NVIDIA/apex)冲突。请改用PyTorch的[本机自动混合精度包](https://pytorch.org/docs/stable/amp.html)。 +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)¶ ``` -这个DDP通信钩子实现了[论文](https://arxiv.org/abs/1905.13727)中描述的PowerSGD梯度压缩算法。一旦梯度张量在所有工作节点上聚合，此钩子将按以下方式应用压缩： +这个 DDP 通信钩子实现了[论文](https://arxiv.org/abs/1905.13727)中描述的 PowerSGD 梯度压缩算法。一旦梯度张量在所有工作节点上聚合，此钩子将按以下方式应用压缩： -1. 将输入扁平化的1D梯度张量视为每个参数张量的列表，并将所有张量分为两组： +1. 将输入扁平化的 1D 梯度张量视为每个参数张量的列表，并将所有张量分为两组： - > 1.1 应在allreduce之前压缩的张量，因为压缩可以在带宽上节省足够的空间。 + > 1.1 应在 allreduce 之前压缩的张量，因为压缩可以在带宽上节省足够的空间。 > - > 1.2 其余张量将直接进行allreduce而不进行压缩，包括所有的向量张量（用于偏置）。 + > 1.2 其余张量将直接进行 allreduce 而不进行压缩，包括所有的向量张量（用于偏置）。 1. 处理未压缩的张量： - > 2.1\. 为这些未压缩的张量分配连续内存，并将所有未压缩的张量作为一个批次进行allreduce，不进行压缩； + > 2.1\. 为这些未压缩的张量分配连续内存，并将所有未压缩的张量作为一个批次进行 allreduce，不进行压缩； > > 2.2\. 将单个未压缩的张量从连续内存复制回输入张量。 -1. 处理应通过PowerSGD压缩进行压缩的张量： +1. 处理应通过 PowerSGD 压缩进行压缩的张量： - > 3.1\. 对于每个张量M，创建两个低秩张量P和Q来分解M，使得M = PQ^T，其中Q从标准正态分布初始化并正交化； + > 3.1\. 对于每个张量 M，创建两个低秩张量 P 和 Q 来分解 M，使得 M = PQ^T，其中 Q 从标准正态分布初始化并正交化； > - > 3.2\. 计算Ps中的每个P，等于MQ； + > 3.2\. 计算 Ps 中的每个 P，等于 MQ； > - > 3.3\. 将Ps作为一个批次进行allreduce； + > 3.3\. 将 Ps 作为一个批次进行 allreduce； > - > 3.4\. 对Ps中的每个P进行正交化； + > 3.4\. 对 Ps 中的每个 P 进行正交化； > - > 3.5\. 计算Qs中的每个Q，大致等于M^TP； + > 3.5\. 计算 Qs 中的每个 Q，大致等于 M^TP； > - > 3.6\. 所有的Q作为一个批次进行allreduce； + > 3.6\. 所有的 Q 作为一个批次进行 allreduce； > - > 3.7\. 计算所有压缩张量中的每个M，大致等于PQ^T。 + > 3.7\. 计算所有压缩张量中的每个 M，大致等于 PQ^T。 -请注意，此通信钩子在前`state.start_powerSGD_iter`次迭代中强制使用普通allreduce。这不仅使用户能够更好地控制速度和准确性之间的权衡，还有助于将DDP的内部优化复杂性抽象化为未来通信钩子开发者。 +请注意，此通信钩子在前`state.start_powerSGD_iter`次迭代中强制使用普通 allreduce。这不仅使用户能够更好地控制速度和准确性之间的权衡，还有助于将 DDP 的内部优化复杂性抽象化为未来通信钩子开发者。 参数 -+ **state**（[*PowerSGDState*](#torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState "torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState")）- 用于配置压缩率和支持错误反馈、热启动等的状态信息。要调整压缩配置，主要需要调整`matrix_approximation_rank`、`start_powerSGD_iter`和`min_compression_rate`。 ++ **state**（*PowerSGDState*）- 用于配置压缩率和支持错误反馈、热启动等的状态信息。要调整压缩配置，主要需要调整`matrix_approximation_rank`、`start_powerSGD_iter`和`min_compression_rate`。 -+ **bucket**（*dist.GradBucket*）- 存储批处理多个每个变量张量的扁平化梯度张量的桶。请注意，由于DDP通信钩子仅支持单进程单设备模式，因此此桶中仅存储一个张量。 ++ **bucket**（*dist.GradBucket*）- 存储批处理多个每个变量张量的扁平化梯度张量的桶。请注意，由于 DDP 通信钩子仅支持单进程单设备模式，因此此桶中仅存储一个张量。 返回 @@ -260,7 +260,7 @@ torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook(state, b 返回类型 -[*未来*](futures.html#torch.futures.Future "torch.jit.Future")[[*张量*](tensors.html#torch.Tensor "torch.Tensor")] +*未来*[*张量*] 示例:: @@ -274,39 +274,39 @@ torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook(state, b torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook(state, bucket)¶ ``` -这个DDP通信钩子实现了一个简化的PowerSGD梯度压缩算法，描述在[论文](https://arxiv.org/abs/1905.13727)中。这个变体不是逐层压缩梯度，而是压缩批处理所有梯度的扁平输入张量。因此，它比[`powerSGD_hook()`](#torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook "torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook")**更快**，但通常会导致**更低的准确性**，除非`matrix_approximation_rank`为1。 +这个 DDP 通信钩子实现了一个简化的 PowerSGD 梯度压缩算法，描述在[论文](https://arxiv.org/abs/1905.13727)中。这个变体不是逐层压缩梯度，而是压缩批处理所有梯度的扁平输入张量。因此，它比`powerSGD_hook()`**更快**，但通常会导致**更低的准确性**，除非`matrix_approximation_rank`为 1。 警告 -在这里增加`matrix_approximation_rank`可能不一定会增加准确性，因为对于没有列/行对齐的每个参数张量进行批处理可能会破坏低秩结构。因此，用户应始终首先考虑[`powerSGD_hook()`](#torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook "torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook")，仅在`matrix_approximation_rank`为1时可以实现令人满意的准确性时才考虑此变体。 +在这里增加`matrix_approximation_rank`可能不一定会增加准确性，因为对于没有列/行对齐的每个参数张量进行批处理可能会破坏低秩结构。因此，用户应始终首先考虑`powerSGD_hook()`，仅在`matrix_approximation_rank`为 1 时可以实现令人满意的准确性时才考虑此变体。 一旦梯度张量在所有工作进程中聚合，此挂钩将应用压缩如下： -1. 将输入扁平化的1D梯度张量视为带有0填充的方形张量M; +1. 将输入扁平化的 1D 梯度张量视为带有 0 填充的方形张量 M; -1. 创建两个低秩张量P和Q以分解M，使得M = PQ^T，其中Q从标准正态分布初始化并正交化; +1. 创建两个低秩张量 P 和 Q 以分解 M，使得 M = PQ^T，其中 Q 从标准正态分布初始化并正交化; -1. 计算P，它等于MQ； +1. 计算 P，它等于 MQ； -1. 全局归约P; +1. 全局归约 P; -1. 正交化P; +1. 正交化 P; -1. 计算Q，它大约等于M^TP; +1. 计算 Q，它大约等于 M^TP; -1. 全局归约Q; +1. 全局归约 Q; -1. 计算M，它大约等于PQ^T。 +1. 计算 M，它大约等于 PQ^T。 1. 将输入张量截断到原始长度。 -请注意，此通信挂钩在前`state.start_powerSGD_iter`次迭代中强制执行基本全局归约。这不仅使用户能够更好地控制速度和准确性之间的权衡，还有助于为未来通信挂钩开发人员抽象出DDP内部优化的一些复杂性。 +请注意，此通信挂钩在前`state.start_powerSGD_iter`次迭代中强制执行基本全局归约。这不仅使用户能够更好地控制速度和准确性之间的权衡，还有助于为未来通信挂钩开发人员抽象出 DDP 内部优化的一些复杂性。 参数 -+ **state** ([*PowerSGDState*](#torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState "torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState")) – 用于配置压缩率和支持错误反馈、热启动等的状态信息。要调整压缩配置，主要需要调整`matrix_approximation_rank`和`start_powerSGD_iter`。 ++ **state** (*PowerSGDState*) – 用于配置压缩率和支持错误反馈、热启动等的状态信息。要调整压缩配置，主要需要调整`matrix_approximation_rank`和`start_powerSGD_iter`。 -+ **bucket** (*dist.GradBucket*) – 存储批处理多个每个变量张量的扁平化梯度张量的桶。请注意，由于DDP通信挂钩仅支持单进程单设备模式，因此此桶中仅存储一个张量。 ++ **bucket** (*dist.GradBucket*) – 存储批处理多个每个变量张量的扁平化梯度张量的桶。请注意，由于 DDP 通信挂钩仅支持单进程单设备模式，因此此桶中仅存储一个张量。 返回 @@ -314,7 +314,7 @@ torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook( 返回类型 -[*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")] +*Future*[*Tensor*] 示例:: @@ -335,9 +335,9 @@ torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook( torch.distributed.algorithms.ddp_comm_hooks.debugging_hooks.noop_hook(_, bucket)¶ ``` -此DDP通信挂钩返回一个包装输入的未来，因此它是一个不会产生任何通信开销的空操作。 +此 DDP 通信挂钩返回一个包装输入的未来，因此它是一个不会产生任何通信开销的空操作。 -此挂钩应**仅**用于全局归约优化的headroom分析，而不是正常的梯度同步。例如，如果在注册此挂钩后只能观察到训练时间少于10%的加速，通常意味着对于这种情况，全局归约不是性能瓶颈。如果GPU跟踪不能轻松检索或跟踪分析受到某些因素的复杂影响，例如全局归约和计算之间的重叠或跨等级的不同步，这种仪器化可能特别有用。 +此挂钩应**仅**用于全局归约优化的 headroom 分析，而不是正常的梯度同步。例如，如果在注册此挂钩后只能观察到训练时间少于 10%的加速，通常意味着对于这种情况，全局归约不是性能瓶颈。如果 GPU 跟踪不能轻松检索或跟踪分析受到某些因素的复杂影响，例如全局归约和计算之间的重叠或跨等级的不同步，这种仪器化可能特别有用。 示例:: @@ -347,7 +347,7 @@ torch.distributed.algorithms.ddp_comm_hooks.debugging_hooks.noop_hook(_, bucket) 返回类型 -[*Future*](futures.html#torch.futures.Future "torch.jit.Future")[[*Tensor*](tensors.html#torch.Tensor "torch.Tensor")] +*Future*[*Tensor*] ## 通信挂钩的检查点[](#checkpointing-of-communication-hooks "跳转到此标题") @@ -361,7 +361,7 @@ torch.distributed.algorithms.ddp_comm_hooks.debugging_hooks.noop_hook(_, bucket) `__setstate__`应正确初始化非可序列化属性，从提供的`state`中排除。 -[`PowerSGDState`](#torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState "torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState")已实现`__setstate__`和`__getstate__`，可用作参考。 +`PowerSGDState`已实现`__setstate__`和`__getstate__`，可用作参考。 ```py class torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState @@ -371,7 +371,7 @@ class torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState __getstate__()¶ ``` -返回一个`Dict[str, Any]`，将被pickle化并保存。`process_group`不可序列化并从返回的状态中排除。 +返回一个`Dict[str, Any]`，将被 pickle 化并保存。`process_group`不可序列化并从返回的状态中排除。 ```py __setstate__(state)¶ @@ -379,7 +379,7 @@ __setstate__(state)¶ 接受一个提供的`state`并检索`PowerSGDState`。`process_group`设置为默认值。 -这里是一个简单的端到端示例，演示了如何保存和重新加载PowerSGD状态和钩子。 +这里是一个简单的端到端示例，演示了如何保存和重新加载 PowerSGD 状态和钩子。 ```py import os @@ -468,4 +468,4 @@ if __name__ == "__main__": ## 致谢 -非常感谢PowerSGD论文作者**Thijs Vogels**对PowerSGD通信钩子的代码审查，以及[比较实验](https://observablehq.com/@tvogels/powersgd-benchmark)，显示PowerSGD通信钩子的性能与原始[论文](https://arxiv.org/abs/1905.13727)中的实现相当。 +非常感谢 PowerSGD 论文作者**Thijs Vogels**对 PowerSGD 通信钩子的代码审查，以及[比较实验](https://observablehq.com/@tvogels/powersgd-benchmark)，显示 PowerSGD 通信钩子的性能与原始[论文](https://arxiv.org/abs/1905.13727)中的实现相当。 diff --git a/totrans/doc22_073.md b/totrans/doc22_073.md index d6f96fb7..50833d24 100644 --- a/totrans/doc22_073.md +++ b/totrans/doc22_073.md @@ -1,62 +1,62 @@ # 管道并行 -> 原文：[https://pytorch.org/docs/stable/pipeline.html](https://pytorch.org/docs/stable/pipeline.html) +> 原文：[`pytorch.org/docs/stable/pipeline.html`](https://pytorch.org/docs/stable/pipeline.html) -管道并行最初在[Gpipe](https://arxiv.org/abs/1811.06965)论文中提出，并且是一种有效的技术，用于在多个GPU上训练大型模型。 +管道并行最初在[Gpipe](https://arxiv.org/abs/1811.06965)论文中提出，并且是一种有效的技术，用于在多个 GPU 上训练大型模型。 警告 管道并行是实验性的，可能会发生变化。 -## 使用多个GPU的模型并行[](#model-parallelism-using-multiple-gpus "此标题的永久链接") +## 使用多个 GPU 的模型并行[](#model-parallelism-using-multiple-gpus "此标题的永久链接") -通常对于无法放入单个GPU的大型模型，会采用模型并行，其中模型的某些部分被放置在不同的GPU上。然而，如果对于顺序模型进行简单划分，训练过程会因GPU的低利用率而受到影响，因为如下图所示，一次只有一个GPU处于活动状态： +通常对于无法放入单个 GPU 的大型模型，会采用模型并行，其中模型的某些部分被放置在不同的 GPU 上。然而，如果对于顺序模型进行简单划分，训练过程会因 GPU 的低利用率而受到影响，因为如下图所示，一次只有一个 GPU 处于活动状态： -![_images/no_pipe.png](../Images/b9cf9a633037f50f7bc1ebee273078d5.png) +![_images/no_pipe.png](img/b9cf9a633037f50f7bc1ebee273078d5.png) -该图表示一个具有4层的模型，这些层分布在4个不同的GPU上（垂直轴）。水平轴表示通过时间训练该模型，演示了每次只有1个GPU被利用（[图片来源](https://arxiv.org/abs/1811.06965)）。[](#id2 "此图片的永久链接") +该图表示一个具有 4 层的模型，这些层分布在 4 个不同的 GPU 上（垂直轴）。水平轴表示通过时间训练该模型，演示了每次只有 1 个 GPU 被利用（[图片来源](https://arxiv.org/abs/1811.06965)）。[](#id2 "此图片的永久链接") ## 管道化执行 -为了缓解这个问题，管道并行将输入的小批量数据分成多个微批量数据，并将这些微批量数据的执行在多个GPU上进行管道化。如下图所示： +为了缓解这个问题，管道并行将输入的小批量数据分成多个微批量数据，并将这些微批量数据的执行在多个 GPU 上进行管道化。如下图所示： -![_images/pipe.png](../Images/ef057fe1265f513c363e3e4cdc5a1cf7.png) +![_images/pipe.png](img/ef057fe1265f513c363e3e4cdc5a1cf7.png) -该图表示一个具有4层的模型，这些层分布在4个不同的GPU上（垂直轴）。水平轴表示通过时间训练该模型，演示了GPU的利用效率更高。然而，仍然存在一个气泡（如图所示），其中某些GPU未被利用。([图片来源](https://arxiv.org/abs/1811.06965)).[](#id3 "此图片的永久链接") +该图表示一个具有 4 层的模型，这些层分布在 4 个不同的 GPU 上（垂直轴）。水平轴表示通过时间训练该模型，演示了 GPU 的利用效率更高。然而，仍然存在一个气泡（如图所示），其中某些 GPU 未被利用。([图片来源](https://arxiv.org/abs/1811.06965)).[](#id3 "此图片的永久链接") -## PyTorch中的Pipe API +## PyTorch 中的 Pipe API ```py class torch.distributed.pipeline.sync.Pipe(module, chunks=1, checkpoint='except_last', deferred_batch_norm=False)¶ ``` -将任意[`nn.Sequential`](generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")模块包装起来，以便使用同步管道并行训练。如果模块需要大量内存且无法放入单个GPU中，则管道并行是一种有用的训练技术。 +将任意`nn.Sequential`模块包装起来，以便使用同步管道并行训练。如果模块需要大量内存且无法放入单个 GPU 中，则管道并行是一种有用的训练技术。 该实现基于[torchgpipe](https://arxiv.org/abs/2004.09910)论文。 -Pipe将管道并行与检查点结合起来，以减少训练所需的峰值内存，同时最大程度地减少设备的低利用率。 +Pipe 将管道并行与检查点结合起来，以减少训练所需的峰值内存，同时最大程度地减少设备的低利用率。 -您应该将所有模块放在适当的设备上，并将它们包装成一个[`nn.Sequential`](generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")模块，定义所需的执行顺序。如果一个模块不包含任何参数/缓冲区，则假定该模块应在CPU上执行，并且在执行之前，将模块的适当输入张量移动到CPU。此行为可以通过`WithDevice`包装器覆盖，该包装器可用于明确指定模块应在哪个设备上运行。 +您应该将所有模块放在适当的设备上，并将它们包装成一个`nn.Sequential`模块，定义所需的执行顺序。如果一个模块不包含任何参数/缓冲区，则假定该模块应在 CPU 上执行，并且在执行之前，将模块的适当输入张量移动到 CPU。此行为可以通过`WithDevice`包装器覆盖，该包装器可用于明确指定模块应在哪个设备上运行。 参数 -+ **module**（[`nn.Sequential`](generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")）- 要使用管道并行化的顺序模块。序列中的每个模块都必须将其所有参数放在单个设备上。序列中的每个模块都必须是nn.Module或[`nn.Sequential`](generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")（用于在单个设备上组合多个顺序模块） ++ **module**（`nn.Sequential`）- 要使用管道并行化的顺序模块。序列中的每个模块都必须将其所有参数放在单个设备上。序列中的每个模块都必须是 nn.Module 或`nn.Sequential`（用于在单个设备上组合多个顺序模块） -+ **chunks**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 微批量的数量（默认值：`1`） ++ **chunks**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- 微批量的数量（默认值：`1`） -+ **checkpoint**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 何时启用检查点，可以是`'always'`、`'except_last'`或`'never'`之一（默认值：`'except_last'`）。`'never'`完全禁用检查点，`'except_last'`对除最后一个微批量之外的所有微批量启用检查点，`'always'`对所有微批量启用检查点。 ++ **checkpoint**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 何时启用检查点，可以是`'always'`、`'except_last'`或`'never'`之一（默认值：`'except_last'`）。`'never'`完全禁用检查点，`'except_last'`对除最后一个微批量之外的所有微批量启用检查点，`'always'`对所有微批量启用检查点。 -+ **deferred_batch_norm** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")) – 是否使用延迟的`BatchNorm`移动统计信息（默认值：[`False`](https://docs.python.org/3/library/constants.html#False "(在Python v3.12中)")). 如果设置为[`True`](https://docs.python.org/3/library/constants.html#True "(在Python v3.12中)"), 我们跟踪跨多个微批次的统计信息，以更新每个小批次的运行统计信息。 ++ **deferred_batch_norm** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 是否使用延迟的`BatchNorm`移动统计信息（默认值：[`False`](https://docs.python.org/3/library/constants.html#False "(在 Python v3.12 中)")). 如果设置为[`True`](https://docs.python.org/3/library/constants.html#True "(在 Python v3.12 中)"), 我们跟踪跨多个微批次的统计信息，以更新每个小批次的运行统计信息。 引发 -+ [**TypeError**](https://docs.python.org/3/library/exceptions.html#TypeError "(在Python v3.12中)") – 模块不是[`nn.Sequential`](generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")。 ++ [**TypeError**](https://docs.python.org/3/library/exceptions.html#TypeError "(在 Python v3.12 中)") – 模块不是`nn.Sequential`。 -+ [**ValueError**](https://docs.python.org/3/library/exceptions.html#ValueError "(在Python v3.12中)") – 无效参数 ++ [**ValueError**](https://docs.python.org/3/library/exceptions.html#ValueError "(在 Python v3.12 中)") – 无效参数 示例:: -跨GPU 0和1的两个FC层的管道。 +跨 GPU 0 和 1 的两个 FC 层的管道。 ```py >>> # Need to initialize RPC framework first. @@ -75,27 +75,27 @@ Pipe将管道并行与检查点结合起来，以减少训练所需的峰值内 注意 -您可以使用[`torch.nn.parallel.DistributedDataParallel`](generated/torch.nn.parallel.DistributedDataParallel.html#torch.nn.parallel.DistributedDataParallel "torch.nn.parallel.DistributedDataParallel")将[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe")模型包装起来，只有当[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe")的检查点参数为`'never'`时才能这样做。 +您可以使用`torch.nn.parallel.DistributedDataParallel`将`Pipe`模型包装起来，只有当`Pipe`的检查点参数为`'never'`时才能这样做。 注意 -[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe")目前仅支持节点内流水线处理，但将来将扩展为支持节点间流水线处理。前向函数返回一个`RRef`，以便将来进行节点间流水线处理，其中输出可能位于远程主机上。对于节点内流水线处理，您可以使用`local_value()`在本地检索输出。 +`Pipe`目前仅支持节点内流水线处理，但将来将扩展为支持节点间流水线处理。前向函数返回一个`RRef`，以便将来进行节点间流水线处理，其中输出可能位于远程主机上。对于节点内流水线处理，您可以使用`local_value()`在本地检索输出。 警告 -[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe")是实验性的，可能会发生变化。 +`Pipe`是实验性的，可能会发生变化。 ```py forward(*inputs)¶ ``` -通过管道处理单个输入小批次并返回指向输出的`RRef`。[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe")是一个相当透明的模块包装器。它不修改底层模块的输入和输出签名。但有类型限制。输入和输出必须至少包含一个张量。此限制也适用于分区边界。 +通过管道处理单个输入小批次并返回指向输出的`RRef`。`Pipe`是一个相当透明的模块包装器。它不修改底层模块的输入和输出签名。但有类型限制。输入和输出必须至少包含一个张量。此限制也适用于分区边界。 输入序列被馈送到管道的第一个阶段作为`*inputs`。因此，此函数的位置参数应与管道第一个阶段的位置参数匹配。对于管道的一个阶段的输出作为下一个阶段的输入也适用相同条件。 -根据用于初始化[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe")的`chunks`参数，将输入张量分成多个微批次。假定批量大小是张量的第一个维度，如果批量大小小于`chunks`，则微批次的数量等于批量大小。 +根据用于初始化`Pipe`的`chunks`参数，将输入张量分成多个微批次。假定批量大小是张量的第一个维度，如果批量大小小于`chunks`，则微批次的数量等于批量大小。 -只有张量会被分成多个微批次，非张量输入只会在每个微批次中按原样复制。对于管道的最后阶段中的非张量输出，它们将作为`List`聚合并返回给用户。例如，如果有2个微批次返回整数5，则用户将收到[5, 5]的合并输出 +只有张量会被分成多个微批次，非张量输入只会在每个微批次中按原样复制。对于管道的最后阶段中的非张量输出，它们将作为`List`聚合并返回给用户。例如，如果有 2 个微批次返回整数 5，则用户将收到[5, 5]的合并输出 所有输入张量都需要与管道的第一个分区位于同一设备上。 @@ -111,7 +111,7 @@ forward(*inputs)¶ 引发 -[**TypeError**](https://docs.python.org/3/library/exceptions.html#TypeError "(在Python v3.12中)") – 输入不包含至少一个张量 +[**TypeError**](https://docs.python.org/3/library/exceptions.html#TypeError "(在 Python v3.12 中)") – 输入不包含至少一个张量 返回类型 @@ -125,9 +125,9 @@ forward(*inputs)¶ torch.distributed.pipeline.sync.skip.skippable.skippable(stash=(), pop=())¶ ``` -定义一个装饰器来创建带有跳过连接的[`nn.Module`](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")。 +定义一个装饰器来创建带有跳过连接的`nn.Module`。 -这些装饰模块称为“可跳过的”。即使模块没有被[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe") 包装，此功能也能正常工作。 +这些装饰模块称为“可跳过的”。即使模块没有被`Pipe` 包装，此功能也能正常工作。 每个跳过张量都由其名称管理。在操作跳过张量之前，可跳过模块必须通过存储和/或弹出参数静态声明跳过张量的名称。具有预先声明名称的跳过张量可以通过 `yield stash(name, tensor)` 存储或通过 `tensor = yield pop(name)` 弹出。 @@ -165,11 +165,11 @@ class StashStashPop(nn.Module): return input + carol ``` -每个跳过张量必须与一对存储和弹出完全关联。[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe") 在包装模块时会自动检查此限制。您还可以通过[`verify_skippables()`](#torch.distributed.pipeline.sync.skip.skippable.verify_skippables "torch.distributed.pipeline.sync.skip.skippable.verify_skippables") 而不使用[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe") 来检查此限制。 +每个跳过张量必须与一对存储和弹出完全关联。`Pipe` 在包装模块时会自动检查此限制。您还可以通过`verify_skippables()` 而不使用`Pipe` 来检查此限制。 返回类型 -[*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*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")]], [*Type*](https://docs.python.org/3/library/typing.html#typing.Type "(在 Python v3.12 中)")[*Skippable*]] +[*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)¶ @@ -187,7 +187,7 @@ def forward(self, input): + **name** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 跳过张量的名称 -+ **input** ([*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor") *或* *None*) – 传递给跳过连接的张量 ++ **input** (*torch.Tensor* *或* *None*) – 传递给跳过连接的张量 ```py class torch.distributed.pipeline.sync.skip.skippable.pop(name)¶ @@ -221,7 +221,7 @@ torch.distributed.pipeline.sync.skip.skippable.verify_skippables(module)¶ 每个跳过张量必须只有一对存储和弹出。如果有一个或多个不匹配的对，它将引发[`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError "(在 Python v3.12 中)") 并附带详细消息。 -以下是一些失败案例。[`verify_skippables()`](#torch.distributed.pipeline.sync.skip.skippable.verify_skippables "torch.distributed.pipeline.sync.skip.skippable.verify_skippables") 将报告这些案例的失败： +以下是一些失败案例。`verify_skippables()` 将报告这些案例的失败： ```py # Layer1 stashes "1to3". @@ -248,12 +248,12 @@ nn.Sequential(Layer1(), Layer1(), Layer2(), Layer3()) ## 教程 -以下教程提供了如何使用[`Pipe`](#torch.distributed.pipeline.sync.Pipe "torch.distributed.pipeline.sync.Pipe") API 来训练模型以及 PyTorch 提供的其他组件的概述： +以下教程提供了如何使用`Pipe` API 来训练模型以及 PyTorch 提供的其他组件的概述： + [使用管道并行训练 Transformer 模型](https://pytorch.org/tutorials/intermediate/pipeline_tutorial.html) -+ [使用分布式数据并行和管道并行训练Transformer模型](https://pytorch.org/tutorials/advanced/ddp_pipeline.html) ++ [使用分布式数据并行和管道并行训练 Transformer 模型](https://pytorch.org/tutorials/advanced/ddp_pipeline.html) ## 致谢 -管道并行实现基于[fairscale的管道实现](https://github.com/facebookresearch/fairscale/tree/main/fairscale/nn/pipe)和[torchgpipe](https://github.com/kakaobrain/torchgpipe)。我们要感谢两个团队对于他们在将管道并行引入PyTorch方面的贡献和指导。 +管道并行实现基于[fairscale 的管道实现](https://github.com/facebookresearch/fairscale/tree/main/fairscale/nn/pipe)和[torchgpipe](https://github.com/kakaobrain/torchgpipe)。我们要感谢两个团队对于他们在将管道并行引入 PyTorch 方面的贡献和指导。 diff --git a/totrans/doc22_074.md b/totrans/doc22_074.md index 45d7a21c..42a2cffa 100644 --- a/totrans/doc22_074.md +++ b/totrans/doc22_074.md @@ -1,6 +1,6 @@ # 量化 -> 原文：[https://pytorch.org/docs/stable/quantization.html](https://pytorch.org/docs/stable/quantization.html) +> 原文：[`pytorch.org/docs/stable/quantization.html`](https://pytorch.org/docs/stable/quantization.html) 警告 @@ -8,36 +8,36 @@ ## 量化简介[](#introduction-to-quantization "跳转到此标题的永久链接") -量化是指在执行计算和存储张量时使用比浮点精度更低的比特宽度的技术。量化模型在张量上执行一些或所有操作时，使用降低的精度而不是完整精度（浮点）值。这样可以实现更紧凑的模型表示，并在许多硬件平台上使用高性能的矢量化操作。PyTorch支持INT8量化，相比典型的FP32模型，可以将模型大小减小4倍，内存带宽需求减小4倍。与FP32计算相比，硬件对INT8计算的支持通常快2到4倍。量化主要是一种加速推断的技术，只支持量化操作符的前向传播。 +量化是指在执行计算和存储张量时使用比浮点精度更低的比特宽度的技术。量化模型在张量上执行一些或所有操作时，使用降低的精度而不是完整精度（浮点）值。这样可以实现更紧凑的模型表示，并在许多硬件平台上使用高性能的矢量化操作。PyTorch 支持 INT8 量化，相比典型的 FP32 模型，可以将模型大小减小 4 倍，内存带宽需求减小 4 倍。与 FP32 计算相比，硬件对 INT8 计算的支持通常快 2 到 4 倍。量化主要是一种加速推断的技术，只支持量化操作符的前向传播。 -PyTorch支持多种量化深度学习模型的方法。在大多数情况下，模型在FP32中训练，然后将模型转换为INT8。此外，PyTorch还支持量化感知训练，该训练模型在前向和后向传递中使用伪量化模块模拟量化误差。请注意，整个计算过程都是在浮点数中进行的。在量化感知训练结束时，PyTorch提供转换函数将训练好的模型转换为较低精度。 +PyTorch 支持多种量化深度学习模型的方法。在大多数情况下，模型在 FP32 中训练，然后将模型转换为 INT8。此外，PyTorch 还支持量化感知训练，该训练模型在前向和后向传递中使用伪量化模块模拟量化误差。请注意，整个计算过程都是在浮点数中进行的。在量化感知训练结束时，PyTorch 提供转换函数将训练好的模型转换为较低精度。 -在较低级别，PyTorch提供了一种表示量化张量并对其进行操作的方法。它们可以用于直接构建在较低精度中执行全部或部分计算的模型。还提供了更高级别的API，其中包含将FP32模型转换为较低精度的典型工作流程，以最小化精度损失。 +在较低级别，PyTorch 提供了一种表示量化张量并对其进行操作的方法。它们可以用于直接构建在较低精度中执行全部或部分计算的模型。还提供了更高级别的 API，其中包含将 FP32 模型转换为较低精度的典型工作流程，以最小化精度损失。 -## 量化API摘要 +## 量化 API 摘要 -PyTorch提供三种不同的量化模式：Eager模式量化，FX图模式量化（维护）和PyTorch 2导出量化。 +PyTorch 提供三种不同的量化模式：Eager 模式量化，FX 图模式量化（维护）和 PyTorch 2 导出量化。 -Eager模式量化是一个测试功能。用户需要手动进行融合并指定量化和去量化发生的位置，它只支持模块而不支持功能。 +Eager 模式量化是一个测试功能。用户需要手动进行融合并指定量化和去量化发生的位置，它只支持模块而不支持功能。 -FX图模式量化是PyTorch中的自动量化工作流程，目前是一个原型功能，自从我们有了PyTorch 2导出量化以来，它处于维护模式。它通过添加对功能的支持和自动化量化过程来改进Eager模式量化，尽管人们可能需要重构模型以使其与FX图模式量化兼容（使用`torch.fx`进行符号跟踪）。请注意，FX图模式量化不适用于任意模型，因为模型可能无法进行符号跟踪，我们将把它集成到领域库中，如torchvision，用户将能够使用FX图模式量化对支持的领域库中的模型进行量化。对于任意模型，我们将提供一般性指导，但要使其正常工作，用户可能需要熟悉`torch.fx`，特别是如何使模型进行符号跟踪。 +FX 图模式量化是 PyTorch 中的自动量化工作流程，目前是一个原型功能，自从我们有了 PyTorch 2 导出量化以来，它处于维护模式。它通过添加对功能的支持和自动化量化过程来改进 Eager 模式量化，尽管人们可能需要重构模型以使其与 FX 图模式量化兼容（使用`torch.fx`进行符号跟踪）。请注意，FX 图模式量化不适用于任意模型，因为模型可能无法进行符号跟踪，我们将把它集成到领域库中，如 torchvision，用户将能够使用 FX 图模式量化对支持的领域库中的模型进行量化。对于任意模型，我们将提供一般性指导，但要使其正常工作，用户可能需要熟悉`torch.fx`，特别是如何使模型进行符号跟踪。 -PyTorch 2导出量化是新的完整图模式量化工作流程，作为PyTorch 2.1原型功能发布。随着PyTorch 2的推出，我们正在转向更好的解决方案，用于完整程序捕获（torch.export），因为与FX图模式量化使用的程序捕获解决方案（torch.fx.symbolic_trace）相比，它可以捕获更高比例（14K模型上的88.8%比14K模型上的72.7%）。torch.export仍然存在一些限制，涉及到一些Python结构，并需要用户参与以支持导出模型中的动态性，但总体而言，它是对以前的程序捕获解决方案的改进。PyTorch 2导出量化是为torch.export捕获的模型构建的，考虑到建模用户和后端开发人员的灵活性和生产力。其主要特点是（1）可编程API，用于配置如何对模型进行量化，可以扩展到更多用例（2）简化的用户体验，用于建模用户和后端开发人员，因为他们只需要与一个对象（量化器）交互，表达用户关于如何量化模型以及后端支持的意图（3）可选的参考量化模型表示，可以用整数操作表示量化计算，更接近硬件中实际发生的量化计算。 +PyTorch 2 导出量化是新的完整图模式量化工作流程，作为 PyTorch 2.1 原型功能发布。随着 PyTorch 2 的推出，我们正在转向更好的解决方案，用于完整程序捕获（torch.export），因为与 FX 图模式量化使用的程序捕获解决方案（torch.fx.symbolic_trace）相比，它可以捕获更高比例（14K 模型上的 88.8%比 14K 模型上的 72.7%）。torch.export 仍然存在一些限制，涉及到一些 Python 结构，并需要用户参与以支持导出模型中的动态性，但总体而言，它是对以前的程序捕获解决方案的改进。PyTorch 2 导出量化是为 torch.export 捕获的模型构建的，考虑到建模用户和后端开发人员的灵活性和生产力。其主要特点是（1）可编程 API，用于配置如何对模型进行量化，可以扩展到更多用例（2）简化的用户体验，用于建模用户和后端开发人员，因为他们只需要与一个对象（量化器）交互，表达用户关于如何量化模型以及后端支持的意图（3）可选的参考量化模型表示，可以用整数操作表示量化计算，更接近硬件中实际发生的量化计算。 -鼓励新用户首先尝试PyTorch 2导出量化，如果效果不佳，用户可以尝试急切模式量化。 +鼓励新用户首先尝试 PyTorch 2 导出量化，如果效果不佳，用户可以尝试急切模式量化。 -以下表格比较了急切模式量化、FX图模式量化和PyTorch 2导出量化之间的区别： +以下表格比较了急切模式量化、FX 图模式量化和 PyTorch 2 导出量化之间的区别： -| | 急切模式量化 | FX图模式量化 | PyTorch 2导出量化 | +| | 急切模式量化 | FX 图模式量化 | PyTorch 2 导出量化 | | --- | --- | --- | --- | | 发布状态 | beta | 原型（维护） | 原型 | | 运算符融合 | 手动 | 自动 | 自动 | | 量化/去量化放置 | 手动 | 自动 | 自动 | | 量化模块 | 支持 | 支持 | 支持 | -| 量化功能/Torch操作 | 手动 | 自动 | 支持 | +| 量化功能/Torch 操作 | 手动 | 自动 | 支持 | | 自定义支持 | 有限支持 | 完全支持 | 完全支持 | | 量化模式支持 | 训练后量化：静态、动态、仅权重量化感知训练：静态 | 训练后量化：静态、动态、仅权重量化感知训练：静态 | 由后端特定量化器定义 | -| 输入/输出模型类型 | `torch.nn.Module` | `torch.nn.Module`（可能需要一些重构以使模型与FX图模式量化兼容） | `torch.fx.GraphModule`（由`torch.export`捕获） | +| 输入/输出模型类型 | `torch.nn.Module` | `torch.nn.Module`（可能需要一些重构以使模型与 FX 图模式量化兼容） | `torch.fx.GraphModule`（由`torch.export`捕获） | 支持三种类型的量化： @@ -47,7 +47,7 @@ PyTorch 2导出量化是新的完整图模式量化工作流程，作为PyTorch 1. 静态量化感知训练（权重量化，激活量化，训练期间建模量化数值） -请查看我们的[PyTorch量化介绍](https://pytorch.org/blog/introduction-to-quantization-on-pytorch/)博客文章，了解这些量化类型之间的权衡更全面的概述。 +请查看我们的[PyTorch 量化介绍](https://pytorch.org/blog/introduction-to-quantization-on-pytorch/)博客文章，了解这些量化类型之间的权衡更全面的概述。 动态量化和静态量化的运算符覆盖范围不同，详见下表。 @@ -56,18 +56,18 @@ PyTorch 2导出量化是新的完整图模式量化工作流程，作为PyTorch | nn.Linearnn.Conv1d/2d/3d | YY | YN | | nn.LSTMnn.GRU | Y（通过自定义模块）N | YY | | nn.RNNCellnn.GRUCellnn.LSTMCell | NNN | YYY | -| nn.EmbeddingBag | Y（激活为fp32） | Y | +| nn.EmbeddingBag | Y（激活为 fp32） | Y | | nn.Embedding | Y | Y | | nn.MultiheadAttention | Y（通过自定义模块） | 不支持 | -| 激活 | 广泛支持 | 保持不变，计算保持在fp32中 | +| 激活 | 广泛支持 | 保持不变，计算保持在 fp32 中 | ### 急切模式量化 -有关量化流程的一般介绍，包括不同类型的量化，请参阅[一般量化流程](#general-quantization-flow)。 +有关量化流程的一般介绍，包括不同类型的量化，请参阅一般量化流程。 #### 训练后动态量化[](#post-training-dynamic-quantization "跳转到此标题") -这是最简单的量化形式，其中权重在预先量化，但激活在推断期间动态量化。这适用于模型执行时间主要由从内存加载权重而不是计算矩阵乘法所主导的情况。这对于批量大小较小的LSTM和Transformer类型模型是真实的。 +这是最简单的量化形式，其中权重在预先量化，但激活在推断期间动态量化。这适用于模型执行时间主要由从内存加载权重而不是计算矩阵乘法所主导的情况。这对于批量大小较小的 LSTM 和 Transformer 类型模型是真实的。 图表： @@ -85,7 +85,7 @@ previous_layer_fp32 -- linear_int8_w_fp32_inp -- activation_fp32 -- next_layer_f linear_weight_int8 ``` -PTDQ API示例: +PTDQ API 示例: ```py import torch @@ -117,9 +117,9 @@ res = model_int8(input_fp32) #### 后训练静态量化[](#post-training-static-quantization "跳转到此标题") -后训练静态量化（PTQ静态）量化模型的权重和激活。它将激活融合到可能的前置层中。它需要使用代表性数据集进行校准，以确定激活的最佳量化参数。后训练静态量化通常用于CNN是典型用例的情况下，其中内存带宽和计算节省都很重要。 +后训练静态量化（PTQ 静态）量化模型的权重和激活。它将激活融合到可能的前置层中。它需要使用代表性数据集进行校准，以确定激活的最佳量化参数。后训练静态量化通常用于 CNN 是典型用例的情况下，其中内存带宽和计算节省都很重要。 -在应用后训练静态量化之前，我们可能需要修改模型。请参阅[急切模式静态量化的模型准备](#model-preparation-for-eager-mode-static-quantization)。 +在应用后训练静态量化之前，我们可能需要修改模型。请参阅急切模式静态量化的模型准备。 图表： @@ -137,7 +137,7 @@ previous_layer_int8 -- linear_with_activation_int8 -- next_layer_int8 linear_weight_int8 ``` -PTSQ API示例： +PTSQ API 示例： ```py import torch @@ -208,9 +208,9 @@ res = model_int8(input_fp32) #### 静态量化的量化感知训练[](#quantization-aware-training-for-static-quantization "跳转到此标题") -量化感知训练（QAT）在训练期间模拟量化的效果，从而使准确性比其他量化方法更高。我们可以对静态、动态或仅权重量化进行QAT。在训练期间，所有计算都是在浮点数中进行的，通过fake_quant模块模拟量化的效果，通过夹紧和四舍五入来模拟INT8的效果。在模型转换后，权重和激活被量化，并且激活被融合到可能的前置层中。它通常与CNN一起使用，并且与静态量化相比，准确性更高。 +量化感知训练（QAT）在训练期间模拟量化的效果，从而使准确性比其他量化方法更高。我们可以对静态、动态或仅权重量化进行 QAT。在训练期间，所有计算都是在浮点数中进行的，通过 fake_quant 模块模拟量化的效果，通过夹紧和四舍五入来模拟 INT8 的效果。在模型转换后，权重和激活被量化，并且激活被融合到可能的前置层中。它通常与 CNN 一起使用，并且与静态量化相比，准确性更高。 -在应用后训练静态量化之前，我们可能需要修改模型。请参阅[急切模式静态量化的模型准备](#model-preparation-for-eager-mode-static-quantization)。 +在应用后训练静态量化之前，我们可能需要修改模型。请参阅急切模式静态量化的模型准备。 图表： @@ -233,7 +233,7 @@ previous_layer_int8 -- linear_with_activation_int8 -- next_layer_int8 linear_weight_int8 ``` -QAT API示例： +QAT API 示例： ```py import torch @@ -298,7 +298,7 @@ model_int8 = torch.ao.quantization.convert(model_fp32_prepared) res = model_int8(input_fp32) ``` -要了解更多关于量化感知训练，请参阅[QAT教程](https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html)。 +要了解更多关于量化感知训练，请参阅[QAT 教程](https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html)。 #### 急切模式静态量化的模型准备[](#model-preparation-for-eager-mode-static-quantization "跳转到此标题") @@ -306,21 +306,21 @@ res = model_int8(input_fp32) 1. 将需要输出重新量化的操作（因此具有额外参数）从功能形式转换为模块形式（例如，使用`torch.nn.ReLU`而不是`torch.nn.functional.relu`）。 -1. 指定模型的哪些部分需要量化，可以通过在子模块上分配`.qconfig`属性或通过指定`qconfig_mapping`来实现。例如，设置`model.conv1.qconfig = None`意味着`model.conv`层不会被量化，设置`model.linear1.qconfig = custom_qconfig`意味着`model.linear1`的量化设置将使用`custom_qconfig`而不是全局qconfig。 +1. 指定模型的哪些部分需要量化，可以通过在子模块上分配`.qconfig`属性或通过指定`qconfig_mapping`来实现。例如，设置`model.conv1.qconfig = None`意味着`model.conv`层不会被量化，设置`model.linear1.qconfig = custom_qconfig`意味着`model.linear1`的量化设置将使用`custom_qconfig`而不是全局 qconfig。 对于量化激活的静态量化技术，用户需要额外执行以下操作： -1. 指定激活量化和去量化的位置。这是使用[`QuantStub`](generated/torch.ao.quantization.QuantStub.html#torch.ao.quantization.QuantStub“torch.ao.quantization.QuantStub”)和[`DeQuantStub`](generated/torch.ao.quantization.DeQuantStub.html#torch.ao.quantization.DeQuantStub“torch.ao.quantization.DeQuantStub”)模块完成的。 +1. 指定激活量化和去量化的位置。这是使用`QuantStub`和`DeQuantStub`模块完成的。 -1. 使用[`FloatFunctional`](generated/torch.ao.nn.quantized.FloatFunctional.html#torch.ao.nn.quantized.FloatFunctional“torch.ao.nn.quantized.FloatFunctional”)将需要特殊处理以进行量化的张量操作包装成模块。例如，需要特殊处理以确定输出量化参数的操作如`add`和`cat`。 +1. 使用`FloatFunctional`将需要特殊处理以进行量化的张量操作包装成模块。例如，需要特殊处理以确定输出量化参数的操作如`add`和`cat`。 -1. 融合模块：将操作/模块组合成单个模块以获得更高的准确性和性能。这是使用[`fuse_modules()`](generated/torch.ao.quantization.fuse_modules.fuse_modules.html#torch.ao.quantization.fuse_modules.fuse_modules“torch.ao.quantization.fuse_modules.fuse_modules”)API完成的，该API接受要融合的模块列表。我们目前支持以下融合：[Conv, Relu]，[Conv, BatchNorm]，[Conv, BatchNorm, Relu]，[Linear, Relu] +1. 融合模块：将操作/模块组合成单个模块以获得更高的准确性和性能。这是使用`fuse_modules()`API 完成的，该 API 接受要融合的模块列表。我们目前支持以下融合：[Conv, Relu]，[Conv, BatchNorm]，[Conv, BatchNorm, Relu]，[Linear, Relu] -### （原型-维护模式）FX图模式量化[]（＃prototype-maintaince-mode-fx-graph-mode-quantization“跳转到此标题”） +### （原型-维护模式）FX 图模式量化[]（＃prototype-maintaince-mode-fx-graph-mode-quantization“跳转到此标题”） -后训练量化中有多种量化类型（仅权重、动态和静态），配置通过qconfig_mapping（prepare_fx函数的参数）完成。 +后训练量化中有多种量化类型（仅权重、动态和静态），配置通过 qconfig_mapping（prepare_fx 函数的参数）完成。 -FXPTQ API示例： +FXPTQ API 示例： ```py import torch @@ -383,17 +383,17 @@ model_to_quantize = copy.deepcopy(model_fp) model_fused = quantize_fx.fuse_fx(model_to_quantize) ``` -请按照以下教程了解有关FX图模式量化的更多信息： +请按照以下教程了解有关 FX 图模式量化的更多信息： -+ [使用FX图模式量化的用户指南](https://pytorch.org/tutorials/prototype/fx_graph_mode_quant_guide.html) ++ [使用 FX 图模式量化的用户指南](https://pytorch.org/tutorials/prototype/fx_graph_mode_quant_guide.html) -+ [FX图模式后训练静态量化](https://pytorch.org/tutorials/prototype/fx_graph_mode_ptq_static.html) ++ [FX 图模式后训练静态量化](https://pytorch.org/tutorials/prototype/fx_graph_mode_ptq_static.html) -+ [FX图模式后训练动态量化](https://pytorch.org/tutorials/prototype/fx_graph_mode_ptq_dynamic.html) ++ [FX 图模式后训练动态量化](https://pytorch.org/tutorials/prototype/fx_graph_mode_ptq_dynamic.html) -### （原型）PyTorch 2导出量化[]（＃prototype-pytorch-2-export-quantization“跳转到此标题”） +### （原型）PyTorch 2 导出量化[]（＃prototype-pytorch-2-export-quantization“跳转到此标题”） -API示例： +API 示例： ```py import torch @@ -444,19 +444,19 @@ m = convert_pt2e(m) # lower to target backend ``` -请按照以下教程开始PyTorch 2导出量化： +请按照以下教程开始 PyTorch 2 导出量化： 建模用户： -+ [PyTorch 2导出后训练量化](https://pytorch.org/tutorials/prototype/pt2e_quant_ptq.html) ++ [PyTorch 2 导出后训练量化](https://pytorch.org/tutorials/prototype/pt2e_quant_ptq.html) -+ [通过电感器在X86后端进行PyTorch 2导出后训练量化](https://pytorch.org/tutorials/prototype/pt2e_quant_ptq_x86_inductor.html) ++ [通过电感器在 X86 后端进行 PyTorch 2 导出后训练量化](https://pytorch.org/tutorials/prototype/pt2e_quant_ptq_x86_inductor.html) -+ [PyTorch 2导出量化感知训练](https://pytorch.org/tutorials/prototype/pt2e_quant_qat.html) ++ [PyTorch 2 导出量化感知训练](https://pytorch.org/tutorials/prototype/pt2e_quant_qat.html) 后端开发人员（请查看所有建模用户文档）： -+ [如何为PyTorch 2导出量化器编写量化器](https://pytorch.org/tutorials/prototype/pt2e_quantizer.html) ++ [如何为 PyTorch 2 导出量化器编写量化器](https://pytorch.org/tutorials/prototype/pt2e_quantizer.html) ## 量化堆栈 @@ -466,9 +466,9 @@ m = convert_pt2e(m) #### 量化张量 -为了在PyTorch中进行量化，我们需要能够在张量中表示量化数据。量化张量允许存储量化数据（表示为int8/uint8/int32）以及量化参数，如比例和零点。量化张量允许进行许多有用的操作，使量化算术变得容易，同时允许以量化格式序列化数据。 +为了在 PyTorch 中进行量化，我们需要能够在张量中表示量化数据。量化张量允许存储量化数据（表示为 int8/uint8/int32）以及量化参数，如比例和零点。量化张量允许进行许多有用的操作，使量化算术变得容易，同时允许以量化格式序列化数据。 -PyTorch支持对称和非对称的每个张量和每个通道量化。每个张量意味着张量中的所有值以相同的方式使用相同的量化参数进行量化。每个通道意味着对于每个维度，通常是张量的通道维度，张量中的值使用不同的量化参数进行量化。这样可以减少将张量转换为量化值时的误差，因为异常值只会影响它所在的通道，而不是整个张量。 +PyTorch 支持对称和非对称的每个张量和每个通道量化。每个张量意味着张量中的所有值以相同的方式使用相同的量化参数进行量化。每个通道意味着对于每个维度，通常是张量的通道维度，张量中的值使用不同的量化参数进行量化。这样可以减少将张量转换为量化值时的误差，因为异常值只会影响它所在的通道，而不是整个张量。 通过将浮点张量转换为 @@ -498,15 +498,15 @@ PyTorch支持对称和非对称的每个张量和每个通道量化。每个张 + torch.float16 -+ 量化参数（根据QScheme的不同而变化）：所选量化方式的参数 ++ 量化参数（根据 QScheme 的不同而变化）：所选量化方式的参数 - + torch.per_tensor_affine将具有量化参数 + + torch.per_tensor_affine 将具有量化参数 + 比例（浮点数） + 零点（整数） - + torch.per_channel_affine将具有量化参数 + + torch.per_channel_affine 将具有量化参数 + 每通道比例（浮点数列表） @@ -530,7 +530,7 @@ PyTorch支持对称和非对称的每个张量和每个通道量化。每个张 + 去量化（量化->浮点） - + quantized_tensor.dequantize() - 在torch.float16张量上调用dequantize将张量转换回torch.float + + quantized_tensor.dequantize() - 在 torch.float16 张量上调用 dequantize 将张量转换回 torch.float + torch.dequantize(x) @@ -538,23 +538,23 @@ PyTorch支持对称和非对称的每个张量和每个通道量化。每个张 + 量化运算符是将量化张量作为输入的运算符，并输出量化张量。 -+ 量化模块是执行量化操作的PyTorch模块。它们通常用于加权操作，如线性和卷积。 ++ 量化模块是执行量化操作的 PyTorch 模块。它们通常用于加权操作，如线性和卷积。 #### 量化引擎 -当执行量化模型时，qengine（torch.backends.quantized.engine）指定要用于执行的后端。重要的是要确保qengine与量化模型在量化激活和权重的值范围方面是兼容的。 +当执行量化模型时，qengine（torch.backends.quantized.engine）指定要用于执行的后端。重要的是要确保 qengine 与量化模型在量化激活和权重的值范围方面是兼容的。 ### 量化流程 -#### 观察器和FakeQuantize +#### 观察器和 FakeQuantize -+ 观察器是PyTorch模块，用于： ++ 观察器是 PyTorch 模块，用于： + 收集张量统计信息，如通过观察器传递的张量的最小值和最大值 + 并根据收集的张量统计数据计算量化参数 -+ FakeQuantize是PyTorch模块，用于： ++ FakeQuantize 是 PyTorch 模块，用于： + 在网络中为张量模拟量化（执行量化/去量化） @@ -562,7 +562,7 @@ PyTorch支持对称和非对称的每个张量和每个通道量化。每个张 #### QConfig -+ QConfig是Observer或FakeQuantize模块类的命名元组，可以配置qscheme、dtype等。它用于配置如何观察运算符 ++ QConfig 是 Observer 或 FakeQuantize 模块类的命名元组，可以配置 qscheme、dtype 等。它用于配置如何观察运算符 + 运算符/模块的量化配置 @@ -576,7 +576,7 @@ PyTorch支持对称和非对称的每个张量和每个通道量化。每个张 + 当前支持激活和权重的配置 - + 我们根据为给定运算符或模块配置的qconfig插入输入/权重/输出观察器 + + 我们根据为给定运算符或模块配置的 qconfig 插入输入/权重/输出观察器 #### 一般量化流程 @@ -633,11 +633,11 @@ Eager Mode Quantization 是一个测试功能。用户需要手动进行融合 FX Graph Mode Quantization 是 PyTorch 中的自动量化框架，目前是一个原型功能。它通过添加对功能的支持和自动化量化过程来改进 Eager Mode Quantization，尽管人们可能需要重构模型以使其与 FX Graph Mode Quantization 兼容（通过 `torch.fx` 进行符号跟踪）。请注意，FX Graph Mode Quantization 不适用于任意模型，因为模型可能无法进行符号跟踪，我们将把它集成到领域库中，如 torchvision，并且用户将能够使用 FX Graph Mode Quantization 对类似于受支持领域库中的模型进行量化。对于任意模型，我们将提供一般性指导，但要使其正常工作，用户可能需要熟悉 `torch.fx`，特别是如何使模型符号可跟踪。 -鼓励量化的新用户首先尝试FX图模式量化，如果不起作用，用户可以尝试遵循[使用FX图模式量化](https://pytorch.org/tutorials/prototype/fx_graph_mode_quant_guide.html)的指南或回退到急切模式量化。 +鼓励量化的新用户首先尝试 FX 图模式量化，如果不起作用，用户可以尝试遵循[使用 FX 图模式量化](https://pytorch.org/tutorials/prototype/fx_graph_mode_quant_guide.html)的指南或回退到急切模式量化。 -以下表格比较了急切模式量化和FX图模式量化之间的差异。 +以下表格比较了急切模式量化和 FX 图模式量化之间的差异。 -| | 急切模式量化 | FX图模式量化 | +| | 急切模式量化 | FX 图模式量化 | | --- | --- | --- | | 发布状态 | beta | 原型 | | 运算符融合 | 手动 | 自动 | @@ -646,31 +646,31 @@ FX Graph Mode Quantization 是 PyTorch 中的自动量化框架，目前是一 | 量化功能/火炬操作 | 手动 | 自动 | | 定制支持 | 有限支持 | 完全支持 | | 量化模式支持 | 后训练量化：静态，动态，仅权重量化感知训练：静态 | 后训练量化：静态，动态，仅权重量化感知训练：静态 | -| 输入/输出模型类型 | `torch.nn.Module` | `torch.nn.Module`（可能需要一些重构以使模型与FX图模式量化兼容） | +| 输入/输出模型类型 | `torch.nn.Module` | `torch.nn.Module`（可能需要一些重构以使模型与 FX 图模式量化兼容） | ### 后端/硬件支持 -| 硬件 | 内核库 | 急切模式量化 | FX图模式量化 | 量化模式支持 | +| 硬件 | 内核库 | 急切模式量化 | FX 图模式量化 | 量化模式支持 | | --- | --- | --- | --- | --- | -| 服务器CPU | fbgemm/onednn | 支持 | 所有支持 | -| 移动CPU | qnnpack/xnnpack | -| 服务器GPU | TensorRT（早期原型） | 不支持，需要图形 | 支持 | 静态量化 | +| 服务器 CPU | fbgemm/onednn | 支持 | 所有支持 | +| 移动 CPU | qnnpack/xnnpack | +| 服务器 GPU | TensorRT（早期原型） | 不支持，需要图形 | 支持 | 静态量化 | -今天，PyTorch支持以下用于高效运行量化运算符的后端： +今天，PyTorch 支持以下用于高效运行量化运算符的后端： -+ 具有AVX2支持或更高版本的x86 CPU（没有AVX2，某些操作具有低效的实现），通过由[fbgemm](https://github.com/pytorch/FBGEMM)和[onednn](https://github.com/oneapi-src/oneDNN)优化的x86（请参阅[RFC](https://github.com/pytorch/pytorch/issues/83888)中的详细信息） ++ 具有 AVX2 支持或更高版本的 x86 CPU（没有 AVX2，某些操作具有低效的实现），通过由[fbgemm](https://github.com/pytorch/FBGEMM)和[onednn](https://github.com/oneapi-src/oneDNN)优化的 x86（请参阅[RFC](https://github.com/pytorch/pytorch/issues/83888)中的详细信息） + ARM CPU（通常在移动/嵌入式设备中找到），通过[qnnpack](https://github.com/pytorch/pytorch/tree/main/aten/src/ATen/native/quantized/cpu/qnnpack) -+ （早期原型）通过[fx2trt](https://developer.nvidia.com/tensorrt)支持NVidia GPU ++ （早期原型）通过[fx2trt](https://developer.nvidia.com/tensorrt)支持 NVidia GPU -#### 本机CPU后端注意事项[](#note-for-native-cpu-backends "跳转到此标题") +#### 本机 CPU 后端注意事项[](#note-for-native-cpu-backends "跳转到此标题") -我们同时暴露了x86和qnnpack，使用相同的本机pytorch量化运算符，因此我们需要额外的标志来区分它们。根据PyTorch构建模式自动选择x86和qnnpack的相应实现，尽管用户可以通过将torch.backends.quantization.engine设置为x86或qnnpack来覆盖此设置。 +我们同时暴露了 x86 和 qnnpack，使用相同的本机 pytorch 量化运算符，因此我们需要额外的标志来区分它们。根据 PyTorch 构建模式自动选择 x86 和 qnnpack 的相应实现，尽管用户可以通过将 torch.backends.quantization.engine 设置为 x86 或 qnnpack 来覆盖此设置。 -在准备量化模型时，必须确保qconfig和用于量化计算的引擎与将执行模型的后端匹配。qconfig控制量化过程中使用的观察者类型。qengine控制在为线性和卷积函数和模块打包权重时使用x86还是qnnpack特定的打包函数。例如： +在准备量化模型时，必须确保 qconfig 和用于量化计算的引擎与将执行模型的后端匹配。qconfig 控制量化过程中使用的观察者类型。qengine 控制在为线性和卷积函数和模块打包权重时使用 x86 还是 qnnpack 特定的打包函数。例如： -x86的默认设置： +x86 的默认设置： ```py # set the qconfig for PTQ @@ -682,7 +682,7 @@ qconfig = torch.ao.quantization.get_default_qat_qconfig('x86') torch.backends.quantized.engine = 'x86' ``` -qnnpack的默认设置： +qnnpack 的默认设置： ```py # set the qconfig for PTQ @@ -695,31 +695,31 @@ torch.backends.quantized.engine = 'qnnpack' ### 运算符支持 -动态和静态量化之间的运算符覆盖范围在下表中捕获。请注意，对于FX图模式量化，相应的功能也受支持。 +动态和静态量化之间的运算符覆盖范围在下表中捕获。请注意，对于 FX 图模式量化，相应的功能也受支持。 | | 静态量化 | 动态量化 | | --- | --- | --- | | nn.Linear | YY | YN | | nn.LSTMnn.GRU | NN | YY | | nn.RNNCellnn.GRUCellnn.LSTMCell | NNN | YYY | -| nn.EmbeddingBag | Y（激活在fp32中） | Y | +| nn.EmbeddingBag | Y（激活在 fp32 中） | Y | | nn.Embedding | Y | Y | | nn.MultiheadAttention | 不支持 | 不支持 | -| 激活 | 广泛支持 | 保持不变，计算保持在fp32中 | +| 激活 | 广泛支持 | 保持不变，计算保持在 fp32 中 | -注意：这将很快更新一些从本机backend_config_dict生成的信息。 +注意：这将很快更新一些从本机 backend_config_dict 生成的信息。 -## 量化API参考[](#quantization-api-reference "跳转到此标题") +## 量化 API 参考[](#quantization-api-reference "跳转到此标题") -[量化API参考](quantization-support.html)包含有关量化API的文档，例如量化传递、量化张量操作以及支持的量化模块和函数。 +量化 API 参考包含有关量化 API 的文档，例如量化传递、量化张量操作以及支持的量化模块和函数。 ## 量化后端配置 -[量化后端配置](quantization-backend-configuration.html)包含有关如何为各种后端配置量化工作流程的文档。 +量化后端配置包含有关如何为各种后端配置量化工作流程的文档。 ## 量化精度调试 -[量化精度调试](quantization-accuracy-debugging.html)包含有关如何调试量化精度的文档。 +量化精度调试包含有关如何调试量化精度的文档。 ## 量化定制 @@ -727,19 +727,19 @@ torch.backends.quantized.engine = 'qnnpack' 我们还为**conv1d()**、**conv2d()**、**conv3d()**和**linear()**提供了通道量化支持。 -量化工作流程通过向模型的模块层次结构添加（例如，将观察者添加为`.observer`子模块）或替换（例如，将`nn.Conv2d`转换为`nn.quantized.Conv2d`）子模块来实现。这意味着模型在整个过程中保持常规的基于`nn.Module`的实例，因此可以与PyTorch的其余API一起使用。 +量化工作流程通过向模型的模块层次结构添加（例如，将观察者添加为`.observer`子模块）或替换（例如，将`nn.Conv2d`转换为`nn.quantized.Conv2d`）子模块来实现。这意味着模型在整个过程中保持常规的基于`nn.Module`的实例，因此可以与 PyTorch 的其余 API 一起使用。 -### 量化定制模块API +### 量化定制模块 API -Eager模式和FX图模式的量化API提供了一个钩子，供用户以自定义方式指定模块的量化，具有用户定义的观察和量化逻辑。用户需要指定： +Eager 模式和 FX 图模式的量化 API 提供了一个钩子，供用户以自定义方式指定模块的量化，具有用户定义的观察和量化逻辑。用户需要指定： -1. 源fp32模块的Python类型（存在于模型中） +1. 源 fp32 模块的 Python 类型（存在于模型中） -1. 观察模块的Python类型（由用户提供）。该模块需要定义一个`from_float`函数，该函数定义了如何从原始fp32模块创建观察模块。 +1. 观察模块的 Python 类型（由用户提供）。该模块需要定义一个`from_float`函数，该函数定义了如何从原始 fp32 模块创建观察模块。 -1. 量化模块的Python类型（由用户提供）。该模块需要定义一个`from_observed`函数，该函数定义了如何从观察到的模块创建量化模块。 +1. 量化模块的 Python 类型（由用户提供）。该模块需要定义一个`from_observed`函数，该函数定义了如何从观察到的模块创建量化模块。 -1. 描述（1）、（2）、（3）的配置，传递给量化API。 +1. 描述（1）、（2）、（3）的配置，传递给量化 API。 然后框架将执行以下操作： @@ -747,9 +747,9 @@ Eager模式和FX图模式的量化API提供了一个钩子，供用户以自定 1. 在转换模块交换期间，它将使用（3）中的类的`from_observed`函数，将（2）中指定类型的每个模块转换为（3）中指定类型。 -目前，ObservedCustomModule将具有单个张量输出的要求，并且观察者将由框架（而不是用户）添加到该输出上。观察者将作为自定义模块实例的属性存储在`activation_post_process`键下。在未来可能会放宽这些限制。 +目前，ObservedCustomModule 将具有单个张量输出的要求，并且观察者将由框架（而不是用户）添加到该输出上。观察者将作为自定义模块实例的属性存储在`activation_post_process`键下。在未来可能会放宽这些限制。 -自定义API示例： +自定义 API 示例： ```py import torch @@ -849,25 +849,25 @@ mq = torch.ao.quantization.quantize_fx.convert_fx( ## 最佳实践 -1. 如果您正在使用`x86`后端，我们需要使用7位而不是8位。确保您减少`quant_min`、`quant_max`的范围，例如，如果`dtype`是`torch.quint8`，请确保将自定义的`quant_min`设置为`0`，`quant_max`设置为`127`（`255` / `2`）；如果`dtype`是`torch.qint8`，请确保将自定义的`quant_min`设置为`-64`（`-128` / `2`），`quant_max`设置为`63`（`127` / `2`），如果您调用`torch.ao.quantization.get_default_qconfig(backend)`或`torch.ao.quantization.get_default_qat_qconfig(backend)`函数来获取`x86`或`qnnpack`后端的默认`qconfig`，我们已经正确设置了这些。 +1. 如果您正在使用`x86`后端，我们需要使用 7 位而不是 8 位。确保您减少`quant_min`、`quant_max`的范围，例如，如果`dtype`是`torch.quint8`，请确保将自定义的`quant_min`设置为`0`，`quant_max`设置为`127`（`255` / `2`）；如果`dtype`是`torch.qint8`，请确保将自定义的`quant_min`设置为`-64`（`-128` / `2`），`quant_max`设置为`63`（`127` / `2`），如果您调用`torch.ao.quantization.get_default_qconfig(backend)`或`torch.ao.quantization.get_default_qat_qconfig(backend)`函数来获取`x86`或`qnnpack`后端的默认`qconfig`，我们已经正确设置了这些。 -2. 如果选择了`onednn`后端，将在默认的qconfig映射`torch.ao.quantization.get_default_qconfig_mapping('onednn')`和默认的qconfig`torch.ao.quantization.get_default_qconfig('onednn')`中使用8位激活。建议在支持向量神经网络指令（VNNI）的CPU上使用。否则，将激活的观察者的`reduce_range`设置为True，以在没有VNNI支持的CPU上获得更好的准确性。 +2. 如果选择了`onednn`后端，将在默认的 qconfig 映射`torch.ao.quantization.get_default_qconfig_mapping('onednn')`和默认的 qconfig`torch.ao.quantization.get_default_qconfig('onednn')`中使用 8 位激活。建议在支持向量神经网络指令（VNNI）的 CPU 上使用。否则，将激活的观察者的`reduce_range`设置为 True，以在没有 VNNI 支持的 CPU 上获得更好的准确性。 ## 常见问题[](#frequently-asked-questions "跳转到此标题的永久链接") -1. 如何在GPU上进行量化推断?： +1. 如何在 GPU 上进行量化推断?： - 我们目前还没有官方的GPU支持，但这是一个积极开发的领域，您可以在[这里](https://github.com/pytorch/pytorch/issues/87395)找到更多信息 + 我们目前还没有官方的 GPU 支持，但这是一个积极开发的领域，您可以在[这里](https://github.com/pytorch/pytorch/issues/87395)找到更多信息 -1. 我如何为我的量化模型获得ONNX支持? +1. 我如何为我的量化模型获得 ONNX 支持? - 如果在导出模型时出现错误（使用`torch.onnx`下的API），您可以在PyTorch存储库中打开一个问题。在问题标题前加上`[ONNX]`并将问题标记为`module: onnx`。 + 如果在导出模型时出现错误（使用`torch.onnx`下的 API），您可以在 PyTorch 存储库中打开一个问题。在问题标题前加上`[ONNX]`并将问题标记为`module: onnx`。 - 如果您在ONNX Runtime中遇到问题，请在[GitHub - microsoft/onnxruntime](https://github.com/microsoft/onnxruntime/issues/)上打开一个问题。 + 如果您在 ONNX Runtime 中遇到问题，请在[GitHub - microsoft/onnxruntime](https://github.com/microsoft/onnxruntime/issues/)上打开一个问题。 -1. 如何在LSTM中使用量化?： +1. 如何在 LSTM 中使用量化?： - LSTM通过我们的自定义模块API在急切模式和fx图模式量化中得到支持。示例可以在急切模式中找到：[pytorch/test_quantized_op.py TestQuantizedOps.test_custom_module_lstm](https://github.com/pytorch/pytorch/blob/9b88dcf248e717ca6c3f8c5e11f600825547a561/test/quantization/core/test_quantized_op.py#L2782) FX图模式中：[pytorch/test_quantize_fx.py TestQuantizeFx.test_static_lstm](https://github.com/pytorch/pytorch/blob/9b88dcf248e717ca6c3f8c5e11f600825547a561/test/quantization/fx/test_quantize_fx.py#L4116) + LSTM 通过我们的自定义模块 API 在急切模式和 fx 图模式量化中得到支持。示例可以在急切模式中找到：[pytorch/test_quantized_op.py TestQuantizedOps.test_custom_module_lstm](https://github.com/pytorch/pytorch/blob/9b88dcf248e717ca6c3f8c5e11f600825547a561/test/quantization/core/test_quantized_op.py#L2782) FX 图模式中：[pytorch/test_quantize_fx.py TestQuantizeFx.test_static_lstm](https://github.com/pytorch/pytorch/blob/9b88dcf248e717ca6c3f8c5e11f600825547a561/test/quantization/fx/test_quantize_fx.py#L4116) ## 常见错误 @@ -879,7 +879,7 @@ mq = torch.ao.quantization.quantize_fx.convert_fx( RuntimeError: Could not run 'quantized::some_operator' with arguments from the 'CPU' backend... ``` -这意味着您正在尝试将一个非量化的张量传递给一个量化的内核。一个常见的解决方法是使用`torch.ao.quantization.QuantStub`来对张量进行量化。这在Eager模式量化中需要手动完成。一个端到端的例子： +这意味着您正在尝试将一个非量化的张量传递给一个量化的内核。一个常见的解决方法是使用`torch.ao.quantization.QuantStub`来对张量进行量化。这在 Eager 模式量化中需要手动完成。一个端到端的例子： ```py class M(torch.nn.Module): @@ -904,7 +904,7 @@ class M(torch.nn.Module): RuntimeError: Could not run 'aten::thnn_conv2d_forward' with arguments from the 'QuantizedCPU' backend. ``` -这意味着您正在尝试将一个量化的张量传递给一个非量化的内核。一个常见的解决方法是使用`torch.ao.quantization.DeQuantStub`来对张量进行去量化。这在Eager模式量化中需要手动完成。一个端到端的例子： +这意味着您正在尝试将一个量化的张量传递给一个非量化的内核。一个常见的解决方法是使用`torch.ao.quantization.DeQuantStub`来对张量进行去量化。这在 Eager 模式量化中需要手动完成。一个端到端的例子： ```py class M(torch.nn.Module): @@ -943,7 +943,7 @@ AttributeError: 'LinearPackedParams' object has no attribute '_modules' 这是因为直接使用`torch.save`和`torch.load`保存和加载一个量化模型是不受支持的。要保存/加载量化模型，可以使用以下方法： -1. 保存/加载量化模型的state_dict +1. 保存/加载量化模型的 state_dict 一个例子： @@ -994,12 +994,12 @@ b.seek(0) scripted_quantized = torch.jit.load(b) ``` -### 在使用FX图模式量化时出现符号跟踪错误[](#symbolic-trace-error-when-using-fx-graph-mode-quantization "跳转到此标题的永久链接") +### 在使用 FX 图模式量化时出现符号跟踪错误[](#symbolic-trace-error-when-using-fx-graph-mode-quantization "跳转到此标题的永久链接") -符号跟踪是[(原型-维护模式) FX图模式量化](#prototype-maintaince-mode-fx-graph-mode-quantization)的要求，因此如果您传递一个不能被符号跟踪的PyTorch模型到torch.ao.quantization.prepare_fx或torch.ao.quantization.prepare_qat_fx，我们可能会看到以下类似的错误： +符号跟踪是(原型-维护模式) FX 图模式量化的要求，因此如果您传递一个不能被符号跟踪的 PyTorch 模型到 torch.ao.quantization.prepare_fx 或 torch.ao.quantization.prepare_qat_fx，我们可能会看到以下类似的错误： ```py torch.fx.proxy.TraceError: symbolically traced variables cannot be used as inputs to control flow ``` -请查看[符号跟踪的限制](https://pytorch.org/docs/2.0/fx.html#limitations-of-symbolic-tracing)并使用-[使用FX图模式量化的用户指南](https://pytorch.org/tutorials/prototype/fx_graph_mode_quant_guide.html)来解决问题。 +请查看[符号跟踪的限制](https://pytorch.org/docs/2.0/fx.html#limitations-of-symbolic-tracing)并使用-[使用 FX 图模式量化的用户指南](https://pytorch.org/tutorials/prototype/fx_graph_mode_quant_guide.html)来解决问题。 diff --git a/totrans/doc22_075.md b/totrans/doc22_075.md index 6086cc12..974222b4 100644 --- a/totrans/doc22_075.md +++ b/totrans/doc22_075.md @@ -1,78 +1,78 @@ -# 分布式RPC框架 +# 分布式 RPC 框架 -> 链接：[https://pytorch.org/docs/stable/rpc.html](https://pytorch.org/docs/stable/rpc.html) +> 链接：[`pytorch.org/docs/stable/rpc.html`](https://pytorch.org/docs/stable/rpc.html) -分布式RPC框架提供了多机模型训练的机制，通过一组原语允许远程通信，并提供一个更高级的API来自动区分跨多台机器分割的模型。 +分布式 RPC 框架提供了多机模型训练的机制，通过一组原语允许远程通信，并提供一个更高级的 API 来自动区分跨多台机器分割的模型。 警告 -RPC包中的API是稳定的。有多个正在进行的工作项目来改进性能和错误处理，这些将在未来的版本中发布。 +RPC 包中的 API 是稳定的。有多个正在进行的工作项目来改进性能和错误处理，这些将在未来的版本中发布。 警告 -CUDA支持在PyTorch 1.9中引入，仍然是一个**beta**功能。RPC包的并非所有功能都与CUDA支持兼容，因此不建议使用。这些不受支持的功能包括：RRefs、JIT兼容性、分布式自动求导和分布式优化器，以及性能分析。这些缺陷将在未来的版本中得到解决。 +CUDA 支持在 PyTorch 1.9 中引入，仍然是一个**beta**功能。RPC 包的并非所有功能都与 CUDA 支持兼容，因此不建议使用。这些不受支持的功能包括：RRefs、JIT 兼容性、分布式自动求导和分布式优化器，以及性能分析。这些缺陷将在未来的版本中得到解决。 注意 -有关与分布式训练相关的所有功能的简要介绍，请参阅[PyTorch分布式概述](https://pytorch.org/tutorials/beginner/dist_overview.html)。 +有关与分布式训练相关的所有功能的简要介绍，请参阅[PyTorch 分布式概述](https://pytorch.org/tutorials/beginner/dist_overview.html)。 ## 基础知识 -分布式RPC框架使远程运行函数变得容易，支持引用远程对象而无需复制真实数据，并提供自动求导和优化器API以透明地在RPC边界上运行反向传播和更新参数。这些功能可以分为四组API。 +分布式 RPC 框架使远程运行函数变得容易，支持引用远程对象而无需复制真实数据，并提供自动求导和优化器 API 以透明地在 RPC 边界上运行反向传播和更新参数。这些功能可以分为四组 API。 -1. **远程过程调用（RPC）**支持在指定的目标工作进程上运行函数，并获取返回值或创建对返回值的引用。有三个主要的RPC API：[`rpc_sync()`](#torch.distributed.rpc.rpc_sync "torch.distributed.rpc.rpc_sync")（同步）、[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")（异步）和[`remote()`](#torch.distributed.rpc.remote "torch.distributed.rpc.remote")（异步并返回对远程返回值的引用）。如果用户代码不能在没有返回值的情况下继续进行，则使用同步API。否则，使用异步API获取一个future，并在调用者需要返回值时等待future。当需求是远程创建某物但从不需要将其提取到调用者时，[`remote()`](#torch.distributed.rpc.remote "torch.distributed.rpc.remote") API是有用的。想象一下，驱动进程正在设置参数服务器和训练器。驱动程序可以在参数服务器上创建一个嵌入表，然后与训练器共享对嵌入表的引用，但本身永远不会在本地使用嵌入表。在这种情况下，[`rpc_sync()`](#torch.distributed.rpc.rpc_sync "torch.distributed.rpc.rpc_sync")和[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")不再适用，因为它们总是意味着返回值将立即或在将来返回给调用者。 +1. **远程过程调用（RPC）**支持在指定的目标工作进程上运行函数，并获取返回值或创建对返回值的引用。有三个主要的 RPC API：`rpc_sync()`（同步）、`rpc_async()`（异步）和`remote()`（异步并返回对远程返回值的引用）。如果用户代码不能在没有返回值的情况下继续进行，则使用同步 API。否则，使用异步 API 获取一个 future，并在调用者需要返回值时等待 future。当需求是远程创建某物但从不需要将其提取到调用者时，`remote()` API 是有用的。想象一下，驱动进程正在设置参数服务器和训练器。驱动程序可以在参数服务器上创建一个嵌入表，然后与训练器共享对嵌入表的引用，但本身永远不会在本地使用嵌入表。在这种情况下，`rpc_sync()`和`rpc_async()`不再适用，因为它们总是意味着返回值将立即或在将来返回给调用者。 -1. **远程引用（RRef）**用作本地或远程对象的分布式共享指针。它可以与其他工作进程共享，并且引用计数将被透明处理。每个RRef只有一个所有者，对象只存在于该所有者上。持有RRefs的非所有者工作进程可以通过显式请求从所有者那里获取对象的副本。当工作进程需要访问某个数据对象，但本身既不是创建者（[`remote()`](#torch.distributed.rpc.remote "torch.distributed.rpc.remote")的调用者）也不是对象的所有者时，这是很有用的。正如我们将在下面讨论的分布式优化器，是这种用例的一个例子。 +1. **远程引用（RRef）**用作本地或远程对象的分布式共享指针。它可以与其他工作进程共享，并且引用计数将被透明处理。每个 RRef 只有一个所有者，对象只存在于该所有者上。持有 RRefs 的非所有者工作进程可以通过显式请求从所有者那里获取对象的副本。当工作进程需要访问某个数据对象，但本身既不是创建者（`remote()`的调用者）也不是对象的所有者时，这是很有用的。正如我们将在下面讨论的分布式优化器，是这种用例的一个例子。 -1. **分布式自动微分**将所有参与前向传递的工作节点上的本地自动微分引擎连接在一起，并在后向传递期间自动到达它们以计算梯度。如果前向传递需要跨多台机器进行，例如进行分布式模型并行训练、参数服务器训练等，这将特别有帮助。有了这个功能，用户代码不再需要担心如何在RPC边界之间发送梯度以及本地自动微分引擎应该以哪种顺序启动，这在前向传递中存在嵌套和相互依赖的RPC调用时可能会变得非常复杂。 +1. **分布式自动微分**将所有参与前向传递的工作节点上的本地自动微分引擎连接在一起，并在后向传递期间自动到达它们以计算梯度。如果前向传递需要跨多台机器进行，例如进行分布式模型并行训练、参数服务器训练等，这将特别有帮助。有了这个功能，用户代码不再需要担心如何在 RPC 边界之间发送梯度以及本地自动微分引擎应该以哪种顺序启动，这在前向传递中存在嵌套和相互依赖的 RPC 调用时可能会变得非常复杂。 -1. **分布式优化器**的构造函数接受一个[`Optimizer()`](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")（例如，[`SGD()`](generated/torch.optim.SGD.html#torch.optim.SGD "torch.optim.SGD")、[`Adagrad()`](generated/torch.optim.Adagrad.html#torch.optim.Adagrad "torch.optim.Adagrad")等）和参数RRef列表，为每个不同的RRef所有者创建一个[`Optimizer()`](optim.html#torch.optim.Optimizer "torch.optim.Optimizer")实例，并在运行`step()`时相应地更新参数。当进行分布式前向和后向传递时，参数和梯度将分散在多个工作节点上，因此每个涉及的工作节点都需要一个优化器。分布式优化器将所有这些本地优化器包装在一起，并提供简洁的构造函数和`step()` API。 +1. **分布式优化器**的构造函数接受一个`Optimizer()`（例如，`SGD()`、`Adagrad()`等）和参数 RRef 列表，为每个不同的 RRef 所有者创建一个`Optimizer()`实例，并在运行`step()`时相应地更新参数。当进行分布式前向和后向传递时，参数和梯度将分散在多个工作节点上，因此每个涉及的工作节点都需要一个优化器。分布式优化器将所有这些本地优化器包装在一起，并提供简洁的构造函数和`step()` API。 ## RPC -在使用RPC和分布式自动微分原语之前，必须进行初始化。要初始化RPC框架，我们需要使用[`init_rpc()`](#torch.distributed.rpc.init_rpc "torch.distributed.rpc.init_rpc")，这将初始化RPC框架、RRef框架和分布式自动微分。 +在使用 RPC 和分布式自动微分原语之前，必须进行初始化。要初始化 RPC 框架，我们需要使用`init_rpc()`，这将初始化 RPC 框架、RRef 框架和分布式自动微分。 ```py torch.distributed.rpc.init_rpc(name, backend=None, rank=-1, world_size=None, rpc_backend_options=None)¶ ``` -初始化RPC原语，如本地RPC代理和分布式自动微分，这将立即使当前进程准备好发送和接收RPC。 +初始化 RPC 原语，如本地 RPC 代理和分布式自动微分，这将立即使当前进程准备好发送和接收 RPC。 参数 -+ **name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 此节点的全局唯一名称。 （例如，`Trainer3`、`ParameterServer2`、`Master`、`Worker1`）名称只能包含数字、字母、下划线、冒号和/或破折号，并且必须少于128个字符。 ++ **name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 此节点的全局唯一名称。 （例如，`Trainer3`、`ParameterServer2`、`Master`、`Worker1`）名称只能包含数字、字母、下划线、冒号和/或破折号，并且必须少于 128 个字符。 -+ **backend**（[*BackendType*](#torch.distributed.rpc.BackendType "torch.distributed.rpc.BackendType")*,* *可选*) - RPC后端实现的类型。支持的值是`BackendType.TENSORPIPE`（默认值）。有关更多信息，请参见[后端](#rpc-backends)。 ++ **backend**（*BackendType**,* *可选*) - RPC 后端实现的类型。支持的值是`BackendType.TENSORPIPE`（默认值）。有关更多信息，请参见后端。 -+ **rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 此节点的全局唯一id/排名。 ++ **rank**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- 此节点的全局唯一 id/排名。 -+ **world_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 组中的工作节点数。 ++ **world_size**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- 组中的工作节点数。 -+ **rpc_backend_options**（[*RpcBackendOptions*](#torch.distributed.rpc.RpcBackendOptions "torch.distributed.rpc.RpcBackendOptions")*,* *可选*) - 传递给RpcAgent构造函数的选项。它必须是[`RpcBackendOptions`](#torch.distributed.rpc.RpcBackendOptions "torch.distributed.rpc.RpcBackendOptions")的特定于代理的子类，并包含特定于代理的初始化配置。默认情况下，对于所有代理，它将默认超时设置为60秒，并使用`init_method = "env://"`初始化底层进程组进行会合，这意味着环境变量`MASTER_ADDR`和`MASTER_PORT`需要正确设置。有关更多信息，请参见[后端](#rpc-backends)，查找可用的选项。 ++ **rpc_backend_options**（*RpcBackendOptions**,* *可选*) - 传递给 RpcAgent 构造函数的选项。它必须是`RpcBackendOptions`的特定于代理的子类，并包含特定于代理的初始化配置。默认情况下，对于所有代理，它将默认超时设置为 60 秒，并使用`init_method = "env://"`初始化底层进程组进行会合，这意味着环境变量`MASTER_ADDR`和`MASTER_PORT`需要正确设置。有关更多信息，请参见后端，查找可用的选项。 -以下API允许用户远程执行函数以及创建对远程数据对象的引用（RRefs）。在这些API中，当将`Tensor`作为参数或返回值传递时，目标工作节点将尝试创建具有相同元数据（即形状、步幅等）的`Tensor`。我们有意禁止传输CUDA张量，因为如果源工作节点和目标工作节点上的设备列表不匹配，可能会导致崩溃。在这种情况下，应用程序始终可以在调用者上明确将输入张量移动到CPU，并在必要时将其移动到被调用者上的所需设备。 +以下 API 允许用户远程执行函数以及创建对远程数据对象的引用（RRefs）。在这些 API 中，当将`Tensor`作为参数或返回值传递时，目标工作节点将尝试创建具有相同元数据（即形状、步幅等）的`Tensor`。我们有意禁止传输 CUDA 张量，因为如果源工作节点和目标工作节点上的设备列表不匹配，可能会导致崩溃。在这种情况下，应用程序始终可以在调用者上明确将输入张量移动到 CPU，并在必要时将其移动到被调用者上的所需设备。 警告 -RPC中的TorchScript支持是一个原型功能，可能会发生变化。自v1.5.0以来，`torch.distributed.rpc`支持将TorchScript函数作为RPC目标函数调用，这将有助于提高被调用者端的并行性，因为执行TorchScript函数不需要GIL。 +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)¶ ``` -在工作节点`to`上运行函数`func`的阻塞RPC调用。RPC消息在执行Python代码的同时并行发送和接收。此方法是线程安全的。 +在工作节点`to`上运行函数`func`的阻塞 RPC 调用。RPC 消息在执行 Python 代码的同时并行发送和接收。此方法是线程安全的。 参数 -+ **to** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* [*WorkerInfo*](#torch.distributed.rpc.WorkerInfo "torch.distributed.rpc.WorkerInfo") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 目标工作节点的名称/等级/`WorkerInfo`。 ++ **to** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* *WorkerInfo* *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 目标工作节点的名称/等级/`WorkerInfo`。 -+ **func** (*Callable*) – 一个可调用函数，例如Python可调用函数，内置运算符（例如[`add()`](generated/torch.add.html#torch.add "torch.add")）和带注释的TorchScript函数。 ++ **func** (*Callable*) – 一个可调用函数，例如 Python 可调用函数，内置运算符（例如`add()`）和带注释的 TorchScript 函数。 + **args** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")) – 用于`func`调用的参数元组。 + **kwargs** ([*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(in Python v3.12)")) – 是`func`调用的关键字参数字典。 -+ **timeout** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*) – 用于此RPC的超时时间（以秒为单位）。如果RPC在此时间内未完成，将引发指示已超时的异常。值为0表示无限超时，即永远不会引发超时错误。如果未提供，则使用在初始化期间或使用`_set_rpc_timeout`设置的默认值。 ++ **timeout** ([*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*) – 用于此 RPC 的超时时间（以秒为单位）。如果 RPC 在此时间内未完成，将引发指示已超时的异常。值为 0 表示无限超时，即永远不会引发超时错误。如果未提供，则使用在初始化期间或使用`_set_rpc_timeout`设置的默认值。 返回 @@ -80,7 +80,7 @@ torch.distributed.rpc.rpc_sync(to, func, args=None, kwargs=None, timeout=-1.0)¶ 示例:: -确保在两个工作节点上正确设置`MASTER_ADDR`和`MASTER_PORT`。有关更多详细信息，请参考[`init_process_group()`](distributed.html#torch.distributed.init_process_group "torch.distributed.init_process_group") API。例如， +确保在两个工作节点上正确设置`MASTER_ADDR`和`MASTER_PORT`。有关更多详细信息，请参考`init_process_group()` API。例如， export MASTER_ADDR=localhost export MASTER_PORT=5678 @@ -102,7 +102,7 @@ export MASTER_ADDR=localhost export MASTER_PORT=5678 >>> rpc.shutdown() ``` -以下是使用RPC运行TorchScript函数的示例。 +以下是使用 RPC 运行 TorchScript 函数的示例。 ```py >>> # On both workers: @@ -130,13 +130,13 @@ export MASTER_ADDR=localhost export MASTER_PORT=5678 torch.distributed.rpc.rpc_async(to, func, args=None, kwargs=None, timeout=-1.0)¶ ``` -在工作节点`to`上运行函数`func`的非阻塞RPC调用。RPC消息在执行Python代码的同时并行发送和接收。此方法是线程安全的。此方法将立即返回一个可以等待的[`Future`](futures.html#torch.futures.Future "torch.futures.Future")。 +在工作节点`to`上运行函数`func`的非阻塞 RPC 调用。RPC 消息在执行 Python 代码的同时并行发送和接收。此方法是线程安全的。此方法将立即返回一个可以等待的`Future`。 参数 -+ **to** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* [*WorkerInfo*](#torch.distributed.rpc.WorkerInfo "torch.distributed.rpc.WorkerInfo") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 目标工作节点的名称/等级/`WorkerInfo`。 ++ **to** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* *WorkerInfo* *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 目标工作节点的名称/等级/`WorkerInfo`。 -+ **func** (*Callable*) – 一个可调用函数，例如Python可调用函数，内置运算符（例如[`add()`](generated/torch.add.html#torch.add "torch.add")）和带注释的TorchScript函数。 ++ **func** (*Callable*) – 一个可调用函数，例如 Python 可调用函数，内置运算符（例如`add()`）和带注释的 TorchScript 函数。 + **args** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")) – 用于`func`调用的参数元组。 @@ -146,7 +146,7 @@ torch.distributed.rpc.rpc_async(to, func, args=None, kwargs=None, timeout=-1.0) 返回 -返回一个 [`Future`](futures.html#torch.futures.Future "torch.futures.Future") 对象，可以等待。完成后，可以从 [`Future`](futures.html#torch.futures.Future "torch.futures.Future") 对象中检索 `func` 在 `args` 和 `kwargs` 上的返回值。 +返回一个 `Future` 对象，可以等待。完成后，可以从 `Future` 对象中检索 `func` 在 `args` 和 `kwargs` 上的返回值。 警告 @@ -154,11 +154,11 @@ torch.distributed.rpc.rpc_async(to, func, args=None, kwargs=None, timeout=-1.0) 警告 -`rpc_async` API 在将参数张量通过网络发送之前不会复制存储，这可能由不同的线程完成，具体取决于 RPC 后端类型。调用者应确保这些张量的内容保持不变，直到返回的 [`Future`](futures.html#torch.futures.Future "torch.futures.Future") 完成。 +`rpc_async` API 在将参数张量通过网络发送之前不会复制存储，这可能由不同的线程完成，具体取决于 RPC 后端类型。调用者应确保这些张量的内容保持不变，直到返回的 `Future` 完成。 示例:: -确保在两个工作节点上正确设置 `MASTER_ADDR` 和 `MASTER_PORT`。有关更多详细信息，请参考 [`init_process_group()`](distributed.html#torch.distributed.init_process_group "torch.distributed.init_process_group") API。例如， +确保在两个工作节点上正确设置 `MASTER_ADDR` 和 `MASTER_PORT`。有关更多详细信息，请参考 `init_process_group()` API。例如， 导出 MASTER_ADDR=localhost 导出 MASTER_PORT=5678 @@ -215,9 +215,9 @@ torch.distributed.rpc.remote(to, func, args=None, kwargs=None, timeout=-1.0)¶ 参数 -+ **to** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* [*WorkerInfo*](#torch.distributed.rpc.WorkerInfo "torch.distributed.rpc.WorkerInfo") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 目标工作节点的名称/等级/`WorkerInfo`。 ++ **to** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* *WorkerInfo* *或* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")) – 目标工作节点的名称/等级/`WorkerInfo`。 -+ **func** (*Callable*) – 可调用函数，例如 Python 可调用函数、内置运算符（例如 [`add()`](generated/torch.add.html#torch.add "torch.add")）和带注释的 TorchScript 函数。 ++ **func** (*Callable*) – 可调用函数，例如 Python 可调用函数、内置运算符（例如 `add()`）和带注释的 TorchScript 函数。 + **args** ([*tuple*](https://docs.python.org/3/library/stdtypes.html#tuple "(in Python v3.12)")) – 用于 `func` 调用的参数元组。 @@ -231,11 +231,11 @@ torch.distributed.rpc.remote(to, func, args=None, kwargs=None, timeout=-1.0)¶ 警告 -`remote` API在将参数张量发送到远程时不会复制存储，这可能由不同的线程完成，具体取决于RPC后端类型。调用者应确保这些张量的内容保持不变，直到所有者确认返回的RRef，可以使用`torch.distributed.rpc.RRef.confirmed_by_owner()` API进行检查。 +`remote` API 在将参数张量发送到远程时不会复制存储，这可能由不同的线程完成，具体取决于 RPC 后端类型。调用者应确保这些张量的内容保持不变，直到所有者确认返回的 RRef，可以使用`torch.distributed.rpc.RRef.confirmed_by_owner()` API 进行检查。 警告 -`remote` API的超时等错误是尽力处理的。这意味着当由`remote`发起的远程调用失败时，比如超时错误，我们会采取尽力处理错误的方法。这意味着错误会异步处理并设置在结果的RRef上。如果在此处理之前应用程序未使用RRef（例如`to_here`或fork调用），则将适当引发`RRef`的错误。但是，用户应用程序可能在处理错误之前使用`RRef`。在这种情况下，错误可能不会被引发，因为它们尚未被处理。 +`remote` API 的超时等错误是尽力处理的。这意味着当由`remote`发起的远程调用失败时，比如超时错误，我们会采取尽力处理错误的方法。这意味着错误会异步处理并设置在结果的 RRef 上。如果在此处理之前应用程序未使用 RRef（例如`to_here`或 fork 调用），则将适当引发`RRef`的错误。但是，用户应用程序可能在处理错误之前使用`RRef`。在这种情况下，错误可能不会被引发，因为它们尚未被处理。 示例： @@ -287,33 +287,33 @@ Below is an example of running a TorchScript function using RPC. torch.distributed.rpc.get_worker_info(worker_name=None)¶ ``` -获取给定工作进程名称的[`WorkerInfo`](#torch.distributed.rpc.WorkerInfo "torch.distributed.rpc.WorkerInfo")。使用此[`WorkerInfo`](#torch.distributed.rpc.WorkerInfo "torch.distributed.rpc.WorkerInfo")以避免在每次调用时传递昂贵的字符串。 +获取给定工作进程名称的`WorkerInfo`。使用此`WorkerInfo`以避免在每次调用时传递昂贵的字符串。 参数 -**worker_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")） - 工作进程的字符串名称。如果为`None`，则返回当前工作进程的ID。（默认为`None`） +**worker_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")） - 工作进程的字符串名称。如果为`None`，则返回当前工作进程的 ID。（默认为`None`） 返回 -给定`worker_name`的[`WorkerInfo`](#torch.distributed.rpc.WorkerInfo "torch.distributed.rpc.WorkerInfo")实例或当前工作进程的[`WorkerInfo`](#torch.distributed.rpc.WorkerInfo "torch.distributed.rpc.WorkerInfo")如果`worker_name`为`None`。 +给定`worker_name`的`WorkerInfo`实例或当前工作进程的`WorkerInfo`如果`worker_name`为`None`。 ```py torch.distributed.rpc.shutdown(graceful=True, timeout=0)¶ ``` -执行RPC代理的关闭，然后销毁RPC代理。这将停止本地代理接受未完成的请求，并通过终止所有RPC线程关闭RPC框架。如果`graceful=True`，这将阻塞，直到所有本地和远程RPC进程到达此方法并等待所有未完成的工作完成。否则，如果`graceful=False`，这是一个本地关闭，不会等待其他RPC进程到达此方法。 +执行 RPC 代理的关闭，然后销毁 RPC 代理。这将停止本地代理接受未完成的请求，并通过终止所有 RPC 线程关闭 RPC 框架。如果`graceful=True`，这将阻塞，直到所有本地和远程 RPC 进程到达此方法并等待所有未完成的工作完成。否则，如果`graceful=False`，这是一个本地关闭，不会等待其他 RPC 进程到达此方法。 警告 -对于由[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")返回的[`Future`](futures.html#torch.futures.Future "torch.futures.Future")对象，在`shutdown()`之后不应调用`future.wait()`。 +对于由`rpc_async()`返回的`Future`对象，在`shutdown()`之后不应调用`future.wait()`。 参数 -**graceful**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 是否进行优雅关闭。如果为True，这将1）等待`UserRRefs`没有挂起的系统消息并删除它们；2）阻塞，直到所有本地和远程RPC进程到达此方法并等待所有未完成的工作完成。 +**graceful**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 是否进行优雅关闭。如果为 True，这将 1）等待`UserRRefs`没有挂起的系统消息并删除它们；2）阻塞，直到所有本地和远程 RPC 进程到达此方法并等待所有未完成的工作完成。 示例:: -确保在两个工作进程上正确设置`MASTER_ADDR`和`MASTER_PORT`。有关更多详细信息，请参考[`init_process_group()`](distributed.html#torch.distributed.init_process_group "torch.distributed.init_process_group") API。例如， +确保在两个工作进程上正确设置`MASTER_ADDR`和`MASTER_PORT`。有关更多详细信息，请参考`init_process_group()` API。例如， export MASTER_ADDR=localhost export MASTER_PORT=5678 @@ -342,13 +342,13 @@ export MASTER_ADDR=localhost export MASTER_PORT=5678 class torch.distributed.rpc.WorkerInfo¶ ``` -封装系统中工作进程信息的结构。包含工作进程的名称和ID。此类不应直接构造，而是可以通过[`get_worker_info()`](#torch.distributed.rpc.get_worker_info "torch.distributed.rpc.get_worker_info")检索实例，并将结果传递给函数，如[`rpc_sync()`](#torch.distributed.rpc.rpc_sync "torch.distributed.rpc.rpc_sync")、[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")、[`remote()`](#torch.distributed.rpc.remote "torch.distributed.rpc.remote")以避免在每次调用时复制字符串。 +封装系统中工作进程信息的结构。包含工作进程的名称和 ID。此类不应直接构造，而是可以通过`get_worker_info()`检索实例，并将结果传递给函数，如`rpc_sync()`、`rpc_async()`、`remote()`以避免在每次调用时复制字符串。 ```py property id¶ ``` -用于标识工作进程的全局唯一ID。 +用于标识工作进程的全局唯一 ID。 ```py property name¶ @@ -356,21 +356,21 @@ property name¶ 工作进程的名称。 -RPC包还提供了装饰器，允许应用程序指定在被调用方如何处理给定函数。 +RPC 包还提供了装饰器，允许应用程序指定在被调用方如何处理给定函数。 ```py torch.distributed.rpc.functions.async_execution(fn)¶ ``` -一个函数的装饰器，指示函数的返回值保证是一个[`Future`](futures.html#torch.futures.Future "torch.futures.Future")对象，并且此函数可以在RPC被调用方异步运行。更具体地说，被调用方提取由包装函数返回的[`Future`](futures.html#torch.futures.Future "torch.futures.Future")并将后续处理步骤安装为该[`Future`](futures.html#torch.futures.Future "torch.futures.Future")的回调。安装的回调将在完成时从[`Future`](futures.html#torch.futures.Future "torch.futures.Future")中读取值并将该值作为RPC响应发送回去。这也意味着返回的[`Future`](futures.html#torch.futures.Future "torch.futures.Future")仅存在于被调用方，并且永远不会通过RPC发送。当包装函数的执行需要暂停和恢复时，例如包含[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")或等待其他信号时，此装饰器非常有用。 +一个函数的装饰器，指示函数的返回值保证是一个`Future`对象，并且此函数可以在 RPC 被调用方异步运行。更具体地说，被调用方提取由包装函数返回的`Future`并将后续处理步骤安装为该`Future`的回调。安装的回调将在完成时从`Future`中读取值并将该值作为 RPC 响应发送回去。这也意味着返回的`Future`仅存在于被调用方，并且永远不会通过 RPC 发送。当包装函数的执行需要暂停和恢复时，例如包含`rpc_async()`或等待其他信号时，此装饰器非常有用。 注意 -为了启用异步执行，应用程序必须将此装饰器返回的函数对象传递给RPC API。如果RPC检测到此装饰器安装的属性，它会知道此函数返回一个`Future`对象，并相应处理。但是，这并不意味着在定义函数时此装饰器必须是最外层的。例如，与`@staticmethod`或`@classmethod`结合时，`@rpc.functions.async_execution`需要是内部装饰器，以允许目标函数被识别为静态或类函数。这个目标函数仍然可以异步执行，因为当访问时，静态或类方法保留了由`@rpc.functions.async_execution`安装的属性。 +为了启用异步执行，应用程序必须将此装饰器返回的函数对象传递给 RPC API。如果 RPC 检测到此装饰器安装的属性，它会知道此函数返回一个`Future`对象，并相应处理。但是，这并不意味着在定义函数时此装饰器必须是最外层的。例如，与`@staticmethod`或`@classmethod`结合时，`@rpc.functions.async_execution`需要是内部装饰器，以允许目标函数被识别为静态或类函数。这个目标函数仍然可以异步执行，因为当访问时，静态或类方法保留了由`@rpc.functions.async_execution`安装的属性。 示例:: -返回的[`Future`](futures.html#torch.futures.Future "torch.futures.Future")对象可以来自[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")、[`then()`](futures.html#torch.futures.Future.then "torch.futures.Future.then")或[`Future`](futures.html#torch.futures.Future "torch.futures.Future")构造函数。下面的示例展示了直接使用由[`then()`](futures.html#torch.futures.Future.then "torch.futures.Future.then")返回的[`Future`](futures.html#torch.futures.Future "torch.futures.Future")。 +返回的`Future`对象可以来自`rpc_async()`、`then()`或`Future`构造函数。下面的示例展示了直接使用由`then()`返回的`Future`。 ```py >>> from torch.distributed import rpc @@ -400,7 +400,7 @@ torch.distributed.rpc.functions.async_execution(fn)¶ >>> print(ret) # prints tensor([3., 3.]) ``` -与TorchScript装饰器结合时，此装饰器必须是最外层的。 +与 TorchScript 装饰器结合时，此装饰器必须是最外层的。 ```py >>> from torch import Tensor @@ -476,7 +476,7 @@ torch.distributed.rpc.functions.async_execution(fn)¶ >>> print(ret) # prints tensor([4., 4.]) ``` -此装饰器还与RRef助手一起使用，即。`torch.distributed.rpc.RRef.rpc_sync()`、`torch.distributed.rpc.RRef.rpc_async()`和`torch.distributed.rpc.RRef.remote()`。 +此装饰器还与 RRef 助手一起使用，即。`torch.distributed.rpc.RRef.rpc_sync()`、`torch.distributed.rpc.RRef.rpc_async()`和`torch.distributed.rpc.RRef.remote()`。 ```py >>> from torch.distributed import rpc @@ -497,7 +497,7 @@ torch.distributed.rpc.functions.async_execution(fn)¶ ### 后端 -RPC模块可以利用不同的后端来执行节点之间的通信。要使用的后端可以在[`init_rpc()`](#torch.distributed.rpc.init_rpc "torch.distributed.rpc.init_rpc")函数中指定，通过传递[`BackendType`](#torch.distributed.rpc.BackendType "torch.distributed.rpc.BackendType")枚举的某个值。无论使用什么后端，RPC API的其余部分都不会改变。每个后端还定义了自己的[`RpcBackendOptions`](#torch.distributed.rpc.RpcBackendOptions "torch.distributed.rpc.RpcBackendOptions")类的子类，该类的实例也可以传递给[`init_rpc()`](#torch.distributed.rpc.init_rpc "torch.distributed.rpc.init_rpc")以配置后端的行为。 +RPC 模块可以利用不同的后端来执行节点之间的通信。要使用的后端可以在`init_rpc()`函数中指定，通过传递`BackendType`枚举的某个值。无论使用什么后端，RPC API 的其余部分都不会改变。每个后端还定义了自己的`RpcBackendOptions`类的子类，该类的实例也可以传递给`init_rpc()`以配置后端的行为。 ```py class torch.distributed.rpc.BackendType(value)¶ @@ -505,31 +505,31 @@ class torch.distributed.rpc.BackendType(value)¶ 可用后端的枚举类。 -PyTorch内置了`BackendType.TENSORPIPE`后端。可以使用`register_backend()`函数注册其他后端。 +PyTorch 内置了`BackendType.TENSORPIPE`后端。可以使用`register_backend()`函数注册其他后端。 ```py class torch.distributed.rpc.RpcBackendOptions¶ ``` -封装传递给RPC后端的选项的抽象结构。可以将此类的实例传递给[`init_rpc()`](#torch.distributed.rpc.init_rpc "torch.distributed.rpc.init_rpc")以使用特定配置初始化RPC，例如RPC超时和要使用的`init_method`。 +封装传递给 RPC 后端的选项的抽象结构。可以将此类的实例传递给`init_rpc()`以使用特定配置初始化 RPC，例如 RPC 超时和要使用的`init_method`。 ```py property init_method¶ ``` -指定如何初始化进程组的URL。默认为`env://`。 +指定如何初始化进程组的 URL。默认为`env://`。 ```py property rpc_timeout¶ ``` -一个浮点数，表示用于所有RPC的超时时间。如果一个RPC在这个时间段内没有完成，它将以超时的异常完成。 +一个浮点数，表示用于所有 RPC 的超时时间。如果一个 RPC 在这个时间段内没有完成，它将以超时的异常完成。 -#### TensorPipe后端 +#### TensorPipe 后端 -TensorPipe代理是默认的，利用了[the TensorPipe library](https://github.com/pytorch/tensorpipe)，它提供了一种专门适用于机器学习的本地点对点通信原语，从根本上解决了Gloo的一些限制。与Gloo相比，它的优势在于是异步的，这允许大量的传输同时进行，每个传输以自己的速度进行，而不会相互阻塞。它只在需要时按需在节点对之间打开管道，当一个节点失败时，只有它的相关管道将被关闭，而所有其他管道将继续正常工作。此外，它能够支持多种不同的传输方式（TCP，当然，还有共享内存，NVLink，InfiniBand等），并且可以自动检测它们的可用性并协商用于每个管道的最佳传输方式。 +TensorPipe 代理是默认的，利用了[the TensorPipe library](https://github.com/pytorch/tensorpipe)，它提供了一种专门适用于机器学习的本地点对点通信原语，从根本上解决了 Gloo 的一些限制。与 Gloo 相比，它的优势在于是异步的，这允许大量的传输同时进行，每个传输以自己的速度进行，而不会相互阻塞。它只在需要时按需在节点对之间打开管道，当一个节点失败时，只有它的相关管道将被关闭，而所有其他管道将继续正常工作。此外，它能够支持多种不同的传输方式（TCP，当然，还有共享内存，NVLink，InfiniBand 等），并且可以自动检测它们的可用性并协商用于每个管道的最佳传输方式。 -TensorPipe后端已经在PyTorch v1.6中引入，并正在积极开发中。目前，它仅支持CPU张量，GPU支持即将到来。它配备了基于TCP的传输，就像Gloo一样。它还能够自动对大张量进行分块和多路复用，以实现非常高的带宽。代理将能够自行选择最佳传输方式，无需干预。 +TensorPipe 后端已经在 PyTorch v1.6 中引入，并正在积极开发中。目前，它仅支持 CPU 张量，GPU 支持即将到来。它配备了基于 TCP 的传输，就像 Gloo 一样。它还能够自动对大张量进行分块和多路复用，以实现非常高的带宽。代理将能够自行选择最佳传输方式，无需干预。 示例： @@ -556,19 +556,19 @@ TensorPipe后端已经在PyTorch v1.6中引入，并正在积极开发中。目 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`](#torch.distributed.rpc.RpcBackendOptions "torch.distributed.rpc.RpcBackendOptions")。 +`TensorPipeAgent`的后端选项，派生自`RpcBackendOptions`。 参数 + **num_worker_threads**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* *可选*) – `TensorPipeAgent`用于执行请求的线程池中的线程数（默认值：16）。 -+ **rpc_timeout**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*) – RPC请求的默认超时时间，以秒为单位（默认值：60秒）。如果RPC在此时间段内未完成，将引发指示的异常。调用者可以在需要时在[`rpc_sync()`](#torch.distributed.rpc.rpc_sync "torch.distributed.rpc.rpc_sync")和[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")中为单独的RPC覆盖此超时。 ++ **rpc_timeout**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*) – RPC 请求的默认超时时间，以秒为单位（默认值：60 秒）。如果 RPC 在此时间段内未完成，将引发指示的异常。调用者可以在需要时在`rpc_sync()`和`rpc_async()`中为单独的 RPC 覆盖此超时。 -+ **init_method**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *可选*) – 用于初始化用于会合的分布式存储的URL。它接受与[`init_process_group()`](distributed.html#torch.distributed.init_process_group "torch.distributed.init_process_group")的相同参数的任何值（默认值：`env://`）。 ++ **init_method**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *可选*) – 用于初始化用于会合的分布式存储的 URL。它接受与`init_process_group()`的相同参数的任何值（默认值：`env://`）。 + **device_maps**（*Dict**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*,* *Dict**]**,* *可选*) – 从此工作器到被调用者的设备放置映射。键是被调用者工作器名称，值是字典（`Dict` of `int`, `str`, or `torch.device`），将此工作器的设备映射到被调用者的设备。（默认值：`None`） -+ **devices**（List[int, str, or `torch.device`]，可选）– RPC代理使用的所有本地CUDA设备。默认情况下，它将被初始化为来自其自身`device_maps`和对等方`device_maps`的所有本地设备。在处理CUDA RPC请求时，代理将为此`List`中的所有设备正确同步CUDA流。 ++ **devices**（List[int, str, or `torch.device`]，可选）– RPC 代理使用的所有本地 CUDA 设备。默认情况下，它将被初始化为来自其自身`device_maps`和对等方`device_maps`的所有本地设备。在处理 CUDA RPC 请求时，代理将为此`List`中的所有设备正确同步 CUDA 流。 ```py property device_maps¶ @@ -586,7 +586,7 @@ property devices¶ property init_method¶ ``` -指定如何初始化进程组的URL。默认为`env://` +指定如何初始化进程组的 URL。默认为`env://` ```py property num_worker_threads¶ @@ -598,19 +598,19 @@ property num_worker_threads¶ property rpc_timeout¶ ``` -指示用于所有RPC的超时的浮点数。如果RPC在此时间段内未完成，它将以超时的异常完成。 +指示用于所有 RPC 的超时的浮点数。如果 RPC 在此时间段内未完成，它将以超时的异常完成。 ```py set_device_map(to, device_map)¶ ``` -设置每个RPC调用者和被调用者对之间的设备映射。此函数可以多次调用以逐步添加设备放置配置。 +设置每个 RPC 调用者和被调用者对之间的设备映射。此函数可以多次调用以逐步添加设备放置配置。 参数 + **to**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")）- 被调用者名称。 -+ **device_map**（*Dict* *of* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*, 或* [*torch.device*](tensor_attributes.html#torch.device "torch.device")）- 从此工作器到被调用者的设备放置映射。此映射必须是可逆的。 ++ **device_map**（*Dict* *of* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*, 或* *torch.device*）- 从此工作器到被调用者的设备放置映射。此映射必须是可逆的。 示例 @@ -651,43 +651,43 @@ set_device_map(to, device_map)¶ set_devices(devices)¶ ``` -设置TensorPipe RPC代理使用的本地设备。在处理CUDA RPC请求时，TensorPipe RPC代理将为此`List`中所有设备适当同步CUDA流。 +设置 TensorPipe RPC 代理使用的本地设备。在处理 CUDA RPC 请求时，TensorPipe RPC 代理将为此`List`中所有设备适当同步 CUDA 流。 参数 -**devices**（*List* *of* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*, 或* [*torch.device*](tensor_attributes.html#torch.device "torch.device")）- TensorPipe RPC代理使用的本地设备。 +**devices**（*List* *of* [*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*, 或* *torch.device*）- TensorPipe RPC 代理使用的本地设备。 注意 -RPC框架不会自动重试任何[`rpc_sync()`](#torch.distributed.rpc.rpc_sync "torch.distributed.rpc.rpc_sync")、[`rpc_async()`](#torch.distributed.rpc.rpc_async "torch.distributed.rpc.rpc_async")和[`remote()`](#torch.distributed.rpc.remote "torch.distributed.rpc.remote")调用。原因是RPC框架无法确定操作是否幂等，以及是否安全重试。因此，应用程序有责任处理失败并在必要时重试。RPC通信基于TCP，因此可能由于网络故障或间歇性网络连接问题而发生故障。在这种情况下，应用程序需要适当地重试，以合理的退避时间确保网络不会被过于激进的重试所压倒。## RRef +RPC 框架不会自动重试任何`rpc_sync()`、`rpc_async()`和`remote()`调用。原因是 RPC 框架无法确定操作是否幂等，以及是否安全重试。因此，应用程序有责任处理失败并在必要时重试。RPC 通信基于 TCP，因此可能由于网络故障或间歇性网络连接问题而发生故障。在这种情况下，应用程序需要适当地重试，以合理的退避时间确保网络不会被过于激进的重试所压倒。## RRef 警告 -在使用CUDA张量时，目前不支持RRefs +在使用 CUDA 张量时，目前不支持 RRefs -`RRef`（远程引用）是对远程工作器上某种类型`T`（例如`Tensor`）的值的引用。此句柄在所有者上保持引用的远程值保持活动状态，但并不意味着该值将来会传输到本地工作器。RRefs可以通过持有对其他工作器上存在的[nn.Modules](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)的引用，在多机训练中使用，并调用适当的函数在训练期间检索或修改它们的参数。有关更多详细信息，请参见[远程引用协议](rpc/rref.html#remote-reference-protocol)。 +`RRef`（远程引用）是对远程工作器上某种类型`T`（例如`Tensor`）的值的引用。此句柄在所有者上保持引用的远程值保持活动状态，但并不意味着该值将来会传输到本地工作器。RRefs 可以通过持有对其他工作器上存在的[nn.Modules](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)的引用，在多机训练中使用，并调用适当的函数在训练期间检索或修改它们的参数。有关更多详细信息，请参见远程引用协议。 ```py class torch.distributed.rpc.PyRRef(RRef)¶ ``` -封装对远程工作器上某种类型值的引用的类。此句柄将保持工作器上引用的远程值保持活动状态。当`UserRRef`被删除时，1）在应用程序代码和本地RRef上没有对它的引用，或2）应用程序已调用了优雅关闭时，`UserRRef`将被删除。在已删除的RRef上调用方法会导致未定义的行为。RRef实现仅提供尽力检测错误，应用程序不应在`rpc.shutdown()`之后使用`UserRRefs`。 +封装对远程工作器上某种类型值的引用的类。此句柄将保持工作器上引用的远程值保持活动状态。当`UserRRef`被删除时，1）在应用程序代码和本地 RRef 上没有对它的引用，或 2）应用程序已调用了优雅关闭时，`UserRRef`将被删除。在已删除的 RRef 上调用方法会导致未定义的行为。RRef 实现仅提供尽力检测错误，应用程序不应在`rpc.shutdown()`之后使用`UserRRefs`。 警告 -RRefs只能由RPC模块序列化和反序列化。在没有RPC的情况下序列化和反序列化RRefs（例如，Python pickle，torch [`save()`](generated/torch.save.html#torch.save "torch.save") / [`load()`](generated/torch.load.html#torch.load "torch.load")，JIT [`save()`](generated/torch.jit.save.html#torch.jit.save "torch.jit.save") / [`load()`](generated/torch.jit.load.html#torch.jit.load "torch.jit.load")等）会导致错误。 +RRefs 只能由 RPC 模块序列化和反序列化。在没有 RPC 的情况下序列化和反序列化 RRefs（例如，Python pickle，torch `save()` / `load()`，JIT `save()` / `load()`等）会导致错误。 参数 -+ **value**（[*object*](https://docs.python.org/3/library/functions.html#object "(in Python v3.12)")）- 要由此RRef包装的值。 ++ **value**（[*object*](https://docs.python.org/3/library/functions.html#object "(in Python v3.12)")）- 要由此 RRef 包装的值。 -+ **type_hint**（*Type**,* *可选*）- 应传递给`TorchScript`编译器作为`value`的类型提示的Python类型。 ++ **type_hint**（*Type**,* *可选*）- 应传递给`TorchScript`编译器作为`value`的类型提示的 Python 类型。 示例： -出于简单起见，以下示例跳过了RPC初始化和关闭代码。有关详细信息，请参阅RPC文档。 +出于简单起见，以下示例跳过了 RPC 初始化和关闭代码。有关详细信息，请参阅 RPC 文档。 -1. 使用rpc.remote创建一个RRef +1. 使用 rpc.remote 创建一个 RRef ```py >>> import torch @@ -697,7 +697,7 @@ RRefs只能由RPC模块序列化和反序列化。在没有RPC的情况下序列 >>> x = rref.to_here() ``` -1. 从本地对象创建一个RRef +1. 从本地对象创建一个 RRef ```py >>> import torch @@ -706,7 +706,7 @@ RRefs只能由RPC模块序列化和反序列化。在没有RPC的情况下序列 >>> rref = RRef(x) ``` -1. 与其他工作人员共享一个RRef +1. 与其他工作人员共享一个 RRef ```py >>> # On both worker0 and worker1: @@ -729,11 +729,11 @@ RRefs只能由RPC模块序列化和反序列化。在没有RPC的情况下序列 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()`](#torch.distributed.autograd.get_gradients "torch.distributed.autograd.get_gradients")来检索梯度。如果`dist_autograd_ctx_id`为`None`，则假定这是一个本地自动梯度图，我们只执行本地反向传递。在本地情况下，调用此API的节点必须是RRef的所有者。预期RRef的值是标量张量。 +> 使用 RRef 作为反向传递的根运行反向传递。如果提供了`dist_autograd_ctx_id`，我们将使用提供的 ctx_id 从 RRef 的所有者开始执行分布式反向传递。在这种情况下，应使用`get_gradients()`来检索梯度。如果`dist_autograd_ctx_id`为`None`，则假定这是一个本地自动梯度图，我们只执行本地反向传递。在本地情况下，调用此 API 的节点必须是 RRef 的所有者。预期 RRef 的值是标量张量。 参数 -+ **dist_autograd_ctx_id**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* *可选*）- 我们应该检索梯度的分布式自动梯度上下文id（默认值：-1）。 ++ **dist_autograd_ctx_id**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")*,* *可选*）- 我们应该检索梯度的分布式自动梯度上下文 id（默认值：-1）。 + **retain_graph**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *可选*）- 如果为`False`，用于计算梯度的图将被释放。请注意，在几乎所有情况下，将此选项设置为`True`是不需要的，并且通常可以以更高效的方式解决。通常，您需要将其设置为`True`以多次运行反向（默认值：False）。 @@ -749,7 +749,7 @@ backward(self: torch._C._distributed_rpc.PyRRef, dist_autograd_ctx_id: int = -1, confirmed_by_owner(self: torch._C._distributed_rpc.PyRRef) → bool¶ ``` -返回此`RRef`是否已被所有者确认。`OwnerRRef`始终返回true，而`UserRRef`仅在所有者知道此`UserRRef`时返回true。 +返回此`RRef`是否已被所有者确认。`OwnerRRef`始终返回 true，而`UserRRef`仅在所有者知道此`UserRRef`时返回 true。 ```py is_owner(self: torch._C._distributed_rpc.PyRRef) → bool¶ @@ -779,7 +779,7 @@ owner_name(self: torch._C._distributed_rpc.PyRRef) → str¶ remote(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object¶ ``` -创建一个辅助代理，以便使用拥有RRef的所有者作为目标轻松启动`remote`，以在此RRef引用的对象上运行函数。更具体地说，`rref.remote().func_name(*args, **kwargs)`等同于以下内容： +创建一个辅助代理，以便使用拥有 RRef 的所有者作为目标轻松启动`remote`，以在此 RRef 引用的对象上运行函数。更具体地说，`rref.remote().func_name(*args, **kwargs)`等同于以下内容： ```py >>> def run(rref, func_name, args, kwargs): @@ -790,7 +790,7 @@ remote(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object 参数 -**timeout**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*）- `rref.remote()`的超时时间。如果在超时时间内未成功完成此`RRef`的创建，则下次尝试使用RRef（例如`to_here`）时将引发超时。如果未提供，将使用默认的RPC超时时间。有关`RRef`的特定超时语义，请参见`rpc.remote()`。 +**timeout**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*）- `rref.remote()`的超时时间。如果在超时时间内未成功完成此`RRef`的创建，则下次尝试使用 RRef（例如`to_here`）时将引发超时。如果未提供，将使用默认的 RPC 超时时间。有关`RRef`的特定超时语义，请参见`rpc.remote()`。 示例： @@ -805,7 +805,7 @@ remote(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)`等同于以下内容： +创建一个辅助代理，以便使用拥有 RRef 的所有者作为目标轻松启动`rpc_async`，以在此 RRef 引用的对象上运行函数。更具体地说，`rref.rpc_async().func_name(*args, **kwargs)`等同于以下内容： ```py >>> def run(rref, func_name, args, kwargs): @@ -816,7 +816,7 @@ rpc_async(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → obj 参数 -**timeout**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*）- `rref.rpc_async()`的超时时间。如果在此时间范围内调用未完成，将引发指示的异常。如果未提供此参数，则将使用默认的RPC超时时间。 +**timeout**（[*float*](https://docs.python.org/3/library/functions.html#float "(in Python v3.12)")*,* *可选*）- `rref.rpc_async()`的超时时间。如果在此时间范围内调用未完成，将引发指示的异常。如果未提供此参数，则将使用默认的 RPC 超时时间。 示例:: @@ -831,7 +831,7 @@ rpc_async(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → obj rpc_sync(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object¶ ``` -创建一个辅助代理，以便使用RRef的所有者轻松启动`rpc_sync`，以运行此RRef引用的对象上的函数。更具体地说，`rref.rpc_sync().func_name(*args, **kwargs)`等同于以下内容： +创建一个辅助代理，以便使用 RRef 的所有者轻松启动`rpc_sync`，以运行此 RRef 引用的对象上的函数。更具体地说，`rref.rpc_sync().func_name(*args, **kwargs)`等同于以下内容： ```py >>> def run(rref, func_name, args, kwargs): @@ -842,7 +842,7 @@ rpc_sync(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → obje 参数 -**timeout** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*,* *optional*) – `rref.rpc_sync()`的超时时间。如果调用在此时间范围内未完成，将引发指示的异常。如果未提供此参数，则将使用默认的RPC超时时间。 +**timeout** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*,* *optional*) – `rref.rpc_sync()`的超时时间。如果调用在此时间范围内未完成，将引发指示的异常。如果未提供此参数，则将使用默认的 RPC 超时时间。 示例:: @@ -857,61 +857,61 @@ rpc_sync(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → obje to_here(self: torch._C._distributed_rpc.PyRRef, timeout: float = -1.0) → object¶ ``` -阻塞调用，将RRef的值从所有者复制到本地节点并返回。如果当前节点是所有者，则返回对本地值的引用。 +阻塞调用，将 RRef 的值从所有者复制到本地节点并返回。如果当前节点是所有者，则返回对本地值的引用。 参数 -**timeout** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*,* *optional*) – `to_here`的超时时间。如果调用在此时间范围内未完成，将引发指示的异常。如果未提供此参数，则将使用默认的RPC超时时间（60秒）。 +**timeout** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*,* *optional*) – `to_here`的超时时间。如果调用在此时间范围内未完成，将引发指示的异常。如果未提供此参数，则将使用默认的 RPC 超时时间（60 秒）。 -有关RRef的更多信息 +有关 RRef 的更多信息 -+ [远程引用协议](rpc/rref.html) ++ 远程引用协议 - + [背景](rpc/rref.html#background) + + 背景 - + [假设](rpc/rref.html#assumptions) + + 假设 - + [RRef生命周期](rpc/rref.html#rref-lifetime) + + RRef 生命周期 - + [设计原理](rpc/rref.html#design-reasoning) + + 设计原理 - + [实现](rpc/rref.html#implementation) + + 实现 - + [协议场景](rpc/rref.html#protocol-scenarios) + + 协议场景 - + [用户与所有者共享RRef作为返回值](rpc/rref.html#user-share-rref-with-owner-as-return-value) + + 用户与所有者共享 RRef 作为返回值 - + [用户与所有者共享RRef作为参数](rpc/rref.html#user-share-rref-with-owner-as-argument) + + 用户与所有者共享 RRef 作为参数 - + [所有者与用户共享RRef](rpc/rref.html#owner-share-rref-with-user) + + 所有者与用户共享 RRef - + [用户与用户共享RRef](rpc/rref.html#user-share-rref-with-user) ## RemoteModule[](#remotemodule "Permalink to this heading") + + 用户与用户共享 RRef ## RemoteModule[](#remotemodule "Permalink to this heading") 警告 -当前不支持使用CUDA张量时，RemoteModule +当前不支持使用 CUDA 张量时，RemoteModule -`RemoteModule`是在不同进程上轻松创建nn.Module的一种方式。实际模块驻留在远程主机上，但本地主机具有对此模块的句柄，并且可以像常规的nn.Module一样调用此模块。但是，调用会导致RPC调用到远程端，并且如果需要，可以通过RemoteModule支持的其他API以异步方式执行。 +`RemoteModule`是在不同进程上轻松创建 nn.Module 的一种方式。实际模块驻留在远程主机上，但本地主机具有对此模块的句柄，并且可以像常规的 nn.Module 一样调用此模块。但是，调用会导致 RPC 调用到远程端，并且如果需要，可以通过 RemoteModule 支持的其他 API 以异步方式执行。 ```py class torch.distributed.nn.api.remote_module.RemoteModule(*args, **kwargs)¶ ``` -> 只有在RPC初始化后才能创建RemoteModule实例。 +> 只有在 RPC 初始化后才能创建 RemoteModule 实例。 > > 它在指定的远程节点上创建一个用户指定的模块。它的行为类似于常规的`nn.Module`，只是`forward`方法在远程节点上执行。它负责自动求导记录，以确保反向传播梯度传播回相应的远程模块。 > -> 它根据`module_cls`的`forward`方法的签名生成两个方法`forward_async`和`forward`。`forward_async`以异步方式运行并返回一个Future。`forward_async`和`forward`的参数与由`module_cls`返回的模块的`forward`方法相同。 +> 它根据`module_cls`的`forward`方法的签名生成两个方法`forward_async`和`forward`。`forward_async`以异步方式运行并返回一个 Future。`forward_async`和`forward`的参数与由`module_cls`返回的模块的`forward`方法相同。 > -> 例如，如果`module_cls`返回`nn.Linear`的实例，该实例具有`forward`方法签名：`def forward(input: Tensor) -> Tensor:`，生成的`RemoteModule`将具有2个带有签名的方法： +> 例如，如果`module_cls`返回`nn.Linear`的实例，该实例具有`forward`方法签名：`def forward(input: Tensor) -> Tensor:`，生成的`RemoteModule`将具有 2 个带有签名的方法： > > `def forward(input: Tensor) -> Tensor:``def forward_async(input: Tensor) -> Future[Tensor]:` 参数 -+ **remote_device** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) – 我们希望将此模块放置在目标工作节点上的设备。格式应为“/”，其中设备字段可以解析为torch.device类型。例如，“trainer0/cpu”，“trainer0”，“ps0/cuda:0”。此外，设备字段可以是可选的，默认值为“cpu”。 ++ **remote_device** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 我们希望将此模块放置在目标工作节点上的设备。格式应为“/”，其中设备字段可以解析为 torch.device 类型。例如，“trainer0/cpu”，“trainer0”，“ps0/cuda:0”。此外，设备字段可以是可选的，默认值为“cpu”。 -+ **module_cls** ([*nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")) – ++ **module_cls** (*nn.Module*) – 用于在远程创建的模块的类。例如， @@ -971,7 +971,7 @@ get_module_rref()¶ 返回类型 -*RRef*[[*Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.modules.module.Module")] +*RRef*[*Module*] ```py remote_parameters(recurse=True)¶ @@ -979,7 +979,7 @@ remote_parameters(recurse=True)¶ 返回一个指向远程模块参数的 `RRef` 列表。 -这通常可以与 [`DistributedOptimizer`](distributed.optim.html#torch.distributed.optim.DistributedOptimizer "torch.distributed.optim.DistributedOptimizer") 结合使用。 +这通常可以与 `DistributedOptimizer` 结合使用。 参数 @@ -991,7 +991,7 @@ remote_parameters(recurse=True)¶ 返回类型 -[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*RRef*[[*Parameter*](generated/torch.nn.parameter.Parameter.html#torch.nn.parameter.Parameter "torch.nn.parameter.Parameter")]] +[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")*RRef*[[*Parameter*]] ## 分布式自动求导框架[](#distributed-autograd-framework "跳转到此标题") @@ -999,17 +999,17 @@ remote_parameters(recurse=True)¶ 当使用 CUDA 张量时，不支持分布式自动求导 -这个模块提供了一个基于 RPC 的分布式自动求导框架，可用于诸如模型并行训练等应用。简而言之，应用程序可以通过 RPC 发送和接收梯度记录张量。在前向传播中，当梯度记录张量通过 RPC 发送时，我们记录下来；在反向传播过程中，我们使用这些信息来使用 RPC 执行分布式反向传播。更多细节请参见[分布式自动求导设计](rpc/distributed_autograd.html#distributed-autograd-design)。 +这个模块提供了一个基于 RPC 的分布式自动求导框架，可用于诸如模型并行训练等应用。简而言之，应用程序可以通过 RPC 发送和接收梯度记录张量。在前向传播中，当梯度记录张量通过 RPC 发送时，我们记录下来；在反向传播过程中，我们使用这些信息来使用 RPC 执行分布式反向传播。更多细节请参见分布式自动求导设计。 ```py torch.distributed.autograd.backward(context_id: int, roots: List[Tensor], retain_graph=False) → None¶ ``` -使用提供的根启动分布式反向传播。目前实现了[FAST mode 算法](rpc/distributed_autograd.html#fast-mode-algorithm)，该算法假定在同一分布式自动求导上下文中的所有 RPC 消息在反向传播过程中都将成为自动求导图的一部分。 +使用提供的根启动分布式反向传播。目前实现了 FAST mode 算法，该算法假定在同一分布式自动求导上下文中的所有 RPC 消息在反向传播过程中都将成为自动求导图的一部分。 我们使用提供的根来发现自动求导图并计算适当的依赖关系。此方法会阻塞，直到整个自动求导计算完成。 -我们在每个节点的适当 [`torch.distributed.autograd.context`](#torch.distributed.autograd.context "torch.distributed.autograd.context") 中累积梯度。要使用的自动求导上下文是根据传入的 `context_id` 查找的，当调用 [`torch.distributed.autograd.backward()`](#torch.distributed.autograd.backward "torch.distributed.autograd.backward") 时传入。如果没有与给定 ID 对应的有效自动求导上下文，我们会抛出错误。您可以使用 [`get_gradients()`](#torch.distributed.autograd.get_gradients "torch.distributed.autograd.get_gradients") API 检索累积的梯度。 +我们在每个节点的适当 `torch.distributed.autograd.context` 中累积梯度。要使用的自动求导上下文是根据传入的 `context_id` 查找的，当调用 `torch.distributed.autograd.backward()` 时传入。如果没有与给定 ID 对应的有效自动求导上下文，我们会抛出错误。您可以使用 `get_gradients()` API 检索累积的梯度。 参数 @@ -1017,7 +1017,7 @@ torch.distributed.autograd.backward(context_id: int, roots: List[Tensor], retain + **roots**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")）- 代表自动求导计算的根的张量。所有张量应为标量。 -+ **retain_graph**（*bool*，可选） - 如果为False，则用于计算梯度的图将被释放。请注意，在几乎所有情况下，将此选项设置为True是不需要的，并且通常可以以更高效的方式解决。通常，您需要将其设置为True以多次运行反向传递。 ++ **retain_graph**（*bool*，可选） - 如果为 False，则用于计算梯度的图将被释放。请注意，在几乎所有情况下，将此选项设置为 True 是不需要的，并且通常可以以更高效的方式解决。通常，您需要将其设置为 True 以多次运行反向传递。 示例:: @@ -1074,27 +1074,27 @@ torch.distributed.autograd.get_gradients(context_id: int) → Dict[Tensor, Tenso >>> print(grads[t2]) ``` -有关RPC自动求导的更多信息 +有关 RPC 自动求导的更多信息 -+ [分布式自动求导设计](rpc/distributed_autograd.html) ++ 分布式自动求导设计 - + [背景](rpc/distributed_autograd.html#background) + + 背景 - + [前向传递期间的自动求导记录](rpc/distributed_autograd.html#autograd-recording-during-the-forward-pass) + + 前向传递期间的自动求导记录 - + [分布式自动求导上下文](rpc/distributed_autograd.html#distributed-autograd-context) + + 分布式自动求导上下文 - + [分布式后向传递](rpc/distributed_autograd.html#distributed-backward-pass) + + 分布式后向传递 - + [计算依赖关系](rpc/distributed_autograd.html#computing-dependencies) + + 计算依赖关系 - + [FAST模式算法](rpc/distributed_autograd.html#fast-mode-algorithm) + + FAST 模式算法 - + [SMART模式算法](rpc/distributed_autograd.html#smart-mode-algorithm) + + SMART 模式算法 - + [分布式优化器](rpc/distributed_autograd.html#distributed-optimizer) + + 分布式优化器 - + [简单的端到端示例](rpc/distributed_autograd.html#simple-end-to-end-example) + + 简单的端到端示例 ## 分布式优化器 @@ -1102,26 +1102,26 @@ torch.distributed.autograd.get_gradients(context_id: int) → Dict[Tensor, Tenso ## 设计说明 -分布式自动求导设计说明涵盖了基于RPC的分布式自动求导框架的设计，对于模型并行训练等应用非常有用。 +分布式自动求导设计说明涵盖了基于 RPC 的分布式自动求导框架的设计，对于模型并行训练等应用非常有用。 -+ [分布式自动求导设计](rpc/distributed_autograd.html#distributed-autograd-design) ++ 分布式自动求导设计 -RRef设计说明涵盖了[RRef](#rref)（远程引用）协议的设计，该协议用于通过框架引用远程工作进程上的值。 +RRef 设计说明涵盖了 RRef（远程引用）协议的设计，该协议用于通过框架引用远程工作进程上的值。 -+ [远程引用协议](rpc/rref.html#remote-reference-protocol) ++ 远程引用协议 ## 教程 -RPC教程介绍了用户如何使用RPC框架，提供了几个示例应用程序，使用torch.distributed.rpc API，并演示如何使用分析器来分析基于RPC的工作负载。 +RPC 教程介绍了用户如何使用 RPC 框架，提供了几个示例应用程序，使用 torch.distributed.rpc API，并演示如何使用分析器来分析基于 RPC 的工作负载。 -+ 使用分布式RPC框架入门 ++ 使用分布式 RPC 框架入门 -+ [使用分布式RPC框架实现参数服务器](https://pytorch.org/tutorials/intermediate/rpc_param_server_tutorial.html) ++ [使用分布式 RPC 框架实现参数服务器](https://pytorch.org/tutorials/intermediate/rpc_param_server_tutorial.html) -+ [将分布式数据并行与分布式RPC框架结合使用](https://pytorch.org/tutorials/advanced/rpc_ddp_tutorial.html)（涵盖**RemoteModule**） ++ [将分布式数据并行与分布式 RPC 框架结合使用](https://pytorch.org/tutorials/advanced/rpc_ddp_tutorial.html)（涵盖**RemoteModule**） -+ [基于RPC的工作负载分析](https://pytorch.org/tutorials/recipes/distributed_rpc_profiling.html) ++ [基于 RPC 的工作负载分析](https://pytorch.org/tutorials/recipes/distributed_rpc_profiling.html) -+ [实现批处理RPC处理](https://pytorch.org/tutorials/intermediate/rpc_async_execution.html) ++ [实现批处理 RPC 处理](https://pytorch.org/tutorials/intermediate/rpc_async_execution.html) + [分布式管道并行](https://pytorch.org/tutorials/intermediate/dist_pipeline_parallel_tutorial.html) diff --git a/totrans/doc22_076.md b/totrans/doc22_076.md index 29c22101..6ada1c26 100644 --- a/totrans/doc22_076.md +++ b/totrans/doc22_076.md @@ -1,68 +1,68 @@ # torch.random -> 原文：[https://pytorch.org/docs/stable/random.html](https://pytorch.org/docs/stable/random.html) +> 原文：[`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')¶ ``` -分叉RNG，以便在返回时，RNG被重置为先前的状态。 +分叉 RNG，以便在返回时，RNG 被重置为先前的状态。 参数 -+ **devices** (*可迭代的* *设备ID*) – 要分叉RNG的设备。CPU RNG状态始终被分叉。默认情况下，[`fork_rng()`](#torch.random.fork_rng "torch.random.fork_rng")在所有设备上操作，但如果您的机器有很多设备，此函数将运行非常缓慢，将发出警告。如果您明确指定设备，则此警告将被抑制 ++ **devices** (*可迭代的* *设备 ID*) – 要分叉 RNG 的设备。CPU RNG 状态始终被分叉。默认情况下，`fork_rng()`在所有设备上操作，但如果您的机器有很多设备，此函数将运行非常缓慢，将发出警告。如果您明确指定设备，则此警告将被抑制 -+ **enabled** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")) – 如果为`False`，则不分叉RNG。这是一个方便的参数，可以轻松禁用上下文管理器，而无需删除它并将Python代码缩进在其下面。 ++ **enabled** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 如果为`False`，则不分叉 RNG。这是一个方便的参数，可以轻松禁用上下文管理器，而无需删除它并将 Python 代码缩进在其下面。 -+ **deivce_type** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) – 设备类型str，默认为cuda。至于自定义设备，请参阅[注：支持带有privateuse1的自定义设备] ++ **deivce_type** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 设备类型 str，默认为 cuda。至于自定义设备，请参阅[注：支持带有 privateuse1 的自定义设备] 返回类型 -[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在Python v3.12中)") +[*生成器*](https://docs.python.org/3/library/typing.html#typing.Generator "(在 Python v3.12 中)") ```py torch.random.get_rng_state()¶ ``` -将随机数生成器状态返回为torch.ByteTensor。 +将随机数生成器状态返回为 torch.ByteTensor。 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* ```py torch.random.initial_seed()¶ ``` -返回生成随机数的初始种子作为Python长整型。 +返回生成随机数的初始种子作为 Python 长整型。 返回类型 -[int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)") +[int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)") ```py torch.random.manual_seed(seed)¶ ``` -设置生成随机数的种子。返回一个torch.Generator对象。 +设置生成随机数的种子。返回一个 torch.Generator 对象。 参数 -**seed** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) – 所需种子。值必须在包含范围[-0x8000_0000_0000_0000, 0xffff_ffff_ffff_ffff]内。否则，将引发RuntimeError。负输入将使用公式0xffff_ffff_ffff_ffff + seed重新映射为正值。 +**seed** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – 所需种子。值必须在包含范围[-0x8000_0000_0000_0000, 0xffff_ffff_ffff_ffff]内。否则，将引发 RuntimeError。负输入将使用公式 0xffff_ffff_ffff_ffff + seed 重新映射为正值。 返回类型 -[*生成器*](generated/torch.Generator.html#torch.Generator "torch._C.Generator") +*生成器* ```py torch.random.seed()¶ ``` -将生成随机数的种子设置为非确定性随机数。返回用于种子RNG的64位数字。 +将生成随机数的种子设置为非确定性随机数。返回用于种子 RNG 的 64 位数字。 返回类型 -[int](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)") +[int](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)") ```py torch.random.set_rng_state(new_state)¶ diff --git a/totrans/doc22_077.md b/totrans/doc22_077.md index ea07cb80..d27e26ed 100644 --- a/totrans/doc22_077.md +++ b/totrans/doc22_077.md @@ -1,6 +1,6 @@ # torch.masked -> [https://pytorch.org/docs/stable/masked.html](https://pytorch.org/docs/stable/masked.html) +> [`pytorch.org/docs/stable/masked.html`](https://pytorch.org/docs/stable/masked.html) ## 介绍 @@ -8,192 +8,192 @@ 警告 -Masked张量的PyTorch API处于原型阶段，未来可能会发生变化。 +Masked 张量的 PyTorch API 处于原型阶段，未来可能会发生变化。 -MaskedTensor作为[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")的扩展，为用户提供以下功能： +MaskedTensor 作为`torch.Tensor`的扩展，为用户提供以下功能： + 使用任何掩码语义（例如，可变长度张量，nan*运算符等）。 -+ 区分0和NaN梯度 ++ 区分 0 和 NaN 梯度 + 各种稀疏应用（请参见下面的教程） -“指定”和“未指定”在PyTorch中有着悠久的历史，没有正式的语义，当然也没有一致性；事实上，MaskedTensor是在积累了一系列问题之后诞生的，这些问题普通的[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")类无法正确解决。因此，MaskedTensor的主要目标是成为PyTorch中“指定”和“未指定”值的真相来源，使其成为一等公民而不是一个事后想法。这应该进一步释放[稀疏性](https://pytorch.org/docs/stable/sparse.html)的潜力，实现更安全和更一致的运算符，并为用户和开发人员提供更流畅、更直观的体验。 +“指定”和“未指定”在 PyTorch 中有着悠久的历史，没有正式的语义，当然也没有一致性；事实上，MaskedTensor 是在积累了一系列问题之后诞生的，这些问题普通的`torch.Tensor`类无法正确解决。因此，MaskedTensor 的主要目标是成为 PyTorch 中“指定”和“未指定”值的真相来源，使其成为一等公民而不是一个事后想法。这应该进一步释放[稀疏性](https://pytorch.org/docs/stable/sparse.html)的潜力，实现更安全和更一致的运算符，并为用户和开发人员提供更流畅、更直观的体验。 -### 什么是MaskedTensor？ +### 什么是 MaskedTensor？ -MaskedTensor是一个张量子类，由1）输入（数据）和2）掩码组成。掩码告诉我们应该包含或忽略输入中的哪些条目。 +MaskedTensor 是一个张量子类，由 1）输入（数据）和 2）掩码组成。掩码告诉我们应该包含或忽略输入中的哪些条目。 -举例来说，假设我们想要掩盖所有等于0的值（用灰色表示）并取最大值： +举例来说，假设我们想要掩盖所有等于 0 的值（用灰色表示）并取最大值： -[![_images/tensor_comparison.jpg](../Images/f5788f266e7378201824743b6b1b7283.png)](_images/tensor_comparison.jpg) +![_images/tensor_comparison.jpg](img/tensor_comparison.jpg) -顶部是普通张量示例，底部是MaskedTensor，其中所有的0都被掩盖了。这显然会产生不同的结果，取决于我们是否有掩码，但这种灵活的结构允许用户在计算过程中系统地忽略任何他们想要的元素。 +顶部是普通张量示例，底部是 MaskedTensor，其中所有的 0 都被掩盖了。这显然会产生不同的结果，取决于我们是否有掩码，但这种灵活的结构允许用户在计算过程中系统地忽略任何他们想要的元素。 我们已经撰写了许多现有的教程，以帮助用户入门，例如： -+ [概述 - 新用户的起点，讨论如何使用MaskedTensors以及它们的用处](https://pytorch.org/tutorials/prototype/maskedtensor_overview) ++ [概述 - 新用户的起点，讨论如何使用 MaskedTensors 以及它们的用处](https://pytorch.org/tutorials/prototype/maskedtensor_overview) -+ [稀疏性 - MaskedTensor支持稀疏的COO和CSR数据以及掩码张量](https://pytorch.org/tutorials/prototype/maskedtensor_sparsity) ++ [稀疏性 - MaskedTensor 支持稀疏的 COO 和 CSR 数据以及掩码张量](https://pytorch.org/tutorials/prototype/maskedtensor_sparsity) -+ [Adagrad稀疏语义 - 一个实际示例，展示了MaskedTensor如何简化稀疏语义和实现](https://pytorch.org/tutorials/prototype/maskedtensor_adagrad) ++ [Adagrad 稀疏语义 - 一个实际示例，展示了 MaskedTensor 如何简化稀疏语义和实现](https://pytorch.org/tutorials/prototype/maskedtensor_adagrad) -+ [高级语义 - 讨论为什么做出某些决定（例如，要求掩码匹配二进制/缩减操作，与NumPy的MaskedArray的区别以及缩减语义）](https://pytorch.org/tutorials/prototype/maskedtensor_advanced_semantics) ++ [高级语义 - 讨论为什么做出某些决定（例如，要求掩码匹配二进制/缩减操作，与 NumPy 的 MaskedArray 的区别以及缩减语义）](https://pytorch.org/tutorials/prototype/maskedtensor_advanced_semantics) ## 支持的运算符 ### 一元运算符 -一元运算符是只包含单个输入的运算符。将它们应用于MaskedTensors相对简单：如果在给定索引处数据被掩盖，我们应用运算符，否则我们将继续掩盖数据。 +一元运算符是只包含单个输入的运算符。将它们应用于 MaskedTensors 相对简单：如果在给定索引处数据被掩盖，我们应用运算符，否则我们将继续掩盖数据。 可用的一元运算符有： -| [`abs`](generated/torch.abs.html#torch.abs "torch.abs") | 计算`input`中每个元素的绝对值。 | +| `abs` | 计算`input`中每个元素的绝对值。 | | --- | --- | -| [`absolute`](generated/torch.absolute.html#torch.absolute "torch.absolute") | [`torch.abs()`](generated/torch.abs.html#torch.abs "torch.abs")的别名 | -| [`acos`](generated/torch.acos.html#torch.acos "torch.acos") | 计算`input`中每个元素的反余弦。 | -| [`arccos`](generated/torch.arccos.html#torch.arccos "torch.arccos") | [`torch.acos()`](generated/torch.acos.html#torch.acos "torch.acos")的别名。 | -| [`acosh`](generated/torch.acosh.html#torch.acosh "torch.acosh") | 返回一个新的张量，其中包含`input`元素的反双曲余弦。 | -| [`arccosh`](generated/torch.arccosh.html#torch.arccosh "torch.arccosh") | [`torch.acosh()`](generated/torch.acosh.html#torch.acosh "torch.acosh")的别名。 | -| [`angle`](generated/torch.angle.html#torch.angle "torch.angle") | 计算给定`input`张量的逐元素角度（弧度）。 | -| [`asin`](generated/torch.asin.html#torch.asin "torch.asin") | 返回一个新张量，其中元素是`input`的反正弦。 | -| [`arcsin`](generated/torch.arcsin.html#torch.arcsin "torch.arcsin") | [`torch.asin()`](generated/torch.asin.html#torch.asin "torch.asin")的别名。 | -| [`asinh`](generated/torch.asinh.html#torch.asinh "torch.asinh") | 返回一个新张量，其中元素是`input`的反双曲正弦。 | -| [`arcsinh`](generated/torch.arcsinh.html#torch.arcsinh "torch.arcsinh") | [`torch.asinh()`](generated/torch.asinh.html#torch.asinh "torch.asinh")的别名。 | -| [`atan`](generated/torch.atan.html#torch.atan "torch.atan") | 返回一个新张量，其中元素是`input`的反正切。 | -| [`arctan`](generated/torch.arctan.html#torch.arctan "torch.arctan") | [`torch.atan()`](generated/torch.atan.html#torch.atan "torch.atan")的别名。 | -| [`atanh`](generated/torch.atanh.html#torch.atanh "torch.atanh") | 返回一个新张量，其中元素是`input`的反双曲正切。 | -| [`arctanh`](generated/torch.arctanh.html#torch.arctanh "torch.arctanh") | [`torch.atanh()`](generated/torch.atanh.html#torch.atanh "torch.atanh")的别名。 | -| [`bitwise_not`](generated/torch.bitwise_not.html#torch.bitwise_not "torch.bitwise_not") | 计算给定输入张量的按位取反。 | -| [`ceil`](generated/torch.ceil.html#torch.ceil "torch.ceil") | 返回一个新张量，其中元素是`input`的上取整，即大于或等于每个元素的最小整数。 | -| [`clamp`](generated/torch.clamp.html#torch.clamp "torch.clamp") | 将`input`中的所有元素夹紧到[ [`min`](generated/torch.min.html#torch.min "torch.min"), [`max`](generated/torch.max.html#torch.max "torch.max") ]范围内。 | -| [`clip`](generated/torch.clip.html#torch.clip "torch.clip") | [`torch.clamp()`](generated/torch.clamp.html#torch.clamp "torch.clamp")的别名。 | -| [`conj_physical`](generated/torch.conj_physical.html#torch.conj_physical "torch.conj_physical") | 计算给定`input`张量的逐元素共轭。 | -| [`cos`](generated/torch.cos.html#torch.cos "torch.cos") | 返回一个新张量，其中元素是`input`的余弦。 | -| [`cosh`](generated/torch.cosh.html#torch.cosh "torch.cosh") | 返回一个新张量，其中元素是`input`的双曲余弦。 | -| [`deg2rad`](generated/torch.deg2rad.html#torch.deg2rad "torch.deg2rad") | 返回一个新张量，其中`input`的每个元素从角度转换为弧度。 | -| [`digamma`](generated/torch.digamma.html#torch.digamma "torch.digamma") | [`torch.special.digamma()`](special.html#torch.special.digamma "torch.special.digamma")的别名。 | -| [`erf`](generated/torch.erf.html#torch.erf "torch.erf") | [`torch.special.erf()`](special.html#torch.special.erf "torch.special.erf")的别名。 | -| [`erfc`](generated/torch.erfc.html#torch.erfc "torch.erfc") | [`torch.special.erfc()`](special.html#torch.special.erfc "torch.special.erfc")的别名。 | -| [`erfinv`](generated/torch.erfinv.html#torch.erfinv "torch.erfinv") | [`torch.special.erfinv()`](special.html#torch.special.erfinv "torch.special.erfinv")的别名。 | -| [`exp`](generated/torch.exp.html#torch.exp "torch.exp") | 返回一个新张量，其中元素是输入张量`input`的指数。 | -| [`exp2`](generated/torch.exp2.html#torch.exp2 "torch.exp2") | [`torch.special.exp2()`](special.html#torch.special.exp2 "torch.special.exp2")的别名。 | -| [`expm1`](generated/torch.expm1.html#torch.expm1 "torch.expm1") | [`torch.special.expm1()`](special.html#torch.special.expm1 "torch.special.expm1")的别名。 | -| [`fix`](generated/torch.fix.html#torch.fix "torch.fix") | [`torch.trunc()`](generated/torch.trunc.html#torch.trunc "torch.trunc")的别名。 | -| [`floor`](generated/torch.floor.html#torch.floor "torch.floor") | 返回一个新的张量，其中每个元素的下限，即小于或等于每个元素的最大整数。 | -| [`frac`](generated/torch.frac.html#torch.frac "torch.frac") | 计算`input`中每个元素的小数部分。 | -| [`lgamma`](generated/torch.lgamma.html#torch.lgamma "torch.lgamma") | 计算`input`上伽玛函数的绝对值的自然对数。 | -| [`log`](generated/torch.log.html#torch.log "torch.log") | 返回一个新的张量，其中每个元素的自然对数。 | -| [`log10`](generated/torch.log10.html#torch.log10 "torch.log10") | 返回一个新的张量，其中每个元素的以10为底的对数。 | -| [`log1p`](generated/torch.log1p.html#torch.log1p "torch.log1p") | 返回一个新的张量，其中每个元素的自然对数(1 + `input`)。 | -| [`log2`](generated/torch.log2.html#torch.log2 "torch.log2") | 返回一个新的张量，其中每个元素的以2为底的对数。 | -| [`logit`](generated/torch.logit.html#torch.logit "torch.logit") | [`torch.special.logit()`](special.html#torch.special.logit "torch.special.logit")的别名。 | -| [`i0`](generated/torch.i0.html#torch.i0 "torch.i0") | [`torch.special.i0()`](special.html#torch.special.i0 "torch.special.i0")的别名。 | -| [`isnan`](generated/torch.isnan.html#torch.isnan "torch.isnan") | 返回一个新的张量，其中布尔元素表示`input`的每个元素是否为NaN。 | -| [`nan_to_num`](generated/torch.nan_to_num.html#torch.nan_to_num "torch.nan_to_num") | 用`nan`、`posinf`和`neginf`指定的值替换`input`中的`NaN`、正无穷大和负无穷大值。 | -| [`neg`](generated/torch.neg.html#torch.neg "torch.neg") | 返回一个新的张量，其中每个元素的负值。 | -| [`negative`](generated/torch.negative.html#torch.negative "torch.negative") | [`torch.neg()`](generated/torch.neg.html#torch.neg "torch.neg")的别名。 | -| [`positive`](generated/torch.positive.html#torch.positive "torch.positive") | 返回`input`。 | -| [`pow`](generated/torch.pow.html#torch.pow "torch.pow") | 将`input`中的每个元素与`exponent`的幂相乘，并返回结果张量。 | -| [`rad2deg`](generated/torch.rad2deg.html#torch.rad2deg "torch.rad2deg") | 返回一个新的张量，其中`input`的每个元素从弧度转换为角度。 | -| [`reciprocal`](generated/torch.reciprocal.html#torch.reciprocal "torch.reciprocal") | 返回一个新的张量，其中每个元素的倒数。 | -| [`round`](generated/torch.round.html#torch.round "torch.round") | 将`input`的元素四舍五入到最近的整数。 | -| [`rsqrt`](generated/torch.rsqrt.html#torch.rsqrt "torch.rsqrt") | 返回一个新的张量，其中每个元素的倒数的平方根。 | -| [`sigmoid`](generated/torch.sigmoid.html#torch.sigmoid "torch.sigmoid") | [`torch.special.expit()`](special.html#torch.special.expit "torch.special.expit")的别名。 | -| [`sign`](generated/torch.sign.html#torch.sign "torch.sign") | 返回一个新的张量，其中每个元素的符号。 | -| [`sgn`](generated/torch.sgn.html#torch.sgn "torch.sgn") | 这个函数是对复数张量的torch.sign()的扩展。 | -| [`signbit`](generated/torch.signbit.html#torch.signbit "torch.signbit") | 检查`input`的每个元素是否设置了符号位。 | -| [`sin`](generated/torch.sin.html#torch.sin "torch.sin") | 返回一个新的张量，其中每个元素的正弦值。 | -| [`sinc`](generated/torch.sinc.html#torch.sinc "torch.sinc") | [`torch.special.sinc()`](special.html#torch.special.sinc "torch.special.sinc")的别名。 | -| [`sinh`](generated/torch.sinh.html#torch.sinh "torch.sinh") | 返回一个新的张量，其中包含`input`元素的双曲正弦。 | -| [`sqrt`](generated/torch.sqrt.html#torch.sqrt "torch.sqrt") | 返回一个新的张量，其中包含`input`元素的平方根。 | -| [`square`](generated/torch.square.html#torch.square "torch.square") | 返回一个新的张量，其中包含`input`元素的平方。 | -| [`tan`](generated/torch.tan.html#torch.tan "torch.tan") | 返回一个新的张量，其中包含`input`元素的正切。 | -| [`tanh`](generated/torch.tanh.html#torch.tanh "torch.tanh") | 返回一个新的张量，其中包含`input`元素的双曲正切。 | -| [`trunc`](generated/torch.trunc.html#torch.trunc "torch.trunc") | 返回一个新的张量，其中包含`input`元素的截断整数值。 | +| `absolute` | `torch.abs()`的别名 | +| `acos` | 计算`input`中每个元素的反余弦。 | +| `arccos` | `torch.acos()`的别名。 | +| `acosh` | 返回一个新的张量，其中包含`input`元素的反双曲余弦。 | +| `arccosh` | `torch.acosh()`的别名。 | +| `angle` | 计算给定`input`张量的逐元素角度（弧度）。 | +| `asin` | 返回一个新张量，其中元素是`input`的反正弦。 | +| `arcsin` | `torch.asin()`的别名。 | +| `asinh` | 返回一个新张量，其中元素是`input`的反双曲正弦。 | +| `arcsinh` | `torch.asinh()`的别名。 | +| `atan` | 返回一个新张量，其中元素是`input`的反正切。 | +| `arctan` | `torch.atan()`的别名。 | +| `atanh` | 返回一个新张量，其中元素是`input`的反双曲正切。 | +| `arctanh` | `torch.atanh()`的别名。 | +| `bitwise_not` | 计算给定输入张量的按位取反。 | +| `ceil` | 返回一个新张量，其中元素是`input`的上取整，即大于或等于每个元素的最小整数。 | +| `clamp` | 将`input`中的所有元素夹紧到 [`min`, `max` ]范围内。 | +| `clip` | `torch.clamp()`的别名。 | +| `conj_physical` | 计算给定`input`张量的逐元素共轭。 | +| `cos` | 返回一个新张量，其中元素是`input`的余弦。 | +| `cosh` | 返回一个新张量，其中元素是`input`的双曲余弦。 | +| `deg2rad` | 返回一个新张量，其中`input`的每个元素从角度转换为弧度。 | +| `digamma` | `torch.special.digamma()`的别名。 | +| `erf` | `torch.special.erf()`的别名。 | +| `erfc` | `torch.special.erfc()`的别名。 | +| `erfinv` | `torch.special.erfinv()`的别名。 | +| `exp` | 返回一个新张量，其中元素是输入张量`input`的指数。 | +| `exp2` | `torch.special.exp2()`的别名。 | +| `expm1` | `torch.special.expm1()`的别名。 | +| `fix` | `torch.trunc()`的别名。 | +| `floor` | 返回一个新的张量，其中每个元素的下限，即小于或等于每个元素的最大整数。 | +| `frac` | 计算`input`中每个元素的小数部分。 | +| `lgamma` | 计算`input`上伽玛函数的绝对值的自然对数。 | +| `log` | 返回一个新的张量，其中每个元素的自然对数。 | +| `log10` | 返回一个新的张量，其中每个元素的以 10 为底的对数。 | +| `log1p` | 返回一个新的张量，其中每个元素的自然对数(1 + `input`)。 | +| `log2` | 返回一个新的张量，其中每个元素的以 2 为底的对数。 | +| `logit` | `torch.special.logit()`的别名。 | +| `i0` | `torch.special.i0()`的别名。 | +| `isnan` | 返回一个新的张量，其中布尔元素表示`input`的每个元素是否为 NaN。 | +| `nan_to_num` | 用`nan`、`posinf`和`neginf`指定的值替换`input`中的`NaN`、正无穷大和负无穷大值。 | +| `neg` | 返回一个新的张量，其中每个元素的负值。 | +| `negative` | `torch.neg()`的别名。 | +| `positive` | 返回`input`。 | +| `pow` | 将`input`中的每个元素与`exponent`的幂相乘，并返回结果张量。 | +| `rad2deg` | 返回一个新的张量，其中`input`的每个元素从弧度转换为角度。 | +| `reciprocal` | 返回一个新的张量，其中每个元素的倒数。 | +| `round` | 将`input`的元素四舍五入到最近的整数。 | +| `rsqrt` | 返回一个新的张量，其中每个元素的倒数的平方根。 | +| `sigmoid` | `torch.special.expit()`的别名。 | +| `sign` | 返回一个新的张量，其中每个元素的符号。 | +| `sgn` | 这个函数是对复数张量的 torch.sign()的扩展。 | +| `signbit` | 检查`input`的每个元素是否设置了符号位。 | +| `sin` | 返回一个新的张量，其中每个元素的正弦值。 | +| `sinc` | `torch.special.sinc()`的别名。 | +| `sinh` | 返回一个新的张量，其中包含`input`元素的双曲正弦。 | +| `sqrt` | 返回一个新的张量，其中包含`input`元素的平方根。 | +| `square` | 返回一个新的张量，其中包含`input`元素的平方。 | +| `tan` | 返回一个新的张量，其中包含`input`元素的正切。 | +| `tanh` | 返回一个新的张量，其中包含`input`元素的双曲正切。 | +| `trunc` | 返回一个新的张量，其中包含`input`元素的截断整数值。 | 可用的就地一元运算符是上述所有内容**除外**： -| [`angle`](generated/torch.angle.html#torch.angle "torch.angle") | 计算给定`input`张量的逐元素角度（弧度）。 | +| `angle` | 计算给定`input`张量的逐元素角度（弧度）。 | | --- | --- | -| [`positive`](generated/torch.positive.html#torch.positive "torch.positive") | 返回`input`。 | -| [`signbit`](generated/torch.signbit.html#torch.signbit "torch.signbit") | 检查`input`的每个元素是否设置了符号位。 | -| [`isnan`](generated/torch.isnan.html#torch.isnan "torch.isnan") | 返回一个新的张量，其中的布尔元素表示`input`的每个元素是否为NaN。 | +| `positive` | 返回`input`。 | +| `signbit` | 检查`input`的每个元素是否设置了符号位。 | +| `isnan` | 返回一个新的张量，其中的布尔元素表示`input`的每个元素是否为 NaN。 | ### 二元运算符 -正如您在教程中看到的，`MaskedTensor`也实现了二元操作，但需要注意的是，两个MaskedTensor中的掩码必须匹配，否则将引发错误。正如错误中所指出的，如果您需要支持特定运算符或提出了它们应该如何行为的语义，请在GitHub上提出问题。目前，我们决定采用最保守的实现方式，以确保用户完全了解正在发生的情况，并且在使用掩码语义时是有意识的。 +正如您在教程中看到的，`MaskedTensor`也实现了二元操作，但需要注意的是，两个 MaskedTensor 中的掩码必须匹配，否则将引发错误。正如错误中所指出的，如果您需要支持特定运算符或提出了它们应该如何行为的语义，请在 GitHub 上提出问题。目前，我们决定采用最保守的实现方式，以确保用户完全了解正在发生的情况，并且在使用掩码语义时是有意识的。 可用的二元运算符有： -| [`add`](generated/torch.add.html#torch.add "torch.add") | 将`other`按`alpha`缩放后加到`input`上。 | +| `add` | 将`other`按`alpha`缩放后加到`input`上。 | | --- | --- | -| [`atan2`](generated/torch.atan2.html#torch.atan2 "torch.atan2") | 考虑象限的$\text{input}_{i} / \text{other}_{i}$inputi​/otheri​的逐元素反正切。 | -| [`arctan2`](generated/torch.arctan2.html#torch.arctan2 "torch.arctan2") | [`torch.atan2()`](generated/torch.atan2.html#torch.atan2 "torch.atan2")的别名。 | -| [`bitwise_and`](generated/torch.bitwise_and.html#torch.bitwise_and "torch.bitwise_and") | 计算`input`和`other`的按位与。 | -| [`bitwise_or`](generated/torch.bitwise_or.html#torch.bitwise_or "torch.bitwise_or") | 计算`input`和`other`的按位或。 | -| [`bitwise_xor`](generated/torch.bitwise_xor.html#torch.bitwise_xor "torch.bitwise_xor") | 计算`input`和`other`的按位异或。 | -| [`bitwise_left_shift`](generated/torch.bitwise_left_shift.html#torch.bitwise_left_shift "torch.bitwise_left_shift") | 计算`input`左移`other`位的算术左移。 | -| [`bitwise_right_shift`](generated/torch.bitwise_right_shift.html#torch.bitwise_right_shift "torch.bitwise_right_shift") | 计算`input`右移`other`位的算术右移。 | -| [`div`](generated/torch.div.html#torch.div "torch.div") | 将输入`input`的每个元素除以对应的`other`元素。 | -| [`divide`](generated/torch.divide.html#torch.divide "torch.divide") | [`torch.div()`](generated/torch.div.html#torch.div "torch.div")的别名。 | -| [`floor_divide`](generated/torch.floor_divide.html#torch.floor_divide "torch.floor_divide") | | -| [`fmod`](generated/torch.fmod.html#torch.fmod "torch.fmod") | 应用C++的[std::fmod](https://en.cppreference.com/w/cpp/numeric/math/fmod)逐元素。 | -| [`logaddexp`](generated/torch.logaddexp.html#torch.logaddexp "torch.logaddexp") | 输入指数的和的对数。 | -| [`logaddexp2`](generated/torch.logaddexp2.html#torch.logaddexp2 "torch.logaddexp2") | 以2为底的输入指数的和的对数。 | -| [`mul`](generated/torch.mul.html#torch.mul "torch.mul") | 将`input`乘以`other`。 | -| [`multiply`](generated/torch.multiply.html#torch.multiply "torch.multiply") | [`torch.mul()`](generated/torch.mul.html#torch.mul "torch.mul")的别名。 | -| [`nextafter`](generated/torch.nextafter.html#torch.nextafter "torch.nextafter") | 返回`input`向`other`方向的下一个浮点值，逐元素。 | -| [`remainder`](generated/torch.remainder.html#torch.remainder "torch.remainder") | 逐个计算[Python的模运算](https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations)。 | -| [`sub`](generated/torch.sub.html#torch.sub "torch.sub") | 从`input`中减去`other`，乘以`alpha`。 | -| [`subtract`](generated/torch.subtract.html#torch.subtract "torch.subtract") | [`torch.sub()`](generated/torch.sub.html#torch.sub "torch.sub")的别名。 | -| [`true_divide`](generated/torch.true_divide.html#torch.true_divide "torch.true_divide") | [`torch.div()`](generated/torch.div.html#torch.div "torch.div")的别名，`rounding_mode=None`。 | -| [`eq`](generated/torch.eq.html#torch.eq "torch.eq") | 逐元素计算相等性。 | -| [`ne`](generated/torch.ne.html#torch.ne "torch.ne") | 逐元素计算 $\text{input} \neq \text{other}$。 | -| [`le`](generated/torch.le.html#torch.le "torch.le") | 逐元素计算 $\text{input} \leq \text{other}$。 | -| [`ge`](generated/torch.ge.html#torch.ge "torch.ge") | 逐元素计算 $\text{input} \geq \text{other}$。 | -| [`greater`](generated/torch.greater.html#torch.greater "torch.greater") | [`torch.gt()`](generated/torch.gt.html#torch.gt "torch.gt")的别名。 | -| [`greater_equal`](generated/torch.greater_equal.html#torch.greater_equal "torch.greater_equal") | [`torch.ge()`](generated/torch.ge.html#torch.ge "torch.ge")的别名。 | -| [`gt`](generated/torch.gt.html#torch.gt "torch.gt") | 逐元素计算 $\text{input} > \text{other}$。 | -| [`less_equal`](generated/torch.less_equal.html#torch.less_equal "torch.less_equal") | [`torch.le()`](generated/torch.le.html#torch.le "torch.le")的别名。 | -| [`lt`](generated/torch.lt.html#torch.lt "torch.lt") | 逐元素计算 $\text{input} < \text{other}$。 | -| [`less`](generated/torch.less.html#torch.less "torch.less") | [`torch.lt()`](generated/torch.lt.html#torch.lt "torch.lt")的别名。 | -| [`maximum`](generated/torch.maximum.html#torch.maximum "torch.maximum") | 计算`input`和`other`的逐元素最大值。 | -| [`minimum`](generated/torch.minimum.html#torch.minimum "torch.minimum") | 计算`input`和`other`的逐元素最小值。 | -| [`fmax`](generated/torch.fmax.html#torch.fmax "torch.fmax") | 计算`input`和`other`的逐元素最大值。 | -| [`fmin`](generated/torch.fmin.html#torch.fmin "torch.fmin") | 计算`input`和`other`的逐元素最小值。 | -| [`not_equal`](generated/torch.not_equal.html#torch.not_equal "torch.not_equal") | [`torch.ne()`](generated/torch.ne.html#torch.ne "torch.ne")的别名。 | +| `atan2` | 考虑象限的$\text{input}_{i} / \text{other}_{i}$inputi​/otheri​的逐元素反正切。 | +| `arctan2` | `torch.atan2()`的别名。 | +| `bitwise_and` | 计算`input`和`other`的按位与。 | +| `bitwise_or` | 计算`input`和`other`的按位或。 | +| `bitwise_xor` | 计算`input`和`other`的按位异或。 | +| `bitwise_left_shift` | 计算`input`左移`other`位的算术左移。 | +| `bitwise_right_shift` | 计算`input`右移`other`位的算术右移。 | +| `div` | 将输入`input`的每个元素除以对应的`other`元素。 | +| `divide` | `torch.div()`的别名。 | +| `floor_divide` | | +| `fmod` | 应用 C++的[std::fmod](https://en.cppreference.com/w/cpp/numeric/math/fmod)逐元素。 | +| `logaddexp` | 输入指数的和的对数。 | +| `logaddexp2` | 以 2 为底的输入指数的和的对数。 | +| `mul` | 将`input`乘以`other`。 | +| `multiply` | `torch.mul()`的别名。 | +| `nextafter` | 返回`input`向`other`方向的下一个浮点值，逐元素。 | +| `remainder` | 逐个计算[Python 的模运算](https://docs.python.org/3/reference/expressions.html#binary-arithmetic-operations)。 | +| `sub` | 从`input`中减去`other`，乘以`alpha`。 | +| `subtract` | `torch.sub()`的别名。 | +| `true_divide` | `torch.div()`的别名，`rounding_mode=None`。 | +| `eq` | 逐元素计算相等性。 | +| `ne` | 逐元素计算 $\text{input} \neq \text{other}$。 | +| `le` | 逐元素计算 $\text{input} \leq \text{other}$。 | +| `ge` | 逐元素计算 $\text{input} \geq \text{other}$。 | +| `greater` | `torch.gt()`的别名。 | +| `greater_equal` | `torch.ge()`的别名。 | +| `gt` | 逐元素计算 $\text{input} > \text{other}$。 | +| `less_equal` | `torch.le()`的别名。 | +| `lt` | 逐元素计算 $\text{input} < \text{other}$。 | +| `less` | `torch.lt()`的别名。 | +| `maximum` | 计算`input`和`other`的逐元素最大值。 | +| `minimum` | 计算`input`和`other`的逐元素最小值。 | +| `fmax` | 计算`input`和`other`的逐元素最大值。 | +| `fmin` | 计算`input`和`other`的逐元素最小值。 | +| `not_equal` | `torch.ne()`的别名。 | 除以下所有可用的就地二元运算符之外： -| [`logaddexp`](generated/torch.logaddexp.html#torch.logaddexp "torch.logaddexp") | 输入指数的和的对数。 | +| `logaddexp` | 输入指数的和的对数。 | | --- | --- | -| [`logaddexp2`](generated/torch.logaddexp2.html#torch.logaddexp2 "torch.logaddexp2") | 以2为底的输入指数的和的对数。 | -| [`equal`](generated/torch.equal.html#torch.equal "torch.equal") | 如果两个张量大小和元素相同，则为`True`，否则为`False`。 | -| [`fmin`](generated/torch.fmin.html#torch.fmin "torch.fmin") | 计算`input`和`other`的逐元素最小值。 | -| [`minimum`](generated/torch.minimum.html#torch.minimum "torch.minimum") | 计算`input`和`other`的逐元素最小值。 | -| [`fmax`](generated/torch.fmax.html#torch.fmax "torch.fmax") | 计算`input`和`other`的逐元素最大值。 | +| `logaddexp2` | 以 2 为底的输入指数的和的对数。 | +| `equal` | 如果两个张量大小和元素相同，则为`True`，否则为`False`。 | +| `fmin` | 计算`input`和`other`的逐元素最小值。 | +| `minimum` | 计算`input`和`other`的逐元素最小值。 | +| `fmax` | 计算`input`和`other`的逐元素最大值。 | ### 缩减 以下缩减操作可用（支持自动微分）。有关更多信息，请参阅[概述](https://pytorch.org/tutorials/prototype/maskedtensor_overview.html)教程详细介绍了一些缩减的示例，而[高级语义](https://pytorch.org/tutorials/prototype/maskedtensor_advanced_semantics.html)教程则对我们如何决定某些缩减语义进行了更深入的讨论。 -| [`sum`](generated/torch.sum.html#torch.sum "torch.sum") | 返回`input`张量中所有元素的总和。 | +| `sum` | 返回`input`张量中所有元素的总和。 | | --- | --- | -| [`mean`](generated/torch.mean.html#torch.mean "torch.mean") | 返回`input`张量中所有元素的平均值。 | -| [`amin`](generated/torch.amin.html#torch.amin "torch.amin") | 返回给定维度`dim`中`input`张量的每个切片的最小值。 | -| [`amax`](generated/torch.amax.html#torch.amax "torch.amax") | 返回给定维度`dim`中`input`张量的每个切片的最大值。 | -| [`argmin`](generated/torch.argmin.html#torch.argmin "torch.argmin") | 返回展平张量的最小值的索引或沿某个维度的最小值的索引。 | -| [`argmax`](generated/torch.argmax.html#torch.argmax "torch.argmax") | 返回`input`张量中所有元素的最大值的索引。 | -| [`prod`](generated/torch.prod.html#torch.prod "torch.prod") | 返回`input`张量中所有元素的乘积。 | -| [`all`](generated/torch.all.html#torch.all "torch.all") | 测试`input`中的所有元素是否都为True。 | -| [`norm`](generated/torch.norm.html#torch.norm "torch.norm") | 返回给定张量的矩阵范数或向量范数。 | -| [`var`](generated/torch.var.html#torch.var "torch.var") | 计算由`dim`指定的维度上的方差。 | -| [`std`](generated/torch.std.html#torch.std "torch.std") | 计算由`dim`指定的维度上的标准差。 | +| `mean` | 返回`input`张量中所有元素的平均值。 | +| `amin` | 返回给定维度`dim`中`input`张量的每个切片的最小值。 | +| `amax` | 返回给定维度`dim`中`input`张量的每个切片的最大值。 | +| `argmin` | 返回展平张量的最小值的索引或沿某个维度的最小值的索引。 | +| `argmax` | 返回`input`张量中所有元素的最大值的索引。 | +| `prod` | 返回`input`张量中所有元素的乘积。 | +| `all` | 测试`input`中的所有元素是否都为 True。 | +| `norm` | 返回给定张量的矩阵范数或向量范数。 | +| `var` | 计算由`dim`指定的维度上的方差。 | +| `std` | 计算由`dim`指定的维度上的标准差。 | ### 视图和选择函数 -我们还包括了一些视图和选择函数；直观地说，这些运算符将同时应用于数据和掩码，然后将结果包装在`MaskedTensor`中。举个快速的例子，考虑[`select()`](generated/torch.select.html#torch.select "torch.select")： +我们还包括了一些视图和选择函数；直观地说，这些运算符将同时应用于数据和掩码，然后将结果包装在`MaskedTensor`中。举个快速的例子，考虑`select()`： ```py >>> data = torch.arange(12, dtype=torch.float).reshape(3, 4) @@ -215,29 +215,29 @@ MaskedTensor( 目前支持以下操作： -| [`atleast_1d`](generated/torch.atleast_1d.html#torch.atleast_1d "torch.atleast_1d") | 返回每个输入张量的零维度的一维视图。 | +| `atleast_1d` | 返回每个输入张量的零维度的一维视图。 | | --- | --- | -| [`broadcast_tensors`](generated/torch.broadcast_tensors.html#torch.broadcast_tensors "torch.broadcast_tensors") | 根据[广播语义](notes/broadcasting.html#broadcasting-semantics)广播给定的张量。 | -| [`broadcast_to`](generated/torch.broadcast_to.html#torch.broadcast_to "torch.broadcast_to") | 将`input`广播到形状`shape`。 | -| [`cat`](generated/torch.cat.html#torch.cat "torch.cat") | 在给定维度中连接给定序列`seq`的张量。 | -| [`chunk`](generated/torch.chunk.html#torch.chunk "torch.chunk") | 尝试将张量分割为指定数量的块。 | -| [`column_stack`](generated/torch.column_stack.html#torch.column_stack "torch.column_stack") | 通过水平堆叠`tensors`中的张量创建一个新张量。 | -| [`dsplit`](generated/torch.dsplit.html#torch.dsplit "torch.dsplit") | 根据`indices_or_sections`将具有三个或更多维度的`input`张量沿深度方向分割为多个张量。 | -| [`flatten`](generated/torch.flatten.html#torch.flatten "torch.flatten") | 通过将其重塑为一维张量来展平`input`。 | -| [`hsplit`](generated/torch.hsplit.html#torch.hsplit "torch.hsplit") | 根据`indices_or_sections`在水平方向上将具有一个或多个维度的`input`张量分割成多个张量。 | -| [`hstack`](generated/torch.hstack.html#torch.hstack "torch.hstack") | 水平（列方向）顺序堆叠张量。 | -| [`kron`](generated/torch.kron.html#torch.kron "torch.kron") | 计算`input`和`other`的Kronecker积，用$\otimes$⊗表示。 | -| [`meshgrid`](generated/torch.meshgrid.html#torch.meshgrid "torch.meshgrid") | 创建由attr:tensors中的1D输入指定的坐标网格。 | -| [`narrow`](generated/torch.narrow.html#torch.narrow "torch.narrow") | 返回一个`input`张量的缩小版本的新张量。 | -| [`ravel`](generated/torch.ravel.html#torch.ravel "torch.ravel") | 返回一个连续的扁平化张量。 | -| [`select`](generated/torch.select.html#torch.select "torch.select") | 沿着给定索引在所选维度上切片`input`张量。 | -| [`split`](generated/torch.split.html#torch.split "torch.split") | 将张量分割成块。 | -| [`t`](generated/torch.t.html#torch.t "torch.t") | 期望`input`是<= 2-D张量，并转置维度0和1。 | -| [`transpose`](generated/torch.transpose.html#torch.transpose "torch.transpose") | 返回一个`input`的转置版本的张量。 | -| [`vsplit`](generated/torch.vsplit.html#torch.vsplit "torch.vsplit") | 根据`indices_or_sections`在垂直方向上将具有两个或更多维度的`input`张量分割成多个张量。 | -| [`vstack`](generated/torch.vstack.html#torch.vstack "torch.vstack") | 垂直（行方向）顺序堆叠张量。 | -| [`Tensor.expand`](generated/torch.Tensor.expand.html#torch.Tensor.expand "torch.Tensor.expand") | 返回一个视图，将`self`张量中的单例维度扩展到更大的尺寸。 | -| [`Tensor.expand_as`](generated/torch.Tensor.expand_as.html#torch.Tensor.expand_as "torch.Tensor.expand_as") | 将此张量扩展到与`other`相同的大小。 | -| [`Tensor.reshape`](generated/torch.Tensor.reshape.html#torch.Tensor.reshape "torch.Tensor.reshape") | 返回一个与`self`具有相同数据和元素数量但具有指定形状的张量。 | -| [`Tensor.reshape_as`](generated/torch.Tensor.reshape_as.html#torch.Tensor.reshape_as "torch.Tensor.reshape_as") | 将此张量重塑为与`other`相同的形状。 | -| [`Tensor.view`](generated/torch.Tensor.view.html#torch.Tensor.view "torch.Tensor.view") | 返回一个与`self`张量具有相同数据但形状不同的新张量。 | +| `broadcast_tensors` | 根据广播语义广播给定的张量。 | +| `broadcast_to` | 将`input`广播到形状`shape`。 | +| `cat` | 在给定维度中连接给定序列`seq`的张量。 | +| `chunk` | 尝试将张量分割为指定数量的块。 | +| `column_stack` | 通过水平堆叠`tensors`中的张量创建一个新张量。 | +| `dsplit` | 根据`indices_or_sections`将具有三个或更多维度的`input`张量沿深度方向分割为多个张量。 | +| `flatten` | 通过将其重塑为一维张量来展平`input`。 | +| `hsplit` | 根据`indices_or_sections`在水平方向上将具有一个或多个维度的`input`张量分割成多个张量。 | +| `hstack` | 水平（列方向）顺序堆叠张量。 | +| `kron` | 计算`input`和`other`的 Kronecker 积，用$\otimes$⊗表示。 | +| `meshgrid` | 创建由 attr:tensors 中的 1D 输入指定的坐标网格。 | +| `narrow` | 返回一个`input`张量的缩小版本的新张量。 | +| `ravel` | 返回一个连续的扁平化张量。 | +| `select` | 沿着给定索引在所选维度上切片`input`张量。 | +| `split` | 将张量分割成块。 | +| `t` | 期望`input`是<= 2-D 张量，并转置维度 0 和 1。 | +| `transpose` | 返回一个`input`的转置版本的张量。 | +| `vsplit` | 根据`indices_or_sections`在垂直方向上将具有两个或更多维度的`input`张量分割成多个张量。 | +| `vstack` | 垂直（行方向）顺序堆叠张量。 | +| `Tensor.expand` | 返回一个视图，将`self`张量中的单例维度扩展到更大的尺寸。 | +| `Tensor.expand_as` | 将此张量扩展到与`other`相同的大小。 | +| `Tensor.reshape` | 返回一个与`self`具有相同数据和元素数量但具有指定形状的张量。 | +| `Tensor.reshape_as` | 将此张量重塑为与`other`相同的形状。 | +| `Tensor.view` | 返回一个与`self`张量具有相同数据但形状不同的新张量。 | diff --git a/totrans/doc22_078.md b/totrans/doc22_078.md index 2a4a7200..c1f0b191 100644 --- a/totrans/doc22_078.md +++ b/totrans/doc22_078.md @@ -1,12 +1,12 @@ # torch.nested -> 原文：[https://pytorch.org/docs/stable/nested.html](https://pytorch.org/docs/stable/nested.html) +> 原文：[`pytorch.org/docs/stable/nested.html`](https://pytorch.org/docs/stable/nested.html) ## 简介 警告 -PyTorch嵌套张量的API处于原型阶段，将来会有变化。 +PyTorch 嵌套张量的 API 处于原型阶段，将来会有变化。 嵌套张量允许用户将一组张量打包到一个单一的、高效的数据结构中。 @@ -14,9 +14,9 @@ PyTorch嵌套张量的API处于原型阶段，将来会有变化。 这样可以更有效地表示元数据并访问专门构建的内核。 -嵌套张量的一个应用是在各种领域中表达顺序数据。传统方法是填充可变长度序列，而嵌套张量使用户可以绕过填充。在嵌套张量上调用操作的API与常规`torch.Tensor`没有区别，这应该允许与现有模型无缝集成，主要区别在于[输入的构造](#construction)。 +嵌套张量的一个应用是在各种领域中表达顺序数据。传统方法是填充可变长度序列，而嵌套张量使用户可以绕过填充。在嵌套张量上调用操作的 API 与常规`torch.Tensor`没有区别，这应该允许与现有模型无缝集成，主要区别在于输入的构造。 -由于这是一个原型功能，[支持的操作](#supported-operations)仍然有限。但是，我们欢迎问题、功能请求和贡献。有关贡献更多信息，请参阅[此Readme](https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/nested/README.md)。 +由于这是一个原型功能，支持的操作仍然有限。但是，我们欢迎问题、功能请求和贡献。有关贡献更多信息，请参阅[此 Readme](https://github.com/pytorch/pytorch/blob/main/aten/src/ATen/native/nested/README.md)。 ## 构造 @@ -47,7 +47,7 @@ nested_tensor([ ], device='cuda:0', requires_grad=True) ``` -类似于`torch.as_tensor`，`torch.nested.as_nested_tensor`可以用来保留传递给构造函数的张量的自动求导历史。有关更多信息，请参考[嵌套张量构造函数和转换函数](#constructor-functions)部分。 +类似于`torch.as_tensor`，`torch.nested.as_nested_tensor`可以用来保留传递给构造函数的张量的自动求导历史。有关更多信息，请参考嵌套张量构造函数和转换函数部分。 为了形成一个有效的嵌套张量，所有传递的张量需要在维度上匹配，但其他属性则不需要。 @@ -76,7 +76,7 @@ RuntimeError: All Tensors given to nested_tensor must have the same dimension. F ## 大小 -尽管嵌套张量不支持`.size()`（或`.shape`），但如果维度i是规则的，它支持`.size(i)`。 +尽管嵌套张量不支持`.size()`（或`.shape`），但如果维度 i 是规则的，它支持`.size(i)`。 ```py >>> a = torch.randn(50, 128) # text 1 @@ -162,29 +162,29 @@ nested_tensor([ torch.nested.nested_tensor(tensor_list, *, dtype=None, layout=None, device=None, requires_grad=False, pin_memory=False)¶ ``` -从`tensor_list`（张量列表）构造一个没有自动求导历史（也称为“叶张量”，参见[自动求导机制](notes/autograd.html#autograd-mechanics)）的嵌套张量。 +从`tensor_list`（张量列表）构造一个没有自动求导历史（也称为“叶张量”，参见自动求导机制）的嵌套张量。 参数 -+ **tensor_list**（*List**[**array_like**]*）- 一个张量列表，或者任何可以传递给torch.tensor的东西， ++ **tensor_list**（*List**[**array_like**]*）- 一个张量列表，或者任何可以传递给 torch.tensor 的东西， + **维度。**（*其中列表的每个元素具有相同的*）- 关键字参数 -+ **dtype**（[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")，可选）- 返回的嵌套张量的期望类型。默认值：如果为None，则与列表中最左边的张量相同[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype") ++ **dtype**（`torch.dtype`，可选）- 返回的嵌套张量的期望类型。默认值：如果为 None，则与列表中最左边的张量相同`torch.dtype` -+ **layout**（[`torch.layout`](tensor_attributes.html#torch.layout "torch.layout")，可选）- 返回的嵌套张量的期望布局。仅支持步进和不规则布局。默认值：如果为None，则为步进布局。 ++ **layout**（`torch.layout`，可选）- 返回的嵌套张量的期望布局。仅支持步进和不规则布局。默认值：如果为 None，则为步进布局。 -+ **device**（[`torch.device`](tensor_attributes.html#torch.device "torch.device")，可选）- 返回的嵌套张量的期望设备。默认值：如果为None，则与列表中最左边的张量相同[`torch.device`](tensor_attributes.html#torch.device "torch.device") ++ **device**（`torch.device`，可选）- 返回的嵌套张量的期望设备。默认值：如果为 None，则与列表中最左边的张量相同`torch.device` -+ **requires_grad**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，可选）- 如果自动求导应记录返回的嵌套张量上的操作。默认值：`False`。 ++ **requires_grad**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，可选）- 如果自动求导应记录返回的嵌套张量上的操作。默认值：`False`。 -+ **pin_memory**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，可选）- 如果设置，返回的嵌套张量将分配在固定内存中。仅适用于CPU张量。默认值：`False`。 ++ **pin_memory**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，可选）- 如果设置，返回的嵌套张量将分配在固定内存中。仅适用于 CPU 张量。默认值：`False`。 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* 示例： @@ -208,19 +208,19 @@ torch.nested.as_nested_tensor(tensor_list, dtype=None, device=None, layout=None) 参数 -**tensor_list**（*列表**[*[*张量*](tensors.html#torch.Tensor "torch.Tensor")*]*）- 具有相同ndim的张量列表 +**tensor_list**（*列表***[*张量**]*）- 具有相同 ndim 的张量列表 关键字参数 -+ **dtype**（[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")，可选）- 返回的嵌套张量的期望类型。默认值：如果为None，则与列表中最左边的张量相同[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype") ++ **dtype**（`torch.dtype`，可选）- 返回的嵌套张量的期望类型。默认值：如果为 None，则与列表中最左边的张量相同`torch.dtype` -+ **device**（[`torch.device`](tensor_attributes.html#torch.device "torch.device")，可选）- 返回的嵌套张量的期望设备。默认值：如果为None，则与列表中最左边的张量相同[`torch.device`](tensor_attributes.html#torch.device "torch.device") ++ **device**（`torch.device`，可选）- 返回的嵌套张量的期望设备。默认值：如果为 None，则与列表中最左边的张量相同`torch.device` -+ **layout**（[`torch.layout`](tensor_attributes.html#torch.layout "torch.layout")，可选）- 返回嵌套张量的期望布局。仅支持步进和不规则布局。默认值：如果为None，则为步进布局。 ++ **layout**（`torch.layout`，可选）- 返回嵌套张量的期望布局。仅支持步进和不规则布局。默认值：如果为 None，则为步进布局。 返回类型 -[*张量*](tensors.html#torch.Tensor "torch.Tensor") +*张量* 示例： @@ -246,17 +246,17 @@ torch.nested.to_padded_tensor(input, padding, output_size=None, out=None) → Te 警告 -[`to_padded_tensor()`](#torch.nested.to_padded_tensor "torch.nested.to_padded_tensor")总是复制底层数据，因为嵌套张量和非嵌套张量在内存布局上有所不同。 +`to_padded_tensor()`总是复制底层数据，因为嵌套张量和非嵌套张量在内存布局上有所不同。 参数 -**padding**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")）- 尾随条目的填充值。 +**padding**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")）- 尾随条目的填充值。 关键字参数 -+ **output_size**（*元组**[*[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")*]*）- 输出张量的大小。如果给定，必须足够大以包含所有嵌套数据；否则，将通过沿每个维度取每个嵌套子张量的最大大小来推断。 ++ **output_size**（*元组**[*[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*]*）- 输出张量的大小。如果给定，必须足够大以包含所有嵌套数据；否则，将通过沿每个维度取每个嵌套子张量的最大大小来推断。 -+ **out**（[*张量*](tensors.html#torch.Tensor "torch.Tensor")，可选）- 输出张量。 ++ **out**（*张量*，可选）- 输出张量。 示例： @@ -289,35 +289,35 @@ tensor([[[ 1.6862, -1.1282, 1.1031, 0.0464, -1.3276, 1.0000], RuntimeError: Value in output_size is less than NestedTensor padded size. Truncation is not supported. ``` ## 支持的操作[](#supported-operations "跳转到此标题") -在本节中，我们总结了当前在NestedTensor上支持的操作以及它们的任何约束。 +在本节中，我们总结了当前在 NestedTensor 上支持的操作以及它们的任何约束。 -| PyTorch操作 | 约束 | +| PyTorch 操作 | 约束 | | --- | --- | -| [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") | 支持两个（>= 3d）嵌套张量之间的矩阵乘法，其中最后两个维度是矩阵维度，前导（批量）维度具有相同的大小（即批量维度尚不支持广播）。 | -| [`torch.bmm()`](generated/torch.bmm.html#torch.bmm "torch.bmm") | 支持两个3维嵌套张量的批量矩阵乘法。 | -| [`torch.nn.Linear()`](generated/torch.nn.Linear.html#torch.nn.Linear "torch.nn.Linear") | 支持3维嵌套输入和一个密集的2维权重矩阵。 | -| [`torch.nn.functional.softmax()`](generated/torch.nn.functional.softmax.html#torch.nn.functional.softmax "torch.nn.functional.softmax") | 支持除`dim=0`以外的所有维度的softmax。 | -| [`torch.nn.Dropout()`](generated/torch.nn.Dropout.html#torch.nn.Dropout "torch.nn.Dropout") | 行为与常规张量相同。 | -| [`torch.Tensor.masked_fill()`](generated/torch.Tensor.masked_fill.html#torch.Tensor.masked_fill "torch.Tensor.masked_fill") | 行为与常规张量相同。 | +| `torch.matmul()` | 支持两个（>= 3d）嵌套张量之间的矩阵乘法，其中最后两个维度是矩阵维度，前导（批量）维度具有相同的大小（即批量维度尚不支持广播）。 | +| `torch.bmm()` | 支持两个 3 维嵌套张量的批量矩阵乘法。 | +| `torch.nn.Linear()` | 支持 3 维嵌套输入和一个密集的 2 维权重矩阵。 | +| `torch.nn.functional.softmax()` | 支持除`dim=0`以外的所有维度的 softmax。 | +| `torch.nn.Dropout()` | 行为与常规张量相同。 | +| `torch.Tensor.masked_fill()` | 行为与常规张量相同。 | | `torch.relu()` | 行为与常规张量相同。 | | `torch.gelu()` | 行为与常规张量相同。 | | `torch.silu()` | 行为与常规张量相同。 | -| [`torch.abs()`](generated/torch.abs.html#torch.abs "torch.abs") | 行为与常规张量相同。 | -| [`torch.sgn()`](generated/torch.sgn.html#torch.sgn "torch.sgn") | 行为与常规张量相同。 | -| [`torch.logical_not()`](generated/torch.logical_not.html#torch.logical_not "torch.logical_not") | 行为与常规张量相同。 | -| [`torch.neg()`](generated/torch.neg.html#torch.neg "torch.neg") | 行为与常规张量相同。 | -| [`torch.sub()`](generated/torch.sub.html#torch.sub "torch.sub") | 支持对两个嵌套张量进行逐元素减法。 | -| [`torch.add()`](generated/torch.add.html#torch.add "torch.add") | 支持两个嵌套张量的逐元素加法。支持将标量添加到嵌套张量中。 | -| [`torch.mul()`](generated/torch.mul.html#torch.mul "torch.mul") | 支持两个嵌套张量的逐元素乘法。支持将嵌套张量乘以标量。 | -| [`torch.select()`](generated/torch.select.html#torch.select "torch.select") | 支持沿所有维度进行选择。 | -| [`torch.clone()`](generated/torch.clone.html#torch.clone "torch.clone") | 行为与常规张量相同。 | +| `torch.abs()` | 行为与常规张量相同。 | +| `torch.sgn()` | 行为与常规张量相同。 | +| `torch.logical_not()` | 行为与常规张量相同。 | +| `torch.neg()` | 行为与常规张量相同。 | +| `torch.sub()` | 支持对两个嵌套张量进行逐元素减法。 | +| `torch.add()` | 支持两个嵌套张量的逐元素加法。支持将标量添加到嵌套张量中。 | +| `torch.mul()` | 支持两个嵌套张量的逐元素乘法。支持将嵌套张量乘以标量。 | +| `torch.select()` | 支持沿所有维度进行选择。 | +| `torch.clone()` | 行为与常规张量相同。 | | `torch.detach()` | 行为与常规张量相同。 | -| [`torch.unbind()`](generated/torch.unbind.html#torch.unbind "torch.unbind") | 仅支持沿`dim=0`解绑。 | -| [`torch.reshape()`](generated/torch.reshape.html#torch.reshape "torch.reshape") | 支持保留`dim=0`大小的重塑（即嵌套张量的数量不能改变）。与常规张量不同，这里的大小为`-1`表示继承现有大小。特别是，不规则维度的唯一有效大小是`-1`。尺寸推断尚未实现，因此对于新维度，大小不能为`-1`。 | -| [`torch.Tensor.reshape_as()`](generated/torch.Tensor.reshape_as.html#torch.Tensor.reshape_as "torch.Tensor.reshape_as") | 新形状的规则与`reshape`类似。 | -| [`torch.transpose()`](generated/torch.transpose.html#torch.transpose "torch.transpose") | 支持除`dim=0`以外的所有维度的转置。 | -| [`torch.Tensor.view()`](generated/torch.Tensor.view.html#torch.Tensor.view "torch.Tensor.view") | 新形状的规则类似于`reshape`。 | -| [`torch.empty_like()`](generated/torch.empty_like.html#torch.empty_like "torch.empty_like") | 行为类似于常规张量；返回一个新的空嵌套张量（即未初始化值），匹配输入的嵌套结构。 | -| [`torch.randn_like()`](generated/torch.randn_like.html#torch.randn_like "torch.randn_like") | 行为类似于常规张量；返回一个新的嵌套张量，其值根据标准正态分布随机初始化，匹配输入的嵌套结构。 | -| [`torch.zeros_like()`](generated/torch.zeros_like.html#torch.zeros_like "torch.zeros_like") | 行为类似于常规张量；返回一个新的嵌套张量，所有零值与输入的嵌套结构匹配。 | -| [`torch.nn.LayerNorm()`](generated/torch.nn.LayerNorm.html#torch.nn.LayerNorm "torch.nn.LayerNorm") | `normalized_shape` 参数受限于不扩展到 NestedTensor 的不规则维度。 | +| `torch.unbind()` | 仅支持沿`dim=0`解绑。 | +| `torch.reshape()` | 支持保留`dim=0`大小的重塑（即嵌套张量的数量不能改变）。与常规张量不同，这里的大小为`-1`表示继承现有大小。特别是，不规则维度的唯一有效大小是`-1`。尺寸推断尚未实现，因此对于新维度，大小不能为`-1`。 | +| `torch.Tensor.reshape_as()` | 新形状的规则与`reshape`类似。 | +| `torch.transpose()` | 支持除`dim=0`以外的所有维度的转置。 | +| `torch.Tensor.view()` | 新形状的规则类似于`reshape`。 | +| `torch.empty_like()` | 行为类似于常规张量；返回一个新的空嵌套张量（即未初始化值），匹配输入的嵌套结构。 | +| `torch.randn_like()` | 行为类似于常规张量；返回一个新的嵌套张量，其值根据标准正态分布随机初始化，匹配输入的嵌套结构。 | +| `torch.zeros_like()` | 行为类似于常规张量；返回一个新的嵌套张量，所有零值与输入的嵌套结构匹配。 | +| `torch.nn.LayerNorm()` | `normalized_shape` 参数受限于不扩展到 NestedTensor 的不规则维度。 | diff --git a/totrans/doc22_079.md b/totrans/doc22_079.md index 1caf8481..04766dd8 100644 --- a/totrans/doc22_079.md +++ b/totrans/doc22_079.md @@ -1,24 +1,24 @@ # torch.sparse -> 原文：[https://pytorch.org/docs/stable/sparse.html](https://pytorch.org/docs/stable/sparse.html) +> 原文：[`pytorch.org/docs/stable/sparse.html`](https://pytorch.org/docs/stable/sparse.html) 警告 -PyTorch稀疏张量的API处于测试阶段，可能会在不久的将来发生变化。我们非常欢迎功能请求、错误报告和一般建议作为GitHub问题。 +PyTorch 稀疏张量的 API 处于测试阶段，可能会在不久的将来发生变化。我们非常欢迎功能请求、错误报告和一般建议作为 GitHub 问题。 ## 何时以及为什么使用稀疏性[](#why-and-when-to-use-sparsity "跳转到此标题的永久链接") -默认情况下，PyTorch将[`torch.Tensor`](张量.html#torch.Tensor "torch.Tensor")元素存储在连续的物理内存中。这导致了对需要快速访问元素的各种数组处理算法的高效实现。 +默认情况下，PyTorch 将`torch.Tensor`元素存储在连续的物理内存中。这导致了对需要快速访问元素的各种数组处理算法的高效实现。 现在，一些用户可能决定通过*元素大部分为零值*的张量来表示数据，如图邻接矩阵、修剪权重或点云。我们认识到这些是重要的应用程序，并旨在通过稀疏存储格式为这些用例提供性能优化。 -多种稀疏存储格式，如COO、CSR/CSC、半结构、LIL等，多年来已经被开发出来。虽然它们在确切的布局上有所不同，但它们都通过高效表示零值元素来压缩数据。我们称未压缩的值为*指定*，与*未指定*、压缩元素相对。 +多种稀疏存储格式，如 COO、CSR/CSC、半结构、LIL 等，多年来已经被开发出来。虽然它们在确切的布局上有所不同，但它们都通过高效表示零值元素来压缩数据。我们称未压缩的值为*指定*，与*未指定*、压缩元素相对。 -通过压缩重复的零值，稀疏存储格式旨在节省各种CPU和GPU上的内存和计算资源。特别是对于高度稀疏或高度结构化的稀疏，这可能会对性能产生重大影响。因此，稀疏存储格式可以被视为性能优化。 +通过压缩重复的零值，稀疏存储格式旨在节省各种 CPU 和 GPU 上的内存和计算资源。特别是对于高度稀疏或高度结构化的稀疏，这可能会对性能产生重大影响。因此，稀疏存储格式可以被视为性能优化。 像许多其他性能优化稀疏存储格式并不总是有利的。当尝试为您的用例使用稀疏格式时，您可能会发现执行时间增加而不是减少。 -如果您在分析中预期性能会显著提高，但实际上却出现了降级，请随时打开一个GitHub问题。这有助于我们优先实现高效的内核和更广泛的性能优化。 +如果您在分析中预期性能会显著提高，但实际上却出现了降级，请随时打开一个 GitHub 问题。这有助于我们优先实现高效的内核和更广泛的性能优化。 我们使尝试不同的稀疏布局并在它们之间转换变得容易，而不对您特定应用程序的最佳选择发表意见。 @@ -26,7 +26,7 @@ PyTorch稀疏张量的API处于测试阶段，可能会在不久的将来发生 我们希望通过为每种布局提供转换例程，从给定的稠密张量构造稀疏张量变得简单。 -在下一个示例中，我们将一个具有默认稠密（分布式）布局的2D张量转换为由COO内存布局支持的2D张量。在这种情况下，仅存储非零元素的值和索引。 +在下一个示例中，我们将一个具有默认稠密（分布式）布局的 2D 张量转换为由 COO 内存布局支持的 2D 张量。在这种情况下，仅存储非零元素的值和索引。 ```py >>> a = torch.tensor([[0, 2.], [3, 0]]) @@ -37,15 +37,15 @@ tensor(indices=tensor([[0, 1], size=(2, 2), nnz=2, layout=torch.sparse_coo) ``` -PyTorch目前支持[COO](#sparse-coo-docs)、[CSR](#sparse-csr-docs)、[CSC](#sparse-csc-docs)、[BSR](#sparse-bsr-docs)和[BSC](#sparse-bsc-docs)。 +PyTorch 目前支持 COO、CSR、CSC、BSR 和 BSC。 我们还有一个原型实现来支持：半结构稀疏<稀疏半结构文档>。更多细节请参考参考资料。 请注意，我们提供了这些格式的轻微概括。 -批处理：诸如GPU之类的设备需要批处理以获得最佳性能，因此我们支持批处理维度。 +批处理：诸如 GPU 之类的设备需要批处理以获得最佳性能，因此我们支持批处理维度。 -我们目前提供了一个非常简单的批处理版本，其中稀疏格式的每个组件本身都被批处理。这也需要每个批次条目相同数量的指定元素。在这个示例中，我们从一个3D稠密张量构造一个3D（批处理）CSR张量。 +我们目前提供了一个非常简单的批处理版本，其中稀疏格式的每个组件本身都被批处理。这也需要每个批次条目相同数量的指定元素。在这个示例中，我们从一个 3D 稠密张量构造一个 3D（批处理）CSR 张量。 ```py >>> t = torch.tensor([[[1., 0], [2., 3.]], [[4., 0], [5., 6.]]]) @@ -63,7 +63,7 @@ tensor(crow_indices=tensor([[0, 1, 3], 稠密维度：另一方面，一些数据，如图嵌入，可能更适合被视为稀疏的向量集合，而不是标量。 -在这个示例中，我们从一个3D分布式张量创建一个具有2个稀疏维度和1个稠密维度的3D混合COO张量。如果3D分布式张量中的整行都是零，则不会存储。但是，如果行中的任何值都是非零的，则整行都会被存储。这减少了索引的数量，因为我们只需要每行一个索引而不是每个元素一个索引。但它也增加了值的存储量。因为只有*完全*为零的行才能被发出，任何非零值元素的存在都会导致整行被存储。 +在这个示例中，我们从一个 3D 分布式张量创建一个具有 2 个稀疏维度和 1 个稠密维度的 3D 混合 COO 张量。如果 3D 分布式张量中的整行都是零，则不会存储。但是，如果行中的任何值都是非零的，则整行都会被存储。这减少了索引的数量，因为我们只需要每行一个索引而不是每个元素一个索引。但它也增加了值的存储量。因为只有*完全*为零的行才能被发出，任何非零值元素的存在都会导致整行被存储。 ```py >>> t = torch.tensor([[[0., 0], [1., 2.]], [[0., 0], [3., 4.]]]) @@ -79,7 +79,7 @@ tensor(indices=tensor([[0, 1], 基本上，对具有稀疏存储格式的张量的操作与对具有步进（或其他）存储格式的张量的操作行为相同。存储的特殊性，即数据的物理布局，影响操作的性能，但不应影响语义。 -我们正在积极增加稀疏张量的操作符覆盖范围。用户不应期望与密集张量相同级别的支持。请查看我们的[操作符](#sparse-ops-docs)文档以获取列表。 +我们正在积极增加稀疏张量的操作符覆盖范围。用户不应期望与密集张量相同级别的支持。请查看我们的操作符文档以获取列表。 ```py >>> b = torch.tensor([[0, 0, 1, 2, 3, 0], [4, 5, 0, 6, 0, 0]]) @@ -95,7 +95,7 @@ tensor(crow_indices=tensor([0, 3, 6]), size=(2, 6), nnz=6, layout=torch.sparse_csr) ``` -如上例所示，我们不支持诸如cos之类的非零保留一元运算符。非零保留一元操作的输出将无法像输入那样充分利用稀疏存储格式，并可能导致内存的灾难性增加。我们依赖用户首先显式转换为密集张量，然后运行操作。 +如上例所示，我们不支持诸如 cos 之类的非零保留一元运算符。非零保留一元操作的输出将无法像输入那样充分利用稀疏存储格式，并可能导致内存的灾难性增加。我们依赖用户首先显式转换为密集张量，然后运行操作。 ```py >>> b_s.to_dense().cos() @@ -103,7 +103,7 @@ tensor([[ 1.0000, -0.4161], [-0.9900, 1.0000]]) ``` -我们知道一些用户希望忽略压缩的零值，而不是保留操作的确切语义，例如cos。对于这一点，我们可以指向torch.masked及其MaskedTensor，后者也由稀疏存储格式和核支持。 +我们知道一些用户希望忽略压缩的零值，而不是保留操作的确切语义，例如 cos。对于这一点，我们可以指向 torch.masked 及其 MaskedTensor，后者也由稀疏存储格式和核支持。 还要注意，目前用户无法选择输出布局。例如，将稀疏张量添加到常规步进张量会导致步进张量。一些用户可能希望保持稀疏布局，因为他们知道结果仍然足够稀疏。 @@ -113,7 +113,7 @@ tensor([[0., 3.], [3., 0.]]) ``` -我们承认，能够高效产生不同输出布局的核对于后续操作可能非常有用。后续操作可能会极大地受益于接收特定布局。我们正在开发一个API来控制结果布局，并认识到这是一个重要功能，可以为任何给定模型规划更优化的执行路径。 +我们承认，能够高效产生不同输出布局的核对于后续操作可能非常有用。后续操作可能会极大地受益于接收特定布局。我们正在开发一个 API 来控制结果布局，并认识到这是一个重要功能，可以为任何给定模型规划更优化的执行路径。 稀疏半结构张量 @@ -121,13 +121,13 @@ tensor([[0., 3.], 稀疏半结构张量目前是一个原型功能，可能会发生变化。请随时提出问题以报告错误或分享反馈。 -半结构稀疏性是首次在NVIDIA的Ampere架构中引入的稀疏数据布局。它也被称为**细粒度结构稀疏性**或**2:4结构稀疏性**。 +半结构稀疏性是首次在 NVIDIA 的 Ampere 架构中引入的稀疏数据布局。它也被称为**细粒度结构稀疏性**或**2:4 结构稀疏性**。 -这种稀疏布局存储每2n个元素中的n个元素，其中n由张量的数据类型（dtype）的宽度确定。最常用的dtype是float16，其中n=2，因此术语“2:4结构稀疏性”。 +这种稀疏布局存储每 2n 个元素中的 n 个元素，其中 n 由张量的数据类型（dtype）的宽度确定。最常用的 dtype 是 float16，其中 n=2，因此术语“2:4 结构稀疏性”。 -半结构稀疏性在[NVIDIA博客文章](https://developer.nvidia.com/blog/exploiting-ampere-structured-sparsity-with-cusparselt)中有更详细的解释。 +半结构稀疏性在[NVIDIA 博客文章](https://developer.nvidia.com/blog/exploiting-ampere-structured-sparsity-with-cusparselt)中有更详细的解释。 -在PyTorch中，半结构稀疏性是通过张量子类实现的。通过子类化，我们可以重写`__torch_dispatch__`，从而在执行矩阵乘法时使用更快的稀疏核。我们还可以将张量存储在子类中的压缩形式中，以减少内存开销。 +在 PyTorch 中，半结构稀疏性是通过张量子类实现的。通过子类化，我们可以重写`__torch_dispatch__`，从而在执行矩阵乘法时使用更快的稀疏核。我们还可以将张量存储在子类中的压缩形式中，以减少内存开销。 在这种压缩形式中，稀疏张量仅保留*指定*元素和一些元数据，用于编码掩码。 @@ -137,21 +137,21 @@ tensor([[0., 3.], 压缩张量 = [原始张量的指定元素 | 元数据掩码] -对于大小为(r, c)的原始张量，我们期望前m * k // 2个元素是保留的元素，剩下的张量是元数据。 +对于大小为(r, c)的原始张量，我们期望前 m * k // 2 个元素是保留的元素，剩下的张量是元数据。 为了让用户更容易查看指定元素和掩码，可以使用`.indices()`和`.values()`分别访问掩码和指定元素。 + `.values()`返回大小为(r, c//2)的张量中的指定元素，并具有与密集矩阵相同的数据类型。 -+ `.indices()`返回一个大小为(r, c//2)的张量，元素类型为`torch.int16`（如果dtype为torch.float16或torch.bfloat16），元素类型为`torch.int32`（如果dtype为torch.int8）。 ++ `.indices()`返回一个大小为(r, c//2)的张量，元素类型为`torch.int16`（如果 dtype 为 torch.float16 或 torch.bfloat16），元素类型为`torch.int32`（如果 dtype 为 torch.int8）。 -对于2:4稀疏张量，元数据开销很小 - 每个指定元素只有2位。 +对于 2:4 稀疏张量，元数据开销很小 - 每个指定元素只有 2 位。 注意 -重要的是要注意，`torch.float32`仅支持1:2稀疏性。因此，它不遵循上述相同的公式。 +重要的是要注意，`torch.float32`仅支持 1:2 稀疏性。因此，它不遵循上述相同的公式。 -在这里，我们分解如何计算2:4稀疏张量的压缩比（稠密大小/稀疏大小）。 +在这里，我们分解如何计算 2:4 稀疏张量的压缩比（稠密大小/稀疏大小）。 设(r, c) = 张量形状，e = 位宽(张量数据类型)，因此对于`torch.float16`和`torch.bfloat16`，e = 16，对于`torch.int8`，e = 8。 @@ -163,23 +163,23 @@ $M_{dense} = r \times c \times e \\ M_{sparse} = M_{specified} + M_{metadata} = $C = \frac{M_{sparse}}{M_{dense}} = \frac{1}{2} + \frac{1}{e}$ C=Mdense​Msparse​​=21​+e1​ -通过使用这个公式，我们发现对于`torch.float16`或`torch.bfloat16`，压缩比为56.25%，对于`torch.int8`，压缩比为62.5%。 +通过使用这个公式，我们发现对于`torch.float16`或`torch.bfloat16`，压缩比为 56.25%，对于`torch.int8`，压缩比为 62.5%。 ### 构建稀疏半结构张量 您可以通过简单使用`torch.to_sparse_semi_structured`函数将稠密张量转换为稀疏半结构张量。 -请注意，由于硬件兼容性有限，我们仅支持CUDA张量用于半结构稀疏性的NVIDIA GPU。 +请注意，由于硬件兼容性有限，我们仅支持 CUDA 张量用于半结构稀疏性的 NVIDIA GPU。 以下数据类型支持半结构稀疏性。请注意，每种数据类型都有自己的形状约束和压缩因子。 -| PyTorch数据类型 | 形状约束 | 压缩因子 | 稀疏模式 | +| PyTorch 数据类型 | 形状约束 | 压缩因子 | 稀疏模式 | | --- | --- | --- | --- | -| `torch.float16` | 张量必须是2D且(r, c)都必须是64的正倍数 | 9/16 | 2:4 | -| `torch.bfloat16` | 张量必须是2D且(r, c)都必须是64的正倍数 | 9/16 | 2:4 | -| `torch.int8` | 张量必须是2D且(r, c)都必须是128的正倍数 | 10/16 | 2:4 | +| `torch.float16` | 张量必须是 2D 且(r, c)都必须是 64 的正倍数 | 9/16 | 2:4 | +| `torch.bfloat16` | 张量必须是 2D 且(r, c)都必须是 64 的正倍数 | 9/16 | 2:4 | +| `torch.int8` | 张量必须是 2D 且(r, c)都必须是 128 的正倍数 | 10/16 | 2:4 | -要构建一个半结构稀疏张量，首先创建一个符合2:4（或半结构）稀疏格式的常规稠密张量。为此，我们将一个小的1x4条带平铺，创建一个16x16的稠密float16张量。之后，我们可以调用`to_sparse_semi_structured`函数对其进行压缩以加速推断。 +要构建一个半结构稀疏张量，首先创建一个符合 2:4（或半结构）稀疏格式的常规稠密张量。为此，我们将一个小的 1x4 条带平铺，创建一个 16x16 的稠密 float16 张量。之后，我们可以调用`to_sparse_semi_structured`函数对其进行压缩以加速推断。 ```py >>> from torch.sparse import to_sparse_semi_structured @@ -224,7 +224,7 @@ dtype=torch.int16)) + aten.t.detach(稀疏) -要使用这些操作，只需在您的张量以半结构稀疏格式具有0时，将`to_sparse_semi_structured(tensor)`的输出传递给`tensor`，就像这样： +要使用这些操作，只需在您的张量以半结构稀疏格式具有 0 时，将`to_sparse_semi_structured(tensor)`的输出传递给`tensor`，就像这样： ```py >>> a = torch.Tensor([0, 0, 1, 1]).tile((64, 16)).half().cuda() @@ -235,7 +235,7 @@ dtype=torch.int16)) True ``` -### 使用半结构稀疏性加速nn.Linear +### 使用半结构稀疏性加速 nn.Linear 如果权重已经是半结构稀疏的，您可以通过几行代码加速模型中的线性层： @@ -244,9 +244,9 @@ True >>> mask = torch.Tensor([0, 0, 1, 1]).tile((64, 16)).cuda().bool() >>> linear = nn.Linear(64, 64).half().cuda() >>> linear.weight = nn.Parameter(to_sparse_semi_structured(linear.weight.masked_fill(~mask, 0))) -``` ## 稀疏COO张量 +``` ## 稀疏 COO 张量 -PyTorch实现了所谓的坐标格式，或COO格式，作为实现稀疏张量的存储格式之一。在COO格式中，指定的元素存储为元素索引和相应值的元组。特别是， +PyTorch 实现了所谓的坐标格式，或 COO 格式，作为实现稀疏张量的存储格式之一。在 COO 格式中，指定的元素存储为元素索引和相应值的元组。特别是， > + 指定元素的索引被收集在大小为(ndim, nse)的`indices`张量中，元素类型为`torch.int64`， > + @@ -256,17 +256,17 @@ PyTorch实现了所谓的坐标格式，或COO格式，作为实现稀疏张量 注意 -稀疏COO张量的内存消耗至少为`(ndim * 8 + <元素类型大小（字节）>) * nse`字节（加上存储其他张量数据的恒定开销）。 +稀疏 COO 张量的内存消耗至少为`(ndim * 8 + <元素类型大小（字节）>) * nse`字节（加上存储其他张量数据的恒定开销）。 分块张量的内存消耗至少为`product(<张量形状>) * <元素类型大小（字节）>`。 -例如，一个大小为10,000 x 10,000的张量，包含100,000个非零的32位浮点数时，至少消耗的内存为`(2 * 8 + 4) * 100,000 = 2,000,000`字节，使用COO张量布局时，而使用默认的分块张量布局时为`10,000 * 10,000 * 4 = 400,000,000`字节。注意使用COO存储格式可以节省200倍的内存。 +例如，一个大小为 10,000 x 10,000 的张量，包含 100,000 个非零的 32 位浮点数时，至少消耗的内存为`(2 * 8 + 4) * 100,000 = 2,000,000`字节，使用 COO 张量布局时，而使用默认的分块张量布局时为`10,000 * 10,000 * 4 = 400,000,000`字节。注意使用 COO 存储格式可以节省 200 倍的内存。 ### 构造 -稀疏的COO张量可以通过提供索引和数值的两个张量，以及稀疏张量的大小（当无法从索引和数值张量中推断出时），传递给[`torch.sparse_coo_tensor()`](generated/torch.sparse_coo_tensor.html#torch.sparse_coo_tensor "torch.sparse_coo_tensor")函数来构建。 +稀疏的 COO 张量可以通过提供索引和数值的两个张量，以及稀疏张量的大小（当无法从索引和数值张量中推断出时），传递给`torch.sparse_coo_tensor()`函数来构建。 -假设我们想要定义一个稀疏张量，位置(0, 2)处的条目为3，位置(1, 0)处的条目为4，位置(1, 2)处的条目为5。未指定的元素假定具有相同的值，填充值，默认为零。我们会这样写： +假设我们想要定义一个稀疏张量，位置(0, 2)处的条目为 3，位置(1, 0)处的条目为 4，位置(1, 2)处的条目为 5。未指定的元素假定具有相同的值，填充值，默认为零。我们会这样写： ```py >>> i = [[0, 1, 1], @@ -296,7 +296,7 @@ tensor([[0, 0, 3], [4, 0, 5]]) ``` -可以通过仅指定其大小来构建一个空的稀疏COO张量： +可以通过仅指定其大小来构建一个空的稀疏 COO 张量： ```py >>> torch.sparse_coo_tensor(size=(2, 3)) @@ -305,11 +305,11 @@ tensor(indices=tensor([], size=(2, 0)), size=(2, 3), nnz=0, layout=torch.sparse_coo) ``` -### 稀疏混合COO张量[](#sparse-hybrid-coo-tensors "跳转到此标题的永久链接") +### 稀疏混合 COO 张量[](#sparse-hybrid-coo-tensors "跳转到此标题的永久链接") -PyTorch实现了将标量值的稀疏张量扩展为具有（连续）张量值的稀疏张量。这样的张量被称为混合张量。 +PyTorch 实现了将标量值的稀疏张量扩展为具有（连续）张量值的稀疏张量。这样的张量被称为混合张量。 -PyTorch混合COO张量通过允许`values`张量为多维张量来扩展稀疏COO张量，因此我们有： +PyTorch 混合 COO 张量通过允许`values`张量为多维张量来扩展稀疏 COO 张量，因此我们有： > + 指定元素的索引被收集在大小为`(sparse_dims, nse)`且元素类型为`torch.int64`的`indices`张量中， > + @@ -317,7 +317,7 @@ PyTorch混合COO张量通过允许`values`张量为多维张量来扩展稀疏CO 注意 -我们使用(M + K)维张量来表示N维稀疏混合张量，其中M和K分别是稀疏和密集维度的数量，使得M + K == N成立。 +我们使用(M + K)维张量来表示 N 维稀疏混合张量，其中 M 和 K 分别是稀疏和密集维度的数量，使得 M + K == N 成立。 假设我们想要创建一个(2 + 1)维张量，位置(0, 2)处的条目为[3, 4]，位置(1, 0)处的条目为[5, 6]，位置(1, 2)处的条目为[7, 8]。我们会这样写 @@ -345,13 +345,13 @@ tensor([[[0, 0], [7, 8]]]) ``` -一般来说，如果`s`是一个稀疏COO张量，`M = s.sparse_dim()`，`K = s.dense_dim()`，那么我们有以下不变性： +一般来说，如果`s`是一个稀疏 COO 张量，`M = s.sparse_dim()`，`K = s.dense_dim()`，那么我们有以下不变性： > + `M + K == len(s.shape) == s.ndim` - 张量的维度是稀疏和密集维度数量的总和， > + > + `s.indices().shape == (M, nse)` - 稀疏索引被显式存储， > + -> + `s.values().shape == (nse,) + s.shape[M : M + K]` - 混合张量的值是K维张量， +> + `s.values().shape == (nse,) + s.shape[M : M + K]` - 混合张量的值是 K 维张量， > + > + `s.values().layout == torch.strided` - 值以分块张量的形式存储。 @@ -361,9 +361,9 @@ tensor([[[0, 0], 注意 -为了确保构建的稀疏张量具有一致的索引、数值和大小，可以通过`check_invariants=True`关键字参数在每个张量创建时启用不变性检查，或者全局使用[`torch.sparse.check_sparse_tensor_invariants`](generated/torch.sparse.check_sparse_tensor_invariants.html#torch.sparse.check_sparse_tensor_invariants "torch.sparse.check_sparse_tensor_invariants")上下文管理器实例。默认情况下，稀疏张量的不变性检查是禁用的。### 未合并的稀疏COO张量 +为了确保构建的稀疏张量具有一致的索引、数值和大小，可以通过`check_invariants=True`关键字参数在每个张量创建时启用不变性检查，或者全局使用`torch.sparse.check_sparse_tensor_invariants`上下文管理器实例。默认情况下，稀疏张量的不变性检查是禁用的。### 未合并的稀疏 COO 张量 -PyTorch稀疏COO张量格式允许稀疏*未合并*张量，在索引中可能存在重复坐标；在这种情况下，该索引处的值被解释为所有重复值条目的总和。例如，可以为相同索引`1`指定多个值`3`和`4`，这导致一个1-D未合并张量： +PyTorch 稀疏 COO 张量格式允许稀疏*未合并*张量，在索引中可能存在重复坐标；在这种情况下，该索引处的值被解释为所有重复值条目的总和。例如，可以为相同索引`1`指定多个值`3`和`4`，这导致一个 1-D 未合并张量： ```py >>> i = [[1, 1]] @@ -384,13 +384,13 @@ tensor(indices=tensor([[1]]), size=(3,), nnz=1, layout=torch.sparse_coo) ``` -一般来说，[`torch.Tensor.coalesce()`](generated/torch.Tensor.coalesce.html#torch.Tensor.coalesce "torch.Tensor.coalesce")方法的输出是具有以下属性的稀疏张量： +一般来说，`torch.Tensor.coalesce()`方法的输出是具有以下属性的稀疏张量： + 指定张量元素的索引是唯一的， + 索引按字典顺序排序， -+ [`torch.Tensor.is_coalesced()`](generated/torch.Tensor.is_coalesced.html#torch.Tensor.is_coalesced "torch.Tensor.is_coalesced") 返回 `True`。 ++ `torch.Tensor.is_coalesced()` 返回 `True`。 注意 @@ -398,7 +398,7 @@ tensor(indices=tensor([[1]]), 然而，一些操作在未合并张量上实现效率更高，一些操作在合并张量上实现效率更高。 -例如，稀疏COO张量的加法是通过简单地连接索引和值张量来实现的： +例如，稀疏 COO 张量的加法是通过简单地连接索引和值张量来实现的： ```py >>> a = torch.sparse_coo_tensor([[1, 1]], [5, 6], (2,)) @@ -409,11 +409,11 @@ tensor(indices=tensor([[0, 0, 1, 1]]), size=(2,), nnz=4, layout=torch.sparse_coo) ``` -如果反复执行可能产生重复条目的操作（例如，[`torch.Tensor.add()`](generated/torch.Tensor.add.html#torch.Tensor.add "torch.Tensor.add"))，应偶尔合并稀疏张量以防止它们变得过大。 +如果反复执行可能产生重复条目的操作（例如，`torch.Tensor.add()`)，应偶尔合并稀疏张量以防止它们变得过大。 另一方面，索引的字典顺序对于实现涉及许多元素选择操作的算法（例如切片或矩阵乘积）可能是有利的。 -### 使用稀疏COO张量进行工作 +### 使用稀疏 COO 张量进行工作 让我们考虑以下示例： @@ -424,7 +424,7 @@ tensor(indices=tensor([[0, 0, 1, 1]]), >>> s = torch.sparse_coo_tensor(i, v, (2, 3, 2)) ``` -如上所述，稀疏COO张量是一个[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")实例，为了区分它与使用其他布局的张量实例，可以使用[`torch.Tensor.is_sparse`](generated/torch.Tensor.is_sparse.html#torch.Tensor.is_sparse "torch.Tensor.is_sparse")或`torch.Tensor.layout`属性： +如上所述，稀疏 COO 张量是一个`torch.Tensor`实例，为了区分它与使用其他布局的张量实例，可以使用`torch.Tensor.is_sparse`或`torch.Tensor.layout`属性： ```py >>> isinstance(s, torch.Tensor) @@ -435,25 +435,25 @@ True True ``` -可以使用方法[`torch.Tensor.sparse_dim()`](generated/torch.Tensor.sparse_dim.html#torch.Tensor.sparse_dim "torch.Tensor.sparse_dim")和[`torch.Tensor.dense_dim()`](generated/torch.Tensor.dense_dim.html#torch.Tensor.dense_dim "torch.Tensor.dense_dim")分别获取稀疏和密集维度的数量。例如： +可以使用方法`torch.Tensor.sparse_dim()`和`torch.Tensor.dense_dim()`分别获取稀疏和密集维度的数量。例如： ```py >>> s.sparse_dim(), s.dense_dim() (2, 1) ``` -如果`s`是一个稀疏COO张量，则可以使用方法[`torch.Tensor.indices()`](generated/torch.Tensor.indices.html#torch.Tensor.indices "torch.Tensor.indices")和[`torch.Tensor.values()`](generated/torch.Tensor.values.html#torch.Tensor.values "torch.Tensor.values")获取其COO格式数据。 +如果`s`是一个稀疏 COO 张量，则可以使用方法`torch.Tensor.indices()`和`torch.Tensor.values()`获取其 COO 格式数据。 注意 -目前，只有当张量实例已合并时才能获取COO格式数据： +目前，只有当张量实例已合并时才能获取 COO 格式数据： ```py >>> s.indices() RuntimeError: Cannot get indices on an uncoalesced tensor, please call .coalesce() first ``` -要获取未合并张量的COO格式数据，请使用`torch.Tensor._values()`和`torch.Tensor._indices()`： +要获取未合并张量的 COO 格式数据，请使用`torch.Tensor._values()`和`torch.Tensor._indices()`： ```py >>> s._indices() @@ -465,14 +465,14 @@ tensor([[0, 1, 1], 调用`torch.Tensor._values()`将返回一个*分离*张量。要跟踪梯度，必须使用`torch.Tensor.coalesce().values()`。 -构造一个新的稀疏COO张量会导致一个未合并的张量： +构造一个新的稀疏 COO 张量会导致一个未合并的张量： ```py >>> s.is_coalesced() False ``` -但可以使用[`torch.Tensor.coalesce()`](generated/torch.Tensor.coalesce.html#torch.Tensor.coalesce "torch.Tensor.coalesce")方法构造稀疏COO张量的合并副本： +但可以使用`torch.Tensor.coalesce()`方法构造稀疏 COO 张量的合并副本： ```py >>> s2 = s.coalesce() @@ -481,9 +481,9 @@ tensor([[0, 1, 1], [2, 0, 2]]) ``` -在处理未压缩稀疏COO张量时，必须考虑未压缩数据的可加性：相同索引的值是一个求和的项，其求值给出对应张量元素的值。例如，对稀疏未压缩张量进行标量乘法可以通过将所有未压缩值与标量相乘来实现，因为 `c * (a + b) == c * a + c * b` 成立。然而，任何非线性操作，比如平方根，不能通过将操作应用于未压缩数据来实现，因为一般情况下 `sqrt(a + b) == sqrt(a) + sqrt(b)` 不成立。 +在处理未压缩稀疏 COO 张量时，必须考虑未压缩数据的可加性：相同索引的值是一个求和的项，其求值给出对应张量元素的值。例如，对稀疏未压缩张量进行标量乘法可以通过将所有未压缩值与标量相乘来实现，因为 `c * (a + b) == c * a + c * b` 成立。然而，任何非线性操作，比如平方根，不能通过将操作应用于未压缩数据来实现，因为一般情况下 `sqrt(a + b) == sqrt(a) + sqrt(b)` 不成立。 -对稀疏COO张量进行切片（带有正步长）仅支持密集维度。索引支持稀疏和密集维度： +对稀疏 COO 张量进行切片（带有正步长）仅支持密集维度。索引支持稀疏和密集维度： ```py >>> s[1] @@ -497,19 +497,19 @@ tensor(6) tensor([6]) ``` -在PyTorch中，稀疏张量的填充值不能被明确指定，一般假定为零。然而，存在一些操作可能会以不同方式解释填充值。例如，[`torch.sparse.softmax()`](generated/torch.sparse.softmax.html#torch.sparse.softmax "torch.sparse.softmax") 计算softmax时假定填充值为负无穷。## 稀疏压缩张量[](#sparse-compressed-tensors "跳转到此标题的永久链接") +在 PyTorch 中，稀疏张量的填充值不能被明确指定，一般假定为零。然而，存在一些操作可能会以不同方式解释填充值。例如，`torch.sparse.softmax()` 计算 softmax 时假定填充值为负无穷。## 稀疏压缩张量[](#sparse-compressed-tensors "跳转到此标题的永久链接") -稀疏压缩张量代表一类稀疏张量，其共同特征是使用编码压缩某个维度的索引，从而在稀疏压缩张量的线性代数核上实现某些优化。这种编码基于[压缩稀疏行（CSR）](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format))格式，PyTorch稀疏压缩张量扩展了对稀疏张量批次的支持，允许多维张量值，并将稀疏张量值存储在密集块中。 +稀疏压缩张量代表一类稀疏张量，其共同特征是使用编码压缩某个维度的索引，从而在稀疏压缩张量的线性代数核上实现某些优化。这种编码基于[压缩稀疏行（CSR）](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_row_(CSR,_CRS_or_Yale_format))格式，PyTorch 稀疏压缩张量扩展了对稀疏张量批次的支持，允许多维张量值，并将稀疏张量值存储在密集块中。 注意 -我们使用（B + M + K）维张量来表示一个N维稀疏压缩混合张量，其中B、M和K分别是批次、稀疏和密集维度的数量，满足 `B + M + K == N`。稀疏压缩张量的稀疏维度总是两个，`M == 2`。 +我们使用（B + M + K）维张量来表示一个 N 维稀疏压缩混合张量，其中 B、M 和 K 分别是批次、稀疏和密集维度的数量，满足 `B + M + K == N`。稀疏压缩张量的稀疏维度总是两个，`M == 2`。 注意 -如果满足以下不变性，我们说一个索引张量 `compressed_indices` 使用CSR编码： +如果满足以下不变性，我们说一个索引张量 `compressed_indices` 使用 CSR 编码： -+ `compressed_indices` 是一个连续的步进为32位或64位整数张量 ++ `compressed_indices` 是一个连续的步进为 32 位或 64 位整数张量 + `compressed_indices` 的形状是 `(*batchsize, compressed_dim_size + 1)`，其中 `compressed_dim_size` 是压缩维度的数量（例如行或列） @@ -519,29 +519,29 @@ tensor([6]) + 对于 `i=1, ..., compressed_dim_size`，`0 <= compressed_indices[..., i] - compressed_indices[..., i - 1] <= plain_dim_size`，其中 `plain_dim_size` 是平面维度的数量（与压缩维度正交，例如列或行）。 -为了确保构建的稀疏张量具有一致的索引、值和大小，可以通过 `check_invariants=True` 关键字参数在每个张量创建时启用不变性检查，或者使用 [`torch.sparse.check_sparse_tensor_invariants`](generated/torch.sparse.check_sparse_tensor_invariants.html#torch.sparse.check_sparse_tensor_invariants "torch.sparse.check_sparse_tensor_invariants") 上下文管理器实例进行全局设置。默认情况下，稀疏张量的不变性检查是禁用的。 +为了确保构建的稀疏张量具有一致的索引、值和大小，可以通过 `check_invariants=True` 关键字参数在每个张量创建时启用不变性检查，或者使用 `torch.sparse.check_sparse_tensor_invariants` 上下文管理器实例进行全局设置。默认情况下，稀疏张量的不变性检查是禁用的。 注意 -将稀疏压缩布局推广到N维张量可能会导致对指定元素数量的混淆。当稀疏压缩张量包含批量维度时，指定元素的数量将对应于每个批量的这些元素的数量。当稀疏压缩张量具有密集维度时，考虑的元素现在是K维数组。对于块稀疏压缩布局，2-D块被视为被指定的元素。以一个具有长度为`b`的批量维度和块形状为`p, q`的3维块稀疏张量为例。如果这个张量有`n`个指定元素，那么实际上我们有每批`n`个块被指定。这个张量将具有形状为`(b, n, p, q)`的`values`。指定元素数量的这种解释来自于所有稀疏压缩布局都源自于2维矩阵的压缩。批量维度被视为稀疏矩阵的堆叠，密集维度改变了元素的含义，从简单的标量值变为具有自己维度的数组。 +将稀疏压缩布局推广到 N 维张量可能会导致对指定元素数量的混淆。当稀疏压缩张量包含批量维度时，指定元素的数量将对应于每个批量的这些元素的数量。当稀疏压缩张量具有密集维度时，考虑的元素现在是 K 维数组。对于块稀疏压缩布局，2-D 块被视为被指定的元素。以一个具有长度为`b`的批量维度和块形状为`p, q`的 3 维块稀疏张量为例。如果这个张量有`n`个指定元素，那么实际上我们有每批`n`个块被指定。这个张量将具有形状为`(b, n, p, q)`的`values`。指定元素数量的这种解释来自于所有稀疏压缩布局都源自于 2 维矩阵的压缩。批量维度被视为稀疏矩阵的堆叠，密集维度改变了元素的含义，从简单的标量值变为具有自己维度的数组。 -### 稀疏CSR张量 +### 稀疏 CSR 张量 -CSR格式相对于COO格式的主要优势是更好地利用存储和更快的计算操作，例如使用MKL和MAGMA后端的稀疏矩阵-向量乘法。 +CSR 格式相对于 COO 格式的主要优势是更好地利用存储和更快的计算操作，例如使用 MKL 和 MAGMA 后端的稀疏矩阵-向量乘法。 -在最简单的情况下，一个(0 + 2 + 0)维稀疏CSR张量由三个1-D张量组成：`crow_indices`、`col_indices`和`values`： +在最简单的情况下，一个(0 + 2 + 0)维稀疏 CSR 张量由三个 1-D 张量组成：`crow_indices`、`col_indices`和`values`： -> + `crow_indices`张量包含压缩的行索引。这是一个大小为`nrows + 1`（行数加1）的1-D张量。`crow_indices`的最后一个元素是指定元素的数量`nse`。该张量根据给定行的起始位置在`values`和`col_indices`中编码索引。张量中的每个连续数字减去前一个数字表示给定行中元素的数量。 +> + `crow_indices`张量包含压缩的行索引。这是一个大小为`nrows + 1`（行数加 1）的 1-D 张量。`crow_indices`的最后一个元素是指定元素的数量`nse`。该张量根据给定行的起始位置在`values`和`col_indices`中编码索引。张量中的每个连续数字减去前一个数字表示给定行中元素的数量。 > + -> + `col_indices`张量包含每个元素的列索引。这是一个大小为`nse`的1-D张量。 +> + `col_indices`张量包含每个元素的列索引。这是一个大小为`nse`的 1-D 张量。 > + -> + `values`张量包含CSR张量元素的值。这是一个大小为`nse`的1-D张量。 +> + `values`张量包含 CSR 张量元素的值。这是一个大小为`nse`的 1-D 张量。 注意 -索引张量`crow_indices`和`col_indices`的元素类型应为`torch.int64`（默认）或`torch.int32`。如果要使用MKL启用的矩阵操作，请使用`torch.int32`。这是由于pytorch的默认链接是与使用32位整数索引的MKL LP64链接。 +索引张量`crow_indices`和`col_indices`的元素类型应为`torch.int64`（默认）或`torch.int32`。如果要使用 MKL 启用的矩阵操作，请使用`torch.int32`。这是由于 pytorch 的默认链接是与使用 32 位整数索引的 MKL LP64 链接。 -在一般情况下，(B + 2 + K)维稀疏CSR张量由两个(B + 1)维索引张量`crow_indices`和`col_indices`以及(1 + K)维`values`张量组成，使得 +在一般情况下，(B + 2 + K)维稀疏 CSR 张量由两个(B + 1)维索引张量`crow_indices`和`col_indices`以及(1 + K)维`values`张量组成，使得 > + `crow_indices.shape == (*batchsize, nrows + 1)` > + @@ -549,25 +549,25 @@ CSR格式相对于COO格式的主要优势是更好地利用存储和更快的 > + > + `values.shape == (nse, *densesize)` -稀疏CSR张量的形状为`(*batchsize, nrows, ncols, *densesize)`，其中`len(batchsize) == B`且`len(densesize) == K`。 +稀疏 CSR 张量的形状为`(*batchsize, nrows, ncols, *densesize)`，其中`len(batchsize) == B`且`len(densesize) == K`。 注意 -稀疏CSR张量的批次是相关的：所有批次中指定元素的数量必须相同。这种有点人为的约束允许有效地存储不同CSR批次的索引。 +稀疏 CSR 张量的批次是相关的：所有批次中指定元素的数量必须相同。这种有点人为的约束允许有效地存储不同 CSR 批次的索引。 注意 -稀疏和密集维度的数量可以使用[`torch.Tensor.sparse_dim()`](generated/torch.Tensor.sparse_dim.html#torch.Tensor.sparse_dim "torch.Tensor.sparse_dim")和[`torch.Tensor.dense_dim()`](generated/torch.Tensor.dense_dim.html#torch.Tensor.dense_dim "torch.Tensor.dense_dim")方法获得。批量维度可以从张量形状中计算得到：`batchsize = tensor.shape[:-tensor.sparse_dim() - tensor.dense_dim()]`。 +稀疏和密集维度的数量可以使用`torch.Tensor.sparse_dim()`和`torch.Tensor.dense_dim()`方法获得。批量维度可以从张量形状中计算得到：`batchsize = tensor.shape[:-tensor.sparse_dim() - tensor.dense_dim()]`。 注意 -稀疏CSR张量的内存消耗至少为`(nrows * 8 + (8 + <元素类型大小字节> * prod(densesize)) * nse) * prod(batchsize)`字节（加上存储其他张量数据的恒定开销）。 +稀疏 CSR 张量的内存消耗至少为`(nrows * 8 + (8 + <元素类型大小字节> * prod(densesize)) * nse) * prod(batchsize)`字节（加上存储其他张量数据的恒定开销）。 -使用[稀疏COO格式介绍中的示例数据](#sparse-coo-docs)相同，一个包含 100 000 个非零32位浮点数的 10 000 x 10 000 张量的内存消耗至少为`(10000 * 8 + (8 + 4 * 1) * 100 000) * 1 = 1 280 000`字节，使用CSR张量布局。请注意，与使用COO和分步格式相比，使用CSR存储格式可以节省1.6倍和310倍的存储空间。 +使用稀疏 COO 格式介绍中的示例数据相同，一个包含 100 000 个非零 32 位浮点数的 10 000 x 10 000 张量的内存消耗至少为`(10000 * 8 + (8 + 4 * 1) * 100 000) * 1 = 1 280 000`字节，使用 CSR 张量布局。请注意，与使用 COO 和分步格式相比，使用 CSR 存储格式可以节省 1.6 倍和 310 倍的存储空间。 -#### 构造CSR张量[](#construction-of-csr-tensors "跳转到此标题") +#### 构造 CSR 张量[](#construction-of-csr-tensors "跳转到此标题") -可以直接使用[`torch.sparse_csr_tensor()`](generated/torch.sparse_csr_tensor.html#torch.sparse_csr_tensor "torch.sparse_csr_tensor")函数构造稀疏CSR张量。用户必须分别提供行索引和列索引以及值张量，其中行索引必须使用CSR压缩编码指定。如果没有提供`size`参数，则将从`crow_indices`和`col_indices`中推断出`size`。 +可以直接使用`torch.sparse_csr_tensor()`函数构造稀疏 CSR 张量。用户必须分别提供行索引和列索引以及值张量，其中行索引必须使用 CSR 压缩编码指定。如果没有提供`size`参数，则将从`crow_indices`和`col_indices`中推断出`size`。 ```py >>> crow_indices = torch.tensor([0, 2, 4]) @@ -588,7 +588,7 @@ tensor([[1., 2.], 推断的`size`中稀疏维度的值是从`crow_indices`的大小和`col_indices`中的最大索引值计算而来的。如果列数需要大于推断的`size`中的列数，则必须明确指定`size`参数。 -从分步或稀疏COO张量构造2-D稀疏CSR张量的最简单方法是使用[`torch.Tensor.to_sparse_csr()`](generated/torch.Tensor.to_sparse_csr.html#torch.Tensor.to_sparse_csr "torch.Tensor.to_sparse_csr")方法。在（分步）张量中的任何零将被解释为稀疏张量中的缺失值： +从分步或稀疏 COO 张量构造 2-D 稀疏 CSR 张量的最简单方法是使用`torch.Tensor.to_sparse_csr()`方法。在（分步）张量中的任何零将被解释为稀疏张量中的缺失值： ```py >>> a = torch.tensor([[0, 0, 1, 0], [1, 2, 0, 0], [0, 0, 0, 0]], dtype=torch.float64) @@ -599,9 +599,9 @@ tensor(crow_indices=tensor([0, 1, 3, 3]), values=tensor([1., 1., 2.]), size=(3, 4), nnz=3, dtype=torch.float64) ``` -#### CSR张量操作 +#### CSR 张量操作 -稀疏矩阵-向量乘法可以使用`tensor.matmul()`方法执行。这是目前CSR张量上支持的唯一数学运算。 +稀疏矩阵-向量乘法可以使用`tensor.matmul()`方法执行。这是目前 CSR 张量上支持的唯一数学运算。 ```py >>> vec = torch.randn(4, 1, dtype=torch.float64) @@ -609,25 +609,25 @@ tensor(crow_indices=tensor([0, 1, 3, 3]), tensor([[0.9078], [1.3180], [0.0000]], dtype=torch.float64) -``` ### 稀疏CSC张量 +``` ### 稀疏 CSC 张量 -稀疏CSC（压缩稀疏列）张量格式实现了CSC格式，用于存储具有扩展支持批量稀疏CSC张量和值为多维张量的二维张量。 +稀疏 CSC（压缩稀疏列）张量格式实现了 CSC 格式，用于存储具有扩展支持批量稀疏 CSC 张量和值为多维张量的二维张量。 注意 -稀疏CSC张量在转置时本质上是稀疏CSR张量的转置，转置是关于交换稀疏维度的。 +稀疏 CSC 张量在转置时本质上是稀疏 CSR 张量的转置，转置是关于交换稀疏维度的。 -与[稀疏CSR张量](#sparse-csr-docs)类似，稀疏CSC张量由三个张量组成：`ccol_indices`、`row_indices`和`values`。 +与稀疏 CSR 张量类似，稀疏 CSC 张量由三个张量组成：`ccol_indices`、`row_indices`和`values`。 -> + `ccol_indices`张量包含压缩的列索引。这是一个形状为`(*batchsize, ncols + 1)`的(B + 1)-D张量。最后一个元素是指定元素的数量`nse`。该张量根据给定列开始的位置编码`values`和`row_indices`的索引。张量中的每个连续数字减去前一个数字表示给定列中元素的数量。 +> + `ccol_indices`张量包含压缩的列索引。这是一个形状为`(*batchsize, ncols + 1)`的(B + 1)-D 张量。最后一个元素是指定元素的数量`nse`。该张量根据给定列开始的位置编码`values`和`row_indices`的索引。张量中的每个连续数字减去前一个数字表示给定列中元素的数量。 > + -> + `row_indices`张量包含每个元素的行索引。这是一个形状为`(*batchsize, nse)`的(B + 1)-D张量。 +> + `row_indices`张量包含每个元素的行索引。这是一个形状为`(*batchsize, nse)`的(B + 1)-D 张量。 > + -> + `values`张量包含CSC张量元素的值。这是一个形状为`(nse, *densesize)`的(1 + K)-D张量。 +> + `values`张量包含 CSC 张量元素的值。这是一个形状为`(nse, *densesize)`的(1 + K)-D 张量。 -#### CSC张量的构造[](#construction-of-csc-tensors "跳转到此标题") +#### CSC 张量的构造[](#construction-of-csc-tensors "跳转到此标题") -可以直接使用[`torch.sparse_csc_tensor()`](generated/torch.sparse_csc_tensor.html#torch.sparse_csc_tensor "torch.sparse_csc_tensor")函数构造稀疏CSC张量。用户必须分别提供行索引和列索引以及值张量，其中列索引必须使用CSR压缩编码指定。如果没有提供`size`参数，则将从`row_indices`和`ccol_indices`张量中推断出`size`。 +可以直接使用`torch.sparse_csc_tensor()`函数构造稀疏 CSC 张量。用户必须分别提供行索引和列索引以及值张量，其中列索引必须使用 CSR 压缩编码指定。如果没有提供`size`参数，则将从`row_indices`和`ccol_indices`张量中推断出`size`。 ```py >>> ccol_indices = torch.tensor([0, 2, 4]) @@ -646,9 +646,9 @@ tensor([[1., 3.], 注意 -稀疏CSC张量的构造函数在行索引参数之前有压缩的列索引参数。 +稀疏 CSC 张量的构造函数在行索引参数之前有压缩的列索引参数。 -(0 + 2 + 0)-维稀疏CSC张量可以使用[`torch.Tensor.to_sparse_csc()`](generated/torch.Tensor.to_sparse_csc.html#torch.Tensor.to_sparse_csc "torch.Tensor.to_sparse_csc")方法从任何二维张量构造。在（分步）张量中的任何零将被解释为稀疏张量中的缺失值： +(0 + 2 + 0)-维稀疏 CSC 张量可以使用`torch.Tensor.to_sparse_csc()`方法从任何二维张量构造。在（分步）张量中的任何零将被解释为稀疏张量中的缺失值： ```py >>> a = torch.tensor([[0, 0, 1, 0], [1, 2, 0, 0], [0, 0, 0, 0]], dtype=torch.float64) @@ -658,21 +658,21 @@ tensor(ccol_indices=tensor([0, 1, 2, 3, 3]), row_indices=tensor([1, 1, 0]), values=tensor([1., 2., 1.]), size=(3, 4), nnz=3, dtype=torch.float64, layout=torch.sparse_csc) -``` ### 稀疏的BSR张量 +``` ### 稀疏的 BSR 张量 -稀疏的BSR（块压缩稀疏行）张量格式实现了BSR格式，用于存储二维张量，并扩展支持稀疏BSR张量的批处理和值为多维张量块的情况。 +稀疏的 BSR（块压缩稀疏行）张量格式实现了 BSR 格式，用于存储二维张量，并扩展支持稀疏 BSR 张量的批处理和值为多维张量块的情况。 -稀疏的BSR张量由三个张量组成：`crow_indices`、`col_indices`和`values`： +稀疏的 BSR 张量由三个张量组成：`crow_indices`、`col_indices`和`values`： -> + `crow_indices`张量包含压缩的行索引。这是一个形状为`(*batchsize, nrowblocks + 1)`的(B + 1)-D张量。最后一个元素是指定块的数量`nse`。该张量根据给定列块的起始位置编码`values`和`col_indices`中的索引。张量中的每个连续数字减去前一个数字表示给定行中块的数量。 +> + `crow_indices`张量包含压缩的行索引。这是一个形状为`(*batchsize, nrowblocks + 1)`的(B + 1)-D 张量。最后一个元素是指定块的数量`nse`。该张量根据给定列块的起始位置编码`values`和`col_indices`中的索引。张量中的每个连续数字减去前一个数字表示给定行中块的数量。 > + -> + `col_indices`张量包含每个元素的列块索引。这是一个形状为`(*batchsize, nse)`的(B + 1)-D张量。 +> + `col_indices`张量包含每个元素的列块索引。这是一个形状为`(*batchsize, nse)`的(B + 1)-D 张量。 > + -> + `values`张量包含稀疏的BSR张量元素的值，收集到二维块中。这是一个形状为`(nse, nrowblocks, ncolblocks, *densesize)`的(1 + 2 + K)-D张量。 +> + `values`张量包含稀疏的 BSR 张量元素的值，收集到二维块中。这是一个形状为`(nse, nrowblocks, ncolblocks, *densesize)`的(1 + 2 + K)-D 张量。 -#### 构建BSR张量[](#construction-of-bsr-tensors "跳转到此标题的永久链接") +#### 构建 BSR 张量[](#construction-of-bsr-tensors "跳转到此标题的永久链接") -稀疏的BSR张量可以直接通过使用[`torch.sparse_bsr_tensor()`](generated/torch.sparse_bsr_tensor.html#torch.sparse_bsr_tensor "torch.sparse_bsr_tensor")函数来构建。用户必须分别提供行和列块索引以及数值张量，其中行块索引必须使用CSR压缩编码指定。如果没有提供`size`参数，它将从`crow_indices`和`col_indices`张量中推断出来。 +稀疏的 BSR 张量可以直接通过使用`torch.sparse_bsr_tensor()`函数来构建。用户必须分别提供行和列块索引以及数值张量，其中行块索引必须使用 CSR 压缩编码指定。如果没有提供`size`参数，它将从`crow_indices`和`col_indices`张量中推断出来。 ```py >>> crow_indices = torch.tensor([0, 2, 4]) @@ -701,7 +701,7 @@ tensor([[ 0., 1., 2., 3., 4., 5.], [18., 19., 20., 21., 22., 23.]], dtype=torch.float64) ``` -可以使用[`torch.Tensor.to_sparse_bsr()`](generated/torch.Tensor.to_sparse_bsr.html#torch.Tensor.to_sparse_bsr "torch.Tensor.to_sparse_bsr")方法从任何二维张量构建(0 + 2 + 0)-维稀疏的BSR张量，该方法还需要指定值块大小： +可以使用`torch.Tensor.to_sparse_bsr()`方法从任何二维张量构建(0 + 2 + 0)-维稀疏的 BSR 张量，该方法还需要指定值块大小： ```py >>> dense = torch.tensor([[0, 1, 2, 3, 4, 5], @@ -721,21 +721,21 @@ tensor(crow_indices=tensor([0, 2, 4]), [[15, 16, 17], [21, 22, 23]]]), size=(4, 6), nnz=4, layout=torch.sparse_bsr) -``` ### 稀疏的BSC张量 +``` ### 稀疏的 BSC 张量 -稀疏的BSC（块压缩稀疏列）张量格式实现了BSC格式，用于存储二维张量，并扩展支持稀疏BSC张量的批处理和值为多维张量块的情况。 +稀疏的 BSC（块压缩稀疏列）张量格式实现了 BSC 格式，用于存储二维张量，并扩展支持稀疏 BSC 张量的批处理和值为多维张量块的情况。 -稀疏的BSC张量由三个张量组成：`ccol_indices`、`row_indices`和`values`： +稀疏的 BSC 张量由三个张量组成：`ccol_indices`、`row_indices`和`values`： -> + `ccol_indices`张量包含压缩的列索引。这是一个形状为`(*batchsize, ncolblocks + 1)`的(B + 1)-D张量。最后一个元素是指定块的数量`nse`。该张量根据给定行块的起始位置编码`values`和`row_indices`中的索引。张量中的每个连续数字减去前一个数字表示给定列中块的数量。 +> + `ccol_indices`张量包含压缩的列索引。这是一个形状为`(*batchsize, ncolblocks + 1)`的(B + 1)-D 张量。最后一个元素是指定块的数量`nse`。该张量根据给定行块的起始位置编码`values`和`row_indices`中的索引。张量中的每个连续数字减去前一个数字表示给定列中块的数量。 > + -> + `row_indices`张量包含每个元素的行块索引。这是一个形状为`(*batchsize, nse)`的(B + 1)-D张量。 +> + `row_indices`张量包含每个元素的行块索引。这是一个形状为`(*batchsize, nse)`的(B + 1)-D 张量。 > + -> + `values`张量包含稀疏的BSC张量元素的值，收集到二维块中。这是一个形状为`(nse, nrowblocks, ncolblocks, *densesize)`的(1 + 2 + K)-D张量。 +> + `values`张量包含稀疏的 BSC 张量元素的值，收集到二维块中。这是一个形状为`(nse, nrowblocks, ncolblocks, *densesize)`的(1 + 2 + K)-D 张量。 -#### 构建BSC张量[](#construction-of-bsc-tensors "跳转到此标题的永久链接") +#### 构建 BSC 张量[](#construction-of-bsc-tensors "跳转到此标题的永久链接") -稀疏的BSC张量可以直接通过使用[`torch.sparse_bsc_tensor()`](generated/torch.sparse_bsc_tensor.html#torch.sparse_bsc_tensor "torch.sparse_bsc_tensor")函数来构建。用户必须分别提供行和列块索引以及数值张量，其中列块索引必须使用CSR压缩编码指定。如果没有提供`size`参数，它将从`ccol_indices`和`row_indices`张量中推断出来。 +稀疏的 BSC 张量可以直接通过使用`torch.sparse_bsc_tensor()`函数来构建。用户必须分别提供行和列块索引以及数值张量，其中列块索引必须使用 CSR 压缩编码指定。如果没有提供`size`参数，它将从`ccol_indices`和`row_indices`张量中推断出来。 ```py >>> ccol_indices = torch.tensor([0, 2, 4]) @@ -765,7 +765,7 @@ tensor(ccol_indices=tensor([0, 2, 4]), #### 稀疏压缩张量的构造[](#construction-of-sparse-compressed-tensors "Permalink to this heading") -CSR、CSC、BSR 和 CSC 张量可以通过使用 [`torch.sparse_compressed_tensor()`](generated/torch.sparse_compressed_tensor.html#torch.sparse_compressed_tensor "torch.sparse_compressed_tensor") 函数构建，该函数具有与上述讨论的构造函数 [`torch.sparse_csr_tensor()`](generated/torch.sparse_csr_tensor.html#torch.sparse_csr_tensor "torch.sparse_csr_tensor")、[`torch.sparse_csc_tensor()`](generated/torch.sparse_csc_tensor.html#torch.sparse_csc_tensor "torch.sparse_csc_tensor")、[`torch.sparse_bsr_tensor()`](generated/torch.sparse_bsr_tensor.html#torch.sparse_bsr_tensor "torch.sparse_bsr_tensor") 和 [`torch.sparse_bsc_tensor()`](generated/torch.sparse_bsc_tensor.html#torch.sparse_bsc_tensor "torch.sparse_bsc_tensor") 相同的接口，但需要额外的 `layout` 参数。以下示例说明了使用相同输入数据通过指定相应的布局参数来构建 CSR 和 CSC 张量的方法，该参数传递给 [`torch.sparse_compressed_tensor()`](generated/torch.sparse_compressed_tensor.html#torch.sparse_compressed_tensor "torch.sparse_compressed_tensor") 函数： +CSR、CSC、BSR 和 CSC 张量可以通过使用 `torch.sparse_compressed_tensor()` 函数构建，该函数具有与上述讨论的构造函数 `torch.sparse_csr_tensor()`、`torch.sparse_csc_tensor()`、`torch.sparse_bsr_tensor()` 和 `torch.sparse_bsc_tensor()` 相同的接口，但需要额外的 `layout` 参数。以下示例说明了使用相同输入数据通过指定相应的布局参数来构建 CSR 和 CSC 张量的方法，该参数传递给 `torch.sparse_compressed_tensor()` 函数： ```py >>> compressed_indices = torch.tensor([0, 2, 4]) @@ -793,112 +793,112 @@ tensor(True) | PyTorch 操作 | 稀疏梯度？ | 布局签名 | | --- | --- | --- | -| [`torch.mv()`](generated/torch.mv.html#torch.mv "torch.mv") | 否 | `M[sparse_coo] @ V[strided] -> V[strided]` | -| [`torch.mv()`](generated/torch.mv.html#torch.mv "torch.mv") | 否 | `M[sparse_csr] @ V[strided] -> V[strided]` | -| [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") | 否 | `M[sparse_coo] @ M[strided] -> M[strided]` | -| [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") | 否 | `M[sparse_csr] @ M[strided] -> M[strided]` | -| [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") | 否 | `M[SparseSemiStructured] @ M[strided] -> M[strided]` | -| [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") | 否 | `M[strided] @ M[SparseSemiStructured] -> M[strided]` | -| [`torch.mm()`](generated/torch.mm.html#torch.mm "torch.mm") | 否 | `M[sparse_coo] @ M[strided] -> M[strided]` | -| [`torch.mm()`](generated/torch.mm.html#torch.mm "torch.mm") | 否 | `M[SparseSemiStructured] @ M[strided] -> M[strided]` | -| [`torch.mm()`](generated/torch.mm.html#torch.mm "torch.mm") | 否 | `M[strided] @ M[SparseSemiStructured] -> M[strided]` | -| [`torch.sparse.mm()`](generated/torch.sparse.mm.html#torch.sparse.mm "torch.sparse.mm") | 是 | `M[sparse_coo] @ M[strided] -> M[strided]` | -| [`torch.smm()`](generated/torch.smm.html#torch.smm "torch.smm") | 否 | `M[sparse_coo] @ M[strided] -> M[sparse_coo]` | -| [`torch.hspmm()`](generated/torch.hspmm.html#torch.hspmm "torch.hspmm") | 否 | `M[sparse_coo] @ M[strided] -> M[hybrid sparse_coo]` | -| [`torch.bmm()`](generated/torch.bmm.html#torch.bmm "torch.bmm") | 否 | `T[sparse_coo] @ T[strided] -> T[strided]` | -| [`torch.addmm()`](generated/torch.addmm.html#torch.addmm "torch.addmm") | 否 | `f * M[strided] + f * (M[sparse_coo] @ M[strided]) -> M[strided]` | -| [`torch.addmm()`](generated/torch.addmm.html#torch.addmm "torch.addmm") | 否 | `f * M[strided] + f * (M[SparseSemiStructured] @ M[strided]) -> M[strided]` | -| [`torch.addmm()`](generated/torch.addmm.html#torch.addmm "torch.addmm") | 否 | `f * M[strided] + f * (M[strided] @ M[SparseSemiStructured]) -> M[strided]` | -| [`torch.sparse.addmm()`](generated/torch.sparse.addmm.html#torch.sparse.addmm "torch.sparse.addmm") | 是 | `f * M[strided] + f * (M[sparse_coo] @ M[strided]) -> M[strided]` | -| [`torch.sspaddmm()`](generated/torch.sspaddmm.html#torch.sspaddmm "torch.sspaddmm") | 否 | `f * M[sparse_coo] + f * (M[sparse_coo] @ M[strided]) -> M[sparse_coo]` | -| [`torch.lobpcg()`](generated/torch.lobpcg.html#torch.lobpcg "torch.lobpcg") | 否 | `GENEIG(M[sparse_coo]) -> M[strided], M[strided]` | -| [`torch.pca_lowrank()`](generated/torch.pca_lowrank.html#torch.pca_lowrank "torch.pca_lowrank") | 是 | `PCA(M[sparse_coo]) -> M[strided], M[strided], M[strided]` | -| [`torch.svd_lowrank()`](generated/torch.svd_lowrank.html#torch.svd_lowrank "torch.svd_lowrank") | 是 | `SVD(M[sparse_coo]) -> M[strided], M[strided], M[strided]` | - -“Sparse grad?”列指示PyTorch操作是否支持对稀疏矩阵参数进行反向传播。除了[`torch.smm()`](generated/torch.smm.html#torch.smm "torch.smm")之外，所有PyTorch操作都支持对分步矩阵参数进行反向传播。 +| `torch.mv()` | 否 | `M[sparse_coo] @ V[strided] -> V[strided]` | +| `torch.mv()` | 否 | `M[sparse_csr] @ V[strided] -> V[strided]` | +| `torch.matmul()` | 否 | `M[sparse_coo] @ M[strided] -> M[strided]` | +| `torch.matmul()` | 否 | `M[sparse_csr] @ M[strided] -> M[strided]` | +| `torch.matmul()` | 否 | `M[SparseSemiStructured] @ M[strided] -> M[strided]` | +| `torch.matmul()` | 否 | `M[strided] @ M[SparseSemiStructured] -> M[strided]` | +| `torch.mm()` | 否 | `M[sparse_coo] @ M[strided] -> M[strided]` | +| `torch.mm()` | 否 | `M[SparseSemiStructured] @ M[strided] -> M[strided]` | +| `torch.mm()` | 否 | `M[strided] @ M[SparseSemiStructured] -> M[strided]` | +| `torch.sparse.mm()` | 是 | `M[sparse_coo] @ M[strided] -> M[strided]` | +| `torch.smm()` | 否 | `M[sparse_coo] @ M[strided] -> M[sparse_coo]` | +| `torch.hspmm()` | 否 | `M[sparse_coo] @ M[strided] -> M[hybrid sparse_coo]` | +| `torch.bmm()` | 否 | `T[sparse_coo] @ T[strided] -> T[strided]` | +| `torch.addmm()` | 否 | `f * M[strided] + f * (M[sparse_coo] @ M[strided]) -> M[strided]` | +| `torch.addmm()` | 否 | `f * M[strided] + f * (M[SparseSemiStructured] @ M[strided]) -> M[strided]` | +| `torch.addmm()` | 否 | `f * M[strided] + f * (M[strided] @ M[SparseSemiStructured]) -> M[strided]` | +| `torch.sparse.addmm()` | 是 | `f * M[strided] + f * (M[sparse_coo] @ M[strided]) -> M[strided]` | +| `torch.sspaddmm()` | 否 | `f * M[sparse_coo] + f * (M[sparse_coo] @ M[strided]) -> M[sparse_coo]` | +| `torch.lobpcg()` | 否 | `GENEIG(M[sparse_coo]) -> M[strided], M[strided]` | +| `torch.pca_lowrank()` | 是 | `PCA(M[sparse_coo]) -> M[strided], M[strided], M[strided]` | +| `torch.svd_lowrank()` | 是 | `SVD(M[sparse_coo]) -> M[strided], M[strided], M[strided]` | + +“Sparse grad?”列指示 PyTorch 操作是否支持对稀疏矩阵参数进行反向传播。除了`torch.smm()`之外，所有 PyTorch 操作都支持对分步矩阵参数进行反向传播。 注意 -目前，PyTorch不支持使用布局签名`M[strided] @ M[sparse_coo]`进行矩阵乘法。然而，应用程序仍然可以使用矩阵关系`D @ S == (S.t() @ D.t()).t()`来计算这个。 +目前，PyTorch 不支持使用布局签名`M[strided] @ M[sparse_coo]`进行矩阵乘法。然而，应用程序仍然可以使用矩阵关系`D @ S == (S.t() @ D.t()).t()`来计算这个。 ### 张量方法和稀疏 以下张量方法与稀疏张量相关： -| [`Tensor.is_sparse`](generated/torch.Tensor.is_sparse.html#torch.Tensor.is_sparse "torch.Tensor.is_sparse") | 如果张量使用稀疏COO存储布局，则返回`True`，否则返回`False`。 | +| `Tensor.is_sparse` | 如果张量使用稀疏 COO 存储布局，则返回`True`，否则返回`False`。 | | --- | --- | -| [`Tensor.is_sparse_csr`](generated/torch.Tensor.is_sparse_csr.html#torch.Tensor.is_sparse_csr "torch.Tensor.is_sparse_csr") | 如果张量使用稀疏CSR存储布局，则返回`True`，否则返回`False`。 | -| [`Tensor.dense_dim`](generated/torch.Tensor.dense_dim.html#torch.Tensor.dense_dim "torch.Tensor.dense_dim") | 返回[sparse tensor](#sparse-docs) `self`中的稠密维度数量。 | -| [`Tensor.sparse_dim`](generated/torch.Tensor.sparse_dim.html#torch.Tensor.sparse_dim "torch.Tensor.sparse_dim") | 返回[sparse tensor](#sparse-docs) `self`中的稀疏维度数量。 | -| [`Tensor.sparse_mask`](generated/torch.Tensor.sparse_mask.html#torch.Tensor.sparse_mask "torch.Tensor.sparse_mask") | 返回一个由稀疏张量`mask`的索引过滤的分步张量`self`的新[稀疏张量](#sparse-docs)。 | -| [`Tensor.to_sparse`](generated/torch.Tensor.to_sparse.html#torch.Tensor.to_sparse "torch.Tensor.to_sparse") | 返回张量的稀疏副本。 | -| [`Tensor.to_sparse_coo`](generated/torch.Tensor.to_sparse_coo.html#torch.Tensor.to_sparse_coo "torch.Tensor.to_sparse_coo") | 将张量转换为[坐标格式](#sparse-coo-docs)。 | -| [`Tensor.to_sparse_csr`](generated/torch.Tensor.to_sparse_csr.html#torch.Tensor.to_sparse_csr "torch.Tensor.to_sparse_csr") | 将张量转换为压缩行存储格式（CSR）。 | -| [`Tensor.to_sparse_csc`](generated/torch.Tensor.to_sparse_csc.html#torch.Tensor.to_sparse_csc "torch.Tensor.to_sparse_csc") | 将张量转换为压缩列存储（CSC）格式。 | -| [`Tensor.to_sparse_bsr`](generated/torch.Tensor.to_sparse_bsr.html#torch.Tensor.to_sparse_bsr "torch.Tensor.to_sparse_bsr") | 将张量转换为给定块大小的块稀疏行（BSR）存储格式。 | -| [`Tensor.to_sparse_bsc`](generated/torch.Tensor.to_sparse_bsc.html#torch.Tensor.to_sparse_bsc "torch.Tensor.to_sparse_bsc") | 将张量转换为给定块大小的块稀疏列（BSC）存储格式。 | -| [`Tensor.to_dense`](generated/torch.Tensor.to_dense.html#torch.Tensor.to_dense "torch.Tensor.to_dense") | 如果`self`不是分步张量，则创建`self`的分步副本，否则返回`self`。 | -| [`Tensor.values`](generated/torch.Tensor.values.html#torch.Tensor.values "torch.Tensor.values") | 返回[稀疏COO张量](#sparse-coo-docs)的值张量。 | - -以下张量方法特定于稀疏COO张量： - -| [`Tensor.coalesce`](generated/torch.Tensor.coalesce.html#torch.Tensor.coalesce "torch.Tensor.coalesce") | 如果`self`是[未合并的张量](#sparse-uncoalesced-coo-docs)，则返回`self`的合并副本。 | +| `Tensor.is_sparse_csr` | 如果张量使用稀疏 CSR 存储布局，则返回`True`，否则返回`False`。 | +| `Tensor.dense_dim` | 返回 sparse tensor `self`中的稠密维度数量。 | +| `Tensor.sparse_dim` | 返回 sparse tensor `self`中的稀疏维度数量。 | +| `Tensor.sparse_mask` | 返回一个由稀疏张量`mask`的索引过滤的分步张量`self`的新稀疏张量。 | +| `Tensor.to_sparse` | 返回张量的稀疏副本。 | +| `Tensor.to_sparse_coo` | 将张量转换为坐标格式。 | +| `Tensor.to_sparse_csr` | 将张量转换为压缩行存储格式（CSR）。 | +| `Tensor.to_sparse_csc` | 将张量转换为压缩列存储（CSC）格式。 | +| `Tensor.to_sparse_bsr` | 将张量转换为给定块大小的块稀疏行（BSR）存储格式。 | +| `Tensor.to_sparse_bsc` | 将张量转换为给定块大小的块稀疏列（BSC）存储格式。 | +| `Tensor.to_dense` | 如果`self`不是分步张量，则创建`self`的分步副本，否则返回`self`。 | +| `Tensor.values` | 返回稀疏 COO 张量的值张量。 | + +以下张量方法特定于稀疏 COO 张量： + +| `Tensor.coalesce` | 如果`self`是未合并的张量，则返回`self`的合并副本。 | | --- | --- | -| [`Tensor.sparse_resize_`](generated/torch.Tensor.sparse_resize_.html#torch.Tensor.sparse_resize_ "torch.Tensor.sparse_resize_") | 调整`self`[稀疏张量](#sparse-docs)到所需大小和稀疏和密集维度的数量。 | -| [`Tensor.sparse_resize_and_clear_`](generated/torch.Tensor.sparse_resize_and_clear_.html#torch.Tensor.sparse_resize_and_clear_ "torch.Tensor.sparse_resize_and_clear_") | 从[稀疏张量](#sparse-docs)`self`中删除所有指定元素，并将`self`调整为所需大小和稀疏和密集维度的数量。 | -| [`Tensor.is_coalesced`](generated/torch.Tensor.is_coalesced.html#torch.Tensor.is_coalesced "torch.Tensor.is_coalesced") | 如果`self`是已合并的[稀疏COO张量](#sparse-coo-docs)，则返回`True`，否则返回`False`。 | -| [`Tensor.indices`](generated/torch.Tensor.indices.html#torch.Tensor.indices "torch.Tensor.indices") | 返回[稀疏COO张量](#sparse-coo-docs)的索引张量。 | +| `Tensor.sparse_resize_` | 调整`self`稀疏张量到所需大小和稀疏和密集维度的数量。 | +| `Tensor.sparse_resize_and_clear_` | 从稀疏张量`self`中删除所有指定元素，并将`self`调整为所需大小和稀疏和密集维度的数量。 | +| `Tensor.is_coalesced` | 如果`self`是已合并的稀疏 COO 张量，则返回`True`，否则返回`False`。 | +| `Tensor.indices` | 返回稀疏 COO 张量的索引张量。 | -以下方法特定于[稀疏CSR张量](#sparse-csr-docs)和[稀疏BSR张量](#sparse-bsr-docs)： +以下方法特定于稀疏 CSR 张量和稀疏 BSR 张量： -| [`Tensor.crow_indices`](generated/torch.Tensor.crow_indices.html#torch.Tensor.crow_indices "torch.Tensor.crow_indices") | 返回包含`self`张量的压缩行索引的张量，当`self`是布局为`sparse_csr`的稀疏CSR张量时。 | +| `Tensor.crow_indices` | 返回包含`self`张量的压缩行索引的张量，当`self`是布局为`sparse_csr`的稀疏 CSR 张量时。 | | --- | --- | -| [`Tensor.col_indices`](generated/torch.Tensor.col_indices.html#torch.Tensor.col_indices "torch.Tensor.col_indices") | 返回包含`self`张量的列索引的张量，当`self`是布局为`sparse_csr`的稀疏CSR张量时。 | +| `Tensor.col_indices` | 返回包含`self`张量的列索引的张量，当`self`是布局为`sparse_csr`的稀疏 CSR 张量时。 | -以下方法特定于[稀疏CSC张量](#sparse-csc-docs)和[稀疏BSC张量](#sparse-bsc-docs)： +以下方法特定于稀疏 CSC 张量和稀疏 BSC 张量： -| [`Tensor.row_indices`](generated/torch.Tensor.row_indices.html#torch.Tensor.row_indices "torch.Tensor.row_indices") | | +| `Tensor.row_indices` | | | --- | --- | -| [`Tensor.ccol_indices`](generated/torch.Tensor.ccol_indices.html#torch.Tensor.ccol_indices "torch.Tensor.ccol_indices") | | +| `Tensor.ccol_indices` | | -以下张量方法支持稀疏COO张量： +以下张量方法支持稀疏 COO 张量： -[`add()`](generated/torch.Tensor.add.html#torch.Tensor.add "torch.Tensor.add") [`add_()`](generated/torch.Tensor.add_.html#torch.Tensor.add_ "torch.Tensor.add_") [`addmm()`](generated/torch.Tensor.addmm.html#torch.Tensor.addmm "torch.Tensor.addmm") [`addmm_()`](generated/torch.Tensor.addmm_.html#torch.Tensor.addmm_ "torch.Tensor.addmm_") [`any()`](generated/torch.Tensor.any.html#torch.Tensor.any "torch.Tensor.any") [`asin()`](generated/torch.Tensor.asin.html#torch.Tensor.asin "torch.Tensor.asin") [`asin_()`](generated/torch.Tensor.asin_.html#torch.Tensor.asin_ "torch.Tensor.asin_") [`arcsin()`](generated/torch.Tensor.arcsin.html#torch.Tensor.arcsin "torch.Tensor.arcsin") [`arcsin_()`](generated/torch.Tensor.arcsin_.html#torch.Tensor.arcsin_ "torch.Tensor.arcsin_") [`bmm()`](generated/torch.Tensor.bmm.html#torch.Tensor.bmm "torch.Tensor.bmm") [`clone()`](generated/torch.Tensor.clone.html#torch.Tensor.clone "torch.Tensor.clone") [`deg2rad()`](generated/torch.Tensor.deg2rad.html#torch.Tensor.deg2rad "torch.Tensor.deg2rad") `deg2rad_()` [`detach()`](generated/torch.Tensor.detach.html#torch.Tensor.detach "torch.Tensor.detach") [`detach_()`](generated/torch.Tensor.detach_.html#torch.Tensor.detach_ "torch.Tensor.detach_") [`dim()`](generated/torch.Tensor.dim.html#torch.Tensor.dim "torch.Tensor.dim") [`div()`](generated/torch.Tensor.div.html#torch.Tensor.div "torch.Tensor.div") [`div_()`](generated/torch.Tensor.div_.html#torch.Tensor.div_ "torch.Tensor.div_") [`floor_divide()`](generated/torch.Tensor.floor_divide.html#torch.Tensor.floor_divide "torch.Tensor.floor_divide") [`floor_divide_()`](generated/torch.Tensor.floor_divide_.html#torch.Tensor.floor_divide_ "torch.Tensor.floor_divide_") [`get_device()`](generated/torch.Tensor.get_device.html#torch.Tensor.get_device "torch.Tensor.get_device") [`index_select()`](generated/torch.Tensor.index_select.html#torch.Tensor.index_select "torch.Tensor.index_select") [`isnan()`](generated/torch.Tensor.isnan.html#torch.Tensor.isnan "torch.Tensor.isnan") [`log1p()`](generated/torch.Tensor.log1p.html#torch.Tensor.log1p "torch.Tensor.log1p") [`log1p_()`](generated/torch.Tensor.log1p_.html#torch.Tensor.log1p_ "torch.Tensor.log1p_") [`mm()`](generated/torch.Tensor.mm.html#torch.Tensor.mm "torch.Tensor.mm") [`mul()`](generated/torch.Tensor.mul.html#torch.Tensor.mul "torch.Tensor.mul") [`mul_()`](generated/torch.Tensor.mul_.html#torch.Tensor.mul_ "torch.Tensor.mul_") [`mv()`](generated/torch.Tensor.mv.html#torch.Tensor.mv "torch.Tensor.mv") [`narrow_copy()`](generated/torch.Tensor.narrow_copy.html#torch.Tensor.narrow_copy "torch.Tensor.narrow_copy") [`neg()`](generated/torch.Tensor.neg.html#torch.Tensor.neg "torch.Tensor.neg") [`neg_()`](generated/torch.Tensor.neg_.html#torch.Tensor.neg_ "torch.Tensor.neg_") [`negative()`](generated/torch.Tensor.negative.html#torch.Tensor.negative "torch.Tensor.negative") [`negative_()`](generated/torch.Tensor.negative_.html#torch.Tensor.negative_ "torch.Tensor.negative_") [`numel()`](generated/torch.Tensor.numel.html#torch.Tensor.numel "torch.Tensor.numel") [`rad2deg()`](generated/torch.Tensor.rad2deg.html#torch.Tensor.rad2deg "torch.Tensor.rad2deg") `rad2deg_()` [`resize_as_()`](generated/torch.Tensor.resize_as_.html#torch.Tensor.resize_as_ "torch.Tensor.resize_as_") [`size()`](generated/torch.Tensor.size.html#torch.Tensor.size "torch.Tensor.size") [`pow()`](generated/torch.Tensor.pow.html#torch.Tensor.pow "torch.Tensor.pow") [`sqrt()`](generated/torch.Tensor.sqrt.html#torch.Tensor.sqrt "torch.Tensor.sqrt") [`square()`](generated/torch.Tensor.square.html#torch.Tensor.square "torch.Tensor.square") [`smm()`](generated/torch.Tensor.smm.html#torch.Tensor.smm "torch.Tensor.smm") [`sspaddmm()`](generated/torch.Tensor.sspaddmm.html#torch.Tensor.sspaddmm "torch.Tensor.sspaddmm") [`sub()`](generated/torch.Tensor.sub.html#torch.Tensor.sub "torch.Tensor.sub") [`sub_()`](generated/torch.Tensor.sub_.html#torch.Tensor.sub_ "torch.Tensor.sub_") [`t()`](generated/torch.Tensor.t.html#torch.Tensor.t "torch.Tensor.t") [`t_()`](generated/torch.Tensor.t_.html#torch.Tensor.t_ "torch.Tensor.t_") [`transpose()`](generated/torch.Tensor.transpose.html#torch.Tensor.transpose "torch.Tensor.transpose") [`transpose_()`](generated/torch.Tensor.transpose_.html#torch.Tensor.transpose_ "torch.Tensor.transpose_") [`zero_()`](generated/torch.Tensor.zero_.html#torch.Tensor.zero_ "torch.Tensor.zero_") +`add()` `add_()` `addmm()` `addmm_()` `any()` `asin()` `asin_()` `arcsin()` `arcsin_()` `bmm()` `clone()` `deg2rad()` `deg2rad_()` `detach()` `detach_()` `dim()` `div()` `div_()` `floor_divide()` `floor_divide_()` `get_device()` `index_select()` `isnan()` `log1p()` `log1p_()` `mm()` `mul()` `mul_()` `mv()` `narrow_copy()` `neg()` `neg_()` `negative()` `negative_()` `numel()` `rad2deg()` `rad2deg_()` `resize_as_()` `size()` `pow()` `sqrt()` `square()` `smm()` `sspaddmm()` `sub()` `sub_()` `t()` `t_()` `transpose()` `transpose_()` `zero_()` -### 针对稀疏张量的Torch函数[](#torch-functions-specific-to-sparse-tensors "跳转到此标题") +### 针对稀疏张量的 Torch 函数[](#torch-functions-specific-to-sparse-tensors "跳转到此标题") -| [`sparse_coo_tensor`](generated/torch.sparse_coo_tensor.html#torch.sparse_coo_tensor "torch.sparse_coo_tensor") | 使用给定的`indices`构造一个[COO（坐标）格式的稀疏张量](#sparse-coo-docs)，其中包含指定的值。 | +| `sparse_coo_tensor` | 使用给定的`indices`构造一个 COO（坐标）格式的稀疏张量，其中包含指定的值。 | | --- | --- | -| [`sparse_csr_tensor`](generated/torch.sparse_csr_tensor.html#torch.sparse_csr_tensor "torch.sparse_csr_tensor") | 使用给定的`crow_indices`和`col_indices`构造一个[CSR（压缩稀疏行）格式的稀疏张量](#sparse-csr-docs)，其中包含指定的值。 | -| [`sparse_csc_tensor`](generated/torch.sparse_csc_tensor.html#torch.sparse_csc_tensor "torch.sparse_csc_tensor") | 使用给定的`ccol_indices`和`row_indices`构造一个[CSC（压缩稀疏列）格式的稀疏张量](#sparse-csc-docs)，其中包含指定的值。 | -| [`sparse_bsr_tensor`](generated/torch.sparse_bsr_tensor.html#torch.sparse_bsr_tensor "torch.sparse_bsr_tensor") | 使用给定的`crow_indices`和`col_indices`构造一个[BSR（块压缩稀疏行）格式的稀疏张量](#sparse-bsr-docs)，其中包含指定的二维块。 | -| [`sparse_bsc_tensor`](generated/torch.sparse_bsc_tensor.html#torch.sparse_bsc_tensor "torch.sparse_bsc_tensor") | 使用给定的`ccol_indices`和`row_indices`构造一个[BSC（块压缩稀疏列）格式的稀疏张量](#sparse-bsc-docs)，其中包含指定的二维块。 | -| [`sparse_compressed_tensor`](generated/torch.sparse_compressed_tensor.html#torch.sparse_compressed_tensor "torch.sparse_compressed_tensor") | 使用给定的`compressed_indices`和`plain_indices`构造一个[压缩稀疏格式的张量 - CSR、CSC、BSR或BSC -](#sparse-compressed-docs)，其中包含指定的值。 | -| [`sparse.sum`](generated/torch.sparse.sum.html#torch.sparse.sum "torch.sparse.sum") | 返回给定稀疏张量每行的和。 | -| [`sparse.addmm`](generated/torch.sparse.addmm.html#torch.sparse.addmm "torch.sparse.addmm") | 此函数在前向传播中与[`torch.addmm()`](generated/torch.addmm.html#torch.addmm "torch.addmm")完全相同，只是它支持稀疏COO矩阵 `mat1` 的反向传播。 | -| [`sparse.sampled_addmm`](generated/torch.sparse.sampled_addmm.html#torch.sparse.sampled_addmm "torch.sparse.sampled_addmm") | 在`input`的稀疏模式指定的位置上，对密集矩阵`mat1`和`mat2`执行矩阵乘法。 | -| [`sparse.mm`](generated/torch.sparse.mm.html#torch.sparse.mm "torch.sparse.mm") | 对稀疏矩阵 `mat1` 执行矩阵乘法。 | -| [`sspaddmm`](generated/torch.sspaddmm.html#torch.sspaddmm "torch.sspaddmm") | 将稀疏张量 `mat1` 与密集张量 `mat2` 相乘，然后将稀疏张量 `input` 加到结果中。 | -| [`hspmm`](generated/torch.hspmm.html#torch.hspmm "torch.hspmm") | 对一个[稀疏COO矩阵](#sparse-coo-docs) `mat1` 和一个分块矩阵 `mat2` 执行矩阵乘法。 | -| [`smm`](generated/torch.smm.html#torch.smm "torch.smm") | 对稀疏矩阵 `input` 和密集矩阵 `mat` 执行矩阵乘法。 | -| [`sparse.softmax`](generated/torch.sparse.softmax.html#torch.sparse.softmax "torch.sparse.softmax") | 应用softmax函数。 | -| [`sparse.log_softmax`](generated/torch.sparse.log_softmax.html#torch.sparse.log_softmax "torch.sparse.log_softmax") | 应用softmax函数后跟对数函数。 | -| [`sparse.spdiags`](generated/torch.sparse.spdiags.html#torch.sparse.spdiags "torch.sparse.spdiags") | 通过将`diagonals`的行值沿输出的指定对角线放置，创建一个稀疏的二维张量。 | +| `sparse_csr_tensor` | 使用给定的`crow_indices`和`col_indices`构造一个 CSR（压缩稀疏行）格式的稀疏张量，其中包含指定的值。 | +| `sparse_csc_tensor` | 使用给定的`ccol_indices`和`row_indices`构造一个 CSC（压缩稀疏列）格式的稀疏张量，其中包含指定的值。 | +| `sparse_bsr_tensor` | 使用给定的`crow_indices`和`col_indices`构造一个 BSR（块压缩稀疏行）格式的稀疏张量，其中包含指定的二维块。 | +| `sparse_bsc_tensor` | 使用给定的`ccol_indices`和`row_indices`构造一个 BSC（块压缩稀疏列）格式的稀疏张量，其中包含指定的二维块。 | +| `sparse_compressed_tensor` | 使用给定的`compressed_indices`和`plain_indices`构造一个压缩稀疏格式的张量 - CSR、CSC、BSR 或 BSC -，其中包含指定的值。 | +| `sparse.sum` | 返回给定稀疏张量每行的和。 | +| `sparse.addmm` | 此函数在前向传播中与`torch.addmm()`完全相同，只是它支持稀疏 COO 矩阵 `mat1` 的反向传播。 | +| `sparse.sampled_addmm` | 在`input`的稀疏模式指定的位置上，对密集矩阵`mat1`和`mat2`执行矩阵乘法。 | +| `sparse.mm` | 对稀疏矩阵 `mat1` 执行矩阵乘法。 | +| `sspaddmm` | 将稀疏张量 `mat1` 与密集张量 `mat2` 相乘，然后将稀疏张量 `input` 加到结果中。 | +| `hspmm` | 对一个稀疏 COO 矩阵 `mat1` 和一个分块矩阵 `mat2` 执行矩阵乘法。 | +| `smm` | 对稀疏矩阵 `input` 和密集矩阵 `mat` 执行矩阵乘法。 | +| `sparse.softmax` | 应用 softmax 函数。 | +| `sparse.log_softmax` | 应用 softmax 函数后跟对数函数。 | +| `sparse.spdiags` | 通过将`diagonals`的行值沿输出的指定对角线放置，创建一个稀疏的二维张量。 | ### 其他函数 -以下[`torch`](torch.html#module-torch "torch")函数支持稀疏张量： +以下`torch`函数支持稀疏张量： -[`cat()`](generated/torch.cat.html#torch.cat "torch.cat") [`dstack()`](generated/torch.dstack.html#torch.dstack "torch.dstack") [`empty()`](generated/torch.empty.html#torch.empty "torch.empty") [`empty_like()`](generated/torch.empty_like.html#torch.empty_like "torch.empty_like") [`hstack()`](generated/torch.hstack.html#torch.hstack "torch.hstack") [`index_select()`](generated/torch.index_select.html#torch.index_select "torch.index_select") [`is_complex()`](generated/torch.is_complex.html#torch.is_complex "torch.is_complex") [`is_floating_point()`](generated/torch.is_floating_point.html#torch.is_floating_point "torch.is_floating_point") [`is_nonzero()`](generated/torch.is_nonzero.html#torch.is_nonzero "torch.is_nonzero") `is_same_size()` `is_signed()` [`is_tensor()`](generated/torch.is_tensor.html#torch.is_tensor "torch.is_tensor") [`lobpcg()`](generated/torch.lobpcg.html#torch.lobpcg "torch.lobpcg") [`mm()`](generated/torch.mm.html#torch.mm "torch.mm") `native_norm()` [`pca_lowrank()`](generated/torch.pca_lowrank.html#torch.pca_lowrank "torch.pca_lowrank") [`select()`](generated/torch.select.html#torch.select "torch.select") [`stack()`](generated/torch.stack.html#torch.stack "torch.stack") [`svd_lowrank()`](generated/torch.svd_lowrank.html#torch.svd_lowrank "torch.svd_lowrank") [`unsqueeze()`](generated/torch.unsqueeze.html#torch.unsqueeze "torch.unsqueeze") [`vstack()`](generated/torch.vstack.html#torch.vstack "torch.vstack") [`zeros()`](generated/torch.zeros.html#torch.zeros "torch.zeros") [`zeros_like()`](generated/torch.zeros_like.html#torch.zeros_like "torch.zeros_like") +`cat()` `dstack()` `empty()` `empty_like()` `hstack()` `index_select()` `is_complex()` `is_floating_point()` `is_nonzero()` `is_same_size()` `is_signed()` `is_tensor()` `lobpcg()` `mm()` `native_norm()` `pca_lowrank()` `select()` `stack()` `svd_lowrank()` `unsqueeze()` `vstack()` `zeros()` `zeros_like()` 要管理检查稀疏张量不变性，请参见： -| [`sparse.check_sparse_tensor_invariants`](generated/torch.sparse.check_sparse_tensor_invariants.html#torch.sparse.check_sparse_tensor_invariants "torch.sparse.check_sparse_tensor_invariants") | 用于控制检查稀疏张量不变性的工具。 | +| `sparse.check_sparse_tensor_invariants` | 用于控制检查稀疏张量不变性的工具。 | | --- | --- | -要在[`gradcheck()`](autograd.html#module-torch.autograd.gradcheck "torch.autograd.gradcheck")函数中使用稀疏张量，请参见： +要在`gradcheck()`函数中使用稀疏张量，请参见： -| [`sparse.as_sparse_gradcheck`](generated/torch.sparse.as_sparse_gradcheck.html#torch.sparse.as_sparse_gradcheck "torch.sparse.as_sparse_gradcheck") | 装饰函数，用于扩展稀疏张量的 gradcheck。 | +| `sparse.as_sparse_gradcheck` | 装饰函数，用于扩展稀疏张量的 gradcheck。 | | --- | --- | ### 一元函数 @@ -909,4 +909,4 @@ tensor(True) 以下运算符目前支持稀疏 COO/CSR/CSC/BSR/CSR 张量输入。 -[`abs()`](generated/torch.abs.html#torch.abs "torch.abs") [`asin()`](generated/torch.asin.html#torch.asin "torch.asin") [`asinh()`](generated/torch.asinh.html#torch.asinh "torch.asinh") [`atan()`](generated/torch.atan.html#torch.atan "torch.atan") [`atanh()`](generated/torch.atanh.html#torch.atanh "torch.atanh") [`ceil()`](generated/torch.ceil.html#torch.ceil "torch.ceil") [`conj_physical()`](generated/torch.conj_physical.html#torch.conj_physical "torch.conj_physical") [`floor()`](generated/torch.floor.html#torch.floor "torch.floor") [`log1p()`](generated/torch.log1p.html#torch.log1p "torch.log1p") [`neg()`](generated/torch.neg.html#torch.neg "torch.neg") [`round()`](generated/torch.round.html#torch.round "torch.round") [`sin()`](generated/torch.sin.html#torch.sin "torch.sin") [`sinh()`](generated/torch.sinh.html#torch.sinh "torch.sinh") [`sign()`](generated/torch.sign.html#torch.sign "torch.sign") [`sgn()`](generated/torch.sgn.html#torch.sgn "torch.sgn") [`signbit()`](generated/torch.signbit.html#torch.signbit "torch.signbit") [`tan()`](generated/torch.tan.html#torch.tan "torch.tan") [`tanh()`](generated/torch.tanh.html#torch.tanh "torch.tanh") [`trunc()`](generated/torch.trunc.html#torch.trunc "torch.trunc") [`expm1()`](generated/torch.expm1.html#torch.expm1 "torch.expm1") [`sqrt()`](generated/torch.sqrt.html#torch.sqrt "torch.sqrt") [`angle()`](generated/torch.angle.html#torch.angle "torch.angle") [`isinf()`](generated/torch.isinf.html#torch.isinf "torch.isinf") [`isposinf()`](generated/torch.isposinf.html#torch.isposinf "torch.isposinf") [`isneginf()`](generated/torch.isneginf.html#torch.isneginf "torch.isneginf") [`isnan()`](generated/torch.isnan.html#torch.isnan "torch.isnan") [`erf()`](generated/torch.erf.html#torch.erf "torch.erf") [`erfinv()`](generated/torch.erfinv.html#torch.erfinv "torch.erfinv") +`abs()` `asin()` `asinh()` `atan()` `atanh()` `ceil()` `conj_physical()` `floor()` `log1p()` `neg()` `round()` `sin()` `sinh()` `sign()` `sgn()` `signbit()` `tan()` `tanh()` `trunc()` `expm1()` `sqrt()` `angle()` `isinf()` `isposinf()` `isneginf()` `isnan()` `erf()` `erfinv()` diff --git a/totrans/doc22_080.md b/totrans/doc22_080.md index 1d5c9906..57ce4522 100644 --- a/totrans/doc22_080.md +++ b/totrans/doc22_080.md @@ -1,18 +1,18 @@ # torch.Storage -> 原文：[https://pytorch.org/docs/stable/storage.html](https://pytorch.org/docs/stable/storage.html) +> 原文：[`pytorch.org/docs/stable/storage.html`](https://pytorch.org/docs/stable/storage.html) -`torch.Storage` 是与默认数据类型对应的存储类的别名（[`torch.get_default_dtype()`](generated/torch.get_default_dtype.html#torch.get_default_dtype "torch.get_default_dtype")）。例如，如果默认数据类型是 `torch.float`，`torch.Storage` 解析为 [`torch.FloatStorage`](#torch.FloatStorage "torch.FloatStorage")。 +`torch.Storage` 是与默认数据类型对应的存储类的别名（`torch.get_default_dtype()`）。例如，如果默认数据类型是 `torch.float`，`torch.Storage` 解析为 `torch.FloatStorage`。 -`torch.Storage` 和 `torch.cuda.Storage` 类，如 [`torch.FloatStorage`](#torch.FloatStorage "torch.FloatStorage")、[`torch.IntStorage`](#torch.IntStorage "torch.IntStorage") 等，实际上从未被实例化。调用它们的构造函数会创建一个具有适当 [`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype") 和 [`torch.device`](tensor_attributes.html#torch.device "torch.device") 的 [`torch.TypedStorage`](#torch.TypedStorage "torch.TypedStorage")。`torch.Storage` 类具有与 [`torch.TypedStorage`](#torch.TypedStorage "torch.TypedStorage") 相同的所有类方法。 +`torch.Storage` 和 `torch.cuda.Storage` 类，如 `torch.FloatStorage`、`torch.IntStorage` 等，实际上从未被实例化。调用它们的构造函数会创建一个具有适当 `torch.dtype` 和 `torch.device` 的 `torch.TypedStorage`。`torch.Storage` 类具有与 `torch.TypedStorage` 相同的所有类方法。 -[`torch.TypedStorage`](#torch.TypedStorage "torch.TypedStorage") 是一个连续的、一维的特定 [`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype") 元素数组。它可以给定任何 [`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")，内部数据将被适当解释。[`torch.TypedStorage`](#torch.TypedStorage "torch.TypedStorage") 包含一个 [`torch.UntypedStorage`](#torch.UntypedStorage "torch.UntypedStorage")，它将数据保存为字节的无类型数组。 +`torch.TypedStorage` 是一个连续的、一维的特定 `torch.dtype` 元素数组。它可以给定任何 `torch.dtype`，内部数据将被适当解释。`torch.TypedStorage` 包含一个 `torch.UntypedStorage`，它将数据保存为字节的无类型数组。 -每个分步的 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 包含一个 [`torch.TypedStorage`](#torch.TypedStorage "torch.TypedStorage")，它存储了 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 视图的所有数据。 +每个分步的 `torch.Tensor` 包含一个 `torch.TypedStorage`，它存储了 `torch.Tensor` 视图的所有数据。 警告 -除了 [`torch.UntypedStorage`](#torch.UntypedStorage "torch.UntypedStorage") 外，所有存储类将来将被移除，而 [`torch.UntypedStorage`](#torch.UntypedStorage "torch.UntypedStorage") 将在所有情况下使用。 +除了 `torch.UntypedStorage` 外，所有存储类将来将被移除，而 `torch.UntypedStorage` 将在所有情况下使用。 ```py class torch.TypedStorage(*args, wrap_storage=None, dtype=None, device=None, _internal=False)¶ @@ -180,13 +180,13 @@ half()¶ hpu(device=None, non_blocking=False, **kwargs)¶ ``` -在HPU内存中返回此对象的副本。 +在 HPU 内存中返回此对象的副本。 -如果此对象已经在HPU内存中且在正确的设备上，则不执行复制操作，并返回原始对象。 +如果此对象已经在 HPU 内存中且在正确的设备上，则不执行复制操作，并返回原始对象。 参数 -+ **device**（[*int*](https://docs.python.org/3/library/functions.html#int)）- 目标HPU id。默认为当前设备。 ++ **device**（[*int*](https://docs.python.org/3/library/functions.html#int)）- 目标 HPU id。默认为当前设备。 + **non_blocking**（[*bool*](https://docs.python.org/3/library/functions.html#bool)）- 如果为`True`且源在固定内存中，则复制将与主机异步进行。否则，参数无效。 @@ -214,11 +214,11 @@ property is_hpu¶ is_pinned(device='cuda')¶ ``` -确定CPU TypedStorage是否已经固定在设备上。 +确定 CPU TypedStorage 是否已经固定在设备上。 参数 -**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str) *或* [*torch.device*](tensor_attributes.html#torch.device)）- 要在其上固定内存的设备。默认：`'cuda'` +**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str) *或* *torch.device*）- 要在其上固定内存的设备。默认：`'cuda'` 返回 @@ -250,15 +250,15 @@ pickle_storage_type()¶ pin_memory(device='cuda')¶ ``` -将CPU TypedStorage复制到固定内存，如果尚未固定。 +将 CPU TypedStorage 复制到固定内存，如果尚未固定。 参数 -**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str) *或* [*torch.device*](tensor_attributes.html#torch.device)）- 要在其上固定内存的设备。默认：`'cuda'`。 +**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str) *或* *torch.device*）- 要在其上固定内存的设备。默认：`'cuda'`。 返回 -固定的CPU存储。 +固定的 CPU 存储。 ```py resize_(size)¶ @@ -268,7 +268,7 @@ resize_(size)¶ share_memory_()¶ ``` -参见[`torch.UntypedStorage.share_memory_()`](#torch.UntypedStorage.share_memory_)。 +参见`torch.UntypedStorage.share_memory_()`。 ```py short()¶ @@ -290,7 +290,7 @@ tolist()¶ type(dtype=None, non_blocking=False)¶ ``` -如果未提供dtype，则返回类型，否则将此对象转换为指定类型。 +如果未提供 dtype，则返回类型，否则将此对象转换为指定类型。 如果已经是正确类型，则不执行复制操作，并返回原始对象。 @@ -298,7 +298,7 @@ type(dtype=None, non_blocking=False)¶ + **dtype**（[*type*](https://docs.python.org/3/library/functions.html#type) *或* *string*）- 所需类型 -+ **non_blocking**（[*bool*](https://docs.python.org/3/library/functions.html#bool)）- 如果为`True`，且源在固定内存中且目的地在GPU上或反之，则复制将与主机异步进行。否则，参数无效。 ++ **non_blocking**（[*bool*](https://docs.python.org/3/library/functions.html#bool)）- 如果为`True`，且源在固定内存中且目的地在 GPU 上或反之，则复制将与主机异步进行。否则，参数无效。 + ****kwargs** - 为了兼容性，可能包含`async`键代替`non_blocking`参数。`async`参数已被弃用。 @@ -310,7 +310,7 @@ type(dtype=None, non_blocking=False)¶ untyped()¶ ``` -返回内部[`torch.UntypedStorage`](#torch.UntypedStorage)。 +返回内部`torch.UntypedStorage`。 ```py class torch.UntypedStorage(*args, **kwargs)¶ @@ -320,7 +320,7 @@ class torch.UntypedStorage(*args, **kwargs)¶ bfloat16()¶ ``` -将此存储转换为bfloat16类型。 +将此存储转换为 bfloat16 类型。 ```py bool()¶ @@ -372,19 +372,19 @@ copy_()¶ cpu()¶ ``` -如果尚未在CPU上，则返回此存储的CPU副本。 +如果尚未在 CPU 上，则返回此存储的 CPU 副本。 ```py cuda(device=None, non_blocking=False, **kwargs)¶ ``` -在CUDA内存中返回此对象的副本。 +在 CUDA 内存中返回此对象的副本。 -如果此对象已经在CUDA内存中且在正确的设备上，则不执行复制操作，并返回原始对象。 +如果此对象已经在 CUDA 内存中且在正确的设备上，则不执行复制操作，并返回原始对象。 参数 -+ **device**（[*int*](https://docs.python.org/3/library/functions.html#int)）- 目标GPU id。默认为当前设备。 ++ **device**（[*int*](https://docs.python.org/3/library/functions.html#int)）- 目标 GPU id。默认为当前设备。 + **non_blocking**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 如果为`True`且源位于固定内存中，则复制将与主机异步进行。否则，该参数不起作用。 @@ -402,7 +402,7 @@ device: device¶ double()¶ ``` -将此存储转换为double类型。 +将此存储转换为 double 类型。 ```py element_size()¶ @@ -422,19 +422,19 @@ fill_()¶ float()¶ ``` -将此存储转换为float类型。 +将此存储转换为 float 类型。 ```py float8_e4m3fn()¶ ``` -将此存储转换为float8_e4m3fn类型 +将此存储转换为 float8_e4m3fn 类型 ```py float8_e5m2()¶ ``` -将此存储转换为float8_e5m2类型 +将此存储转换为 float8_e5m2 类型 ```py static from_buffer()¶ @@ -444,7 +444,7 @@ static from_buffer()¶ static from_file(filename, shared=False, size=0) → Storage¶ ``` -创建由内存映射文件支持的CPU存储。 +创建由内存映射文件支持的 CPU 存储。 如果`shared`为`True`，则内存在所有进程之间共享。所有更改都将写入文件。如果`shared`为`False`，则存储上的更改不会影响文件。 @@ -472,19 +472,19 @@ get_device()¶ half()¶ ``` -将此存储转换为half类型。 +将此存储转换为 half 类型。 ```py hpu(device=None, non_blocking=False, **kwargs)¶ ``` -在HPU内存中返回此对象的副本。 +在 HPU 内存中返回此对象的副本。 -如果此对象已经在HPU内存中且在正确的设备上，则不执行复制，并返回原始对象。 +如果此对象已经在 HPU 内存中且在正确的设备上，则不执行复制，并返回原始对象。 参数 -+ **device**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 目标HPU id。默认为当前设备。 ++ **device**（[*int*](https://docs.python.org/3/library/functions.html#int "(in Python v3.12)")） - 目标 HPU id。默认为当前设备。 + **non_blocking**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")） - 如果为`True`且源位于固定内存中，则复制将与主机异步进行。否则，该参数不起作用。 @@ -494,7 +494,7 @@ hpu(device=None, non_blocking=False, **kwargs)¶ int()¶ ``` -将此存储转换为int类型。 +将此存储转换为 int 类型。 ```py property is_cuda¶ @@ -508,11 +508,11 @@ property is_hpu¶ is_pinned(device='cuda')¶ ``` -确定CPU存储是否已固定在设备上。 +确定 CPU 存储是否已固定在设备上。 参数 -**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* [*torch.device*](tensor_attributes.html#torch.device "torch.device")） - 要固定内存的设备。默认值：`'cuda'`。 +**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* *torch.device*） - 要固定内存的设备。默认值：`'cuda'`。 返回 @@ -534,13 +534,13 @@ is_sparse_csr: bool = False¶ long()¶ ``` -将此存储转换为long类型。 +将此存储转换为 long 类型。 ```py mps()¶ ``` -如果尚未在MPS上，则返回此存储的MPS副本。 +如果尚未在 MPS 上，则返回此存储的 MPS 副本。 ```py nbytes()¶ @@ -554,15 +554,15 @@ new()¶ pin_memory(device='cuda')¶ ``` -将CPU存储复制到固定内存，如果尚未固定。 +将 CPU 存储复制到固定内存，如果尚未固定。 参数 -**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* [*torch.device*](tensor_attributes.html#torch.device "torch.device")） - 要固定内存的设备。默认值：`'cuda'`。 +**device**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)") *或* *torch.device*） - 要固定内存的设备。默认值：`'cuda'`。 返回 -一个固定的CPU存储。 +一个固定的 CPU 存储。 ```py resize_()¶ @@ -574,17 +574,17 @@ share_memory_(*args, **kwargs)¶ 将存储移动到共享内存。 -对于已经在共享内存中的存储和不需要移动以在进程间共享的CUDA存储，这是一个无操作。共享内存中的存储无法调整大小。 +对于已经在共享内存中的存储和不需要移动以在进程间共享的 CUDA 存储，这是一个无操作。共享内存中的存储无法调整大小。 -请注意，为了缓解诸如[此](https://github.com/pytorch/pytorch/issues/95606)等问题，可以安全地从同一对象的多个线程调用此函数。但是，在没有适当同步的情况下调用self上的任何其他函数是不安全的。有关更多详细信息，请参阅[多进程最佳实践](notes/multiprocessing.html)。 +请注意，为了缓解诸如[此](https://github.com/pytorch/pytorch/issues/95606)等问题，可以安全地从同一对象的多个线程调用此函数。但是，在没有适当同步的情况下调用 self 上的任何其他函数是不安全的。有关更多详细信息，请参阅多进程最佳实践。 注意 -当删除共享内存中对存储的所有引用时，相关的共享内存对象也将被删除。PyTorch具有特殊的清理过程，以确保即使当前进程意外退出也会发生这种情况。 +当删除共享内存中对存储的所有引用时，相关的共享内存对象也将被删除。PyTorch 具有特殊的清理过程，以确保即使当前进程意外退出也会发生这种情况。 -值得注意的是[`share_memory_()`](#torch.UntypedStorage.share_memory_ "torch.UntypedStorage.share_memory_")和[`from_file()`](generated/torch.from_file.html#torch.from_file "torch.from_file")之间的区别，其中`shared = True` +值得注意的是`share_memory_()`和`from_file()`之间的区别，其中`shared = True` -1. `share_memory_`使用[shm_open(3)](https://man7.org/linux/man-pages/man3/shm_open.3.html)创建POSIX共享内存对象，而[`from_file()`](generated/torch.from_file.html#torch.from_file "torch.from_file")使用[open(2)](https://man7.org/linux/man-pages/man2/open.2.html)打开用户传递的文件名。 +1. `share_memory_`使用[shm_open(3)](https://man7.org/linux/man-pages/man3/shm_open.3.html)创建 POSIX 共享内存对象，而`from_file()`使用[open(2)](https://man7.org/linux/man-pages/man2/open.2.html)打开用户传递的文件名。 1. 两者都使用[mmap(2)调用](https://man7.org/linux/man-pages/man2/mmap.2.html)与`MAP_SHARED`将文件/对象映射到当前虚拟地址空间 @@ -598,7 +598,7 @@ share_memory_(*args, **kwargs)¶ short()¶ ``` -将此存储转换为short类型。 +将此存储转换为 short 类型。 ```py size()¶ @@ -618,7 +618,7 @@ tolist()¶ type(dtype=None, non_blocking=False, **kwargs)¶ ``` -如果未提供dtype，则返回类型，否则将此对象转换为指定类型。 +如果未提供 dtype，则返回类型，否则将此对象转换为指定类型。 如果已经是正确类型，则不执行复制操作，返回原始对象。 @@ -626,7 +626,7 @@ type(dtype=None, non_blocking=False, **kwargs)¶ + **dtype**（[*type*](https://docs.python.org/3/library/functions.html#type "(in Python v3.12)") *或* *string*）- 所需类型 -+ **non_blocking**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为`True`，且源位于固定内存中，目标位于GPU上或反之，则复制操作将异步执行，与主机无关。否则，该参数无效。 ++ **non_blocking**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")）- 如果为`True`，且源位于固定内存中，目标位于 GPU 上或反之，则复制操作将异步执行，与主机无关。否则，该参数无效。 + ****kwargs** - 为了兼容性，可能包含`async`键代替`non_blocking`参数。`async`参数已被弃用。 diff --git a/totrans/doc22_081.md b/totrans/doc22_081.md index fcb008a0..9bd9d7db 100644 --- a/totrans/doc22_081.md +++ b/totrans/doc22_081.md @@ -1,6 +1,6 @@ # torch.testing -> [https://pytorch.org/docs/stable/testing.html](https://pytorch.org/docs/stable/testing.html) +> [`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)¶ @@ -16,7 +16,7 @@ $\lvert \text{actual} - \text{expected} \rvert \le \texttt{atol} + \texttt{rtol} 此外，只有当它们相同时才被视为接近 -+ [`device`](generated/torch.Tensor.device.html#torch.Tensor.device "torch.Tensor.device")（如果`check_device`为`True`）， ++ `device`（如果`check_device`为`True`）， + `dtype`（如果`check_dtype`为`True`）， @@ -26,15 +26,15 @@ $\lvert \text{actual} - \text{expected} \rvert \le \texttt{atol} + \texttt{rtol} 如果`actual`或`expected`是元张量，则仅执行属性检查。 -如果`actual`和`expected`是稀疏的（具有COO、CSR、CSC、BSR或BSC布局），它们的分步成员将被单独检查。索引，即COO的`indices`，CSR和BSR的`crow_indices`和`col_indices`，或CSC和BSC布局的`ccol_indices`和`row_indices`，始终被检查是否相等，而值根据上述定义被视为接近。 +如果`actual`和`expected`是稀疏的（具有 COO、CSR、CSC、BSR 或 BSC 布局），它们的分步成员将被单独检查。索引，即 COO 的`indices`，CSR 和 BSR 的`crow_indices`和`col_indices`，或 CSC 和 BSC 布局的`ccol_indices`和`row_indices`，始终被检查是否相等，而值根据上述定义被视为接近。 -如果`actual`和`expected`是量化的，则它们被视为接近，如果它们具有相同的[`qscheme()`](generated/torch.Tensor.qscheme.html#torch.Tensor.qscheme "torch.Tensor.qscheme")并且[`dequantize()`](generated/torch.Tensor.dequantize.html#torch.Tensor.dequantize "torch.Tensor.dequantize")的结果根据上述定义接近。 +如果`actual`和`expected`是量化的，则它们被视为接近，如果它们具有相同的`qscheme()`并且`dequantize()`的结果根据上述定义接近。 -`actual`和`expected`可以是[`Tensor`](tensors.html#torch.Tensor "torch.Tensor")或任何张量或标量，可以使用[`torch.as_tensor()`](generated/torch.as_tensor.html#torch.as_tensor "torch.as_tensor")构造[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")。除了Python标量外，输入类型必须直接相关。此外，`actual`和`expected`可以是[`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(在Python v3.12中)")或[`Mapping`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Mapping "(在Python v3.12中)")，在这种情况下，如果它们的结构匹配并且所有元素根据上述定义被视为接近，则它们被视为接近。 +`actual`和`expected`可以是`Tensor`或任何张量或标量，可以使用`torch.as_tensor()`构造`torch.Tensor`。除了 Python 标量外，输入类型必须直接相关。此外，`actual`和`expected`可以是[`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(在 Python v3.12 中)")或[`Mapping`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Mapping "(在 Python v3.12 中)")，在这种情况下，如果它们的结构匹配并且所有元素根据上述定义被视为接近，则它们被视为接近。 注意 -Python标量是类型关系要求的一个例外，因为它们的`type()`，即[`int`](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")，[`float`](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")和[`complex`](https://docs.python.org/3/library/functions.html#complex "(在Python v3.12中)")，等同于张量类的`dtype`。因此，不同类型的Python标量可以被检查，但需要`check_dtype=False`。 +Python 标量是类型关系要求的一个例外，因为它们的`type()`，即[`int`](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")，[`float`](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")和[`complex`](https://docs.python.org/3/library/functions.html#complex "(在 Python v3.12 中)")，等同于张量类的`dtype`。因此，不同类型的 Python 标量可以被检查，但需要`check_dtype=False`。 参数 @@ -42,17 +42,17 @@ Python标量是类型关系要求的一个例外，因为它们的`type()`，即 + **expected**（*任意*）- 预期输入。 -+ **allow_subclasses**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")）- 如果为`True`（默认）并且除了Python标量之外，直接相关类型的输入是允许的。否则需要类型相等。 ++ **allow_subclasses**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")）- 如果为`True`（默认）并且除了 Python 标量之外，直接相关类型的输入是允许的。否则需要类型相等。 -+ **rtol**（*可选**[*[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*]*) - 相对容差。如果指定了`atol`，必须同时指定。如果省略，默认值基于`dtype`从下表中选择。 ++ **rtol**（*可选**[*[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*]*) - 相对容差。如果指定了`atol`，必须同时指定。如果省略，默认值基于`dtype`从下表中选择。 -+ **atol**（*可选**[*[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*]*) - 绝对容差。如果指定了`rtol`，必须同时指定。如果省略，默认值基于`dtype`从下表中选择。 ++ **atol**（*可选**[*[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*]*) - 绝对容差。如果指定了`rtol`，必须同时指定。如果省略，默认值基于`dtype`从下表中选择。 + **equal_nan** (*Union**[*[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*]*) – 如果为`True`，则认为两个`NaN`值相等。 -+ **check_device** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`（默认），则断言相应的张量位于相同的[`device`](generated/torch.Tensor.device.html#torch.Tensor.device "torch.Tensor.device")上。如果禁用此检查，则位于不同[`device`](generated/torch.Tensor.device.html#torch.Tensor.device "torch.Tensor.device")上的张量在比较之前将移动到CPU。 ++ **check_device** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`（默认），则断言相应的张量位于相同的`device`上。如果禁用此检查，则位于不同`device`上的张量在比较之前将移动到 CPU。 -+ **check_dtype** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`（默认），则断言相应的张量具有相同的`dtype`。如果禁用此检查，则在比较之前将具有不同`dtype`的张量提升为公共`dtype`（根据[`torch.promote_types()`](generated/torch.promote_types.html#torch.promote_types "torch.promote_types")）。 ++ **check_dtype** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`（默认），则断言相应的张量具有相同的`dtype`。如果禁用此检查，则在比较之前将具有不同`dtype`的张量提升为公共`dtype`（根据`torch.promote_types()`）。 + **check_layout** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")) – 如果为`True`（默认），则断言相应的张量具有相同的`layout`。如果禁用此检查，则在比较之前将具有不同`layout`的张量转换为分步张量。 @@ -62,27 +62,27 @@ Python标量是类型关系要求的一个例外，因为它们的`type()`，即 引发 -+ [**ValueError**](https://docs.python.org/3/library/exceptions.html#ValueError "(in Python v3.12)") – 如果无法从输入构造[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")。 ++ [**ValueError**](https://docs.python.org/3/library/exceptions.html#ValueError "(in Python v3.12)") – 如果无法从输入构造`torch.Tensor`。 + [**ValueError**](https://docs.python.org/3/library/exceptions.html#ValueError "(in Python v3.12)") – 如果只指定了`rtol`或`atol`。 -+ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果相应的输入不是Python标量且不直接相关。 ++ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果相应的输入不是 Python 标量且不直接相关。 -+ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果`allow_subclasses`为`False`，但相应的输入不是Python标量并且类型不同。 ++ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果`allow_subclasses`为`False`，但相应的输入不是 Python 标量并且类型不同。 + [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果输入是[`Sequence`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence "(in Python v3.12)")，但它们的长度不匹配。 + [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果输入是[`Mapping`](https://docs.python.org/3/library/collections.abc.html#collections.abc.Mapping "(in Python v3.12)")，但它们的键集不匹配。 -+ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果相应的张量的[`shape`](generated/torch.Tensor.shape.html#torch.Tensor.shape "torch.Tensor.shape")不相同。 ++ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果相应的张量的`shape`不相同。 + [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(in Python v3.12)") – 如果`check_layout`为`True`，但相应的张量的`layout`不相同。 + [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(在 Python v3.12 中)") – 如果仅有一组相应的张量被量化。 -+ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(在 Python v3.12 中)") – 如果相应的张量被量化，但具有不同的[`qscheme()`](generated/torch.Tensor.qscheme.html#torch.Tensor.qscheme "torch.Tensor.qscheme")。 ++ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(在 Python v3.12 中)") – 如果相应的张量被量化，但具有不同的`qscheme()`。 -+ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(在 Python v3.12 中)") – 如果`check_device`为`True`，但相应的张量不在相同的[`device`](generated/torch.Tensor.device.html#torch.Tensor.device "torch.Tensor.device")上。 ++ [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(在 Python v3.12 中)") – 如果`check_device`为`True`，但相应的张量不在相同的`device`上。 + [**AssertionError**](https://docs.python.org/3/library/exceptions.html#AssertionError "(在 Python v3.12 中)") – 如果`check_dtype`为`True`，但相应的张量的`dtype`不相同。 @@ -110,7 +110,7 @@ Python标量是类型关系要求的一个例外，因为它们的`type()`，即 注意 -[`assert_close()`](#torch.testing.assert_close "torch.testing.assert_close") 具有严格的默认设置，可以高度配置。鼓励用户使用[`partial()`](https://docs.python.org/3/library/functools.html#functools.partial "(在 Python v3.12 中)") 来适应其用例。例如，如果需要进行相等性检查，可以定义一个`assert_equal`，默认情况下对每个`dtype`使用零容差： +`assert_close()` 具有严格的默认设置，可以高度配置。鼓励用户使用[`partial()`](https://docs.python.org/3/library/functools.html#functools.partial "(在 Python v3.12 中)") 来适应其用例。例如，如果需要进行相等性检查，可以定义一个`assert_equal`，默认情况下对每个`dtype`使用零容差： ```py >>> import functools @@ -259,17 +259,17 @@ torch.testing.make_tensor(*shape, dtype, device, low=None, high=None, requires_g + **shape** (*元组**[*[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*,* *...**]*) – 定义输出张量形状的单个整数或整数序列。 -+ **dtype** ([`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")) – 返回张量的数据类型。 ++ **dtype** (`torch.dtype`) – 返回张量的数据类型。 -+ **device** (*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* [*torch.device*](tensor_attributes.html#torch.device "torch.device")*]*) – 返回张量的设备。 ++ **device** (*Union**[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* *torch.device**]*) – 返回张量的设备。 -+ **low** (*可选**[**数字**]*) – 设置给定范围的下限（包括）。如果提供了一个数字，它将被夹紧到给定dtype的最小可表示有限值。当为`None`（默认）时，此值根据`dtype`（见上表）确定。默认值：`None`。 ++ **low** (*可选**[**数字**]*) – 设置给定范围的下限（包括）。如果提供了一个数字，它将被夹紧到给定 dtype 的最小可表示有限值。当为`None`（默认）时，此值根据`dtype`（见上表）确定。默认值：`None`。 + **high** (*可选**[**数字**]*) – 设置给定范围的上限（不包括）。如果提供了一个数字，则它将被夹紧到给定 dtype 的最大可表示有限值。当为 `None`（默认）时，此值基于 `dtype` 决定（参见上表）。默认值：`None`。 - 自版本 2.1 起已弃用：对于浮点或复数类型，将 `low==high` 传递给 [`make_tensor()`](#torch.testing.make_tensor "torch.testing.make_tensor") 自 2.1 版本起已弃用，并将在 2.3 版本中移除。请改用 [`torch.full()`](generated/torch.full.html#torch.full "torch.full")。 + 自版本 2.1 起已弃用：对于浮点或复数类型，将 `low==high` 传递给 `make_tensor()` 自 2.1 版本起已弃用，并将在 2.3 版本中移除。请改用 `torch.full()`。 + **requires_grad**（*可选**[*[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*]*) – 如果 autograd 应记录返回的张量上的操作。默认值：`False`。 @@ -277,7 +277,7 @@ torch.testing.make_tensor(*shape, dtype, device, low=None, high=None, requires_g + **exclude_zero**（*可选**[*[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*]*) – 如果为 `True`，则零将被替换为依赖于 `dtype` 的小正值。对于布尔和整数类型，零将被替换为一。对于浮点类型，它将被替换为 `dtype` 的最小正常数（`dtype` 的 `finfo()` 对象的“微小”值），对于复数类型，它将被替换为一个实部和虚部都是复数类型可表示的最小正常数的复数。默认为 `False`。 -+ **memory_format**（*可选**[*[*torch.memory_format*](tensor_attributes.html#torch.memory_format "torch.memory_format")*]*) – 返回张量的内存格式。与 `noncontiguous` 互斥。 ++ **memory_format**（*可选***[*torch.memory_format**]*) – 返回张量的内存格式。与 `noncontiguous` 互斥。 引发 @@ -293,7 +293,7 @@ torch.testing.make_tensor(*shape, dtype, device, low=None, high=None, requires_g 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* 示例 @@ -314,4 +314,4 @@ torch.testing.assert_allclose(actual, expected, rtol=None, atol=None, equal_nan= 警告 -[`torch.testing.assert_allclose()`](#torch.testing.assert_allclose "torch.testing.assert_allclose") 自 `1.12` 版本起已被弃用，并将在将来的版本中移除。请改用 [`torch.testing.assert_close()`](#torch.testing.assert_close "torch.testing.assert_close")。您可以在[此处](https://github.com/pytorch/pytorch/issues/61844)找到详细的升级说明。 +`torch.testing.assert_allclose()` 自 `1.12` 版本起已被弃用，并将在将来的版本中移除。请改用 `torch.testing.assert_close()`。您可以在[此处](https://github.com/pytorch/pytorch/issues/61844)找到详细的升级说明。 diff --git a/totrans/doc22_082.md b/totrans/doc22_082.md index 4d91aee4..7e506001 100644 --- a/totrans/doc22_082.md +++ b/totrans/doc22_082.md @@ -1,9 +1,9 @@ # torch.utils -> 原文：[https://pytorch.org/docs/stable/utils.html](https://pytorch.org/docs/stable/utils.html) +> 原文：[`pytorch.org/docs/stable/utils.html`](https://pytorch.org/docs/stable/utils.html) -| [`rename_privateuse1_backend`](generated/torch.utils.rename_privateuse1_backend.html#torch.utils.rename_privateuse1_backend "torch.utils.rename_privateuse1_backend") | 将privateuse1后端设备重命名，使其在PyTorch API中更方便使用作为设备名称。 | +| `rename_privateuse1_backend` | 将 privateuse1 后端设备重命名，使其在 PyTorch API 中更方便使用作为设备名称。 | | --- | --- | -| [`generate_methods_for_privateuse1_backend`](generated/torch.utils.generate_methods_for_privateuse1_backend.html#torch.utils.generate_methods_for_privateuse1_backend "torch.utils.generate_methods_for_privateuse1_backend") | 在将privateuse1后端重命名后，自动生成自定义后端的属性和方法。 | -| [`get_cpp_backtrace`](generated/torch.utils.get_cpp_backtrace.html#torch.utils.get_cpp_backtrace "torch.utils.get_cpp_backtrace") | 返回一个包含当前线程C++堆栈跟踪的字符串。 | -| [`set_module`](generated/torch.utils.set_module.html#torch.utils.set_module "torch.utils.set_module") | 为给定对象设置python对象的模块属性，以便更好地打印。 | +| `generate_methods_for_privateuse1_backend` | 在将 privateuse1 后端重命名后，自动生成自定义后端的属性和方法。 | +| `get_cpp_backtrace` | 返回一个包含当前线程 C++堆栈跟踪的字符串。 | +| `set_module` | 为给定对象设置 python 对象的模块属性，以便更好地打印。 | diff --git a/totrans/doc22_083.md b/totrans/doc22_083.md index dc320629..7f31c3d8 100644 --- a/totrans/doc22_083.md +++ b/totrans/doc22_083.md @@ -1,64 +1,64 @@ # 基准工具 - torch.utils.benchmark -> [https://pytorch.org/docs/stable/benchmark_utils.html](https://pytorch.org/docs/stable/benchmark_utils.html) +> [`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=, globals=None, label=None, sub_label=None, description=None, env=None, num_threads=1, language=Language.PYTHON)¶ ``` -用于测量PyTorch语句执行时间的辅助类。 +用于测量 PyTorch 语句执行时间的辅助类。 -有关如何使用此类的完整教程，请参见：[https://pytorch.org/tutorials/recipes/recipes/benchmark.html](https://pytorch.org/tutorials/recipes/recipes/benchmark.html) +有关如何使用此类的完整教程，请参见：[`pytorch.org/tutorials/recipes/recipes/benchmark.html`](https://pytorch.org/tutorials/recipes/recipes/benchmark.html) -PyTorch计时器基于timeit.Timer（实际上在内部使用timeit.Timer），但有几个关键区别： +PyTorch 计时器基于 timeit.Timer（实际上在内部使用 timeit.Timer），但有几个关键区别： 1. 运行时感知: - 计时器将执行预热（因为PyTorch的某些元素是惰性初始化的），设置线程池大小以便进行苹果对苹果的比较，并在必要时同步异步CUDA函数。 + 计时器将执行预热（因为 PyTorch 的某些元素是惰性初始化的），设置线程池大小以便进行苹果对苹果的比较，并在必要时同步异步 CUDA 函数。 1. 专注于复制品： - 在测量代码时，特别是复杂的内核/模型时，运行到运行的变化是一个重要的混淆因素。预计所有测量都应包括复制品以量化噪声并允许中位数计算，这比平均值更稳健。为此，该类从时间API的概念上合并了timeit.Timer.repeat和timeit.Timer.autorange。（确切的算法在方法文档字符串中讨论。）对于不希望使用自适应策略的情况，复制了timeit方法。 + 在测量代码时，特别是复杂的内核/模型时，运行到运行的变化是一个重要的混淆因素。预计所有测量都应包括复制品以量化噪声并允许中位数计算，这比平均值更稳健。为此，该类从时间 API 的概念上合并了 timeit.Timer.repeat 和 timeit.Timer.autorange。（确切的算法在方法文档字符串中讨论。）对于不希望使用自适应策略的情况，复制了 timeit 方法。 1. 可选元数据： - 在定义计时器时，可以选择指定标签、子标签、描述和环境。（稍后定义）这些字段包含在结果对象的表示中，并由Compare类用于分组和显示比较结果。 + 在定义计时器时，可以选择指定标签、子标签、描述和环境。（稍后定义）这些字段包含在结果对象的表示中，并由 Compare 类用于分组和显示比较结果。 1. 指令计数 - 除了墙上时间，计时器还可以在Callgrind下运行语句并报告执行的指令。 + 除了墙上时间，计时器还可以在 Callgrind 下运行语句并报告执行的指令。 -直接类似于timeit.Timer构造函数参数： +直接类似于 timeit.Timer 构造函数参数： > stmt、setup、timer、globals -PyTorch计时器特定的构造函数参数： +PyTorch 计时器特定的构造函数参数： > 标签、子标签、描述、环境、线程数 参数 -+ **stmt**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 要在循环中运行和计时的代码片段。 ++ **stmt**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 要在循环中运行和计时的代码片段。 -+ **设置**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 可选的设置代码。用于定义在stmt中使用的变量 ++ **设置**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 可选的设置代码。用于定义在 stmt 中使用的变量 -+ **全局设置**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- （仅限C++）放置在文件顶层的代码，用于#include语句等。 ++ **全局设置**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- （仅限 C++）放置在文件顶层的代码，用于#include 语句等。 -+ **计时器**（[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在Python v3.12中)")*[**[**]**,* [*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*]*) - 返回当前时间的可调用函数。如果PyTorch没有使用CUDA构建或没有GPU存在，则默认为timeit.default_timer；否则在测量时间之前将同步CUDA。 ++ **计时器**（[*Callable*](https://docs.python.org/3/library/typing.html#typing.Callable "(在 Python v3.12 中)")*[**[**]**,* [*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*]*) - 返回当前时间的可调用函数。如果 PyTorch 没有使用 CUDA 构建或没有 GPU 存在，则默认为 timeit.default_timer；否则在测量时间之前将同步 CUDA。 -+ **全局**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*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中)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在Python v3.12中)")*]**]*) - 在执行stmt时定义全局变量的字典。这是提供stmt需要的变量的另一种方法。 ++ **全局**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*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 中)")*,* [*Any*](https://docs.python.org/3/library/typing.html#typing.Any "(在 Python v3.12 中)")*]**]*) - 在执行 stmt 时定义全局变量的字典。这是提供 stmt 需要的变量的另一种方法。 -+ **标签**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*]*) - 概括stmt的字符串。例如，如果stmt是“torch.nn.functional.relu(torch.add(x, 1, out=out))”，可以将标签设置为“ReLU(x + 1)”以提高可读性。 ++ **标签**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]*) - 概括 stmt 的字符串。例如，如果 stmt 是“torch.nn.functional.relu(torch.add(x, 1, out=out))”，可以将标签设置为“ReLU(x + 1)”以提高可读性。 -+ **子标签**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在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.Optional "(在 Python v3.12 中)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*]*) - - 提供额外信息以消除具有相同stmt或标签的测量的歧义。例如，在我们上面的示例中，sub_label可能是“float”或“int”，这样就很容易区分：“ReLU(x + 1): (float)” + 提供额外信息以消除具有相同 stmt 或标签的测量的歧义。例如，在我们上面的示例中，sub_label 可能是“float”或“int”，这样就很容易区分：“ReLU(x + 1): (float)” - 在打印Measurements或使用Compare进行总结时，“ReLU(x + 1): (int)”。 + 在打印 Measurements 或使用 Compare 进行总结时，“ReLU(x + 1): (int)”。 -+ **description**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")*]*) - ++ **description**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")*]*) - - 用于区分具有相同标签和sub_label的测量的字符串。description的主要用途是向Compare信号数据列。例如，可以基于输入大小设置它以创建以下形式的表： + 用于区分具有相同标签和 sub_label 的测量的字符串。description 的主要用途是向 Compare 信号数据列。例如，可以基于输入大小设置它以创建以下形式的表： ```py | n=1 | n=4 | ... @@ -67,19 +67,19 @@ PyTorch计时器特定的构造函数参数： ReLU(x + 1): (int) | ... | ... | ... ``` - 使用Compare。在打印Measurement时也包括在内。 + 使用 Compare。在打印 Measurement 时也包括在内。 -+ **env**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12)")*]*) - 此标记表示在不同环境中运行了相同任务，因此它们不等效，例如在对内核进行A/B测试时。当合并复制运行时，Compare将处理具有不同env规范的Measurements为不同。 ++ **env**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12)")*]*) - 此标记表示在不同环境中运行了相同任务，因此它们不等效，例如在对内核进行 A/B 测试时。当合并复制运行时，Compare 将处理具有不同 env 规范的 Measurements 为不同。 -+ **num_threads**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12)")） - 在执行stmt时PyTorch线程池的大小。单线程性能很重要，既是关键的推理工作负载，也是内在算法效率的良好指标，因此默认设置为1。这与默认的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)¶ ``` -类似于blocked_autorange，但还检查测量中的变异性，并重复直到iqr/median小于阈值或达到max_run_time。 +类似于 blocked_autorange，但还检查测量中的变异性，并重复直到 iqr/median 小于阈值或达到 max_run_time。 -在高层次上，adaptive_autorange执行以下伪代码： +在高层次上，adaptive_autorange 执行以下伪代码： ```py `setup` @@ -100,19 +100,19 @@ while times.sum < max_run_time 参数 -+ **threshold**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 停止的iqr/median阈值的值 ++ **threshold**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 停止的 iqr/median 阈值的值 -+ **min_run_time**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 在检查阈值之前所需的总运行时间 ++ **min_run_time**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 在检查阈值之前所需的总运行时间 -+ **max_run_time**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12)")） - 所有测量的总运行时间，无论阈值如何 ++ **max_run_time**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12)")） - 所有测量的总运行时间，无论阈值如何 返回 -包含测量运行时间和重复计数的Measurement对象，可用于计算统计数据（均值、中位数等）。 +包含测量运行时间和重复计数的 Measurement 对象，可用于计算统计数据（均值、中位数等）。 返回类型 -[*Measurement*](#torch.utils.benchmark.Measurement "torch.utils.benchmark.utils.common.Measurement") +*Measurement* ```py blocked_autorange(callback=None, min_run_time=0.2)¶ @@ -120,7 +120,7 @@ blocked_autorange(callback=None, min_run_time=0.2)¶ 在保持计时器开销最低的情况下测量许多复制品。 -在高层次上，blocked_autorange执行以下伪代码： +在高层次上，blocked_autorange 执行以下伪代码： ```py `setup` @@ -133,21 +133,21 @@ while total_time < min_run_time total_time += (timer() - start) ``` -请注意内部循环中的变量block_size。块大小的选择对测量质量很重要，必须平衡两个竞争目标： +请注意内部循环中的变量 block_size。块大小的选择对测量质量很重要，必须平衡两个竞争目标： > 1. 较小的块大小会产生更多的复制品，通常会有更好的统计数据。 > 1. -> 1. 较大的块大小更好地分摊计时器调用的成本，并导致较少偏倚的测量。这很重要，因为CUDA同步时间不容忽视（单个到低双位数微秒的顺序），否则会影响测量结果。 +> 1. 较大的块大小更好地分摊计时器调用的成本，并导致较少偏倚的测量。这很重要，因为 CUDA 同步时间不容忽视（单个到低双位数微秒的顺序），否则会影响测量结果。 -blocked_autorange通过运行预热期来设置块大小，增加块大小直到计时器开销小于总体计算的0.1%。然后将此值用于主测量循环。 +blocked_autorange 通过运行预热期来设置块大小，增加块大小直到计时器开销小于总体计算的 0.1%。然后将此值用于主测量循环。 返回 -包含测量运行时间和重复计数的Measurement对象，可用于计算统计数据（均值、中位数等）。 +包含测量运行时间和重复计数的 Measurement 对象，可用于计算统计数据（均值、中位数等）。 返回类型 -[*Measurement*](#torch.utils.benchmark.Measurement "torch.utils.benchmark.utils.common.Measurement") +*Measurement* ```py collect_callgrind(number: int, *, repeats: None, collect_baseline: bool, retain_out_file: bool) → CallgrindStats¶ @@ -157,31 +157,31 @@ collect_callgrind(number: int, *, repeats: None, collect_baseline: bool, retain_ collect_callgrind(number: int, *, repeats: int, collect_baseline: bool, retain_out_file: bool) → Tuple[CallgrindStats, ...] ``` -使用Callgrind收集指令计数。 +使用 Callgrind 收集指令计数。 -与墙上时间不同，指令计数是确定性的（除了程序本身的非确定性和来自Python解释器的少量抖动）。这使它们非常适合进行详细的性能分析。此方法在单独的进程中运行stmt，以便Valgrind可以对程序进行仪器化。由于仪器化，性能会严重下降，但是由于通常少量迭代就足以获得良好的测量结果，这一点得到了改善。 +与墙上时间不同，指令计数是确定性的（除了程序本身的非确定性和来自 Python 解释器的少量抖动）。这使它们非常适合进行详细的性能分析。此方法在单独的进程中运行 stmt，以便 Valgrind 可以对程序进行仪器化。由于仪器化，性能会严重下降，但是由于通常少量迭代就足以获得良好的测量结果，这一点得到了改善。 -为了使用这种方法，必须安装valgrind、callgrind_control和callgrind_annotate。 +为了使用这种方法，必须安装 valgrind、callgrind_control 和 callgrind_annotate。 -由于调用者（此进程）和stmt执行之间存在进程边界，全局变量不能包含任意的内存数据结构。（与计时方法不同）相反，全局变量仅限于内置函数、nn.Modules和TorchScripted函数/模块，以减少由于序列化和后续反序列化而引起的意外因素。GlobalsBridge类提供了更多关于此主题的详细信息。特别注意nn.Modules：它们依赖pickle，您可能需要为它们添加一个导入以便正确传输。 +由于调用者（此进程）和 stmt 执行之间存在进程边界，全局变量不能包含任意的内存数据结构。（与计时方法不同）相反，全局变量仅限于内置函数、nn.Modules 和 TorchScripted 函数/模块，以减少由于序列化和后续反序列化而引起的意外因素。GlobalsBridge 类提供了更多关于此主题的详细信息。特别注意 nn.Modules：它们依赖 pickle，您可能需要为它们添加一个导入以便正确传输。 -默认情况下，将收集并缓存一个空语句的性能分析，以指示有多少指令来自驱动语句的Python循环。 +默认情况下，将收集并缓存一个空语句的性能分析，以指示有多少指令来自驱动语句的 Python 循环。 返回 -一个CallgrindStats对象，提供指令计数和一些基本设施用于分析和操作结果。 +一个 CallgrindStats 对象，提供指令计数和一些基本设施用于分析和操作结果。 ```py timeit(number=1000000)¶ ``` -反映了timeit.Timer.timeit()的语义。 +反映了 timeit.Timer.timeit()的语义。 -执行主语句（stmt）的次数。[https://docs.python.org/3/library/timeit.html#timeit.Timer.timeit](https://docs.python.org/3/library/timeit.html#timeit.Timer.timeit) +执行主语句（stmt）的次数。[`docs.python.org/3/library/timeit.html#timeit.Timer.timeit`](https://docs.python.org/3/library/timeit.html#timeit.Timer.timeit) 返回类型 -[*Measurement*](#torch.utils.benchmark.Measurement "torch.utils.benchmark.utils.common.Measurement") +*Measurement* ```py class torch.utils.benchmark.Measurement(number_per_run, raw_times, task_spec, metadata=None)¶ @@ -189,7 +189,7 @@ class torch.utils.benchmark.Measurement(number_per_run, raw_times, task_spec, me 计时器测量的结果。 -这个类存储给定语句的一个或多个测量。它是可序列化的，并为下游消费者提供几种便利方法（包括详细的__repr__）。 +这个类存储给定语句的一个或多个测量。它是可序列化的，并为下游消费者提供几种便利方法（包括详细的 __repr__）。 ```py static merge(measurements)¶ @@ -197,11 +197,11 @@ static merge(measurements)¶ 用于合并重复实验的便利方法。 -合并将将时间推断为number_per_run=1，并且不会传输任何元数据。（因为在重复实验之间可能会有差异） +合并将将时间推断为 number_per_run=1，并且不会传输任何元数据。（因为在重复实验之间可能会有差异） 返回类型 -[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")[[*Measurement*](#torch.utils.benchmark.Measurement "torch.utils.benchmark.utils.common.Measurement")] +[*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")[*Measurement*] ```py property significant_figures: int¶ @@ -209,17 +209,17 @@ property significant_figures: int¶ 近似的显著数字估计。 -此属性旨在提供一种方便的方法来估计测量的精度。它仅使用四分位范围来估计统计数据，以尝试减少尾部的偏差，并使用静态z值1.645，因为不希望用于小值n，所以z可以近似于t。 +此属性旨在提供一种方便的方法来估计测量的精度。它仅使用四分位范围来估计统计数据，以尝试减少尾部的偏差，并使用静态 z 值 1.645，因为不希望用于小值 n，所以 z 可以近似于 t。 -与trim_sigfig方法一起使用的显著数字估计，以提供更易于人类理解的数据摘要。__repr__不使用此方法；它只显示原始值。显著数字估计用于Compare。 +与 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)¶ ``` -由计时器收集的Callgrind结果的顶层容器。 +由计时器收集的 Callgrind 结果的顶层容器。 -通常使用FunctionCounts类进行操作，该类通过调用CallgrindStats.stats(…)获得。还提供了几种便利方法；最重要的是CallgrindStats.as_standardized()。 +通常使用 FunctionCounts 类进行操作，该类通过调用 CallgrindStats.stats(…)获得。还提供了几种便利方法；最重要的是 CallgrindStats.as_standardized()。 ```py as_standardized()¶ @@ -227,7 +227,7 @@ as_standardized()¶ 从函数字符串中删除库名称和一些前缀。 -在比较两组不同的指令计数时，一个障碍可能是路径前缀。Callgrind在报告函数时包括完整的文件路径（应该如此）。但是，在进行性能分析时，这可能会导致问题。如果两个性能分析中的关键组件（如Python或PyTorch）在不同位置构建，可能会导致类似以下的情况： +在比较两组不同的指令计数时，一个障碍可能是路径前缀。Callgrind 在报告函数时包括完整的文件路径（应该如此）。但是，在进行性能分析时，这可能会导致问题。如果两个性能分析中的关键组件（如 Python 或 PyTorch）在不同位置构建，可能会导致类似以下的情况： ```py 23234231 /tmp/first_build_dir/thing.c:foo(...) @@ -243,7 +243,7 @@ as_standardized()¶ 返回类型 -[*CallgrindStats*](#torch.utils.benchmark.CallgrindStats "torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.CallgrindStats") +*CallgrindStats* ```py counts(*, denoise=False)¶ @@ -267,7 +267,7 @@ delta(other, inclusive=False)¶ 返回类型 -[*FunctionCounts*](#torch.utils.benchmark.FunctionCounts "torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts") +*FunctionCounts* ```py stats(inclusive=False)¶ @@ -281,7 +281,7 @@ inclusive 匹配 callgrind 的语义。如果为 True，则计数包括子级执 返回类型 -[*FunctionCounts*](#torch.utils.benchmark.FunctionCounts "torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts") +*FunctionCounts* ```py class torch.utils.benchmark.FunctionCounts(_data, inclusive, truncate_rows=True, _linewidth=None)¶ @@ -309,7 +309,7 @@ CPython 解释器中的几条指令相当嘈杂。这些指令涉及 Python 用 返回类型 -[*FunctionCounts*](#torch.utils.benchmark.FunctionCounts "torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts") +*FunctionCounts* ```py filter(filter_fn)¶ @@ -319,7 +319,7 @@ filter(filter_fn)¶ 返回类型 -[*FunctionCounts*](#torch.utils.benchmark.FunctionCounts "torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts") +*FunctionCounts* ```py transform(map_fn)¶ @@ -331,4 +331,4 @@ transform(map_fn)¶ 返回类型 -[*FunctionCounts*](#torch.utils.benchmark.FunctionCounts "torch.utils.benchmark.utils.valgrind_wrapper.timer_interface.FunctionCounts") +*FunctionCounts* diff --git a/totrans/doc22_084.md b/totrans/doc22_084.md index d5a23e11..c71dab62 100644 --- a/totrans/doc22_084.md +++ b/totrans/doc22_084.md @@ -1,8 +1,8 @@ # torch.utils.bottleneck -> 原文：[https://pytorch.org/docs/stable/bottleneck.html](https://pytorch.org/docs/stable/bottleneck.html) +> 原文：[`pytorch.org/docs/stable/bottleneck.html`](https://pytorch.org/docs/stable/bottleneck.html) -torch.utils.bottleneck是一个工具，可用作调试程序中瓶颈的初始步骤。它使用Python分析器和PyTorch的autograd分析器对脚本运行进行总结。 +torch.utils.bottleneck 是一个工具，可用作调试程序中瓶颈的初始步骤。它使用 Python 分析器和 PyTorch 的 autograd 分析器对脚本运行进行总结。 在命令行上运行它 @@ -10,7 +10,7 @@ torch.utils.bottleneck是一个工具，可用作调试程序中瓶颈的初始 python -m torch.utils.bottleneck /path/to/source/script.py [args] ``` -[args]是传递给script.py的任意数量的参数，或者运行`python -m torch.utils.bottleneck -h`以获取更多用法说明。 +[args]是传递给 script.py 的任意数量的参数，或者运行`python -m torch.utils.bottleneck -h`以获取更多用法说明。 警告 @@ -18,16 +18,16 @@ python -m torch.utils.bottleneck /path/to/source/script.py [args] 警告 -由于CUDA内核的异步性质，当针对CUDA代码运行时，cProfile输出和CPU模式的autograd分析器可能不会显示正确的时间：报告的CPU时间报告了用于启动内核的时间，但不包括内核在GPU上执行的时间，除非操作进行同步。在常规CPU模式分析器下，执行同步的操作似乎非常昂贵。在这些时间不正确的情况下，CUDA模式的autograd分析器可能有所帮助。 +由于 CUDA 内核的异步性质，当针对 CUDA 代码运行时，cProfile 输出和 CPU 模式的 autograd 分析器可能不会显示正确的时间：报告的 CPU 时间报告了用于启动内核的时间，但不包括内核在 GPU 上执行的时间，除非操作进行同步。在常规 CPU 模式分析器下，执行同步的操作似乎非常昂贵。在这些时间不正确的情况下，CUDA 模式的 autograd 分析器可能有所帮助。 注意 -要决定查看哪种（仅CPU模式还是CUDA模式）autograd分析器输出，请首先检查您的脚本是否受CPU限制（“CPU总时间远远大于CUDA总时间”）。如果是CPU受限的，查看CPU模式autograd分析器的结果将有所帮助。另一方面，如果您的脚本大部分时间在GPU上执行，则有意义的是开始查找CUDA模式autograd分析器输出中负责的CUDA运算符。 +要决定查看哪种（仅 CPU 模式还是 CUDA 模式）autograd 分析器输出，请首先检查您的脚本是否受 CPU 限制（“CPU 总时间远远大于 CUDA 总时间”）。如果是 CPU 受限的，查看 CPU 模式 autograd 分析器的结果将有所帮助。另一方面，如果您的脚本大部分时间在 GPU 上执行，则有意义的是开始查找 CUDA 模式 autograd 分析器输出中负责的 CUDA 运算符。 -当然，现实情况要复杂得多，根据您评估的模型部分，您的脚本可能不属于这两个极端之一。如果分析器的输出没有帮助，您可以尝试查看[`torch.autograd.profiler.emit_nvtx()`](autograd.html#torch.autograd.profiler.emit_nvtx "torch.autograd.profiler.emit_nvtx")的结果，使用`nvprof`。但请注意，NVTX的开销非常高，通常会导致时间线严重倾斜。同样，`Intel® VTune™ Profiler`可以通过[`torch.autograd.profiler.emit_itt()`](autograd.html#torch.autograd.profiler.emit_itt "torch.autograd.profiler.emit_itt")进一步分析在Intel平台上的性能。 +当然，现实情况要复杂得多，根据您评估的模型部分，您的脚本可能不属于这两个极端之一。如果分析器的输出没有帮助，您可以尝试查看`torch.autograd.profiler.emit_nvtx()`的结果，使用`nvprof`。但请注意，NVTX 的开销非常高，通常会导致时间线严重倾斜。同样，`Intel® VTune™ Profiler`可以通过`torch.autograd.profiler.emit_itt()`进一步分析在 Intel 平台上的性能。 警告 -如果您正在分析CUDA代码，`bottleneck`运行的第一个分析器（cProfile）将在其时间报告中包括CUDA启动时间（CUDA缓冲区分配成本）。如果您的瓶颈导致代码比CUDA启动时间慢得多，则这并不重要。 +如果您正在分析 CUDA 代码，`bottleneck`运行的第一个分析器（cProfile）将在其时间报告中包括 CUDA 启动时间（CUDA 缓冲区分配成本）。如果您的瓶颈导致代码比 CUDA 启动时间慢得多，则这并不重要。 -对于分析器的更复杂用法（如在多GPU情况下），请参阅[https://docs.python.org/3/library/profile.html](https://docs.python.org/3/library/profile.html)或[`torch.autograd.profiler.profile()`](autograd.html#torch.autograd.profiler.profile "torch.autograd.profiler.profile")获取更多信息。 +对于分析器的更复杂用法（如在多 GPU 情况下），请参阅[`docs.python.org/3/library/profile.html`](https://docs.python.org/3/library/profile.html)或`torch.autograd.profiler.profile()`获取更多信息。 diff --git a/totrans/doc22_085.md b/totrans/doc22_085.md index 80f9c8af..6ba4a6bc 100644 --- a/totrans/doc22_085.md +++ b/totrans/doc22_085.md @@ -1,12 +1,12 @@ # torch.utils.checkpoint -> 原文：[https://pytorch.org/docs/stable/checkpoint.html](https://pytorch.org/docs/stable/checkpoint.html) +> 原文：[`pytorch.org/docs/stable/checkpoint.html`](https://pytorch.org/docs/stable/checkpoint.html) 注意 -检查点是通过在反向传播期间为每个检查点段重新运行一个前向传播段来实现的。这可能会导致持久状态（如RNG状态）比没有检查点更快地前进。默认情况下，检查点包含逻辑来调整RNG状态，使得使用RNG的检查点通过（例如通过dropout）与未检查点的通过相比具有确定性输出。存储和恢复RNG状态的逻辑可能会导致适度的性能损失，具体取决于检查点操作的运行时。如果不需要与未检查点的通过相比的确定性输出，请在`checkpoint`或`checkpoint_sequential`中提供`preserve_rng_state=False`以省略在每个检查点期间存储和恢复RNG状态。 +检查点是通过在反向传播期间为每个检查点段重新运行一个前向传播段来实现的。这可能会导致持久状态（如 RNG 状态）比没有检查点更快地前进。默认情况下，检查点包含逻辑来调整 RNG 状态，使得使用 RNG 的检查点通过（例如通过 dropout）与未检查点的通过相比具有确定性输出。存储和恢复 RNG 状态的逻辑可能会导致适度的性能损失，具体取决于检查点操作的运行时。如果不需要与未检查点的通过相比的确定性输出，请在`checkpoint`或`checkpoint_sequential`中提供`preserve_rng_state=False`以省略在每个检查点期间存储和恢复 RNG 状态。 -存储逻辑会保存并恢复CPU和另一设备类型（通过`_infer_device_type`从张量参数中排除CPU张量推断设备类型）的RNG状态到`run_fn`。如果有多个设备，设备状态只会为单个设备类型的设备保存，其余设备将被忽略。因此，如果任何检查点函数涉及随机性，可能会导致梯度不正确。（请注意，如果检测到CUDA设备，则会优先考虑；否则，将选择遇到的第一个设备。）如果没有CPU张量，则将保存和恢复默认设备类型状态（默认值为cuda，可以通过`DefaultDeviceType`设置为其他设备）。然而，该逻辑无法预测用户是否会在`run_fn`内将张量移动到新设备。因此，如果您在`run_fn`内将张量移动到新设备（“新”意味着不属于[当前设备+张量参数的设备]集合），则与未检查点的通过相比，确定性输出永远无法保证。 +存储逻辑会保存并恢复 CPU 和另一设备类型（通过`_infer_device_type`从张量参数中排除 CPU 张量推断设备类型）的 RNG 状态到`run_fn`。如果有多个设备，设备状态只会为单个设备类型的设备保存，其余设备将被忽略。因此，如果任何检查点函数涉及随机性，可能会导致梯度不正确。（请注意，如果检测到 CUDA 设备，则会优先考虑；否则，将选择遇到的第一个设备。）如果没有 CPU 张量，则将保存和恢复默认设备类型状态（默认值为 cuda，可以通过`DefaultDeviceType`设置为其他设备）。然而，该逻辑无法预测用户是否会在`run_fn`内将张量移动到新设备。因此，如果您在`run_fn`内将张量移动到新设备（“新”意味着不属于[当前设备+张量参数的设备]集合），则与未检查点的通过相比，确定性输出永远无法保证。 ```py torch.utils.checkpoint.checkpoint(function, *args, use_reentrant=None, context_fn=, determinism_check='default', debug=False, **kwargs)¶ @@ -32,23 +32,23 @@ torch.utils.checkpoint.checkpoint(function, *args, use_reentrant=None, context_f + 非可重入检查点在所有需要的中间激活重新计算后立即停止重新计算。此功能默认启用，但可以使用`set_checkpoint_early_stop()`禁用。可重入检查点在反向传播期间始终重新计算`function`的全部内容。 -+ 可重入变体在正向传播期间不记录自动求导图，因为它在[`torch.no_grad()`](generated/torch.no_grad.html#torch.no_grad "torch.no_grad")下运行正向传播。非可重入版本记录自动求导图，允许在检查点区域内对图进行反向传播。 ++ 可重入变体在正向传播期间不记录自动求导图，因为它在`torch.no_grad()`下运行正向传播。非可重入版本记录自动求导图，允许在检查点区域内对图进行反向传播。 -+ 可重入检查点仅支持后向传递的[`torch.autograd.backward()`](generated/torch.autograd.backward.html#torch.autograd.backward "torch.autograd.backward") API，不带其输入参数，而非可重入版本支持执行后向传递的所有方式。 ++ 可重入检查点仅支持后向传递的`torch.autograd.backward()` API，不带其输入参数，而非可重入版本支持执行后向传递的所有方式。 + 至少一个输入和输出必须具有`requires_grad=True`，以便支持可重入变体。如果不满足此条件，模型的被检查部分将没有梯度。非可重入版本不具有此要求。 + 可重入版本不考虑嵌套结构中的张量（例如自定义对象、列表、字典等）是否参与自动梯度，而非可重入版本则考虑。 -+ 可重入检查点不支持从计算图中分离的张量的检查点区域，而非可重入版本支持。对于可重入变体，如果检查点段包含使用`detach()`分离的张量或使用[`torch.no_grad()`](generated/torch.no_grad.html#torch.no_grad "torch.no_grad")的张量，后向传递将引发错误。这是因为`checkpoint`使所有输出都需要梯度，当在模型中定义张量为无梯度时会出现问题。为了避免这种情况，在`checkpoint`函数之外分离张量。 ++ 可重入检查点不支持从计算图中分离的张量的检查点区域，而非可重入版本支持。对于可重入变体，如果检查点段包含使用`detach()`分离的张量或使用`torch.no_grad()`的张量，后向传递将引发错误。这是因为`checkpoint`使所有输出都需要梯度，当在模型中定义张量为无梯度时会出现问题。为了避免这种情况，在`checkpoint`函数之外分离张量。 参数 -+ **function** - 描述模型或模型部分前向传递中要运行的内容。它还应该知道如何处理作为元组传递的输入。例如，在LSTM中，如果用户传递了`(activation, hidden)`，`function`应该正确地将第一个输入用作`activation`，第二个输入用作`hidden` ++ **function** - 描述模型或模型部分前向传递中要运行的内容。它还应该知道如何处理作为元组传递的输入。例如，在 LSTM 中，如果用户传递了`(activation, hidden)`，`function`应该正确地将第一个输入用作`activation`，第二个输入用作`hidden` -+ **preserve_rng_state** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) - 在每个检查点期间省略保存和恢复RNG状态。默认值：`True` ++ **preserve_rng_state** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) - 在每个检查点期间省略保存和恢复 RNG 状态。默认值：`True` -+ **use_reentrant** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) - 使用需要可重入自动梯度的检查点实现。如果指定了`use_reentrant=False`，`checkpoint`将使用不需要可重入自动梯度的实现。这允许`checkpoint`支持额外功能，例如与`torch.autograd.grad`正常工作以及支持输入到被检查函数的关键字参数。请注意，未来版本的PyTorch将默认为`use_reentrant=False`。默认值：`True` ++ **use_reentrant** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*,* *optional*) - 使用需要可重入自动梯度的检查点实现。如果指定了`use_reentrant=False`，`checkpoint`将使用不需要可重入自动梯度的实现。这允许`checkpoint`支持额外功能，例如与`torch.autograd.grad`正常工作以及支持输入到被检查函数的关键字参数。请注意，未来版本的 PyTorch 将默认为`use_reentrant=False`。默认值：`True` + **context_fn** (*Callable**,* *optional*) - 返回两个上下文管理器元组的可调用函数。函数及其重新计算将分别在第一个和第二个上下文管理器下运行。只有在`use_reentrant=False`时才支持此参数。 @@ -76,13 +76,13 @@ torch.utils.checkpoint.checkpoint_sequential(functions, segments, input, use_ree 参数 -+ **functions** - 一个[`torch.nn.Sequential`](generated/torch.nn.Sequential.html#torch.nn.Sequential "torch.nn.Sequential")或者要依次运行的模块或函数列表（组成模型）。 ++ **functions** - 一个`torch.nn.Sequential`或者要依次运行的模块或函数列表（组成模型）。 + **segments** - 要在模型中创建的块数 + **input** - 作为`functions`输入的张量 -+ **preserve_rng_state**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")，可选） - 在每个检查点期间省略保存和恢复RNG状态。默认值：`True` ++ **preserve_rng_state**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")，可选） - 在每个检查点期间省略保存和恢复 RNG 状态。默认值：`True` + **use_reentrant**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")，可选） - 使用需要可重入自动求导的检查点实现。如果指定了`use_reentrant=False`，`checkpoint`将使用不需要可重入自动求导的实现。这允许`checkpoint`支持额外的功能，例如与`torch.autograd.grad`正常工作以及支持传递给检查点函数的关键字参数。默认值：`True` @@ -101,7 +101,7 @@ torch.utils.checkpoint.checkpoint_sequential(functions, segments, input, use_ree torch.utils.checkpoint.set_checkpoint_debug_enabled(enabled)¶ ``` -上下文管理器，设置检查点在运行时是否应该打印额外的调试信息。有关更多信息，请参阅[`checkpoint()`](#torch.utils.checkpoint.checkpoint "torch.utils.checkpoint.checkpoint")中的`debug`标志。请注意，当设置时，此上下文管理器会覆盖传递给检查点的`debug`值。要推迟到本地设置，请将`None`传递给此上下文。 +上下文管理器，设置检查点在运行时是否应该打印额外的调试信息。有关更多信息，请参阅`checkpoint()`中的`debug`标志。请注意，当设置时，此上下文管理器会覆盖传递给检查点的`debug`值。要推迟到本地设置，请将`None`传递给此上下文。 参数 diff --git a/totrans/doc22_086.md b/totrans/doc22_086.md index 7e2d195d..5b45bcc3 100644 --- a/totrans/doc22_086.md +++ b/totrans/doc22_086.md @@ -1,14 +1,14 @@ # torch.utils.cpp_extension -> 原文：[https://pytorch.org/docs/stable/cpp_extension.html](https://pytorch.org/docs/stable/cpp_extension.html) +> 原文：[`pytorch.org/docs/stable/cpp_extension.html`](https://pytorch.org/docs/stable/cpp_extension.html) ```py torch.utils.cpp_extension.CppExtension(name, sources, *args, **kwargs)¶ ``` -为C++创建一个`setuptools.Extension`。 +为 C++创建一个`setuptools.Extension`。 -使用最少的参数创建一个`setuptools.Extension`的便捷方法，用于构建C++扩展。 +使用最少的参数创建一个`setuptools.Extension`的便捷方法，用于构建 C++扩展。 所有参数都会传递给`setuptools.Extension`构造函数。 @@ -34,9 +34,9 @@ torch.utils.cpp_extension.CppExtension(name, sources, *args, **kwargs)¶ torch.utils.cpp_extension.CUDAExtension(name, sources, *args, **kwargs)¶ ``` -为CUDA/C++创建一个`setuptools.Extension`。 +为 CUDA/C++创建一个`setuptools.Extension`。 -使用最少的参数创建一个`setuptools.Extension`的便捷方法，用于构建CUDA/C++扩展。这包括CUDA包含路径、库路径和运行时库。 +使用最少的参数创建一个`setuptools.Extension`的便捷方法，用于构建 CUDA/C++扩展。这包括 CUDA 包含路径、库路径和运行时库。 所有参数都会传递给`setuptools.Extension`构造函数。 @@ -61,17 +61,17 @@ torch.utils.cpp_extension.CUDAExtension(name, sources, *args, **kwargs)¶ 计算能力： -默认情况下，扩展将被编译以在构建过程中可见的所有卡的所有archs上运行，再加上PTX。如果将来安装了新的卡，可能需要重新编译扩展。如果可见卡的计算能力（CC）比您的nvcc可以完全编译的最新版本要新，Pytorch将使nvcc退回到使用您的nvcc支持的最新版本的PTX构建内核（有关PTX的详细信息，请参见下文）。 +默认情况下，扩展将被编译以在构建过程中可见的所有卡的所有 archs 上运行，再加上 PTX。如果将来安装了新的卡，可能需要重新编译扩展。如果可见卡的计算能力（CC）比您的 nvcc 可以完全编译的最新版本要新，Pytorch 将使 nvcc 退回到使用您的 nvcc 支持的最新版本的 PTX 构建内核（有关 PTX 的详细信息，请参见下文）。 -您可以使用TORCH_CUDA_ARCH_LIST来覆盖默认行为，明确指定扩展要支持的CCs： +您可以使用 TORCH_CUDA_ARCH_LIST 来覆盖默认行为，明确指定扩展要支持的 CCs： `TORCH_CUDA_ARCH_LIST="6.1 8.6" python build_my_extension.py` `TORCH_CUDA_ARCH_LIST="5.2 6.0 6.1 7.0 7.5 8.0 8.6+PTX" python build_my_extension.py` -+PTX选项会导致扩展内核二进制文件包含指定CC的PTX指令。PTX是一种中间表示，允许内核为任何CC >= 指定的CC（例如，8.6+PTX生成的PTX可以为任何具有CC >= 8.6的GPU运行时编译）。这提高了二进制文件的向前兼容性。然而，依赖于旧的PTX来通过运行时编译为新的CC提供向前兼容性可能会在这些新的CC上略微降低性能。如果您知道要针对的GPU的确切CC(s)，最好是分别指定它们。例如，如果您希望您的扩展在8.0和8.6上运行，“8.0+PTX”在功能上可以工作，因为它包含了可以为8.6运行时编译的PTX，但“8.0 8.6”会更好。 ++PTX 选项会导致扩展内核二进制文件包含指定 CC 的 PTX 指令。PTX 是一种中间表示，允许内核为任何 CC >= 指定的 CC（例如，8.6+PTX 生成的 PTX 可以为任何具有 CC >= 8.6 的 GPU 运行时编译）。这提高了二进制文件的向前兼容性。然而，依赖于旧的 PTX 来通过运行时编译为新的 CC 提供向前兼容性可能会在这些新的 CC 上略微降低性能。如果您知道要针对的 GPU 的确切 CC(s)，最好是分别指定它们。例如，如果您希望您的扩展在 8.0 和 8.6 上运行，“8.0+PTX”在功能上可以工作，因为它包含了可以为 8.6 运行时编译的 PTX，但“8.0 8.6”会更好。 -请注意，虽然可以包含所有支持的archs，但是包含的archs越多，构建过程就会变得越慢，因为它将为每个arch构建单独的内核映像。 +请注意，虽然可以包含所有支持的 archs，但是包含的 archs 越多，构建过程就会变得越慢，因为它将为每个 arch 构建单独的内核映像。 -请注意，CUDA-11.5 nvcc在Windows上解析torch/extension.h时会遇到内部编译器错误。为了解决这个问题，将Python绑定逻辑移动到纯C++文件中。 +请注意，CUDA-11.5 nvcc 在 Windows 上解析 torch/extension.h 时会遇到内部编译器错误。为了解决这个问题，将 Python 绑定逻辑移动到纯 C++文件中。 示例用法： @@ -81,15 +81,15 @@ torch.utils.cpp_extension.CUDAExtension(name, sources, *args, **kwargs)¶ #include torch::Tensor SigmoidAlphaBlendForwardCuda(…) -目前有一个关于nvcc bug的未解决问题：[https://github.com/pytorch/pytorch/issues/69460](https://github.com/pytorch/pytorch/issues/69460) 完整的解决方案代码示例：[https://github.com/facebookresearch/pytorch3d/commit/cb170ac024a949f1f9614ffe6af1c38d972f7d48](https://github.com/facebookresearch/pytorch3d/commit/cb170ac024a949f1f9614ffe6af1c38d972f7d48) +目前有一个关于 nvcc bug 的未解决问题：[`github.com/pytorch/pytorch/issues/69460`](https://github.com/pytorch/pytorch/issues/69460) 完整的解决方案代码示例：[`github.com/facebookresearch/pytorch3d/commit/cb170ac024a949f1f9614ffe6af1c38d972f7d48`](https://github.com/facebookresearch/pytorch3d/commit/cb170ac024a949f1f9614ffe6af1c38d972f7d48) 可重定位设备代码链接： -如果要在编译单元之间引用设备符号（跨目标文件），则需要使用可重定位设备代码（-rdc=true或-dc）构建目标文件。这个规则的一个例外是“动态并行性”（嵌套内核启动），这在现在已经不太常用了。可重定位设备代码不太优化，因此只有在需要的目标文件上使用它时才需要使用。在设备代码编译步骤和dlink步骤中使用-dlto（设备链接时间优化）有助于减少-rdc的潜在性能降低。请注意，它需要在两个步骤中使用才能发挥作用。 +如果要在编译单元之间引用设备符号（跨目标文件），则需要使用可重定位设备代码（-rdc=true 或-dc）构建目标文件。这个规则的一个例外是“动态并行性”（嵌套内核启动），这在现在已经不太常用了。可重定位设备代码不太优化，因此只有在需要的目标文件上使用它时才需要使用。在设备代码编译步骤和 dlink 步骤中使用-dlto（设备链接时间优化）有助于减少-rdc 的潜在性能降低。请注意，它需要在两个步骤中使用才能发挥作用。 -如果您有rdc对象，则需要在CPU符号链接步骤之前进行额外的-dlink（设备链接）步骤。还有一种情况是在没有-rdc时使用-dlink：当一个扩展链接到包含rdc编译对象的静态库时，比如[NVSHMEM库]（[https://developer.nvidia.com/nvshmem](https://developer.nvidia.com/nvshmem)）。 +如果您有 rdc 对象，则需要在 CPU 符号链接步骤之前进行额外的-dlink（设备链接）步骤。还有一种情况是在没有-rdc 时使用-dlink：当一个扩展链接到包含 rdc 编译对象的静态库时，比如[NVSHMEM 库]（[`developer.nvidia.com/nvshmem`](https://developer.nvidia.com/nvshmem)）。 -注意：构建CUDA扩展需要使用Ninja进行RDC链接。 +注意：构建 CUDA 扩展需要使用 Ninja 进行 RDC 链接。 示例 @@ -109,39 +109,39 @@ torch.utils.cpp_extension.BuildExtension(*args, **kwargs)¶ 一个自定义的`setuptools`构建扩展。 -这个`setuptools.build_ext`子类负责传递最低要求的编译器标志（例如`-std=c++17`）以及混合C++/CUDA编译（以及对CUDA文件的支持）。 +这个`setuptools.build_ext`子类负责传递最低要求的编译器标志（例如`-std=c++17`）以及混合 C++/CUDA 编译（以及对 CUDA 文件的支持）。 -在使用[`BuildExtension`](#torch.utils.cpp_extension.BuildExtension "torch.utils.cpp_extension.BuildExtension")时，允许为`extra_compile_args`（而不是通常的列表）提供一个字典，将语言（`cxx`或`nvcc`）映射到要提供给编译器的附加编译器标志列表。这样可以在混合编译期间为C++和CUDA编译器提供不同的标志。 +在使用`BuildExtension`时，允许为`extra_compile_args`（而不是通常的列表）提供一个字典，将语言（`cxx`或`nvcc`）映射到要提供给编译器的附加编译器标志列表。这样可以在混合编译期间为 C++和 CUDA 编译器提供不同的标志。 -`use_ninja`（布尔值）：如果`use_ninja`为`True`（默认值），则我们尝试使用Ninja后端进行构建。与标准的`setuptools.build_ext`相比，Ninja大大加快了编译速度。如果Ninja不可用，则回退到标准的distutils后端。 +`use_ninja`（布尔值）：如果`use_ninja`为`True`（默认值），则我们尝试使用 Ninja 后端进行构建。与标准的`setuptools.build_ext`相比，Ninja 大大加快了编译速度。如果 Ninja 不可用，则回退到标准的 distutils 后端。 注意 -默认情况下，Ninja后端使用#CPUS + 2个工作进程来构建扩展。这可能会在某些系统上使用过多资源。可以通过将MAX_JOBS环境变量设置为非负数来控制工作进程的数量。 +默认情况下，Ninja 后端使用#CPUS + 2 个工作进程来构建扩展。这可能会在某些系统上使用过多资源。可以通过将 MAX_JOBS 环境变量设置为非负数来控制工作进程的数量。 ```py torch.utils.cpp_extension.load(name, sources, extra_cflags=None, extra_cuda_cflags=None, extra_ldflags=None, extra_include_paths=None, build_directory=None, verbose=False, with_cuda=None, is_python_module=True, is_standalone=False, keep_intermediates=True)¶ ``` -即时加载PyTorch C++扩展（JIT）。 +即时加载 PyTorch C++扩展（JIT）。 -要加载一个扩展，将生成一个Ninja构建文件，用于将给定的源编译成动态库。然后将此库作为模块加载到当前Python进程中，并从此函数返回，准备供使用。 +要加载一个扩展，将生成一个 Ninja 构建文件，用于将给定的源编译成动态库。然后将此库作为模块加载到当前 Python 进程中，并从此函数返回，准备供使用。 默认情况下，生成的构建文件和编译后的库的目录是`/torch_extensions/`，其中``是当前平台上的临时文件夹，``是扩展的名称。可以通过两种方式覆盖此位置。首先，如果设置了`TORCH_EXTENSIONS_DIR`环境变量，则它将替换`/torch_extensions`，并且所有扩展将被编译到此目录的子文件夹中。其次，如果提供了此函数的`build_directory`参数，则它将覆盖整个路径，即库将直接编译到该文件夹中。 要编译源文件，将使用默认的系统编译器（`c++`），可以通过设置`CXX`环境变量来覆盖。要向编译过程传递附加参数，可以提供`extra_cflags`或`extra_ldflags`。例如，要使用优化编译您的扩展，请传递`extra_cflags=['-O3']`。您还可以使用`extra_cflags`来传递更多的包含目录。 -提供了混合编译的CUDA支持。只需传递CUDA源文件（`.cu`或`.cuh`）以及其他源文件。这些文件将被检测并使用nvcc而不是C++编译器进行编译。这包括将CUDA lib64目录作为库目录，并链接`cudart`。您可以通过`extra_cuda_cflags`向nvcc传递额外的标志，就像对C++使用`extra_cflags`一样。通常会使用各种启发式方法来查找CUDA安装目录，这通常可以正常工作。如果不行，设置`CUDA_HOME`环境变量是最安全的选择。 +提供了混合编译的 CUDA 支持。只需传递 CUDA 源文件（`.cu`或`.cuh`）以及其他源文件。这些文件将被检测并使用 nvcc 而不是 C++编译器进行编译。这包括将 CUDA lib64 目录作为库目录，并链接`cudart`。您可以通过`extra_cuda_cflags`向 nvcc 传递额外的标志，就像对 C++使用`extra_cflags`一样。通常会使用各种启发式方法来查找 CUDA 安装目录，这通常可以正常工作。如果不行，设置`CUDA_HOME`环境变量是最安全的选择。 参数 -+ **name** - 要构建的扩展的名称。这必须与pybind11模块的名称相同！ ++ **name** - 要构建的扩展的名称。这必须与 pybind11 模块的名称相同！ -+ **sources**（[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")*,* [*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中)")*]**]*) – 一个包含C++源文件的相对或绝对路径列表。 ++ **sources**（[*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*[*[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")*,* [*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 中)")*]**]*) – 一个包含 C++源文件的相对或绝对路径列表。 + **extra_cflags** – 转发到构建的编译器标志的可选列表。 -+ **extra_cuda_cflags** – 转发到构建CUDA源代码时传递给nvcc的编译器标志的可选列表。 ++ **extra_cuda_cflags** – 转发到构建 CUDA 源代码时传递给 nvcc 的编译器标志的可选列表。 + **extra_ldflags** – 转发到构建的链接器标志的可选列表。 @@ -151,15 +151,15 @@ torch.utils.cpp_extension.load(name, sources, extra_cflags=None, extra_cuda_cfla + **verbose** – 如果为`True`，则打开加载步骤的详细日志记录。 -+ **with_cuda**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")*]*) – 确定是否将CUDA头文件和库添加到构建中。如果设置为`None`（默认值），则根据`sources`中是否存在`.cu`或`.cuh`自动确定此值。将其设置为True`以强制包含CUDA头文件和库。 ++ **with_cuda**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")*]*) – 确定是否将 CUDA 头文件和库添加到构建中。如果设置为`None`（默认值），则根据`sources`中是否存在`.cu`或`.cuh`自动确定此值。将其设置为 True`以强制包含 CUDA 头文件和库。 -+ **is_python_module** – 如果为`True`（默认值），将生成的共享库导入为Python模块。如果为`False`，行为取决于`is_standalone`。 ++ **is_python_module** – 如果为`True`（默认值），将生成的共享库导入为 Python 模块。如果为`False`，行为取决于`is_standalone`。 + **is_standalone** – 如果为`False`（默认值），将构建的扩展程序加载到进程中作为普通动态库。如果为`True`，则构建一个独立的可执行文件。 返回值 -将加载的PyTorch扩展程序作为Python模块返回。 +将加载的 PyTorch 扩展程序作为 Python 模块返回。 如果`is_python_module`为`False`且`is_standalone`为`False`： @@ -167,7 +167,7 @@ torch.utils.cpp_extension.load(name, sources, extra_cflags=None, extra_cuda_cfla 如果`is_standalone`为`True`。 -返回可执行文件的路径。（在Windows上，TORCH_LIB_PATH会作为副作用添加到PATH环境变量中。） +返回可执行文件的路径。（在 Windows 上，TORCH_LIB_PATH 会作为副作用添加到 PATH 环境变量中。） 返回类型 @@ -188,31 +188,31 @@ torch.utils.cpp_extension.load(name, sources, extra_cflags=None, extra_cuda_cfla torch.utils.cpp_extension.load_inline(name, cpp_sources, cuda_sources=None, functions=None, extra_cflags=None, extra_cuda_cflags=None, extra_ldflags=None, extra_include_paths=None, build_directory=None, verbose=False, with_cuda=None, is_python_module=True, with_pytorch_error_handling=True, keep_intermediates=True, use_pch=False)¶ ``` -从字符串源加载PyTorch C++扩展程序。 +从字符串源加载 PyTorch C++扩展程序。 -此函数的行为与[`load()`](#torch.utils.cpp_extension.load "torch.utils.cpp_extension.load")完全相同，但是它将源代码作为字符串而不是文件名。这些字符串存储到构建目录中的文件中，之后[`load_inline()`](#torch.utils.cpp_extension.load_inline "torch.utils.cpp.cpp_extension.load_inline")的行为与[`load()`](#torch.utils.cpp_extension.load "torch.utils.cpp.cpp_extension.load")相同。 +此函数的行为与`load()`完全相同，但是它将源代码作为字符串而不是文件名。这些字符串存储到构建目录中的文件中，之后`load_inline()`的行为与`load()`相同。 查看[测试](https://github.com/pytorch/pytorch/blob/master/test/test_cpp_extensions_jit.py)以获取使用此函数的良好示例。 -源代码可能省略典型非内联C++扩展程序的两个必需部分：必要的头文件包含以及（pybind11）绑定代码。更确切地说，传递给`cpp_sources`的字符串首先连接成一个单独的`.cpp`文件。然后在文件开头加上`#include `。 +源代码可能省略典型非内联 C++扩展程序的两个必需部分：必要的头文件包含以及（pybind11）绑定代码。更确切地说，传递给`cpp_sources`的字符串首先连接成一个单独的`.cpp`文件。然后在文件开头加上`#include `。 此外，如果提供了`functions`参数，将自动生成每个指定函数的绑定。`functions`可以是函数名称列表，也可以是从函数名称到文档字符串的映射的字典。如果给出了列表，则每个函数的名称将用作其文档字符串。 -`cuda_sources`中的源代码被连接到单独的`.cu`文件中，并在前面加上`torch/types.h`、`cuda.h`和`cuda_runtime.h`包含。`.cpp`和`.cu`文件分别编译，但最终链接成一个单独的库。请注意，`cuda_sources`中的函数不会自动生成绑定。要绑定到CUDA内核，您必须创建一个调用它的C++函数，并在`cpp_sources`中声明或定义此C++函数（并将其名称包含在`functions`中）。 +`cuda_sources`中的源代码被连接到单独的`.cu`文件中，并在前面加上`torch/types.h`、`cuda.h`和`cuda_runtime.h`包含。`.cpp`和`.cu`文件分别编译，但最终链接成一个单独的库。请注意，`cuda_sources`中的函数不会自动生成绑定。要绑定到 CUDA 内核，您必须创建一个调用它的 C++函数，并在`cpp_sources`中声明或定义此 C++函数（并将其名称包含在`functions`中）。 -有关下面省略的参数的描述，请参阅[`load()`](#torch.utils.cpp_extension.load "torch.utils.cpp_extension.load")。 +有关下面省略的参数的描述，请参阅`load()`。 参数 -+ **cpp_sources** - 包含C++源代码的字符串或字符串列表。 ++ **cpp_sources** - 包含 C++源代码的字符串或字符串列表。 -+ **cuda_sources** - 包含CUDA源代码的字符串或字符串列表。 ++ **cuda_sources** - 包含 CUDA 源代码的字符串或字符串列表。 + **函数** - 一个要生成函数绑定的函数名称列表。如果给定一个字典，它应该将函数名称映射到文档字符串（否则只是函数名称）。 -+ **with_cuda** - 确定是否将CUDA头文件和库添加到构建中。如果设置为`None`（默认值），则此值将根据是否提供了`cuda_sources`自动确定。将其设置为`True`以强制包含CUDA头文件和库。 ++ **with_cuda** - 确定是否将 CUDA 头文件和库添加到构建中。如果设置为`None`（默认值），则此值将根据是否提供了`cuda_sources`自动确定。将其设置为`True`以强制包含 CUDA 头文件和库。 -+ **with_pytorch_error_handling** - 确定是否由pytorch处理pytorch错误和警告宏，而不是由pybind处理。为此，每个函数`foo`都通过一个中间函数`_safe_foo`调用。这种重定向可能会在cpp的一些复杂情况下引起问题。当此重定向引起问题时，应将此标志设置为`False`。 ++ **with_pytorch_error_handling** - 确定是否由 pytorch 处理 pytorch 错误和警告宏，而不是由 pybind 处理。为此，每个函数`foo`都通过一个中间函数`_safe_foo`调用。这种重定向可能会在 cpp 的一些复杂情况下引起问题。当此重定向引起问题时，应将此标志设置为`False`。 示例 @@ -230,17 +230,17 @@ at::Tensor sin_add(at::Tensor x, at::Tensor y) { 注意 -默认情况下，Ninja后端使用#CPUS + 2个工作进程来构建扩展。这可能会在某些系统上使用过多资源。可以通过将MAX_JOBS环境变量设置为非负数来控制工作进程的数量。 +默认情况下，Ninja 后端使用#CPUS + 2 个工作进程来构建扩展。这可能会在某些系统上使用过多资源。可以通过将 MAX_JOBS 环境变量设置为非负数来控制工作进程的数量。 ```py torch.utils.cpp_extension.include_paths(cuda=False)¶ ``` -获取构建C++或CUDA扩展所需的包含路径。 +获取构建 C++或 CUDA 扩展所需的包含路径。 参数 -**cuda**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 如果为True，则包含特定于CUDA的包含路径。 +**cuda**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 如果为 True，则包含特定于 CUDA 的包含路径。 返回 @@ -248,25 +248,25 @@ torch.utils.cpp_extension.include_paths(cuda=False)¶ 返回类型 -[*列表*](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中)")] +[*列表*](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 torch.utils.cpp_extension.get_compiler_abi_compatibility_and_version(compiler)¶ ``` -确定给定编译器是否与PyTorch ABI兼容以及其版本。 +确定给定编译器是否与 PyTorch ABI 兼容以及其版本。 参数 -**编译器**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 要检查的编译器可执行文件名称（例如`g++`）。必须在shell进程中可执行。 +**编译器**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 要检查的编译器可执行文件名称（例如`g++`）。必须在 shell 进程中可执行。 返回 -一个包含一个布尔值的元组，该布尔值定义编译器是否（可能）与PyTorch不兼容的ABI，后跟一个包含由点分隔的编译器版本的TorchVersion字符串。 +一个包含一个布尔值的元组，该布尔值定义编译器是否（可能）与 PyTorch 不兼容的 ABI，后跟一个包含由点分隔的编译器版本的 TorchVersion 字符串。 返回类型 -[*元组*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在Python v3.12中)")[[bool](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)"), *TorchVersion*] +[*元组*](https://docs.python.org/3/library/typing.html#typing.Tuple "(在 Python v3.12 中)")[[bool](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)"), *TorchVersion*] ```py torch.utils.cpp_extension.verify_ninja_availability()¶ diff --git a/totrans/doc22_087.md b/totrans/doc22_087.md index f3807a56..d7657dd0 100644 --- a/totrans/doc22_087.md +++ b/totrans/doc22_087.md @@ -1,20 +1,20 @@ # torch.utils.data -> 原文：[https://pytorch.org/docs/stable/data.html](https://pytorch.org/docs/stable/data.html) +> 原文：[`pytorch.org/docs/stable/data.html`](https://pytorch.org/docs/stable/data.html) -PyTorch数据加载实用程序的核心是[`torch.utils.data.DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")类。它表示数据集的Python可迭代对象，支持 +PyTorch 数据加载实用程序的核心是`torch.utils.data.DataLoader`类。它表示数据集的 Python 可迭代对象，支持 -+ [映射风格和可迭代风格数据集](#dataset-types)， ++ 映射风格和可迭代风格数据集， -+ [自定义数据加载顺序](#data-loading-order-and-sampler)， ++ 自定义数据加载顺序， -+ [自动批处理](#loading-batched-and-non-batched-data)， ++ 自动批处理， -+ [单进程和多进程数据加载](#single-and-multi-process-data-loading)， ++ 单进程和多进程数据加载， -+ [自动内存固定](#memory-pinning)。 ++ 自动内存固定。 -这些选项由[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的构造函数参数配置，其签名为： +这些选项由`DataLoader`的构造函数参数配置，其签名为： ```py DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, @@ -28,11 +28,11 @@ DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, ## 数据集类型 -[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")构造函数最重要的参数是[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")，表示要从中加载数据的数据集对象。PyTorch支持两种不同类型的数据集： +`DataLoader`构造函数最重要的参数是`dataset`，表示要从中加载数据的数据集对象。PyTorch 支持两种不同类型的数据集： -+ [映射风格数据集](#map-style-datasets)， ++ 映射风格数据集， -+ [可迭代风格数据集](#iterable-style-datasets)。 ++ 可迭代风格数据集。 ### 映射风格数据集 @@ -40,37 +40,37 @@ DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, 例如，这样一个数据集，当使用`dataset[idx]`访问时，可以从磁盘上的文件夹读取第`idx`个图像及其对应的标签。 -更多详情请参阅[`Dataset`](#torch.utils.data.Dataset "torch.utils.data.Dataset")。 +更多详情请参阅`Dataset`。 ### 可迭代风格数据集 -可迭代风格数据集是[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")子类的实例，实现了`__iter__()`协议，表示数据样本的可迭代。这种类型的数据集特别适用于随机读取昂贵甚至不太可能的情况，批量大小取决于获取的数据。 +可迭代风格数据集是`IterableDataset`子类的实例，实现了`__iter__()`协议，表示数据样本的可迭代。这种类型的数据集特别适用于随机读取昂贵甚至不太可能的情况，批量大小取决于获取的数据。 例如，这样一个数据集，当调用`iter(dataset)`时，可以返回从数据库、远程服务器甚至实时生成的日志中读取的数据流。 -更多详情请参阅[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")。 +更多详情请参阅`IterableDataset`。 注意 -当使用带有[多进程数据加载](#multi-process-data-loading)的[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")时。相同的数据集对象在每个工作进程上复制，因此必须对副本进行不同配置以避免重复数据。请参阅[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")文档以了解如何实现此目的。 +当使用带有多进程数据加载的`IterableDataset`时。相同的数据集对象在每个工作进程上复制，因此必须对副本进行不同配置以避免重复数据。请参阅`IterableDataset`文档以了解如何实现此目的。 -## 数据加载顺序和[`Sampler`](#torch.utils.data.Sampler "torch.utils.data.Sampler")[](#data-loading-order-and-sampler "跳转到此标题") +## 数据加载顺序和`Sampler`[](#data-loading-order-and-sampler "跳转到此标题") -对于[可迭代风格数据集](#iterable-style-datasets)，数据加载顺序完全由用户定义的可迭代对象控制。这允许更容易实现分块读取和动态批量大小（例如，每次产生一个批量样本）。 +对于可迭代风格数据集，数据加载顺序完全由用户定义的可迭代对象控制。这允许更容易实现分块读取和动态批量大小（例如，每次产生一个批量样本）。 -本节剩余部分涉及[映射风格数据集](#map-style-datasets)的情况。[`torch.utils.data.Sampler`](#torch.utils.data.Sampler "torch.utils.data.Sampler")类用于指定数据加载中使用的索引/键的顺序。它们表示数据集索引的可迭代对象。例如，在随机梯度下降（SGD）的常见情况下，[`Sampler`](#torch.utils.data.Sampler "torch.utils.data.Sampler")可以随机排列索引列表并逐个产生每个索引，或者为小批量SGD产生少量索引。 +本节剩余部分涉及映射风格数据集的情况。`torch.utils.data.Sampler`类用于指定数据加载中使用的索引/键的顺序。它们表示数据集索引的可迭代对象。例如，在随机梯度下降（SGD）的常见情况下，`Sampler`可以随机排列索引列表并逐个产生每个索引，或者为小批量 SGD 产生少量索引。 -基于传递给[`DataLoader`](#torch.utils.data.DataLoader“torch.utils.data.DataLoader”)的`shuffle`参数，将自动构建顺序或随机采样器。或者，用户可以使用[`sampler`](utils.html#module-torch.utils.data.sampler“torch.utils.data.sampler”)参数指定自定义[`Sampler`](#torch.utils.data.Sampler“torch.utils.data.Sampler”)对象，该对象在每次产生下一个索引/键以获取时。 +基于传递给`DataLoader`的`shuffle`参数，将自动构建顺序或随机采样器。或者，用户可以使用`sampler`参数指定自定义`Sampler`对象，该对象在每次产生下一个索引/键以获取时。 -可以将一次产生一批批次索引列表的自定义[`Sampler`](#torch.utils.data.Sampler“torch.utils.data.Sampler”)作为`batch_sampler`参数传递。也可以通过`batch_size`和`drop_last`参数启用自动批处理。有关此内容的更多详细信息，请参见[下一节](#loading-batched-and-non-batched-data)。 +可以将一次产生一批批次索引列表的自定义`Sampler`作为`batch_sampler`参数传递。也可以通过`batch_size`和`drop_last`参数启用自动批处理。有关此内容的更多详细信息，请参见下一节。 注意 -既不[`sampler`](utils.html#module-torch.utils.data.sampler“torch.utils.data.sampler”)也不`batch_sampler`与可迭代样式数据集兼容，因为这类数据集没有键或索引的概念。 +既不`sampler`也不`batch_sampler`与可迭代样式数据集兼容，因为这类数据集没有键或索引的概念。 ## 加载批量和非批量数据[]（＃加载批量和非批量数据“链接到此标题”） -[`DataLoader`](#torch.utils.data.DataLoader“torch.utils.data.DataLoader”)支持通过参数`batch_size`，`drop_last`，`batch_sampler`和`collate_fn`（具有默认函数）自动整理单独获取的数据样本为批次。 +`DataLoader`支持通过参数`batch_size`，`drop_last`，`batch_sampler`和`collate_fn`（具有默认函数）自动整理单独获取的数据样本为批次。 ### 自动批处理（默认）[]（＃自动批处理默认“链接到此标题”） @@ -80,11 +80,11 @@ DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, 注意 -`batch_size`和`drop_last`参数本质上用于从[`sampler`](utils.html#module-torch.utils.data.sampler“torch.utils.data.sampler”)构建`batch_sampler`。对于映射样式数据集，[`sampler`](utils.html#module-torch.utils.data.sampler“torch.utils.data.sampler”)由用户提供或基于`shuffle`参数构建。对于可迭代样式数据集，[`sampler`](utils.html#module-torch.utils.data.sampler“torch.utils.data.sampler”)是一个虚拟的无限循环。有关采样器的更多详细信息，请参见[此部分](#data-loading-order-and-sampler)。 +`batch_size`和`drop_last`参数本质上用于从`sampler`构建`batch_sampler`。对于映射样式数据集，`sampler`由用户提供或基于`shuffle`参数构建。对于可迭代样式数据集，`sampler`是一个虚拟的无限循环。有关采样器的更多详细信息，请参见此部分。 注意 -从[可迭代样式数据集](#iterable-style-datasets)中获取数据时，使用[多处理](#multi-process-data-loading)，`drop_last`参数会丢弃每个工作进程数据集副本的最后一个非完整批次。 +从可迭代样式数据集中获取数据时，使用多处理，`drop_last`参数会丢弃每个工作进程数据集副本的最后一个非完整批次。 使用来自采样器的索引获取样本列表后，作为`collate_fn`参数传递的函数用于将样本列表整理成批次。 @@ -103,15 +103,15 @@ for indices in batch_sampler: yield collate_fn([next(dataset_iter) for _ in indices]) ``` -可以使用自定义的`collate_fn`来自定义整理，例如，将顺序数据填充到批次的最大长度。有关`collate_fn`的更多信息，请参见[此部分](#dataloader-collate-fn)。 +可以使用自定义的`collate_fn`来自定义整理，例如，将顺序数据填充到批次的最大长度。有关`collate_fn`的更多信息，请参见此部分。 ### 禁用自动批处理[]（＃禁用自动批处理“链接到此标题”） -在某些情况下，用户可能希望在数据集代码中手动处理批处理，或者仅加载单个样本。例如，直接加载批量数据可能更便宜（例如，从数据库进行批量读取或读取连续的内存块），或者批处理大小取决于数据，或者程序设计为处理单个样本。在这些情况下，最好不使用自动批处理（其中`collate_fn`用于整理样本），而是让数据加载器直接返回[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")对象的每个成员。 +在某些情况下，用户可能希望在数据集代码中手动处理批处理，或者仅加载单个样本。例如，直接加载批量数据可能更便宜（例如，从数据库进行批量读取或读取连续的内存块），或者批处理大小取决于数据，或者程序设计为处理单个样本。在这些情况下，最好不使用自动批处理（其中`collate_fn`用于整理样本），而是让数据加载器直接返回`dataset`对象的每个成员。 -当`batch_size`和`batch_sampler`都为`None`时（`batch_sampler`的默认值已经是`None`），自动批处理被禁用。从[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")获取的每个样本都会使用作为`collate_fn`参数传递的函数进行处理。 +当`batch_size`和`batch_sampler`都为`None`时（`batch_sampler`的默认值已经是`None`），自动批处理被禁用。从`dataset`获取的每个样本都会使用作为`collate_fn`参数传递的函数进行处理。 -**当禁用自动批处理时**，默认的`collate_fn`只是将NumPy数组转换为PyTorch张量，并保持其他所有内容不变。 +**当禁用自动批处理时**，默认的`collate_fn`只是将 NumPy 数组转换为 PyTorch 张量，并保持其他所有内容不变。 在这种情况下，从映射样式数据集加载大致等同于： @@ -127,37 +127,37 @@ for data in iter(dataset): yield collate_fn(data) ``` -查看关于`collate_fn`的更多信息[此部分](#dataloader-collate-fn)。 +查看关于`collate_fn`的更多信息此部分。 ### 使用`collate_fn`[](#working-with-collate-fn "跳转到此标题") 当启用或禁用自动批处理时，使用`collate_fn`略有不同。 -**当禁用自动批处理时**，`collate_fn`会对每个单独的数据样本进行调用，并且输出会从数据加载器迭代器中产生。在这种情况下，默认的`collate_fn`只是将NumPy数组转换为PyTorch张量。 +**当禁用自动批处理时**，`collate_fn`会对每个单独的数据样本进行调用，并且输出会从数据加载器迭代器中产生。在这种情况下，默认的`collate_fn`只是将 NumPy 数组转换为 PyTorch 张量。 -**当启用自动批处理时**，`collate_fn`会在每次调用时传入一个数据样本列表。它预期将输入样本整理成一个批次以便从数据加载器迭代器中产生。本节的其余部分描述了默认`collate_fn`的行为（[`default_collate()`](#torch.utils.data.default_collate "torch.utils.data.default_collate")）。 +**当启用自动批处理时**，`collate_fn`会在每次调用时传入一个数据样本列表。它预期将输入样本整理成一个批次以便从数据加载器迭代器中产生。本节的其余部分描述了默认`collate_fn`的行为（`default_collate()`）。 -例如，如果每个数据样本由一个3通道图像和一个整数类标签组成，即数据集的每个元素返回一个元组`(image, class_index)`，默认的`collate_fn`将这样的元组列表整理成一个批量图像张量和一个批量类标签张量的单个元组。特别是，默认的`collate_fn`具有以下属性： +例如，如果每个数据样本由一个 3 通道图像和一个整数类标签组成，即数据集的每个元素返回一个元组`(image, class_index)`，默认的`collate_fn`将这样的元组列表整理成一个批量图像张量和一个批量类标签张量的单个元组。特别是，默认的`collate_fn`具有以下属性： + 它总是在批处理维度之前添加一个新维度。 -+ 它会自动将NumPy数组和Python数值转换为PyTorch张量。 ++ 它会自动将 NumPy 数组和 Python 数值转换为 PyTorch 张量。 + 它保留了数据结构，例如，如果每个样本是一个字典，它会输出一个具有相同键集的字典，但批量化的张量作为值（或者如果值无法转换为张量，则为列表）。对于`list`、`tuple`、`namedtuple`等也是一样的。 用户可以使用定制的`collate_fn`来实现自定义的批处理，例如，沿着不同于第一个维度进行整理，填充不同长度的序列，或者添加对自定义数据类型的支持。 -如果您发现[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的输出维度或类型与您的期望不同，您可能需要检查您的`collate_fn`。 +如果您发现`DataLoader`的输出维度或类型与您的期望不同，您可能需要检查您的`collate_fn`。 ## 单进程和多进程数据加载[](#single-and-multi-process-data-loading "跳转到此标题") -[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")默认使用单进程数据加载。 +`DataLoader`默认使用单进程数据加载。 -在Python进程中，[全局解释器锁（GIL）](https://wiki.python.org/moin/GlobalInterpreterLock)阻止了真正将Python代码在线程间完全并行化。为了避免用数据加载阻塞计算代码，PyTorch提供了一个简单的开关，通过将参数`num_workers`设置为正整数来执行多进程数据加载。 +在 Python 进程中，[全局解释器锁（GIL）](https://wiki.python.org/moin/GlobalInterpreterLock)阻止了真正将 Python 代码在线程间完全并行化。为了避免用数据加载阻塞计算代码，PyTorch 提供了一个简单的开关，通过将参数`num_workers`设置为正整数来执行多进程数据加载。 ### 单进程数据加载（默认）[](#single-process-data-loading-default "跳转到此标题的永久链接") -在此模式下，数据获取是在初始化[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的同一进程中完成的。因此，数据加载可能会阻塞计算。但是，当用于在进程之间共享数据的资源（例如共享内存、文件描述符）有限时，或者整个数据集很小且可以完全加载到内存中时，可能更喜欢此模式。此外，单进程加载通常显示更易读的错误跟踪，因此对于调试很有用。 +在此模式下，数据获取是在初始化`DataLoader`的同一进程中完成的。因此，数据加载可能会阻塞计算。但是，当用于在进程之间共享数据的资源（例如共享内存、文件描述符）有限时，或者整个数据集很小且可以完全加载到内存中时，可能更喜欢此模式。此外，单进程加载通常显示更易读的错误跟踪，因此对于调试很有用。 ### 多进程数据加载[](#multi-process-data-loading "跳转到此标题的永久链接") @@ -165,47 +165,47 @@ for data in iter(dataset): 警告 -经过几次迭代，加载器工作进程将消耗与父进程中从工作进程访问的所有Python对象相同的CPU内存量。如果数据集包含大量数据（例如，在数据集构建时加载了非常大的文件名列表），和/或您使用了大量工作进程（总内存使用量为`工作进程数量 * 父进程大小`），这可能会有问题。最简单的解决方法是用Pandas、Numpy或PyArrow对象等非引用计数表示替换Python对象。查看[问题＃13246](https://github.com/pytorch/pytorch/issues/13246#issuecomment-905703662)以获取更多关于为什么会发生这种情况以及如何解决这些问题的示例代码。 +经过几次迭代，加载器工作进程将消耗与父进程中从工作进程访问的所有 Python 对象相同的 CPU 内存量。如果数据集包含大量数据（例如，在数据集构建时加载了非常大的文件名列表），和/或您使用了大量工作进程（总内存使用量为`工作进程数量 * 父进程大小`），这可能会有问题。最简单的解决方法是用 Pandas、Numpy 或 PyArrow 对象等非引用计数表示替换 Python 对象。查看[问题＃13246](https://github.com/pytorch/pytorch/issues/13246#issuecomment-905703662)以获取更多关于为什么会发生这种情况以及如何解决这些问题的示例代码。 -在此模式下，每次创建[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的迭代器（例如，当调用`enumerate(dataloader)`时），将创建`num_workers`个工作进程。在这一点上，[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")、`collate_fn`和`worker_init_fn`被传递给每个工作进程，它们用于初始化和获取数据。这意味着数据集访问以及其内部IO、转换（包括`collate_fn`）在工作进程中运行。 +在此模式下，每次创建`DataLoader`的迭代器（例如，当调用`enumerate(dataloader)`时），将创建`num_workers`个工作进程。在这一点上，`dataset`、`collate_fn`和`worker_init_fn`被传递给每个工作进程，它们用于初始化和获取数据。这意味着数据集访问以及其内部 IO、转换（包括`collate_fn`）在工作进程中运行。 -[`torch.utils.data.get_worker_info()`](#torch.utils.data.get_worker_info "torch.utils.data.get_worker_info")在工作进程中返回各种有用信息（包括工作进程ID、数据集副本、初始种子等），在主进程中返回`None`。用户可以在数据集代码和/或`worker_init_fn`中使用此函数来单独配置每个数据集副本，并确定代码是否在工作进程中运行。例如，在对数据集进行分片时，这可能特别有帮助。 +`torch.utils.data.get_worker_info()`在工作进程中返回各种有用信息（包括工作进程 ID、数据集副本、初始种子等），在主进程中返回`None`。用户可以在数据集代码和/或`worker_init_fn`中使用此函数来单独配置每个数据集副本，并确定代码是否在工作进程中运行。例如，在对数据集进行分片时，这可能特别有帮助。 -对于映射式数据集，主进程使用[`sampler`](utils.html#module-torch.utils.data.sampler "torch.utils.data.sampler")生成索引并将其发送给工作进程。因此，任何洗牌随机化都是在主进程中完成的，主进程通过分配索引来指导加载。 +对于映射式数据集，主进程使用`sampler`生成索引并将其发送给工作进程。因此，任何洗牌随机化都是在主进程中完成的，主进程通过分配索引来指导加载。 -对于可迭代式数据集，由于每个工作进程都会获得一个[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")对象的副本，天真的多进程加载通常会导致数据重复。使用[`torch.utils.data.get_worker_info()`](#torch.utils.data.get_worker_info "torch.utils.data.get_worker_info")和/或`worker_init_fn`，用户可以独立配置每个副本。（请参阅[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")文档以了解如何实现。）出于类似的原因，在多进程加载中，`drop_last`参数会删除每个工作进程的可迭代式数据集副本的最后一个非完整批次。 +对于可迭代式数据集，由于每个工作进程都会获得一个`dataset`对象的副本，天真的多进程加载通常会导致数据重复。使用`torch.utils.data.get_worker_info()`和/或`worker_init_fn`，用户可以独立配置每个副本。（请参阅`IterableDataset`文档以了解如何实现。）出于类似的原因，在多进程加载中，`drop_last`参数会删除每个工作进程的可迭代式数据集副本的最后一个非完整批次。 工作进程在迭代结束时关闭，或者当迭代器被垃圾回收时关闭。 警告 -通常不建议在多进程加载中返回CUDA张量，因为在使用CUDA和在多进程中共享CUDA张量时存在许多微妙之处（请参阅[CUDA在多进程中的使用](notes/multiprocessing.html#multiprocessing-cuda-note)）。相反，我们建议使用[自动内存固定](#memory-pinning)（即设置`pin_memory=True`），这样可以实现快速数据传输到支持CUDA的GPU。 +通常不建议在多进程加载中返回 CUDA 张量，因为在使用 CUDA 和在多进程中共享 CUDA 张量时存在许多微妙之处（请参阅 CUDA 在多进程中的使用）。相反，我们建议使用自动内存固定（即设置`pin_memory=True`），这样可以实现快速数据传输到支持 CUDA 的 GPU。 #### 平台特定行为[](#platform-specific-behaviors "跳转到此标题") -由于工作人员依赖于Python [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在Python v3.12中)")，与Unix相比，在Windows上工作启动行为是不同的。 +由于工作人员依赖于 Python [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在 Python v3.12 中)")，与 Unix 相比，在 Windows 上工作启动行为是不同的。 -+ 在Unix上，`fork()`是默认的[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在Python v3.12中)")启动方法。使用`fork()`，子工作进程通常可以直接通过克隆的地址空间访问[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")和Python参数函数。 ++ 在 Unix 上，`fork()`是默认的[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在 Python v3.12 中)")启动方法。使用`fork()`，子工作进程通常可以直接通过克隆的地址空间访问`dataset`和 Python 参数函数。 -+ 在Windows或MacOS上，`spawn()`是默认的[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在Python v3.12中)")启动方法。使用`spawn()`，会启动另一个解释器来运行您的主脚本，然后是接收[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")、`collate_fn`和其他参数的内部工作函数，通过[`pickle`](https://docs.python.org/3/library/pickle.html#module-pickle "(在Python v3.12中)")序列化。 ++ 在 Windows 或 MacOS 上，`spawn()`是默认的[`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing "(在 Python v3.12 中)")启动方法。使用`spawn()`，会启动另一个解释器来运行您的主脚本，然后是接收`dataset`、`collate_fn`和其他参数的内部工作函数，通过[`pickle`](https://docs.python.org/3/library/pickle.html#module-pickle "(在 Python v3.12 中)")序列化。 -这种单独的序列化意味着在使用多进程数据加载时，您应该采取两个步骤来确保与Windows兼容： +这种单独的序列化意味着在使用多进程数据加载时，您应该采取两个步骤来确保与 Windows 兼容： -+ 将大部分主脚本代码放在`if __name__ == '__main__':`块中，以确保在启动每个工作进程时不会再次运行（很可能会生成错误）。您可以在这里放置数据集和[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")实例创建逻辑，因为它不需要在工作进程中重新执行。 ++ 将大部分主脚本代码放在`if __name__ == '__main__':`块中，以确保在启动每个工作进程时不会再次运行（很可能会生成错误）。您可以在这里放置数据集和`DataLoader`实例创建逻辑，因为它不需要在工作进程中重新执行。 -+ 确保任何自定义的`collate_fn`、`worker_init_fn`或[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")代码被声明为顶层定义，放在`__main__`检查之外。这样可以确保它们在工作进程中可用。（这是因为函数只被序列化为引用，而不是`bytecode`。） ++ 确保任何自定义的`collate_fn`、`worker_init_fn`或`dataset`代码被声明为顶层定义，放在`__main__`检查之外。这样可以确保它们在工作进程中可用。（这是因为函数只被序列化为引用，而不是`bytecode`。） #### 多进程数据加载中的随机性[](#randomness-in-multi-process-data-loading "跳转到此标题") -默认情况下，每个工作进程的PyTorch种子将设置为`base_seed + worker_id`，其中`base_seed`是由主进程使用其RNG生成的长整型（因此，强制消耗RNG状态）或指定的`generator`。然而，初始化工作进程时，其他库的种子可能会重复，导致每个工作进程返回相同的随机数。（请参阅FAQ中的[此部分](notes/faq.html#dataloader-workers-random-seed)。） +默认情况下，每个工作进程的 PyTorch 种子将设置为`base_seed + worker_id`，其中`base_seed`是由主进程使用其 RNG 生成的长整型（因此，强制消耗 RNG 状态）或指定的`generator`。然而，初始化工作进程时，其他库的种子可能会重复，导致每个工作进程返回相同的随机数。（请参阅 FAQ 中的此部分。） -在`worker_init_fn`中，您可以使用[`torch.utils.data.get_worker_info().seed`](#torch.utils.data.get_worker_info "torch.utils.data.get_worker_info")或[`torch.initial_seed()`](generated/torch.initial_seed.html#torch.initial_seed "torch.initial_seed")访问为每个工作进程设置的PyTorch种子，并在数据加载之前用它来为其他库设置种子。 +在`worker_init_fn`中，您可以使用`torch.utils.data.get_worker_info().seed`或`torch.initial_seed()`访问为每个工作进程设置的 PyTorch 种子，并在数据加载之前用它来为其他库设置种子。 ## 内存固定 -当从固定（页锁定）内存发起主机到GPU的复制时，复制速度要快得多。有关何时以及如何通常使用固定内存，请参阅[使用固定内存缓冲区](notes/cuda.html#cuda-memory-pinning)以获取更多详细信息。 +当从固定（页锁定）内存发起主机到 GPU 的复制时，复制速度要快得多。有关何时以及如何通常使用固定内存，请参阅使用固定内存缓冲区以获取更多详细信息。 -对于数据加载，将`pin_memory=True`传递给[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")将自动将获取的数据张量放在固定内存中，从而实现更快的数据传输到支持CUDA的GPU。 +对于数据加载，将`pin_memory=True`传递给`DataLoader`将自动将获取的数据张量放在固定内存中，从而实现更快的数据传输到支持 CUDA 的 GPU。 默认的内存固定逻辑仅识别张量和包含张量的映射和可迭代对象。默认情况下，如果固定逻辑看到一个批次是自定义类型（如果您有一个返回自定义批次类型的`collate_fn`，或者如果批次的每个元素是自定义类型），或者如果批次（或这些元素）是自定义类型，则固定逻辑将不会识别它们，并且将返回该批次（或这些元素）而不固定内存。要为自定义批次或数据类型启用内存固定，请在自定义类型上定义一个`pin_memory()`方法。 @@ -247,9 +247,9 @@ class torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=N 数据加载器结合了数据集和采样器，并提供了对给定数据集的可迭代对象。 -[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")支持单进程或多进程加载的映射样式和可迭代样式数据集，自定义加载顺序以及可选的自动分批（整理）和内存固定。 +`DataLoader`支持单进程或多进程加载的映射样式和可迭代样式数据集，自定义加载顺序以及可选的自动分批（整理）和内存固定。 -请查看[`torch.utils.data`](#module-torch.utils.data "torch.utils.data")文档页面以获取更多详细信息。 +请查看`torch.utils.data`文档页面以获取更多详细信息。 参数 @@ -261,25 +261,25 @@ class torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=N + **sampler**（*Sampler*或*Iterable*，可选）- 定义从数据集中抽取样本的策略。可以是任何实现了`__len__`的`Iterable`。如果指定了，必须不指定`shuffle`。 -+ **batch_sampler**（*Sampler*或*Iterable*，可选）- 类似于[`sampler`](utils.html#module-torch.utils.data.sampler "torch.utils.data.sampler")，但一次返回一批索引。与`batch_size`、`shuffle`、[`sampler`](utils.html#module-torch.utils.data.sampler "torch.utils.data.sampler")和`drop_last`互斥。 ++ **batch_sampler**（*Sampler*或*Iterable*，可选）- 类似于`sampler`，但一次返回一批索引。与`batch_size`、`shuffle`、`sampler`和`drop_last`互斥。 + **num_workers**（*int*，可选）- 用于数据加载的子进程数。`0`表示数据将在主进程中加载。（默认值：`0`） -+ **collate_fn**（可调用，可选）- 将样本列表合并为一个Tensor(s)的小批量。在从映射样式数据集进行批量加载时使用。 ++ **collate_fn**（可调用，可选）- 将样本列表合并为一个 Tensor(s)的小批量。在从映射样式数据集进行批量加载时使用。 -+ **pin_memory**（*bool*，可选）- 如果为`True`，数据加载器将在返回之前将张量复制到设备/CUDA固定内存中。如果您的数据元素是自定义类型，或者您的`collate_fn`返回一个自定义类型的批次，请参见下面的示例。 ++ **pin_memory**（*bool*，可选）- 如果为`True`，数据加载器将在返回之前将张量复制到设备/CUDA 固定内存中。如果您的数据元素是自定义类型，或者您的`collate_fn`返回一个自定义类型的批次，请参见下面的示例。 + **drop_last**（*bool*，可选）- 设置为`True`以丢弃最后一个不完整的批次，如果数据集大小不是批次大小的整数倍。如果为`False`且数据集大小不是批次大小的整数倍，则最后一个批次将更小。（默认值：`False`） + **timeout**（数值，可选）- 如果为正数，则为从工作进程收集一批数据的超时值。应始终为非负数。（默认值：`0`） -+ **worker_init_fn**（可调用，可选）- 如果不为`None`，则将在每个工作进程上调用此函数，输入为工作进程的工作ID（一个在`[0，num_workers - 1]`中的整数），在种子和数据加载之后。 （默认值：`None`） ++ **worker_init_fn**（可调用，可选）- 如果不为`None`，则将在每个工作进程上调用此函数，输入为工作进程的工作 ID（一个在`[0，num_workers - 1]`中的整数），在种子和数据加载之后。 （默认值：`None`） + **multiprocessing_context**（*str*或*multiprocessing.context.BaseContext*，可选）- 如果为`None`，则将使用您操作系统的默认[多进程上下文](https://docs.python.org/3/library/multiprocessing.html#contexts-and-start-methods)。（默认值：`None`） -+ **generator**（*torch.Generator*，可选）- 如果不为`None`，则RandomSampler将使用此RNG生成随机索引，多进程将生成工作进程的`base_seed`。（默认值：`None`） ++ **generator**（*torch.Generator*，可选）- 如果不为`None`，则 RandomSampler 将使用此 RNG 生成随机索引，多进程将生成工作进程的`base_seed`。（默认值：`None`） -+ **prefetch_factor**（*int*，可选，关键字参数）- 每个工作进程提前加载的批次数。`2`表示所有工作进程中将预取2*num_workers批次。 （默认值取决于num_workers的设置值。如果num_workers=0，默认值为`None`。否则，如果`num_workers > 0`，默认值为`2`）。 ++ **prefetch_factor**（*int*，可选，关键字参数）- 每个工作进程提前加载的批次数。`2`表示所有工作进程中将预取 2*num_workers 批次。 （默认值取决于 num_workers 的设置值。如果 num_workers=0，默认值为`None`。否则，如果`num_workers > 0`，默认值为`2`）。 + **persistent_workers**（*bool*，可选）- 如果为`True`，数据加载器将在数据集被消耗一次后不关闭工作进程。这允许保持工作进程的数据集实例处于活动状态。（默认值：`False`） @@ -287,31 +287,31 @@ class torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=N 警告 -如果使用`spawn`启动方法，则`worker_init_fn`不能是一个不可序列化的对象，例如lambda函数。有关PyTorch中多进程的更多详细信息，请参见[多进程最佳实践](notes/multiprocessing.html#multiprocessing-best-practices)。 +如果使用`spawn`启动方法，则`worker_init_fn`不能是一个不可序列化的对象，例如 lambda 函数。有关 PyTorch 中多进程的更多详细信息，请参见多进程最佳实践。 警告 -`len(dataloader)`的启发式方法基于使用的采样器的长度。当[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")是一个[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")时，它将根据`len(dataset) / batch_size`估算一个值，根据`drop_last`进行适当的四舍五入，而不考虑多进程加载配置。这代表PyTorch可以做出的最佳猜测，因为PyTorch信任用户[`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")代码正确处理多进程加载以避免重复数据。 +`len(dataloader)`的启发式方法基于使用的采样器的长度。当`dataset`是一个`IterableDataset`时，它将根据`len(dataset) / batch_size`估算一个值，根据`drop_last`进行适当的四舍五入，而不考虑多进程加载配置。这代表 PyTorch 可以做出的最佳猜测，因为 PyTorch 信任用户`dataset`代码正确处理多进程加载以避免重复数据。 -然而，如果分片导致多个工作进程具有不完整的最后批次，这个估计仍然可能不准确，因为（1）一个否则完整的批次可以被分成多个批次，（2）当设置`drop_last`时，可以丢弃超过一个批次的样本。不幸的是，PyTorch通常无法检测到这种情况。 +然而，如果分片导致多个工作进程具有不完整的最后批次，这个估计仍然可能不准确，因为（1）一个否则完整的批次可以被分成多个批次，（2）当设置`drop_last`时，可以丢弃超过一个批次的样本。不幸的是，PyTorch 通常无法检测到这种情况。 -有关这两种数据集类型以及[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")如何与[多进程数据加载](#multi-process-data-loading)交互的更多详细信息，请参见[数据集类型](#dataset-types)。 +有关这两种数据集类型以及`IterableDataset`如何与多进程数据加载交互的更多详细信息，请参见数据集类型。 警告 -有关随机种子相关问题，请参见[可重现性](notes/randomness.html#reproducibility)，以及[我的数据加载器工作进程返回相同的随机数](notes/faq.html#dataloader-workers-random-seed)，以及[多进程数据加载中的随机性](#data-loading-randomness)注释。 +有关随机种子相关问题，请参见可重现性，以及我的数据加载器工作进程返回相同的随机数，以及多进程数据加载中的随机性注释。 ```py class torch.utils.data.Dataset(*args, **kwds)¶ ``` -表示[`Dataset`](#torch.utils.data.Dataset "torch.utils.data.Dataset")的抽象类。 +表示`Dataset`的抽象类。 -所有表示从键到数据样本的映射的数据集都应该是它的子类。所有子类都应该重写`__getitem__()`，支持为给定键获取数据样本。子类还可以选择重写`__len__()`，许多[`Sampler`](#torch.utils.data.Sampler "torch.utils.data.Sampler")实现和[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的默认选项期望返回数据集的大小。子类还可以选择实现`__getitems__()`，以加快批量样本加载。此方法接受批次样本的索引列表，并返回样本列表。 +所有表示从键到数据样本的映射的数据集都应该是它的子类。所有子类都应该重写`__getitem__()`，支持为给定键获取数据样本。子类还可以选择重写`__len__()`，许多`Sampler`实现和`DataLoader`的默认选项期望返回数据集的大小。子类还可以选择实现`__getitems__()`，以加快批量样本加载。此方法接受批次样本的索引列表，并返回样本列表。 注意 -[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader") 默认构造一个产生整数索引的索引采样器。要使其与具有非整数索引/键的映射样式数据集一起工作，必须提供自定义采样器。 +`DataLoader` 默认构造一个产生整数索引的索引采样器。要使其与具有非整数索引/键的映射样式数据集一起工作，必须提供自定义采样器。 ```py class torch.utils.data.IterableDataset(*args, **kwds)¶ @@ -323,9 +323,9 @@ class torch.utils.data.IterableDataset(*args, **kwds)¶ 所有子类都应该重写`__iter__()`，它将返回此数据集中样本的迭代器。 -当子类与[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")一起使用时，数据集中的每个项目将从[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")迭代器中产生。当`num_workers > 0`时，每个工作进程将有数据集对象的不同副本，因此通常希望配置每个副本以避免从工作进程返回重复数据。当在工作进程中调用时，[`get_worker_info()`](#torch.utils.data.get_worker_info "torch.utils.data.get_worker_info")返回有关工作进程的信息。它可以在数据集的`__iter__()`方法或[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的`worker_init_fn`选项中使用，以修改每个副本的行为。 +当子类与`DataLoader`一起使用时，数据集中的每个项目将从`DataLoader`迭代器中产生。当`num_workers > 0`时，每个工作进程将有数据集对象的不同副本，因此通常希望配置每个副本以避免从工作进程返回重复数据。当在工作进程中调用时，`get_worker_info()`返回有关工作进程的信息。它可以在数据集的`__iter__()`方法或`DataLoader`的`worker_init_fn`选项中使用，以修改每个副本的行为。 -示例1：在`__iter__()`中将工作负载分配给所有工作进程： +示例 1：在`__iter__()`中将工作负载分配给所有工作进程： ```py >>> class MyIterableDataset(torch.utils.data.IterableDataset): @@ -365,7 +365,7 @@ class torch.utils.data.IterableDataset(*args, **kwds)¶ [tensor([3]), tensor([5]), tensor([4]), tensor([6])] ``` -示例2：使用`worker_init_fn`在所有工作进程之间分配工作负载： +示例 2：使用`worker_init_fn`在所有工作进程之间分配工作负载： ```py >>> class MyIterableDataset(torch.utils.data.IterableDataset): @@ -422,7 +422,7 @@ class torch.utils.data.TensorDataset(*tensors)¶ 参数 -***tensors** ([*Tensor*](tensors.html#torch.Tensor "torch.Tensor")) - 具有相同第一维度大小的张量。 +***tensors** (*Tensor*) - 具有相同第一维度大小的张量。 ```py class torch.utils.data.StackDataset(*args, **kwargs)¶ @@ -445,9 +445,9 @@ class torch.utils.data.StackDataset(*args, **kwargs)¶ 参数 -+ ***args** ([*Dataset*](#torch.utils.data.Dataset "torch.utils.data.Dataset")) - 作为元组返回的堆叠数据集。 ++ ***args** (*Dataset*) - 作为元组返回的堆叠数据集。 -+ ****kwargs** ([*Dataset*](#torch.utils.data.Dataset "torch.utils.data.Dataset")) - 作为字典返回的堆叠数据集。 ++ ****kwargs** (*Dataset*) - 作为字典返回的堆叠数据集。 ```py class torch.utils.data.ConcatDataset(datasets)¶ @@ -465,13 +465,13 @@ class torch.utils.data.ConcatDataset(datasets)¶ class torch.utils.data.ChainDataset(datasets)¶ ``` -用于链接多个[`IterableDataset`](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")的数据集。 +用于链接多个`IterableDataset`的数据集。 这个类对于组装不同的现有数据集流很有用。链式操作是即时进行的，因此使用这个类连接大规模数据集将是高效的。 参数 -**datasets** (*可迭代的* [*IterableDataset*](#torch.utils.data.IterableDataset "torch.utils.data.IterableDataset")) - 要链接在一起的数据集 +**datasets** (*可迭代的* *IterableDataset*) - 要链接在一起的数据集 ```py class torch.utils.data.Subset(dataset, indices)¶ @@ -481,7 +481,7 @@ class torch.utils.data.Subset(dataset, indices)¶ 参数 -+ **dataset** ([*Dataset*](#torch.utils.data.Dataset "torch.utils.data.Dataset")) - 整个数据集 ++ **dataset** (*Dataset*) - 整个数据集 + **indices** (*序列*) - 选择子集的整个集合中的索引 @@ -491,7 +491,7 @@ torch.utils.data._utils.collate.collate(batch, *, collate_fn_map=None)¶ 处理每个批次中元素的集合类型的一般整理函数。 -该函数还打开函数注册表以处理特定元素类型。default_collate_fn_map为张量、numpy数组、数字和字符串提供默认整理函数。 +该函数还打开函数注册表以处理特定元素类型。default_collate_fn_map 为张量、numpy 数组、数字和字符串提供默认整理函数。 参数 @@ -522,17 +522,17 @@ torch.utils.data.default_collate(batch)¶ 接收一批数据并将批次内的元素放入一个具有额外外部维度（批量大小）的张量中。 -确切的输出类型可以是 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")、[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 序列、[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") 集合，或保持不变，具体取决于输入类型。当在 [`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader") 中定义了 batch_size 或 batch_sampler 时，这将用作默认的聚合函数。 +确切的输出类型可以是 `torch.Tensor`、`torch.Tensor` 序列、`torch.Tensor` 集合，或保持不变，具体取决于输入类型。当在 `DataLoader` 中定义了 batch_size 或 batch_sampler 时，这将用作默认的聚合函数。 这是一般输入类型（基于批次内元素类型）到输出类型的映射： -> + [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") -> [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")（带有额外的外部维度批量大小） +> + `torch.Tensor` -> `torch.Tensor`（带有额外的外部维度批量大小） > + -> + NumPy 数组 -> [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") +> + NumPy 数组 -> `torch.Tensor` > + -> + 浮点数 -> [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") +> + 浮点数 -> `torch.Tensor` > + -> + 整数 -> [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor") +> + 整数 -> `torch.Tensor` > + > + 字符串 -> 字符串（保持不变） > + @@ -589,11 +589,11 @@ Point(x=tensor([0, 1]), y=tensor([0, 1])) torch.utils.data.default_convert(data)¶ ``` -将每个 NumPy 数组元素转换为 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")。 +将每个 NumPy 数组元素转换为 `torch.Tensor`。 -如果输入是序列、集合或映射，则尝试将其中的每个元素转换为 [`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")。如果输入不是 NumPy 数组，则保持不变。当 [`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader") 中未定义 batch_sampler 和 batch_size 时，这将用作默认的聚合函数。 +如果输入是序列、集合或映射，则尝试将其中的每个元素转换为 `torch.Tensor`。如果输入不是 NumPy 数组，则保持不变。当 `DataLoader` 中未定义 batch_sampler 和 batch_size 时，这将用作默认的聚合函数。 -一般的输入类型到输出类型的映射类似于 [`default_collate()`](#torch.utils.data.default_collate "torch.utils.data.default_collate")。有关更多详细信息，请参阅那里的描述。 +一般的输入类型到输出类型的映射类似于 `default_collate()`。有关更多详细信息，请参阅那里的描述。 参数 @@ -623,7 +623,7 @@ Point(x=tensor(0), y=tensor(0)) torch.utils.data.get_worker_info()¶ ``` -返回有关当前 [`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader") 迭代器工作进程的信息。 +返回有关当前 `DataLoader` 迭代器工作进程的信息。 在工作进程中调用时，此函数返回一个对象，保证具有以下属性： @@ -631,19 +631,19 @@ torch.utils.data.get_worker_info()¶ + `num_workers`: 总工作人员数量。 -+ `seed`: 为当前工作进程设置的随机种子。此值由主进程 RNG 和工作进程 ID 确定。有关更多详细信息，请参阅 [`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader") 的文档。 ++ `seed`: 为当前工作进程设置的随机种子。此值由主进程 RNG 和工作进程 ID 确定。有关更多详细信息，请参阅 `DataLoader` 的文档。 -+ [`dataset`](utils.html#module-torch.utils.data.dataset "torch.utils.data.dataset")：**此**进程中数据集对象的副本。请注意，这将与主进程中的对象不同。 ++ `dataset`：**此**进程中数据集对象的副本。请注意，这将与主进程中的对象不同。 在主进程中调用时，返回`None`。 注意 -当在传递给[`DataLoader`](#torch.utils.data.DataLoader "torch.utils.data.DataLoader")的`worker_init_fn`中使用时，此方法可用于设置每个工作进程的不同设置，例如，使用`worker_id`来配置`dataset`对象，以仅读取分片数据集的特定部分，或使用`seed`来为数据集代码中使用的其他库设置种子。 +当在传递给`DataLoader`的`worker_init_fn`中使用时，此方法可用于设置每个工作进程的不同设置，例如，使用`worker_id`来配置`dataset`对象，以仅读取分片数据集的特定部分，或使用`seed`来为数据集代码中使用的其他库设置种子。 返回类型 -[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")[*WorkerInfo*] +[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")[*WorkerInfo*] ```py torch.utils.data.random_split(dataset, lengths, generator=)¶ @@ -651,7 +651,7 @@ torch.utils.data.random_split(dataset, lengths, generator= [https://pytorch.org/docs/stable/deterministic.html](https://pytorch.org/docs/stable/deterministic.html) +> [`pytorch.org/docs/stable/deterministic.html`](https://pytorch.org/docs/stable/deterministic.html) ```py torch.utils.deterministic.fill_uninitialized_memory¶ ``` -一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")，如果为True，则在将[`torch.use_deterministic_algorithms()`](generated/torch.use_deterministic_algorithms.html#torch.use_deterministic_algorithms "torch.use_deterministic_algorithms")设置为`True`时，未初始化的内存将被填充为已知值。浮点数和复数值设置为NaN，整数值设置为最大值。 +一个[`bool`](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")，如果为 True，则在将`torch.use_deterministic_algorithms()`设置为`True`时，未初始化的内存将被填充为已知值。浮点数和复数值设置为 NaN，整数值设置为最大值。 默认值：`True` @@ -14,12 +14,12 @@ torch.utils.deterministic.fill_uninitialized_memory¶ 当此设置打开时，以下操作将填充未初始化的内存： -> + [`torch.Tensor.resize_()`](generated/torch.Tensor.resize_.html#torch.Tensor.resize_ "torch.Tensor.resize_") 当使用未量化的张量调用时 +> + `torch.Tensor.resize_()` 当使用未量化的张量调用时 > + -> + [`torch.empty()`](generated/torch.empty.html#torch.empty "torch.empty") +> + `torch.empty()` > + -> + [`torch.empty_strided()`](generated/torch.empty_strided.html#torch.empty_strided "torch.empty_strided") +> + `torch.empty_strided()` > + > + `torch.empty_permuted()` > + -> + [`torch.empty_like()`](generated/torch.empty_like.html#torch.empty_like "torch.empty_like") +> + `torch.empty_like()` diff --git a/totrans/doc22_089.md b/totrans/doc22_089.md index 8d8f91f0..eb02a460 100644 --- a/totrans/doc22_089.md +++ b/totrans/doc22_089.md @@ -1,3 +1,3 @@ # JIT Utils - torch.utils.jit -> 原文：[https://pytorch.org/docs/stable/jit_utils.html](https://pytorch.org/docs/stable/jit_utils.html) +> 原文：[`pytorch.org/docs/stable/jit_utils.html`](https://pytorch.org/docs/stable/jit_utils.html) diff --git a/totrans/doc22_090.md b/totrans/doc22_090.md index be03e5eb..46374f47 100644 --- a/totrans/doc22_090.md +++ b/totrans/doc22_090.md @@ -1,6 +1,6 @@ # torch.utils.dlpack -> 原文：[https://pytorch.org/docs/stable/dlpack.html](https://pytorch.org/docs/stable/dlpack.html) +> 原文：[`pytorch.org/docs/stable/dlpack.html`](https://pytorch.org/docs/stable/dlpack.html) ```py torch.utils.dlpack.from_dlpack(ext_tensor) → Tensor¶ @@ -8,19 +8,19 @@ torch.utils.dlpack.from_dlpack(ext_tensor) → Tensor¶ 将来自外部库的张量转换为`torch.Tensor`。 -返回的PyTorch张量将与输入张量共享内存（可能来自另一个库）。请注意，因此就地操作也会影响输入张量的数据。这可能会导致意外问题（例如，其他库可能具有只读标志或不可变数据结构），因此用户只有在确定这样做没问题时才应该这样做。 +返回的 PyTorch 张量将与输入张量共享内存（可能来自另一个库）。请注意，因此就地操作也会影响输入张量的数据。这可能会导致意外问题（例如，其他库可能具有只读标志或不可变数据结构），因此用户只有在确定这样做没问题时才应该这样做。 参数 -**ext_tensor**（具有`__dlpack__`属性或DLPack胶囊的对象） - +**ext_tensor**（具有`__dlpack__`属性或 DLPack 胶囊的对象） - -要转换的张量或DLPack胶囊。 +要转换的张量或 DLPack 胶囊。 -如果`ext_tensor`是张量（或ndarray）对象，则必须支持`__dlpack__`协议（即，具有`ext_tensor.__dlpack__`方法）。否则，`ext_tensor`可能是一个DLPack胶囊，这是一个不透明的`PyCapsule`实例，通常由`to_dlpack`函数或方法生成。 +如果`ext_tensor`是张量（或 ndarray）对象，则必须支持`__dlpack__`协议（即，具有`ext_tensor.__dlpack__`方法）。否则，`ext_tensor`可能是一个 DLPack 胶囊，这是一个不透明的`PyCapsule`实例，通常由`to_dlpack`函数或方法生成。 返回类型 -[*Tensor*](tensors.html#torch.Tensor "torch.Tensor") +*Tensor* 示例： @@ -56,11 +56,11 @@ tensor([-9, -1, 2, 3]) torch.utils.dlpack.to_dlpack(tensor) → PyCapsule¶ ``` -返回表示张量的不透明对象（“DLPack胶囊”）。 +返回表示张量的不透明对象（“DLPack 胶囊”）。 注意 -`to_dlpack`是一个传统的DLPack接口。它返回的胶囊在Python中除了用作`from_dlpack`的输入之外不能用于任何其他用途。DLPack的更符合习惯的用法是直接在张量对象上调用`from_dlpack` - 当该对象具有`__dlpack__`方法时，这将起作用，PyTorch和大多数其他库现在确实都有这个方法。 +`to_dlpack`是一个传统的 DLPack 接口。它返回的胶囊在 Python 中除了用作`from_dlpack`的输入之外不能用于任何其他用途。DLPack 的更符合习惯的用法是直接在张量对象上调用`from_dlpack` - 当该对象具有`__dlpack__`方法时，这将起作用，PyTorch 和大多数其他库现在确实都有这个方法。 警告 @@ -70,4 +70,4 @@ torch.utils.dlpack.to_dlpack(tensor) → PyCapsule¶ **tensor** - 要导出的张量 -DLPack胶囊共享张量的内存。 +DLPack 胶囊共享张量的内存。 diff --git a/totrans/doc22_091.md b/totrans/doc22_091.md index d40b67fa..86cda09b 100644 --- a/totrans/doc22_091.md +++ b/totrans/doc22_091.md @@ -1,6 +1,6 @@ # torch.utils.mobile_optimizer -> [https://pytorch.org/docs/stable/mobile_optimizer.html](https://pytorch.org/docs/stable/mobile_optimizer.html) +> [`pytorch.org/docs/stable/mobile_optimizer.html`](https://pytorch.org/docs/stable/mobile_optimizer.html) 警告 @@ -36,17 +36,17 @@ torch.utils.mobile_optimizer.optimize_for_mobile(script_module, optimization_blo 参数 -+ **script_module**（[*ScriptModule*](generated/torch.jit.ScriptModule.html#torch.jit.ScriptModule "torch.jit._script.ScriptModule")） - 一个具有ScriptModule类型的torch脚本模块的实例。 ++ **script_module**（*ScriptModule*） - 一个具有 ScriptModule 类型的 torch 脚本模块的实例。 -+ **optimization_blocklist**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*集合*](https://docs.python.org/3/library/typing.html#typing.Set "(在Python v3.12中)")*[**_MobileOptimizerType**]**]*) - 一个具有MobileOptimizerType类型的集合。当未传递集合时，优化方法将运行所有优化器pass；否则，优化器方法将运行未包含在optimization_blocklist中的优化pass。 ++ **optimization_blocklist**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*集合*](https://docs.python.org/3/library/typing.html#typing.Set "(在 Python v3.12 中)")*[**_MobileOptimizerType**]**]*) - 一个具有 MobileOptimizerType 类型的集合。当未传递集合时，优化方法将运行所有优化器 pass；否则，优化器方法将运行未包含在 optimization_blocklist 中的优化 pass。 -+ **preserved_methods**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")*]*) - 在调用freeze_module pass时需要保留的方法列表 ++ **preserved_methods**（[*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*列表*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")*]*) - 在调用 freeze_module pass 时需要保留的方法列表 -+ **backend**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 用于运行结果模型的设备类型（‘CPU’（默认），‘Vulkan’或‘Metal’）。 ++ **backend**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 用于运行结果模型的设备类型（‘CPU’（默认），‘Vulkan’或‘Metal’）。 返回 -一个新的优化过的torch脚本模块 +一个新的优化过的 torch 脚本模块 返回类型 diff --git a/totrans/doc22_092.md b/totrans/doc22_092.md index 7266aac7..b3da6808 100644 --- a/totrans/doc22_092.md +++ b/totrans/doc22_092.md @@ -1,34 +1,34 @@ # torch.utils.model_zoo -> [https://pytorch.org/docs/stable/model_zoo.html](https://pytorch.org/docs/stable/model_zoo.html) +> [`pytorch.org/docs/stable/model_zoo.html`](https://pytorch.org/docs/stable/model_zoo.html) -移至torch.hub。 +移至 torch.hub。 ```py torch.utils.model_zoo.load_url(url, model_dir=None, map_location=None, progress=True, check_hash=False, file_name=None, weights_only=False)¶ ``` -加载给定URL处的Torch序列化对象。 +加载给定 URL 处的 Torch 序列化对象。 -如果下载的文件是zip文件，它将自动解压缩。 +如果下载的文件是 zip 文件，它将自动解压缩。 -如果对象已经存在于model_dir中，则将对其进行反序列化并返回。`model_dir`的默认值是`/checkpoints`，其中`hub_dir`是由[`get_dir()`](hub.html#torch.hub.get_dir "torch.hub.get_dir")返回的目录。 +如果对象已经存在于 model_dir 中，则将对其进行反序列化并返回。`model_dir`的默认值是`/checkpoints`，其中`hub_dir`是由`get_dir()`返回的目录。 参数 -+ **url**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")） - 要下载的对象的URL ++ **url**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")） - 要下载的对象的 URL + **model_dir**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*，*可选） - 保存对象的目录 -+ **map_location**（可选） - 一个函数或指定如何重新映射存储位置的字典（参见torch.load） ++ **map_location**（可选） - 一个函数或指定如何重新映射存储位置的字典（参见 torch.load） -+ **progress**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*，*可选） - 是否在stderr上显示进度条。默认值：True ++ **progress**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*，*可选） - 是否在 stderr 上显示进度条。默认值：True -+ **check_hash**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*，*可选） - 如果为True，则URL的文件名部分应遵循命名约定`filename-.ext`，其中``是文件内容的SHA256哈希的前八位或更多位数字。哈希用于确保唯一名称并验证文件的内容。默认值：False ++ **check_hash**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*，*可选） - 如果为 True，则 URL 的文件名部分应遵循命名约定`filename-.ext`，其中``是文件内容的 SHA256 哈希的前八位或更多位数字。哈希用于确保唯一名称并验证文件的内容。默认值：False + **file_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(in Python v3.12)")*，*可选） - 下载文件的名称。如果未设置，则将使用`url`中的文件名。 -+ **weights_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*，*可选） - 如果为True，则仅加载权重，不加载复杂的pickled对象。建议用于不受信任的来源。有关更多详细信息，请参阅[`load()`](generated/torch.load.html#torch.load "torch.load")。 ++ **weights_only**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")*，*可选） - 如果为 True，则仅加载权重，不加载复杂的 pickled 对象。建议用于不受信任的来源。有关更多详细信息，请参阅`load()`。 返回类型 diff --git a/totrans/doc22_093.md b/totrans/doc22_093.md index d56fbec0..5f418bcd 100644 --- a/totrans/doc22_093.md +++ b/totrans/doc22_093.md @@ -1,12 +1,12 @@ # torch.utils.tensorboard -> 原文：[https://pytorch.org/docs/stable/tensorboard.html](https://pytorch.org/docs/stable/tensorboard.html) +> 原文：[`pytorch.org/docs/stable/tensorboard.html`](https://pytorch.org/docs/stable/tensorboard.html) -在继续之前，可以在[https://www.tensorflow.org/tensorboard/](https://www.tensorflow.org/tensorboard/)找到有关TensorBoard的更多详细信息 +在继续之前，可以在[`www.tensorflow.org/tensorboard/`](https://www.tensorflow.org/tensorboard/)找到有关 TensorBoard 的更多详细信息 -安装了TensorBoard后，这些实用程序可以让您将PyTorch模型和指标记录到目录中，以便在TensorBoard UI中进行可视化。标量、图像、直方图、图形和嵌入可视化都支持PyTorch模型和张量，以及Caffe2网络和blob。 +安装了 TensorBoard 后，这些实用程序可以让您将 PyTorch 模型和指标记录到目录中，以便在 TensorBoard UI 中进行可视化。标量、图像、直方图、图形和嵌入可视化都支持 PyTorch 模型和张量，以及 Caffe2 网络和 blob。 -SummaryWriter类是您记录数据以供TensorBoard消费和可视化的主要入口。例如： +SummaryWriter 类是您记录数据以供 TensorBoard 消费和可视化的主要入口。例如： ```py import torch @@ -31,14 +31,14 @@ writer.add_graph(model, images) writer.close() ``` -然后可以使用TensorBoard进行可视化，应该可以通过以下方式进行安装和运行： +然后可以使用 TensorBoard 进行可视化，应该可以通过以下方式进行安装和运行： ```py pip install tensorboard tensorboard --logdir=runs ``` -可以为一个实验记录大量信息。为了避免使UI混乱并获得更好的结果聚类，我们可以通过层次命名来对图进行分组。例如，“Loss/train”和“Loss/test”将被分组在一起，而“Accuracy/train”和“Accuracy/test”将在TensorBoard界面中分别分组。 +可以为一个实验记录大量信息。为了避免使 UI 混乱并获得更好的结果聚类，我们可以通过层次命名来对图进行分组。例如，“Loss/train”和“Loss/test”将被分组在一起，而“Accuracy/train”和“Accuracy/test”将在 TensorBoard 界面中分别分组。 ```py from torch.utils.tensorboard import SummaryWriter @@ -55,35 +55,35 @@ for n_iter in range(100): 预期结果: -[![_images/hier_tags.png](../Images/58f4f40256d7b3e208ac29880d7a1053.png)](_images/hier_tags.png) +![_images/hier_tags.png](img/hier_tags.png) ```py class torch.utils.tensorboard.writer.SummaryWriter(log_dir=None, comment='', purge_step=None, max_queue=10, flush_secs=120, filename_suffix='')¶ ``` -直接将条目写入log_dir中的事件文件，以供TensorBoard消费。 +直接将条目写入 log_dir 中的事件文件，以供 TensorBoard 消费。 -SummaryWriter类提供了一个高级API，用于在给定目录中创建事件文件并向其中添加摘要和事件。该类异步更新文件内容。这允许训练程序从训练循环中直接调用方法将数据添加到文件中，而不会减慢训练速度。 +SummaryWriter 类提供了一个高级 API，用于在给定目录中创建事件文件并向其中添加摘要和事件。该类异步更新文件内容。这允许训练程序从训练循环中直接调用方法将数据添加到文件中，而不会减慢训练速度。 ```py __init__(log_dir=None, comment='', purge_step=None, max_queue=10, flush_secs=120, filename_suffix='')¶ ``` -创建一个SummaryWriter，将事件和摘要写入事件文件。 +创建一个 SummaryWriter，将事件和摘要写入事件文件。 参数 -+ **log_dir**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 保存目录位置。默认为runs/**CURRENT_DATETIME_HOSTNAME**，每次运行后都会更改。使用分层文件夹结构可以轻松比较不同运行之间的差异。例如，对于每个新实验，传入‘runs/exp1’，‘runs/exp2’等，以便进行比较。 ++ **log_dir**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 保存目录位置。默认为 runs/**CURRENT_DATETIME_HOSTNAME**，每次运行后都会更改。使用分层文件夹结构可以轻松比较不同运行之间的差异。例如，对于每个新实验，传入‘runs/exp1’，‘runs/exp2’等，以便进行比较。 -+ **comment**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 附加到默认`log_dir`的注释log_dir后缀。如果分配了`log_dir`，则此参数无效。 ++ **comment**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 附加到默认`log_dir`的注释 log_dir 后缀。如果分配了`log_dir`，则此参数无效。 -+ **purge_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 当日志在步骤$T+X$T+X处崩溃并在步骤$T$T处重新启动时，任何全局步骤大于或等于$T$T的事件将被清除并从TensorBoard中隐藏。请注意，崩溃和恢复的实验应该具有相同的`log_dir`。 ++ **purge_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 当日志在步骤$T+X$T+X 处崩溃并在步骤$T$T 处重新启动时，任何全局步骤大于或等于$T$T 的事件将被清除并从 TensorBoard 中隐藏。请注意，崩溃和恢复的实验应该具有相同的`log_dir`。 -+ **max_queue**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 在一个‘add’调用强制刷新到磁盘之前，待处理事件和摘要队列的大小。默认为十个项目。 ++ **max_queue**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 在一个‘add’调用强制刷新到磁盘之前，待处理事件和摘要队列的大小。默认为十个项目。 -+ **flush_secs**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 多久刷新一次待处理事件和摘要到磁盘。默认为每两分钟一次。 ++ **flush_secs**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 多久刷新一次待处理事件和摘要到磁盘。默认为每两分钟一次。 -+ **filename_suffix**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 添加到log_dir目录中所有事件文件的后缀。有关文件名构造的更多详细信息，请参阅tensorboard.summary.writer.event_file_writer.EventFileWriter。 ++ **filename_suffix**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 添加到 log_dir 目录中所有事件文件的后缀。有关文件名构造的更多详细信息，请参阅 tensorboard.summary.writer.event_file_writer.EventFileWriter。 示例： @@ -111,15 +111,15 @@ add_scalar(tag, scalar_value, global_step=None, walltime=None, new_style=False, 参数 -+ **标签**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 数据标识符 ++ **标签**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 数据标识符 -+ **scalar_value**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* *string/blobname*） - 要保存的值 ++ **scalar_value**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* *string/blobname*） - 要保存的值 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 要记录的全局步骤值 -+ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")） - 可选，用秒数替换默认的walltime（time.time()）事件后的纪元 ++ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")） - 可选，用秒数替换默认的 walltime（time.time()）事件后的纪元 -+ **new_style**（*布尔值*）- 是否使用新样式（张量字段）或旧样式（simple_value字段）。新样式可能导致更快的数据加载。 ++ **new_style**（*布尔值*）- 是否使用新样式（张量字段）或旧样式（simple_value 字段）。新样式可能导致更快的数据加载。 示例： @@ -134,7 +134,7 @@ writer.close() 预期结果： -[![_images/add_scalar.png](../Images/4141e5882a8a2676fa22ef39cd078e8a.png)](_images/add_scalar.png) +![_images/add_scalar.png](img/add_scalar.png) ```py add_scalars(main_tag, tag_scalar_dict, global_step=None, walltime=None)¶ @@ -144,13 +144,13 @@ add_scalars(main_tag, tag_scalar_dict, global_step=None, walltime=None)¶ 参数 -+ **main_tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 标签的父名称 ++ **main_tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 标签的父名称 -+ **tag_scalar_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12中)")）- 存储标签和相应值的键值对 ++ **tag_scalar_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")）- 存储标签和相应值的键值对 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- 要记录的全局步骤值 -+ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 可选，覆盖默认的事件时刻（time.time()）从纪元后的秒数 ++ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 可选，覆盖默认的事件时刻（time.time()）从纪元后的秒数 示例： @@ -169,7 +169,7 @@ writer.close() 预期结果： -[![_images/add_scalars.png](../Images/815894710cb8be2fb3e45b4dbe87c8a3.png)](_images/add_scalars.png) +![_images/add_scalars.png](img/add_scalars.png) ```py add_histogram(tag, values, global_step=None, bins='tensorflow', walltime=None, max_bins=None)¶ @@ -179,15 +179,15 @@ add_histogram(tag, values, global_step=None, bins='tensorflow', walltime=None, m 参数 -+ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 数据标识符 ++ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 数据标识符 -+ **values**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在NumPy v1.26中)")*，或* *string/blobname*）- 构建直方图的值 ++ **values**（*torch.Tensor**，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在 NumPy v1.26 中)")*，或* *string/blobname*）- 构建直方图的值 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- 要记录的全局步骤值 -+ **bins**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 其中之一{‘tensorflow’，’auto’，‘fd’，…}。这决定了如何制作箱子。您可以在此处找到其他选项：[https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html](https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html) ++ **bins**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 其中之一{‘tensorflow’，’auto’，‘fd’，…}。这决定了如何制作箱子。您可以在此处找到其他选项：[`docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.histogram.html) -+ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 可选，覆盖默认的事件时刻（time.time()）从纪元后的秒数 ++ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 可选，覆盖默认的事件时刻（time.time()）从纪元后的秒数 示例： @@ -203,7 +203,7 @@ writer.close() 预期结果： -[![_images/add_histogram.png](../Images/d61cc1e0bc0bb484d5f77e9d34fd003b.png)](_images/add_histogram.png) +![_images/add_histogram.png](img/add_histogram.png) ```py add_image(tag, img_tensor, global_step=None, walltime=None, dataformats='CHW')¶ @@ -215,19 +215,19 @@ add_image(tag, img_tensor, global_step=None, walltime=None, dataformats='CHW')¶ 参数 -+ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 数据标识符 ++ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 数据标识符 -+ **img_tensor**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在NumPy v1.26中)")*，或* *string/blobname*）- 图像数据 ++ **img_tensor**（*torch.Tensor**，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在 NumPy v1.26 中)")*，或* *string/blobname*）- 图像数据 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")）- 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")）- 要记录的全局步骤值 -+ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")）- 可选，覆盖默认的事件时刻（time.time()）从纪元后的秒数 ++ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")）- 可选，覆盖默认的事件时刻（time.time()）从纪元后的秒数 -+ **dataformats**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 图像数据格式规范，形式为CHW、HWC、HW、WH等 ++ **dataformats**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 图像数据格式规范，形式为 CHW、HWC、HW、WH 等 形状： -img_tensor：默认为$(3, H, W)$(3,H,W)。您可以使用`torchvision.utils.make_grid()`将一批张量转换为3xHxW格式，或调用`add_images`并让我们来做这项工作。张量$(1, H, W)$(1,H,W)、$(H, W)$(H,W)、$(H, W, 3)$(H,W,3)也适合，只要传递相应的`dataformats`参数，例如`CHW`、`HWC`、`HW`。 +img_tensor：默认为$(3, H, W)$(3,H,W)。您可以使用`torchvision.utils.make_grid()`将一批张量转换为 3xHxW 格式，或调用`add_images`并让我们来做这项工作。张量$(1, H, W)$(1,H,W)、$(H, W)$(H,W)、$(H, W, 3)$(H,W,3)也适合，只要传递相应的`dataformats`参数，例如`CHW`、`HWC`、`HW`。 示例： @@ -252,7 +252,7 @@ writer.close() 预期结果： -[![_images/add_image.png](../Images/e1f0afa1c1dc33a13af1b90b678262cf.png)](_images/add_image.png) +![_images/add_image.png](img/add_image.png) ```py add_images(tag, img_tensor, global_step=None, walltime=None, dataformats='NCHW')¶ @@ -264,19 +264,19 @@ add_images(tag, img_tensor, global_step=None, walltime=None, dataformats='NCHW') 参数 -+ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")）- 数据标识符 ++ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")）- 数据标识符 -+ **img_tensor** ([*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")*,* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在NumPy v1.26中)")*, 或* *string/blobname*) – 图像数据 ++ **img_tensor** (*torch.Tensor**,* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在 NumPy v1.26 中)")*, 或* *string/blobname*) – 图像数据 -+ **global_step** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) – 要记录的全局步骤值 ++ **global_step** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – 要记录的全局步骤值 -+ **walltime** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 ++ **walltime** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 -+ **dataformats** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) – 图像数据格式规范，如NCHW、NHWC、CHW、HWC、HW、WH等。 ++ **dataformats** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 图像数据格式规范，如 NCHW、NHWC、CHW、HWC、HW、WH 等。 形状： -img_tensor: 默认为$(N, 3, H, W)$(N,3,H,W)。如果指定了`dataformats`，将接受其他形状。例如NCHW或NHWC。 +img_tensor: 默认为$(N, 3, H, W)$(N,3,H,W)。如果指定了`dataformats`，将接受其他形状。例如 NCHW 或 NHWC。 示例： @@ -296,27 +296,27 @@ writer.close() 预期结果： -[![_images/add_images.png](../Images/e4fd37001efd1121a008df6384d2fc6a.png)](_images/add_images.png) +![_images/add_images.png](img/add_images.png) ```py add_figure(tag, figure, global_step=None, close=True, walltime=None)¶ ``` -将matplotlib图形渲染为图像并将其添加到摘要中。 +将 matplotlib 图形渲染为图像并将其添加到摘要中。 请注意，这需要`matplotlib`包。 参数 -+ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) – 数据标识符 ++ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 数据标识符 -+ **figure** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在Python v3.12中)")*[**Figure**,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(在Python v3.12中)")*[**Figure**]**]*) – 图形或图形列表 ++ **figure** ([*Union*](https://docs.python.org/3/library/typing.html#typing.Union "(在 Python v3.12 中)")*[**Figure**,* [*List*](https://docs.python.org/3/library/typing.html#typing.List "(在 Python v3.12 中)")*[**Figure**]**]*) – 图形或图形列表 -+ **global_step** ([*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")*]*) – 要记录的全局步骤值 ++ **global_step** ([*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")*]*) – 要记录的全局步骤值 -+ **close** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")) – 标志，自动关闭图形 ++ **close** ([*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")) – 标志，自动关闭图形 -+ **walltime** ([*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在Python v3.12中)")*[*[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")*]*) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 ++ **walltime** ([*可选*](https://docs.python.org/3/library/typing.html#typing.Optional "(在 Python v3.12 中)")*[*[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")*]*) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 ```py add_video(tag, vid_tensor, global_step=None, fps=4, walltime=None)¶ @@ -328,19 +328,19 @@ add_video(tag, vid_tensor, global_step=None, fps=4, walltime=None)¶ 参数 -+ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) – 数据标识符 ++ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 数据标识符 -+ **vid_tensor** ([*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 视频数据 ++ **vid_tensor** (*torch.Tensor*) – 视频数据 -+ **global_step** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) – 要记录的全局步骤值 ++ **global_step** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – 要记录的全局步骤值 -+ **fps** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) – 每秒帧数 ++ **fps** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)") *或* [*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – 每秒帧数 -+ **walltime** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 ++ **walltime** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 形状： -vid_tensor: $(N, T, C, H, W)$(N,T,C,H,W)。值应在[0, 255]之间，对于uint8类型为[0, 255]，对于float类型为[0, 1]。 +vid_tensor: $(N, T, C, H, W)$(N,T,C,H,W)。值应在[0, 255]之间，对于 uint8 类型为[0, 255]，对于 float 类型为[0, 1]。 ```py add_audio(tag, snd_tensor, global_step=None, sample_rate=44100, walltime=None)¶ @@ -350,15 +350,15 @@ add_audio(tag, snd_tensor, global_step=None, sample_rate=44100, walltime=None)¶ 参数 -+ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) – 数据标识符 ++ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 数据标识符 -+ **snd_tensor** ([*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")) – 声音数据 ++ **snd_tensor** (*torch.Tensor*) – 声音数据 -+ **global_step** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) – 要记录的全局步骤值 ++ **global_step** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – 要记录的全局步骤值 -+ **sample_rate** ([*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) – Hz中的采样率 ++ **sample_rate** ([*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) – Hz 中的采样率 -+ **walltime** ([*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 ++ **walltime** ([*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) – 可选，覆盖默认的事件发生时的墙上时间（time.time()）秒数 形状： @@ -372,13 +372,13 @@ add_text(tag, text_string, global_step=None, walltime=None)¶ 参数 -+ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) – 数据标识符 ++ **tag** ([*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) – 数据标识符 -+ **text_string**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 要保存的字符串 ++ **text_string**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 要保存的字符串 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 要记录的全局步骤值 -+ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")） - 可选覆盖默认的walltime（time.time()）事件纪元后的秒数 ++ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")） - 可选覆盖默认的 walltime（time.time()）事件纪元后的秒数 示例： @@ -395,13 +395,13 @@ add_graph(model, input_to_model=None, verbose=False, use_strict_trace=True)¶ 参数 -+ **model**（[*torch.nn.Module*](generated/torch.nn.Module.html#torch.nn.Module "torch.nn.Module")） - 要绘制的模型。 ++ **model**（*torch.nn.Module*） - 要绘制的模型。 -+ **input_to_model**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor") *或* [*list*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)") *of* [*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 要馈送的变量或变量元组。 ++ **input_to_model**（*torch.Tensor* *或* [*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)") *of* *torch.Tensor*） - 要馈送的变量或变量元组。 -+ **verbose**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 是否在控制台中打印图形结构。 ++ **verbose**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 是否在控制台中打印图形结构。 -+ **use_strict_trace**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在Python v3.12中)")） - 是否将关键字参数strict传递给torch.jit.trace。当您希望跟踪器记录您的可变容器类型（列表、字典）时，请传递False ++ **use_strict_trace**（[*bool*](https://docs.python.org/3/library/functions.html#bool "(在 Python v3.12 中)")） - 是否将关键字参数 strict 传递给 torch.jit.trace。当您希望跟踪器记录您的可变容器类型（列表、字典）时，请传递 False ```py add_embedding(mat, metadata=None, label_img=None, global_step=None, tag='default', metadata_header=None)¶ @@ -411,19 +411,19 @@ add_embedding(mat, metadata=None, label_img=None, global_step=None, tag='default 参数 -+ **mat**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor") *或* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在NumPy v1.26中)")） - 每行是数据点特征向量的矩阵 ++ **mat**（*torch.Tensor* *或* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在 NumPy v1.26 中)")） - 每行是数据点特征向量的矩阵 -+ **metadata**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在Python v3.12中)")） - 一个标签列表，每个元素将被转换为字符串 ++ **metadata**（[*list*](https://docs.python.org/3/library/stdtypes.html#list "(在 Python v3.12 中)")） - 一个标签列表，每个元素将被转换为字符串 -+ **label_img**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")） - 图像对应于每个数据点 ++ **label_img**（*torch.Tensor*） - 图像对应于每个数据点 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 要记录的全局步骤值 -+ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 嵌入的名称 ++ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 嵌入的名称 形状： -mat：$(N, D)$(N,D)，其中N是数据的数量，D是特征维度 +mat：$(N, D)$(N,D)，其中 N 是数据的数量，D 是特征维度 label_img：$(N, C, H, W)$(N,C,H,W) @@ -455,21 +455,21 @@ add_pr_curve(tag, labels, predictions, global_step=None, num_thresholds=127, wei 添加精度召回曲线。 -绘制精度-召回曲线可以让您了解模型在不同阈值设置下的性能。使用此函数，您为每个目标提供地面真实标签（T/F）和预测置信度（通常是您模型的输出）。TensorBoard UI将允许您交互式选择阈值。 +绘制精度-召回曲线可以让您了解模型在不同阈值设置下的性能。使用此函数，您为每个目标提供地面真实标签（T/F）和预测置信度（通常是您模型的输出）。TensorBoard UI 将允许您交互式选择阈值。 参数 -+ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 数据标识符 ++ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 数据标识符 -+ **labels**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在NumPy v1.26中)")*，或* *string/blobname*） - 地面真实数据。每个元素的二进制标签。 ++ **labels**（*torch.Tensor**，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在 NumPy v1.26 中)")*，或* *string/blobname*） - 地面真实数据。每个元素的二进制标签。 -+ **predictions**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")*，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在NumPy v1.26中)")*，或* *string/blobname*） - 元素被分类为真的概率。值应在[0, 1]之间 ++ **predictions**（*torch.Tensor**，* [*numpy.ndarray*](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray "(在 NumPy v1.26 中)")*，或* *string/blobname*） - 元素被分类为真的概率。值应在[0, 1]之间 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 要记录的全局步骤值 -+ **num_thresholds**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")） - 用于绘制曲线的阈值数量。 ++ **num_thresholds**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")） - 用于绘制曲线的阈值数量。 -+ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")） - 可选覆盖默认的walltime（time.time()）事件纪元后的秒数 ++ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")） - 可选覆盖默认的 walltime（time.time()）事件纪元后的秒数 示例： @@ -489,13 +489,13 @@ add_custom_scalars(layout)¶ 通过在“标量”中收集图表标签创建特殊图表。 -注意：此函数每个SummaryWriter()对象只能调用一次。 +注意：此函数每个 SummaryWriter()对象只能调用一次。 -因为它只提供元数据给tensorboard，所以该函数可以在训练循环之前或之后调用。 +因为它只提供元数据给 tensorboard，所以该函数可以在训练循环之前或之后调用。 参数 -**layout**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12中)")) - {categoryName: *charts*}，其中*charts*也是一个字典{chartName: *ListOfProperties*}。*ListOfProperties*中的第一个元素是图表的类型（**Multiline**或**Margin**之一），第二个元素应该是一个包含您在add_scalar函数中使用的标签的列表，这些标签将被收集到新的图表中。 +**layout**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")) - {categoryName: *charts*}，其中*charts*也是一个字典{chartName: *ListOfProperties*}。*ListOfProperties*中的第一个元素是图表的类型（**Multiline**或**Margin**之一），第二个元素应该是一个包含您在 add_scalar 函数中使用的标签的列表，这些标签将被收集到新的图表中。 示例： @@ -511,33 +511,33 @@ writer.add_custom_scalars(layout) add_mesh(tag, vertices, colors=None, faces=None, config_dict=None, global_step=None, walltime=None)¶ ``` -将网格或3D点云添加到TensorBoard。 +将网格或 3D 点云添加到 TensorBoard。 -可视化基于Three.js，因此允许用户与渲染的对象进行交互。除了基本定义如顶点、面外，用户还可以进一步提供相机参数、光照条件等。请查看[https://threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene](https://threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene)以获取高级用法。 +可视化基于 Three.js，因此允许用户与渲染的对象进行交互。除了基本定义如顶点、面外，用户还可以进一步提供相机参数、光照条件等。请查看[`threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene`](https://threejs.org/docs/index.html#manual/en/introduction/Creating-a-scene)以获取高级用法。 参数 -+ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 数据标识符 ++ **tag**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 数据标识符 -+ **vertices**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")) - 顶点的3D坐标列表。 ++ **vertices**（*torch.Tensor*) - 顶点的 3D 坐标列表。 -+ **colors**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")) - 每个顶点的颜色 ++ **colors**（*torch.Tensor*) - 每个顶点的颜色 -+ **faces**（[*torch.Tensor*](tensors.html#torch.Tensor "torch.Tensor")) - 每个三角形内顶点的索引。 (可选) ++ **faces**（*torch.Tensor*) - 每个三角形内顶点的索引。 (可选) -+ **config_dict** - 包含ThreeJS类名称和配置的字典。 ++ **config_dict** - 包含 ThreeJS 类名称和配置的字典。 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) - 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) - 要记录的全局步骤值 -+ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在Python v3.12中)")) - 可选覆盖默认walltime（time.time()）事件后的秒数 ++ **walltime**（[*float*](https://docs.python.org/3/library/functions.html#float "(在 Python v3.12 中)")) - 可选覆盖默认 walltime（time.time()）事件后的秒数 形状： 顶点：$(B, N, 3)$(B,N,3)。 (批次，顶点数量，通道) -颜色：$(B, N, 3)$(B,N,3)。值应该在[0, 255]之间，对于uint8类型或[0, 1]之间，对于float类型。 +颜色：$(B, N, 3)$(B,N,3)。值应该在[0, 255]之间，对于 uint8 类型或[0, 1]之间，对于 float 类型。 -面：$(B, N, 3)$(B,N,3)。值应该在[0, 顶点数量]之间，对于uint8类型。 +面：$(B, N, 3)$(B,N,3)。值应该在[0, 顶点数量]之间，对于 uint8 类型。 示例： @@ -572,19 +572,19 @@ writer.close() add_hparams(hparam_dict, metric_dict, hparam_domain_discrete=None, run_name=None, global_step=None)¶ ``` -添加一组要在TensorBoard中进行比较的超参数。 +添加一组要在 TensorBoard 中进行比较的超参数。 参数 -+ **hparam_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12中)")) - 字典中的每个键值对是超参数的名称及其对应的值。值的类型可以是bool、string、float、int或None中的一个。 ++ **hparam_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")) - 字典中的每个键值对是超参数的名称及其对应的值。值的类型可以是 bool、string、float、int 或 None 中的一个。 -+ **metric_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在Python v3.12中)")) - 字典中的每个键值对是指标的名称及其对应的值。请注意，此处使用的键应在tensorboard记录中是唯一的。否则，您通过`add_scalar`添加的值将显示在hparam插件中。在大多数情况下，这是不希望的。 ++ **metric_dict**（[*dict*](https://docs.python.org/3/library/stdtypes.html#dict "(在 Python v3.12 中)")) - 字典中的每个键值对是指标的名称及其对应的值。请注意，此处使用的键应在 tensorboard 记录中是唯一的。否则，您通过`add_scalar`添加的值将显示在 hparam 插件中。在大多数情况下，这是不希望的。 + **hparam_domain_discrete** - （Optional[Dict[str, List[Any]]）包含超参数名称及其所有离散值的字典 -+ **run_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")) - 运行的名称，将包含在logdir的一部分中。如果未指定，将使用当前时间戳。 ++ **run_name**（[*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")) - 运行的名称，将包含在 logdir 的一部分中。如果未指定，将使用当前时间戳。 -+ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在Python v3.12中)")) - 要记录的全局步骤值 ++ **global_step**（[*int*](https://docs.python.org/3/library/functions.html#int "(在 Python v3.12 中)")) - 要记录的全局步骤值 示例： @@ -598,7 +598,7 @@ with SummaryWriter() as w: 预期结果： -[![_images/add_hparam.png](../Images/dd8f9e83c6f7c7f46390b6069cc8e6de.png)](_images/add_hparam.png) +![_images/add_hparam.png](img/add_hparam.png) ```py flush()¶ diff --git a/totrans/doc22_094.md b/totrans/doc22_094.md index ff2e6250..bf69f1f8 100644 --- a/totrans/doc22_094.md +++ b/totrans/doc22_094.md @@ -1,8 +1,8 @@ # 类型信息 -> 原文：[https://pytorch.org/docs/stable/type_info.html](https://pytorch.org/docs/stable/type_info.html) +> 原文：[`pytorch.org/docs/stable/type_info.html`](https://pytorch.org/docs/stable/type_info.html) -[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")的数字属性可以通过[`torch.finfo`](#torch.torch.finfo "torch.torch.finfo")或[`torch.iinfo`](#torch.torch.iinfo "torch.torch.iinfo")来访问。 +`torch.dtype`的数字属性可以通过`torch.finfo`或`torch.iinfo`来访问。 ## torch.finfo @@ -10,9 +10,9 @@ class torch.finfo¶ ``` -[`torch.finfo`](#torch.torch.finfo "torch.torch.finfo")是一个表示浮点数[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")（即`torch.float32`、`torch.float64`、`torch.float16`和`torch.bfloat16`）的数字属性的对象。这类似于[numpy.finfo](https://docs.scipy.org/doc/numpy/reference/generated/numpy.finfo.html)。 +`torch.finfo`是一个表示浮点数`torch.dtype`（即`torch.float32`、`torch.float64`、`torch.float16`和`torch.bfloat16`）的数字属性的对象。这类似于[numpy.finfo](https://docs.scipy.org/doc/numpy/reference/generated/numpy.finfo.html)。 -[`torch.finfo`](#torch.torch.finfo "torch.torch.finfo")提供以下属性： +`torch.finfo`提供以下属性： | 名称 | 类型 | 描述 | | --- | --- | --- | @@ -26,19 +26,19 @@ class torch.finfo¶ 注意 -可以在不带参数的情况下调用[`torch.finfo`](#torch.torch.finfo "torch.torch.finfo")的构造函数，此时类将为pytorch默认dtype创建（由[`torch.get_default_dtype()`](generated/torch.get_default_dtype.html#torch.get_default_dtype "torch.get_default_dtype")返回）。 +可以在不带参数的情况下调用`torch.finfo`的构造函数，此时类将为 pytorch 默认 dtype 创建（由`torch.get_default_dtype()`返回）。 注意 -smallest_normal返回最小的*正常*数，但存在更小的次正常数。有关更多信息，请参阅[https://en.wikipedia.org/wiki/Denormal_number](https://en.wikipedia.org/wiki/Denormal_number)。## torch.iinfo +smallest_normal 返回最小的*正常*数，但存在更小的次正常数。有关更多信息，请参阅[`en.wikipedia.org/wiki/Denormal_number`](https://en.wikipedia.org/wiki/Denormal_number)。## torch.iinfo ```py class torch.iinfo¶ ``` -[`torch.iinfo`](#torch.torch.iinfo "torch.torch.iinfo")是一个表示整数[`torch.dtype`](tensor_attributes.html#torch.dtype "torch.dtype")（即`torch.uint8`、`torch.int8`、`torch.int16`、`torch.int32`和`torch.int64`）的数字属性的对象。这类似于[numpy.iinfo](https://docs.scipy.org/doc/numpy/reference/generated/numpy.iinfo.html)。 +`torch.iinfo`是一个表示整数`torch.dtype`（即`torch.uint8`、`torch.int8`、`torch.int16`、`torch.int32`和`torch.int64`）的数字属性的对象。这类似于[numpy.iinfo](https://docs.scipy.org/doc/numpy/reference/generated/numpy.iinfo.html)。 -[`torch.iinfo`](#torch.torch.iinfo "torch.torch.iinfo")提供以下属性： +`torch.iinfo`提供以下属性： | 名称 | 类型 | 描述 | | --- | --- | --- | diff --git a/totrans/doc22_095.md b/totrans/doc22_095.md index e6164b4b..a2a64bad 100644 --- a/totrans/doc22_095.md +++ b/totrans/doc22_095.md @@ -1,12 +1,12 @@ # 命名张量 -> 原文：[https://pytorch.org/docs/stable/named_tensor.html](https://pytorch.org/docs/stable/named_tensor.html) +> 原文：[`pytorch.org/docs/stable/named_tensor.html`](https://pytorch.org/docs/stable/named_tensor.html) -命名张量允许用户为张量维度提供显式名称。在大多数情况下，接受维度参数的操作将接受维度名称，避免了按位置跟踪维度的需要。此外，命名张量使用名称在运行时自动检查API是否被正确使用，提供额外的安全性。名称还可以用于重新排列维度，例如，支持“按名称广播”而不是“按位置广播”。 +命名张量允许用户为张量维度提供显式名称。在大多数情况下，接受维度参数的操作将接受维度名称，避免了按位置跟踪维度的需要。此外，命名张量使用名称在运行时自动检查 API 是否被正确使用，提供额外的安全性。名称还可以用于重新排列维度，例如，支持“按名称广播”而不是“按位置广播”。 警告 -命名张量API是一个原型功能，可能会发生变化。 +命名张量 API 是一个原型功能，可能会发生变化。 ## 创建命名张量 @@ -22,23 +22,23 @@ tensor([[0., 0., 0.], 以下工厂函数支持命名张量： -+ [`torch.empty()`](generated/torch.empty.html#torch.empty "torch.empty") ++ `torch.empty()` -+ [`torch.rand()`](generated/torch.rand.html#torch.rand "torch.rand") ++ `torch.rand()` -+ [`torch.randn()`](generated/torch.randn.html#torch.randn "torch.randn") ++ `torch.randn()` -+ [`torch.ones()`](generated/torch.ones.html#torch.ones "torch.ones") ++ `torch.ones()` -+ [`torch.tensor()`](generated/torch.tensor.html#torch.tensor "torch.tensor") ++ `torch.tensor()` -+ [`torch.zeros()`](generated/torch.zeros.html#torch.zeros "torch.zeros") ++ `torch.zeros()` ## 命名维度 -请参阅[`names`](#torch.Tensor.names "torch.Tensor.names")以了解张量名称的限制。 +请参阅`names`以了解张量名称的限制。 -使用[`names`](#torch.Tensor.names "torch.Tensor.names")来访问张量的维度名称，使用[`rename()`](#torch.Tensor.rename "torch.Tensor.rename")来重命名命名维度。 +使用`names`来访问张量的维度名称，使用`rename()`来重命名命名维度。 ```py >>> imgs = torch.randn(1, 2, 2, 3 , names=('N', 'C', 'H', 'W')) @@ -50,7 +50,7 @@ tensor([[0., 0., 0.], ('N', 'C', 'height', 'width) ``` -命名张量可以与未命名张量共存；命名张量是[`torch.Tensor`](tensors.html#torch.Tensor "torch.Tensor")的实例。未命名张量具有`None`命名的维度。命名张量不要求所有维度都有名称。 +命名张量可以与未命名张量共存；命名张量是`torch.Tensor`的实例。未命名张量具有`None`命名的维度。命名张量不要求所有维度都有名称。 ```py >>> imgs = torch.randn(1, 2, 2, 3 , names=(None, 'C', 'H', 'W')) @@ -60,7 +60,7 @@ tensor([[0., 0., 0.], ## 名称传播语义 -命名张量使用名称在运行时自动检查API是否被正确调用。这发生在一个称为*名称推断*的过程中。更正式地说，名称推断包括以下两个步骤： +命名张量使用名称在运行时自动检查 API 是否被正确调用。这发生在一个称为*名称推断*的过程中。更正式地说，名称推断包括以下两个步骤： + **检查名称**：运算符可能在运行时执行自动检查，检查某些维度名称必须匹配。 @@ -82,7 +82,7 @@ tensor([[0., 0., 0.], 注意 -在实践中，当使用命名张量时，应避免具有未命名维度，因为它们的处理可能会变得复杂。建议使用[`refine_names()`](#torch.Tensor.refine_names "torch.Tensor.refine_names")将所有未命名维度提升为命名维度。 +在实践中，当使用命名张量时，应避免具有未命名维度，因为它们的处理可能会变得复杂。建议使用`refine_names()`将所有未命名维度提升为命名维度。 ### 基本名称推断规则 @@ -116,15 +116,15 @@ Error when attempting to broadcast dims ['X'] and dims ['Z']: dim 'X' and dim 'Z ('X',) ``` -有关名称推断规则的全面列表，请参见[命名张量运算符覆盖范围](name_inference.html#name-inference-reference-doc)。以下是可能有用的两个常见操作： +有关名称推断规则的全面列表，请参见命名张量运算符覆盖范围。以下是可能有用的两个常见操作： -+ 二进制算术运算：[统一输入的名称](name_inference.html#unifies-names-from-inputs-doc) ++ 二进制算术运算：统一输入的名称 -+ 矩阵乘法运算：[消除维度](name_inference.html#contracts-away-dims-doc) ++ 矩阵乘法运算：消除维度 ## 通过名称进行显式对齐[](#explicit-alignment-by-names "跳转到此标题") -使用[`align_as()`](#torch.Tensor.align_as "torch.Tensor.align_as")或[`align_to()`](#torch.Tensor.align_to "torch.Tensor.align_to")按名称对齐张量维度到指定的顺序。这对执行“按名称广播”很有用。 +使用`align_as()`或`align_to()`按名称对齐张量维度到指定的顺序。这对执行“按名称广播”很有用。 ```py # This function is agnostic to the dimension ordering of `input`, @@ -146,7 +146,7 @@ def scale_channels(input, scale): ## 操作维度 -使用[`align_to()`](#torch.Tensor.align_to "torch.Tensor.align_to")来对大量维度进行排列，而不需要像[`permute()`](generated/torch.Tensor.permute.html#torch.Tensor.permute "torch.Tensor.permute")那样提及所有维度。 +使用`align_to()`来对大量维度进行排列，而不需要像`permute()`那样提及所有维度。 ```py >>> tensor = torch.randn(2, 2, 2, 2, 2, 2) @@ -158,7 +158,7 @@ def scale_channels(input, scale): >>> named_tensor.align_to('F', 'E', ...) ``` -使用[`flatten()`](generated/torch.Tensor.flatten.html#torch.Tensor.flatten "torch.Tensor.flatten")和[`unflatten()`](generated/torch.Tensor.unflatten.html#torch.Tensor.unflatten "torch.Tensor.unflatten")分别对维度进行展平和展开。这些方法比[`view()`](generated/torch.Tensor.view.html#torch.Tensor.view "torch.Tensor.view")和[`reshape()`](generated/torch.Tensor.reshape.html#torch.Tensor.reshape "torch.Tensor.reshape")更冗长，但对于阅读代码的人来说具有更多的语义意义。 +使用`flatten()`和`unflatten()`分别对维度进行展平和展开。这些方法比`view()`和`reshape()`更冗长，但对于阅读代码的人来说具有更多的语义意义。 ```py >>> imgs = torch.randn(32, 3, 128, 128) @@ -176,7 +176,7 @@ def scale_channels(input, scale): ## 自动求导支持 -Autograd目前以有限的方式支持命名张量：autograd会忽略所有张量上的名称。梯度计算仍然是正确的，但我们失去了名称给我们带来的安全性。 +Autograd 目前以有限的方式支持命名张量：autograd 会忽略所有张量上的名称。梯度计算仍然是正确的，但我们失去了名称给我们带来的安全性。 ```py >>> x = torch.randn(3, names=('D',)) @@ -200,39 +200,39 @@ tensor([-1.8107, -0.6357, 0.0783]) ### 运算符 -查看[命名张量运算符覆盖](name_inference.html#name-inference-reference-doc)以获取支持的torch和张量操作的完整列表。我们尚不支持以下链接未涵盖的内容： +查看命名张量运算符覆盖以获取支持的 torch 和张量操作的完整列表。我们尚不支持以下链接未涵盖的内容： + 索引，高级索引。 对于`torch.nn.functional`运算符，我们支持以下内容： -+ [`torch.nn.functional.relu()`](generated/torch.nn.functional.relu.html#torch.nn.functional.relu "torch.nn.functional.relu") ++ `torch.nn.functional.relu()` -+ [`torch.nn.functional.softmax()`](generated/torch.nn.functional.softmax.html#torch.nn.functional.softmax "torch.nn.functional.softmax") ++ `torch.nn.functional.softmax()` -+ [`torch.nn.functional.log_softmax()`](generated/torch.nn.functional.log_softmax.html#torch.nn.functional.log_softmax "torch.nn.functional.log_softmax") ++ `torch.nn.functional.log_softmax()` -+ [`torch.nn.functional.tanh()`](generated/torch.nn.functional.tanh.html#torch.nn.functional.tanh "torch.nn.functional.tanh") ++ `torch.nn.functional.tanh()` -+ [`torch.nn.functional.sigmoid()`](generated/torch.nn.functional.sigmoid.html#torch.nn.functional.sigmoid "torch.nn.functional.sigmoid") ++ `torch.nn.functional.sigmoid()` -+ [`torch.nn.functional.dropout()`](generated/torch.nn.functional.dropout.html#torch.nn.functional.dropout "torch.nn.functional.dropout") ++ `torch.nn.functional.dropout()` ### 子系统 -自动求导是支持的，请参见[自动求导支持](#named-tensors-autograd-doc)。因为梯度目前没有名称，优化器可能会工作，但尚未经过测试。 +自动求导是支持的，请参见自动求导支持。因为梯度目前没有名称，优化器可能会工作，但尚未经过测试。 -NN模块目前不受支持。当使用具有命名张量输入的模块时，可能会导致以下情况： +NN 模块目前不受支持。当使用具有命名张量输入的模块时，可能会导致以下情况： -+ NN模块参数没有名称，因此输出可能部分具有名称。 ++ NN 模块参数没有名称，因此输出可能部分具有名称。 -+ NN模块的前向传递代码不支持命名张量，并将适当地报错。 ++ NN 模块的前向传递代码不支持命名张量，并将适当地报错。 我们还不支持以下子系统，尽管其中一些可能可以直接使用： + 分布 -+ 序列化（[`torch.load()`](generated/torch.load.html#torch.load "torch.load"), [`torch.save()`](generated/torch.save.html#torch.save "torch.save")) ++ 序列化（`torch.load()`, `torch.save()`) + 多进程 @@ -244,9 +244,9 @@ NN模块目前不受支持。当使用具有命名张量输入的模块时，可 如果其中任何一个对您的用例有帮助，请[搜索是否已经提交了问题](https://github.com/pytorch/pytorch/issues?q=is%3Aopen+is%3Aissue+label%3A%22module%3A+named+tensor%22)，如果没有，请[提交一个](https://github.com/pytorch/pytorch/issues/new/choose)。 -## 命名张量API参考[](#named-tensor-api-reference "跳转到此标题") +## 命名张量 API 参考[](#named-tensor-api-reference "跳转到此标题") -在本节中，请查找命名张量特定API的文档。有关如何通过其他PyTorch运算符传播名称的全面参考，请参见[命名张量运算符覆盖](name_inference.html#name-inference-reference-doc)。 +在本节中，请查找命名张量特定 API 的文档。有关如何通过其他 PyTorch 运算符传播名称的全面参考，请参见命名张量运算符覆盖。 ```py class torch.Tensor @@ -260,13 +260,13 @@ names¶ `names[idx]` 对应于张量维度`idx`的名称。名称是一个字符串，如果维度有名称，或者是`None`，如果维度没有名称。 -维度名称可以包含字符或下划线。此外，维度名称必须是有效的Python变量名（即不以下划线开头）。 +维度名称可以包含字符或下划线。此外，维度名称必须是有效的 Python 变量名（即不以下划线开头）。 张量不能具有两个具有相同名称的命名维度。 警告 -命名张量API是实验性的，可能会发生变化。 +命名张量 API 是实验性的，可能会发生变化。 ```py rename(*names, **rename_map)¶ @@ -278,9 +278,9 @@ rename(*names, **rename_map)¶ `self.rename(**rename_map)` 返回一个张量视图，其维度按照映射`rename_map`中指定的方式重命名。 -`self.rename(*names)` 返回一个张量视图，使用[`names`](#torch.Tensor.names "torch.Tensor.names")按位置重命名所有维度。使用`self.rename(None)`来删除张量上的名称。 +`self.rename(*names)` 返回一个张量视图，使用`names`按位置重命名所有维度。使用`self.rename(None)`来删除张量上的名称。 -不能同时指定位置参数[`names`](#torch.Tensor.names "torch.Tensor.names")和关键字参数`rename_map`。 +不能同时指定位置参数`names`和关键字参数`rename_map`。 示例： @@ -301,27 +301,27 @@ rename(*names, **rename_map)¶ 警告 -命名张量API是实验性的，可能会发生变化。 +命名张量 API 是实验性的，可能会发生变化。 ```py rename_(*names, **rename_map)¶ ``` -[`rename()`](#torch.Tensor.rename "torch.Tensor.rename")的原地版本。 +`rename()`的原地版本。 ```py refine_names(*names)¶ ``` -根据[`names`](#torch.Tensor.names "torch.Tensor.names")细化`self`的维度名称。 +根据`names`细化`self`的维度名称。 细化是重命名的特殊情况，它“提升”了未命名的维度。`None`维度可以细化为任何名称；命名维度只能细化为相同的名称。 因为命名张量可以与未命名张量共存，细化名称提供了一种很好的方法来编写能够同时处理命名和未命名张量的命名张量感知代码。 -[`names`](#torch.Tensor.names "torch.Tensor.names") 可以包含最多一个省略号 (`...`)。省略号会贪婪地扩展；它会就地扩展以填充[`names`](#torch.Tensor.names "torch.Tensor.names")，使其与`self.dim()`的长度相同，使用来自`self.names`相应索引的名称。 +`names` 可以包含最多一个省略号 (`...`)。省略号会贪婪地扩展；它会就地扩展以填充`names`，使其与`self.dim()`的长度相同，使用来自`self.names`相应索引的名称。 -Python 2不支持省略号，但可以使用字符串文字代替（`'...'`）。 +Python 2 不支持省略号，但可以使用字符串文字代替（`'...'`）。 参数 @@ -343,7 +343,7 @@ Python 2不支持省略号，但可以使用字符串文字代替（`'...'`） 警告 -命名张量API是实验性的，可能会发生变化。 +命名张量 API 是实验性的，可能会发生变化。 ```py align_as(other) → Tensor¶ @@ -357,7 +357,7 @@ align_as(other) → Tensor¶ `self`的所有维度名称必须存在于`other.names`中。`other`可能包含未在`self.names`中的命名维度；输出张量对于每个新名称都有一个大小为一的维度。 -要将张量对齐到特定顺序，请使用[`align_to()`](#torch.Tensor.align_to "torch.Tensor.align_to")。 +要将张量对齐到特定顺序，请使用`align_to()`。 示例： @@ -386,25 +386,25 @@ align_as(other) → Tensor¶ 警告 -命名张量API是实验性的，可能会发生变化。 +命名张量 API 是实验性的，可能会发生变化。 ```py align_to(*names)¶ ``` -重新排列`self`张量的维度，以匹配[`names`](#torch.Tensor.names "torch.Tensor.names")中指定的顺序，在任何新名称中添加大小为一的维度。 +重新排列`self`张量的维度，以匹配`names`中指定的顺序，在任何新名称中添加大小为一的维度。 `self`的所有维度必须按顺序命名才能使用此方法。结果张量是原始张量的视图。 -`self`的所有维度名称必须存在于[`names`](#torch.Tensor.names "torch.Tensor.names")中。[`names`](#torch.Tensor.names "torch.Tensor.names")可能包含未在`self.names`中的其他名称；输出张量对于每个新名称都有一个大小为一的维度。 +`self`的所有维度名称必须存在于`names`中。`names`可能包含未在`self.names`中的其他名称；输出张量对于每个新名称都有一个大小为一的维度。 -[`names`](#torch.Tensor.names "torch.Tensor.names") 可以包含最多一个省略号 (`...`)。省略号会扩展为`self`中未在[`names`](#torch.Tensor.names "torch.Tensor.names")中提到的所有维度名称，按照它们在`self`中出现的顺序。 +`names` 可以包含最多一个省略号 (`...`)。省略号会扩展为`self`中未在`names`中提到的所有维度名称，按照它们在`self`中出现的顺序。 -Python 2不支持省略号，但可以使用字符串文字代替（`'...'`）。 +Python 2 不支持省略号，但可以使用字符串文字代替（`'...'`）。 参数 -**names**（*可迭代的* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在Python v3.12中)")） - 输出张量的期望维度顺序。可能包含最多一个省略号，该省略号会扩展到`self`未提及的所有维度名称。 +**names**（*可迭代的* [*str*](https://docs.python.org/3/library/stdtypes.html#str "(在 Python v3.12 中)")） - 输出张量的期望维度顺序。可能包含最多一个省略号，该省略号会扩展到`self`未提及的所有维度名称。 示例： @@ -418,7 +418,7 @@ Python 2不支持省略号，但可以使用字符串文字代替（`'...'`） 警告 -命名张量API是实验性的，可能会发生变化。 +命名张量 API 是实验性的，可能会发生变化。 ```py flatten(dims, out_dim) → Tensor @@ -439,4 +439,4 @@ flatten(dims, out_dim) → Tensor 警告 -命名张量API是实验性的，可能会发生变化。 +命名张量 API 是实验性的，可能会发生变化。 diff --git a/totrans/doc22_096.md b/totrans/doc22_096.md index 8fa2ba66..0aa089ca 100644 --- a/totrans/doc22_096.md +++ b/totrans/doc22_096.md @@ -1,8 +1,8 @@ # 具名张量操作覆盖范围 -> 原文：[https://pytorch.org/docs/stable/name_inference.html](https://pytorch.org/docs/stable/name_inference.html) +> 原文：[`pytorch.org/docs/stable/name_inference.html`](https://pytorch.org/docs/stable/name_inference.html) -请先阅读[具名张量](named_tensor.html#named-tensors-doc)以了解具名张量的介绍。 +请先阅读具名张量以了解具名张量的介绍。 本文档是关于*名称推断*的参考，该过程定义了具名张量如何： @@ -16,229 +16,229 @@ 警告 -具名张量API是实验性的，可能会发生变化。 +具名张量 API 是实验性的，可能会发生变化。 支持的操作 | API | 名称推断规则 | | --- | --- | -| [`Tensor.abs()`](generated/torch.Tensor.abs.html#torch.Tensor.abs "torch.Tensor.abs"), [`torch.abs()`](generated/torch.abs.html#torch.abs "torch.abs") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.abs_()`](generated/torch.Tensor.abs_.html#torch.Tensor.abs_ "torch.Tensor.abs_") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.acos()`](generated/torch.Tensor.acos.html#torch.Tensor.acos "torch.Tensor.acos"), [`torch.acos()`](generated/torch.acos.html#torch.acos "torch.acos") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.acos_()`](generated/torch.Tensor.acos_.html#torch.Tensor.acos_ "torch.Tensor.acos_") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.add()`](generated/torch.Tensor.add.html#torch.Tensor.add "torch.Tensor.add"), [`torch.add()`](generated/torch.add.html#torch.add "torch.add") | [统一来自输入的名称](#unifies-names-from-inputs-doc) | -| [`Tensor.add_()`](generated/torch.Tensor.add_.html#torch.Tensor.add_ "torch.Tensor.add_") | [统一来自输入的名称](#unifies-names-from-inputs-doc) | -| [`Tensor.addmm()`](generated/torch.Tensor.addmm.html#torch.Tensor.addmm "torch.Tensor.addmm"), [`torch.addmm()`](generated/torch.addmm.html#torch.addmm "torch.addmm") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.addmm_()`](generated/torch.Tensor.addmm_.html#torch.Tensor.addmm_ "torch.Tensor.addmm_") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.addmv()`](generated/torch.Tensor.addmv.html#torch.Tensor.addmv "torch.Tensor.addmv"), [`torch.addmv()`](generated/torch.addmv.html#torch.addmv "torch.addmv") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.addmv_()`](generated/torch.Tensor.addmv_.html#torch.Tensor.addmv_ "torch.Tensor.addmv_") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.align_as()`](named_tensor.html#torch.Tensor.align_as "torch.Tensor.align_as") | 查看文档 | -| [`Tensor.align_to()`](named_tensor.html#torch.Tensor.align_to "torch.Tensor.align_to") | 查看文档 | -| [`Tensor.all()`](generated/torch.Tensor.all.html#torch.Tensor.all "torch.Tensor.all"), [`torch.all()`](generated/torch.all.html#torch.all "torch.all") | 无 | -| [`Tensor.any()`](generated/torch.Tensor.any.html#torch.Tensor.any "torch.Tensor.any"), [`torch.any()`](generated/torch.any.html#torch.any "torch.any") | 无 | -| [`Tensor.asin()`](generated/torch.Tensor.asin.html#torch.Tensor.asin "torch.Tensor.asin"), [`torch.asin()`](generated/torch.asin.html#torch.asin "torch.asin") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.asin_()`](generated/torch.Tensor.asin_.html#torch.Tensor.asin_ "torch.Tensor.asin_") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.atan()`](generated/torch.Tensor.atan.html#torch.Tensor.atan "torch.Tensor.atan"), [`torch.atan()`](generated/torch.atan.html#torch.atan "torch.atan") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.atan2()`](generated/torch.Tensor.atan2.html#torch.Tensor.atan2 "torch.Tensor.atan2"), [`torch.atan2()`](generated/torch.atan2.html#torch.atan2 "torch.atan2") | [统一来自输入的名称](#unifies-names-from-inputs-doc) | -| [`Tensor.atan2_()`](generated/torch.Tensor.atan2_.html#torch.Tensor.atan2_ "torch.Tensor.atan2_") | [统一来自输入的名称](#unifies-names-from-inputs-doc) | -| [`Tensor.atan_()`](generated/torch.Tensor.atan_.html#torch.Tensor.atan_ "torch.Tensor.atan_") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.bernoulli()`](generated/torch.Tensor.bernoulli.html#torch.Tensor.bernoulli "torch.Tensor.bernoulli"), [`torch.bernoulli()`](generated/torch.bernoulli.html#torch.bernoulli "torch.bernoulli") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.bernoulli_()`](generated/torch.Tensor.bernoulli_.html#torch.Tensor.bernoulli_ "torch.Tensor.bernoulli_") | 无 | -| [`Tensor.bfloat16()`](generated/torch.Tensor.bfloat16.html#torch.Tensor.bfloat16 "torch.Tensor.bfloat16") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.bitwise_not()`](generated/torch.Tensor.bitwise_not.html#torch.Tensor.bitwise_not "torch.Tensor.bitwise_not"), [`torch.bitwise_not()`](generated/torch.bitwise_not.html#torch.bitwise_not "torch.bitwise_not") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.bitwise_not_()`](generated/torch.Tensor.bitwise_not_.html#torch.Tensor.bitwise_not_ "torch.Tensor.bitwise_not_") | 无 | -| [`Tensor.bmm()`](generated/torch.Tensor.bmm.html#torch.Tensor.bmm "torch.Tensor.bmm"), [`torch.bmm()`](generated/torch.bmm.html#torch.bmm "torch.bmm") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.bool()`](generated/torch.Tensor.bool.html#torch.Tensor.bool "torch.Tensor.bool") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.byte()`](generated/torch.Tensor.byte.html#torch.Tensor.byte "torch.Tensor.byte") | [保留输入名称](#keeps-input-names-doc) | -| [`torch.cat()`](generated/torch.cat.html#torch.cat "torch.cat") | [统一来自输入的名称](#unifies-names-from-inputs-doc) | -| [`Tensor.cauchy_()`](generated/torch.Tensor.cauchy_.html#torch.Tensor.cauchy_ "torch.Tensor.cauchy_") | 无 | -| [`Tensor.ceil()`](generated/torch.Tensor.ceil.html#torch.Tensor.ceil "torch.Tensor.ceil"), [`torch.ceil()`](generated/torch.ceil.html#torch.ceil "torch.ceil") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.ceil_()`](generated/torch.Tensor.ceil_.html#torch.Tensor.ceil_ "torch.Tensor.ceil_") | 无 | -| [`Tensor.char()`](generated/torch.Tensor.char.html#torch.Tensor.char "torch.Tensor.char") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.chunk()`](generated/torch.Tensor.chunk.html#torch.Tensor.chunk "torch.Tensor.chunk"), [`torch.chunk()`](generated/torch.chunk.html#torch.chunk "torch.chunk") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.clamp()`](generated/torch.Tensor.clamp.html#torch.Tensor.clamp "torch.Tensor.clamp"), [`torch.clamp()`](generated/torch.clamp.html#torch.clamp "torch.clamp") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.clamp_()`](generated/torch.Tensor.clamp_.html#torch.Tensor.clamp_ "torch.Tensor.clamp_") | 无 | -| [`Tensor.copy_()`](generated/torch.Tensor.copy_.html#torch.Tensor.copy_ "torch.Tensor.copy_") | [输出函数和原地变体](#out-function-semantics-doc) | -| [`Tensor.cos()`](generated/torch.Tensor.cos.html#torch.Tensor.cos "torch.Tensor.cos"), [`torch.cos()`](generated/torch.cos.html#torch.cos "torch.cos") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.cos_()`](generated/torch.Tensor.cos_.html#torch.Tensor.cos_ "torch.Tensor.cos_") | 无 | -| [`Tensor.cosh()`](generated/torch.Tensor.cosh.html#torch.Tensor.cosh "torch.Tensor.cosh"), [`torch.cosh()`](generated/torch.cosh.html#torch.cosh "torch.cosh") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.cosh_()`](generated/torch.Tensor.cosh_.html#torch.Tensor.cosh_ "torch.Tensor.cosh_") | 无 | -| [`Tensor.acosh()`](generated/torch.Tensor.acosh.html#torch.Tensor.acosh "torch.Tensor.acosh"), [`torch.acosh()`](generated/torch.acosh.html#torch.acosh "torch.acosh") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.acosh_()`](generated/torch.Tensor.acosh_.html#torch.Tensor.acosh_ "torch.Tensor.acosh_") | 无 | -| [`Tensor.cpu()`](generated/torch.Tensor.cpu.html#torch.Tensor.cpu "torch.Tensor.cpu") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.cuda()`](generated/torch.Tensor.cuda.html#torch.Tensor.cuda "torch.Tensor.cuda") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.cumprod()`](generated/torch.Tensor.cumprod.html#torch.Tensor.cumprod "torch.Tensor.cumprod"), [`torch.cumprod()`](generated/torch.cumprod.html#torch.cumprod "torch.cumprod") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.cumsum()`](generated/torch.Tensor.cumsum.html#torch.Tensor.cumsum "torch.Tensor.cumsum"), [`torch.cumsum()`](generated/torch.cumsum.html#torch.cumsum "torch.cumsum") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.data_ptr()`](generated/torch.Tensor.data_ptr.html#torch.Tensor.data_ptr "torch.Tensor.data_ptr") | 无 | -| [`Tensor.deg2rad()`](generated/torch.Tensor.deg2rad.html#torch.Tensor.deg2rad "torch.Tensor.deg2rad"), [`torch.deg2rad()`](generated/torch.deg2rad.html#torch.deg2rad "torch.deg2rad") | [保留输入名称](#keeps-input-names-doc) | +| `Tensor.abs()`, `torch.abs()` | 保留输入名称 | +| `Tensor.abs_()` | 保留输入名称 | +| `Tensor.acos()`, `torch.acos()` | 保留输入名称 | +| `Tensor.acos_()` | 保留输入名称 | +| `Tensor.add()`, `torch.add()` | 统一来自输入的名称 | +| `Tensor.add_()` | 统一来自输入的名称 | +| `Tensor.addmm()`, `torch.addmm()` | 消除维度 | +| `Tensor.addmm_()` | 消除维度 | +| `Tensor.addmv()`, `torch.addmv()` | 消除维度 | +| `Tensor.addmv_()` | 消除维度 | +| `Tensor.align_as()` | 查看文档 | +| `Tensor.align_to()` | 查看文档 | +| `Tensor.all()`, `torch.all()` | 无 | +| `Tensor.any()`, `torch.any()` | 无 | +| `Tensor.asin()`, `torch.asin()` | 保留输入名称 | +| `Tensor.asin_()` | 保留输入名称 | +| `Tensor.atan()`, `torch.atan()` | 保留输入名称 | +| `Tensor.atan2()`, `torch.atan2()` | 统一来自输入的名称 | +| `Tensor.atan2_()` | 统一来自输入的名称 | +| `Tensor.atan_()` | 保留输入名称 | +| `Tensor.bernoulli()`, `torch.bernoulli()` | 保留输入名称 | +| `Tensor.bernoulli_()` | 无 | +| `Tensor.bfloat16()` | 保留输入名称 | +| `Tensor.bitwise_not()`, `torch.bitwise_not()` | 保留输入名称 | +| `Tensor.bitwise_not_()` | 无 | +| `Tensor.bmm()`, `torch.bmm()` | 消除维度 | +| `Tensor.bool()` | 保留输入名称 | +| `Tensor.byte()` | 保留输入名称 | +| `torch.cat()` | 统一来自输入的名称 | +| `Tensor.cauchy_()` | 无 | +| `Tensor.ceil()`, `torch.ceil()` | 保留输入名称 | +| `Tensor.ceil_()` | 无 | +| `Tensor.char()` | 保留输入名称 | +| `Tensor.chunk()`, `torch.chunk()` | 保留输入名称 | +| `Tensor.clamp()`, `torch.clamp()` | 保留输入名称 | +| `Tensor.clamp_()` | 无 | +| `Tensor.copy_()` | 输出函数和原地变体 | +| `Tensor.cos()`, `torch.cos()` | 保留输入名称 | +| `Tensor.cos_()` | 无 | +| `Tensor.cosh()`, `torch.cosh()` | 保留输入名称 | +| `Tensor.cosh_()` | 无 | +| `Tensor.acosh()`, `torch.acosh()` | 保留输入名称 | +| `Tensor.acosh_()` | 无 | +| `Tensor.cpu()` | 保留输入名称 | +| `Tensor.cuda()` | 保留输入名称 | +| `Tensor.cumprod()`, `torch.cumprod()` | 保留输入名称 | +| `Tensor.cumsum()`, `torch.cumsum()` | 保留输入名称 | +| `Tensor.data_ptr()` | 无 | +| `Tensor.deg2rad()`, `torch.deg2rad()` | 保留输入名称 | | `Tensor.deg2rad_()` | 无 | -| [`Tensor.detach()`](generated/torch.Tensor.detach.html#torch.Tensor.detach "torch.Tensor.detach"), `torch.detach()` | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.detach_()`](generated/torch.Tensor.detach_.html#torch.Tensor.detach_ "torch.Tensor.detach_") | 无 | -| [`Tensor.device`](generated/torch.Tensor.device.html#torch.Tensor.device "torch.Tensor.device"), [`torch.device()`](tensor_attributes.html#torch.device "torch.device") | 无 | -| [`Tensor.digamma()`](generated/torch.Tensor.digamma.html#torch.Tensor.digamma "torch.Tensor.digamma"), [`torch.digamma()`](generated/torch.digamma.html#torch.digamma "torch.digamma") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.digamma_()`](generated/torch.Tensor.digamma_.html#torch.Tensor.digamma_ "torch.Tensor.digamma_") | 无 | -| [`Tensor.dim()`](generated/torch.Tensor.dim.html#torch.Tensor.dim "torch.Tensor.dim") | 无 | -| [`Tensor.div()`](generated/torch.Tensor.div.html#torch.Tensor.div "torch.Tensor.div"), [`torch.div()`](generated/torch.div.html#torch.div "torch.div") | [统一输入名称](#unifies-names-from-inputs-doc) | -| [`Tensor.div_()`](generated/torch.Tensor.div_.html#torch.Tensor.div_ "torch.Tensor.div_") | [统一输入名称](#unifies-names-from-inputs-doc) | -| [`Tensor.dot()`](generated/torch.Tensor.dot.html#torch.Tensor.dot "torch.Tensor.dot"), [`torch.dot()`](generated/torch.dot.html#torch.dot "torch.dot") | 无 | -| [`Tensor.double()`](generated/torch.Tensor.double.html#torch.Tensor.double "torch.Tensor.double") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.element_size()`](generated/torch.Tensor.element_size.html#torch.Tensor.element_size "torch.Tensor.element_size") | 无 | -| [`torch.empty()`](generated/torch.empty.html#torch.empty "torch.empty") | [工厂函数](#factory-doc) | -| [`torch.empty_like()`](generated/torch.empty_like.html#torch.empty_like "torch.empty_like") | [工厂函数](#factory-doc) | -| [`Tensor.eq()`](generated/torch.Tensor.eq.html#torch.Tensor.eq "torch.Tensor.eq"), [`torch.eq()`](generated/torch.eq.html#torch.eq "torch.eq") | [统一输入名称](#unifies-names-from-inputs-doc) | -| [`Tensor.erf()`](generated/torch.Tensor.erf.html#torch.Tensor.erf "torch.Tensor.erf"), [`torch.erf()`](generated/torch.erf.html#torch.erf "torch.erf") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.erf_()`](generated/torch.Tensor.erf_.html#torch.Tensor.erf_ "torch.Tensor.erf_") | 无 | -| [`Tensor.erfc()`](generated/torch.Tensor.erfc.html#torch.Tensor.erfc "torch.Tensor.erfc"), [`torch.erfc()`](generated/torch.erfc.html#torch.erfc "torch.erfc") | 保留输入名称 | -| [`Tensor.erfc_()`](generated/torch.Tensor.erfc_.html#torch.Tensor.erfc_ "torch.Tensor.erfc_") | 无 | -| [`Tensor.erfinv()`](generated/torch.Tensor.erfinv.html#torch.Tensor.erfinv "torch.Tensor.erfinv"), [`torch.erfinv()`](generated/torch.erfinv.html#torch.erfinv "torch.erfinv") | 保留输入名称 | -| [`Tensor.erfinv_()`](generated/torch.Tensor.erfinv_.html#torch.Tensor.erfinv_ "torch.Tensor.erfinv_") | 无 | -| [`Tensor.exp()`](generated/torch.Tensor.exp.html#torch.Tensor.exp "torch.Tensor.exp"), [`torch.exp()`](generated/torch.exp.html#torch.exp "torch.exp") | 保留输入名称 | -| [`Tensor.exp_()`](generated/torch.Tensor.exp_.html#torch.Tensor.exp_ "torch.Tensor.exp_") | 无 | -| [`Tensor.expand()`](generated/torch.Tensor.expand.html#torch.Tensor.expand "torch.Tensor.expand") | 保留输入名称 | -| [`Tensor.expm1()`](generated/torch.Tensor.expm1.html#torch.Tensor.expm1 "torch.Tensor.expm1"), [`torch.expm1()`](generated/torch.expm1.html#torch.expm1 "torch.expm1") | 保留输入名称 | -| [`Tensor.expm1_()`](generated/torch.Tensor.expm1_.html#torch.Tensor.expm1_ "torch.Tensor.expm1_") | 无 | -| [`Tensor.exponential_()`](generated/torch.Tensor.exponential_.html#torch.Tensor.exponential_ "torch.Tensor.exponential_") | 无 | -| [`Tensor.fill_()`](generated/torch.Tensor.fill_.html#torch.Tensor.fill_ "torch.Tensor.fill_") | 无 | -| [`Tensor.flatten()`](generated/torch.Tensor.flatten.html#torch.Tensor.flatten "torch.Tensor.flatten"), [`torch.flatten()`](generated/torch.flatten.html#torch.flatten "torch.flatten") | 查看文档 | -| [`Tensor.float()`](generated/torch.Tensor.float.html#torch.Tensor.float "torch.Tensor.float") | 保留输入名称 | -| [`Tensor.floor()`](generated/torch.Tensor.floor.html#torch.Tensor.floor "torch.Tensor.floor"), [`torch.floor()`](generated/torch.floor.html#torch.floor "torch.floor") | 保留输入名称 | -| [`Tensor.floor_()`](generated/torch.Tensor.floor_.html#torch.Tensor.floor_ "torch.Tensor.floor_") | 无 | -| [`Tensor.frac()`](generated/torch.Tensor.frac.html#torch.Tensor.frac "torch.Tensor.frac"), [`torch.frac()`](generated/torch.frac.html#torch.frac "torch.frac") | 保留输入名称 | -| [`Tensor.frac_()`](generated/torch.Tensor.frac_.html#torch.Tensor.frac_ "torch.Tensor.frac_") | 无 | -| [`Tensor.ge()`](generated/torch.Tensor.ge.html#torch.Tensor.ge "torch.Tensor.ge"), [`torch.ge()`](generated/torch.ge.html#torch.ge "torch.ge") | 统一输入的名称 | -| [`Tensor.get_device()`](generated/torch.Tensor.get_device.html#torch.Tensor.get_device "torch.Tensor.get_device"), `torch.get_device()` | 无 | -| [`Tensor.grad`](generated/torch.Tensor.grad.html#torch.Tensor.grad "torch.Tensor.grad") | 无 | -| [`Tensor.gt()`](generated/torch.Tensor.gt.html#torch.Tensor.gt "torch.Tensor.gt"), [`torch.gt()`](generated/torch.gt.html#torch.gt "torch.gt") | 统一输入的名称 | -| [`Tensor.half()`](generated/torch.Tensor.half.html#torch.Tensor.half "torch.Tensor.half") | 保留输入名称 | +| `Tensor.detach()`, `torch.detach()` | 保留输入名称 | +| `Tensor.detach_()` | 无 | +| `Tensor.device`, `torch.device()` | 无 | +| `Tensor.digamma()`, `torch.digamma()` | 保留输入名称 | +| `Tensor.digamma_()` | 无 | +| `Tensor.dim()` | 无 | +| `Tensor.div()`, `torch.div()` | 统一输入名称 | +| `Tensor.div_()` | 统一输入名称 | +| `Tensor.dot()`, `torch.dot()` | 无 | +| `Tensor.double()` | 保留输入名称 | +| `Tensor.element_size()` | 无 | +| `torch.empty()` | 工厂函数 | +| `torch.empty_like()` | 工厂函数 | +| `Tensor.eq()`, `torch.eq()` | 统一输入名称 | +| `Tensor.erf()`, `torch.erf()` | 保留输入名称 | +| `Tensor.erf_()` | 无 | +| `Tensor.erfc()`, `torch.erfc()` | 保留输入名称 | +| `Tensor.erfc_()` | 无 | +| `Tensor.erfinv()`, `torch.erfinv()` | 保留输入名称 | +| `Tensor.erfinv_()` | 无 | +| `Tensor.exp()`, `torch.exp()` | 保留输入名称 | +| `Tensor.exp_()` | 无 | +| `Tensor.expand()` | 保留输入名称 | +| `Tensor.expm1()`, `torch.expm1()` | 保留输入名称 | +| `Tensor.expm1_()` | 无 | +| `Tensor.exponential_()` | 无 | +| `Tensor.fill_()` | 无 | +| `Tensor.flatten()`, `torch.flatten()` | 查看文档 | +| `Tensor.float()` | 保留输入名称 | +| `Tensor.floor()`, `torch.floor()` | 保留输入名称 | +| `Tensor.floor_()` | 无 | +| `Tensor.frac()`, `torch.frac()` | 保留输入名称 | +| `Tensor.frac_()` | 无 | +| `Tensor.ge()`, `torch.ge()` | 统一输入的名称 | +| `Tensor.get_device()`, `torch.get_device()` | 无 | +| `Tensor.grad` | 无 | +| `Tensor.gt()`, `torch.gt()` | 统一输入的名称 | +| `Tensor.half()` | 保留输入名称 | | `Tensor.has_names()` | 查看文档 | -| [`Tensor.index_fill()`](generated/torch.Tensor.index_fill.html#torch.Tensor.index_fill "torch.Tensor.index_fill"), `torch.index_fill()` | 保留输入名称 | -| [`Tensor.index_fill_()`](generated/torch.Tensor.index_fill_.html#torch.Tensor.index_fill_ "torch.Tensor.index_fill_") | 无 | -| [`Tensor.int()`](generated/torch.Tensor.int.html#torch.Tensor.int "torch.Tensor.int") | 保留输入名称 | -| [`Tensor.is_contiguous()`](generated/torch.Tensor.is_contiguous.html#torch.Tensor.is_contiguous "torch.Tensor.is_contiguous") | 无 | -| [`Tensor.is_cuda`](generated/torch.Tensor.is_cuda.html#torch.Tensor.is_cuda "torch.Tensor.is_cuda") | 无 | -| [`Tensor.is_floating_point()`](generated/torch.Tensor.is_floating_point.html#torch.Tensor.is_floating_point "torch.Tensor.is_floating_point"), [`torch.is_floating_point()`](generated/torch.is_floating_point.html#torch.is_floating_point "torch.is_floating_point") | 无 | -| [`Tensor.is_leaf`](generated/torch.Tensor.is_leaf.html#torch.Tensor.is_leaf "torch.Tensor.is_leaf") | 无 | -| [`Tensor.is_pinned()`](generated/torch.Tensor.is_pinned.html#torch.Tensor.is_pinned "torch.Tensor.is_pinned") | 无 | -| [`Tensor.is_shared()`](generated/torch.Tensor.is_shared.html#torch.Tensor.is_shared "torch.Tensor.is_shared") | 无 | -| [`Tensor.is_signed()`](generated/torch.Tensor.is_signed.html#torch.Tensor.is_signed "torch.Tensor.is_signed"), `torch.is_signed()` | 无 | -| [`Tensor.is_sparse`](generated/torch.Tensor.is_sparse.html#torch.Tensor.is_sparse "torch.Tensor.is_sparse") | 无 | -| [`Tensor.is_sparse_csr`](generated/torch.Tensor.is_sparse_csr.html#torch.Tensor.is_sparse_csr "torch.Tensor.is_sparse_csr") | 无 | -| [`torch.is_tensor()`](generated/torch.is_tensor.html#torch.is_tensor "torch.is_tensor") | 无 | -| [`Tensor.item()`](generated/torch.Tensor.item.html#torch.Tensor.item "torch.Tensor.item") | 无 | -| [`Tensor.itemsize`](generated/torch.Tensor.itemsize.html#torch.Tensor.itemsize "torch.Tensor.itemsize") | 无 | -| [`Tensor.kthvalue()`](generated/torch.Tensor.kthvalue.html#torch.Tensor.kthvalue "torch.Tensor.kthvalue"), [`torch.kthvalue()`](generated/torch.kthvalue.html#torch.kthvalue "torch.kthvalue") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.le()`](generated/torch.Tensor.le.html#torch.Tensor.le "torch.Tensor.le"), [`torch.le()`](generated/torch.le.html#torch.le "torch.le") | [从输入中统一名称](#unifies-names-from-inputs-doc) | -| [`Tensor.log()`](generated/torch.Tensor.log.html#torch.Tensor.log "torch.Tensor.log"), [`torch.log()`](generated/torch.log.html#torch.log "torch.log") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.log10()`](generated/torch.Tensor.log10.html#torch.Tensor.log10 "torch.Tensor.log10"), [`torch.log10()`](generated/torch.log10.html#torch.log10 "torch.log10") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.log10_()`](generated/torch.Tensor.log10_.html#torch.Tensor.log10_ "torch.Tensor.log10_") | 无 | -| [`Tensor.log1p()`](generated/torch.Tensor.log1p.html#torch.Tensor.log1p "torch.Tensor.log1p"), [`torch.log1p()`](generated/torch.log1p.html#torch.log1p "torch.log1p") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.log1p_()`](generated/torch.Tensor.log1p_.html#torch.Tensor.log1p_ "torch.Tensor.log1p_") | 无 | -| [`Tensor.log2()`](generated/torch.Tensor.log2.html#torch.Tensor.log2 "torch.Tensor.log2"), [`torch.log2()`](generated/torch.log2.html#torch.log2 "torch.log2") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.log2_()`](generated/torch.Tensor.log2_.html#torch.Tensor.log2_ "torch.Tensor.log2_") | 无 | -| [`Tensor.log_()`](generated/torch.Tensor.log_.html#torch.Tensor.log_ "torch.Tensor.log_") | 无 | -| [`Tensor.log_normal_()`](generated/torch.Tensor.log_normal_.html#torch.Tensor.log_normal_ "torch.Tensor.log_normal_") | 无 | -| [`Tensor.logical_not()`](generated/torch.Tensor.logical_not.html#torch.Tensor.logical_not "torch.Tensor.logical_not"), [`torch.logical_not()`](generated/torch.logical_not.html#torch.logical_not "torch.logical_not") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.logical_not_()`](generated/torch.Tensor.logical_not_.html#torch.Tensor.logical_not_ "torch.Tensor.logical_not_") | 无 | -| [`Tensor.logsumexp()`](generated/torch.Tensor.logsumexp.html#torch.Tensor.logsumexp "torch.Tensor.logsumexp"), [`torch.logsumexp()`](generated/torch.logsumexp.html#torch.logsumexp "torch.logsumexp") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.long()`](generated/torch.Tensor.long.html#torch.Tensor.long "torch.Tensor.long") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.lt()`](generated/torch.Tensor.lt.html#torch.Tensor.lt "torch.Tensor.lt"), [`torch.lt()`](generated/torch.lt.html#torch.lt "torch.lt") | [从输入统一名称](#unifies-names-from-inputs-doc) | -| [`torch.manual_seed()`](generated/torch.manual_seed.html#torch.manual_seed "torch.manual_seed") | 无 | -| [`Tensor.masked_fill()`](generated/torch.Tensor.masked_fill.html#torch.Tensor.masked_fill "torch.Tensor.masked_fill"), `torch.masked_fill()` | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.masked_fill_()`](generated/torch.Tensor.masked_fill_.html#torch.Tensor.masked_fill_ "torch.Tensor.masked_fill_") | 无 | -| [`Tensor.masked_select()`](generated/torch.Tensor.masked_select.html#torch.Tensor.masked_select "torch.Tensor.masked_select"), [`torch.masked_select()`](generated/torch.masked_select.html#torch.masked_select "torch.masked_select") | 将掩码与输入对齐，然后统一输入张量的名称 | -| [`Tensor.matmul()`](generated/torch.Tensor.matmul.html#torch.Tensor.matmul "torch.Tensor.matmul"), [`torch.matmul()`](generated/torch.matmul.html#torch.matmul "torch.matmul") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.mean()`](generated/torch.Tensor.mean.html#torch.Tensor.mean "torch.Tensor.mean"), [`torch.mean()`](generated/torch.mean.html#torch.mean "torch.mean") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.median()`](generated/torch.Tensor.median.html#torch.Tensor.median "torch.Tensor.median"), [`torch.median()`](generated/torch.median.html#torch.median "torch.median") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.nanmedian()`](generated/torch.Tensor.nanmedian.html#torch.Tensor.nanmedian "torch.Tensor.nanmedian"), [`torch.nanmedian()`](generated/torch.nanmedian.html#torch.nanmedian "torch.nanmedian") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.mm()`](generated/torch.Tensor.mm.html#torch.Tensor.mm "torch.Tensor.mm"), [`torch.mm()`](generated/torch.mm.html#torch.mm "torch.mm") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.mode()`](generated/torch.Tensor.mode.html#torch.Tensor.mode "torch.Tensor.mode"), [`torch.mode()`](generated/torch.mode.html#torch.mode "torch.mode") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.mul()`](generated/torch.Tensor.mul.html#torch.Tensor.mul "torch.Tensor.mul"), [`torch.mul()`](generated/torch.mul.html#torch.mul "torch.mul") | [从输入统一名称](#unifies-names-from-inputs-doc) | -| [`Tensor.mul_()`](generated/torch.Tensor.mul_.html#torch.Tensor.mul_ "torch.Tensor.mul_") | [从输入统一名称](#unifies-names-from-inputs-doc) | -| [`Tensor.mv()`](generated/torch.Tensor.mv.html#torch.Tensor.mv "torch.Tensor.mv"), [`torch.mv()`](generated/torch.mv.html#torch.mv "torch.mv") | [消除维度](#contracts-away-dims-doc) | -| [`Tensor.names`](named_tensor.html#torch.Tensor.names "torch.Tensor.names") | 查看文档 | -| [`Tensor.narrow()`](generated/torch.Tensor.narrow.html#torch.Tensor.narrow "torch.Tensor.narrow"), [`torch.narrow()`](generated/torch.narrow.html#torch.narrow "torch.narrow") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.nbytes`](generated/torch.Tensor.nbytes.html#torch.Tensor.nbytes "torch.Tensor.nbytes") | 无 | -| [`Tensor.ndim`](generated/torch.Tensor.ndim.html#torch.Tensor.ndim "torch.Tensor.ndim") | 无 | -| [`Tensor.ndimension()`](generated/torch.Tensor.ndimension.html#torch.Tensor.ndimension "torch.Tensor.ndimension") | 无 | -| [`Tensor.ne()`](generated/torch.Tensor.ne.html#torch.Tensor.ne "torch.Tensor.ne"), [`torch.ne()`](generated/torch.ne.html#torch.ne "torch.ne") | [统一输入名称](#unifies-names-from-inputs-doc) | -| [`Tensor.neg()`](generated/torch.Tensor.neg.html#torch.Tensor.neg "torch.Tensor.neg"), [`torch.neg()`](generated/torch.neg.html#torch.neg "torch.neg") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.neg_()`](generated/torch.Tensor.neg_.html#torch.Tensor.neg_ "torch.Tensor.neg_") | 无 | -| [`torch.normal()`](generated/torch.normal.html#torch.normal "torch.normal") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.normal_()`](generated/torch.Tensor.normal_.html#torch.Tensor.normal_ "torch.Tensor.normal_") | 无 | -| [`Tensor.numel()`](generated/torch.Tensor.numel.html#torch.Tensor.numel "torch.Tensor.numel"), [`torch.numel()`](generated/torch.numel.html#torch.numel "torch.numel") | 无 | -| [`torch.ones()`](generated/torch.ones.html#torch.ones "torch.ones") | [工厂函数](#factory-doc) | -| [`Tensor.pow()`](generated/torch.Tensor.pow.html#torch.Tensor.pow "torch.Tensor.pow"), [`torch.pow()`](generated/torch.pow.html#torch.pow "torch.pow") | [统一输入名称](#unifies-names-from-inputs-doc) | -| [`Tensor.pow_()`](generated/torch.Tensor.pow_.html#torch.Tensor.pow_ "torch.Tensor.pow_") | 无 | -| [`Tensor.prod()`](generated/torch.Tensor.prod.html#torch.Tensor.prod "torch.Tensor.prod"), [`torch.prod()`](generated/torch.prod.html#torch.prod "torch.prod") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.rad2deg()`](generated/torch.Tensor.rad2deg.html#torch.Tensor.rad2deg "torch.Tensor.rad2deg"), [`torch.rad2deg()`](generated/torch.rad2deg.html#torch.rad2deg "torch.rad2deg") | [保留输入名称](#keeps-input-names-doc) | +| `Tensor.index_fill()`, `torch.index_fill()` | 保留输入名称 | +| `Tensor.index_fill_()` | 无 | +| `Tensor.int()` | 保留输入名称 | +| `Tensor.is_contiguous()` | 无 | +| `Tensor.is_cuda` | 无 | +| `Tensor.is_floating_point()`, `torch.is_floating_point()` | 无 | +| `Tensor.is_leaf` | 无 | +| `Tensor.is_pinned()` | 无 | +| `Tensor.is_shared()` | 无 | +| `Tensor.is_signed()`, `torch.is_signed()` | 无 | +| `Tensor.is_sparse` | 无 | +| `Tensor.is_sparse_csr` | 无 | +| `torch.is_tensor()` | 无 | +| `Tensor.item()` | 无 | +| `Tensor.itemsize` | 无 | +| `Tensor.kthvalue()`, `torch.kthvalue()` | 移除维度 | +| `Tensor.le()`, `torch.le()` | 从输入中统一名称 | +| `Tensor.log()`, `torch.log()` | 保留输入名称 | +| `Tensor.log10()`, `torch.log10()` | 保留输入名称 | +| `Tensor.log10_()` | 无 | +| `Tensor.log1p()`, `torch.log1p()` | 保留输入名称 | +| `Tensor.log1p_()` | 无 | +| `Tensor.log2()`, `torch.log2()` | 保留输入名称 | +| `Tensor.log2_()` | 无 | +| `Tensor.log_()` | 无 | +| `Tensor.log_normal_()` | 无 | +| `Tensor.logical_not()`, `torch.logical_not()` | 保留输入名称 | +| `Tensor.logical_not_()` | 无 | +| `Tensor.logsumexp()`, `torch.logsumexp()` | 移除维度 | +| `Tensor.long()` | 保留输入名称 | +| `Tensor.lt()`, `torch.lt()` | 从输入统一名称 | +| `torch.manual_seed()` | 无 | +| `Tensor.masked_fill()`, `torch.masked_fill()` | 保留输入名称 | +| `Tensor.masked_fill_()` | 无 | +| `Tensor.masked_select()`, `torch.masked_select()` | 将掩码与输入对齐，然后统一输入张量的名称 | +| `Tensor.matmul()`, `torch.matmul()` | 消除维度 | +| `Tensor.mean()`, `torch.mean()` | 移除维度 | +| `Tensor.median()`, `torch.median()` | 移除维度 | +| `Tensor.nanmedian()`, `torch.nanmedian()` | 移除维度 | +| `Tensor.mm()`, `torch.mm()` | 消除维度 | +| `Tensor.mode()`, `torch.mode()` | 移除维度 | +| `Tensor.mul()`, `torch.mul()` | 从输入统一名称 | +| `Tensor.mul_()` | 从输入统一名称 | +| `Tensor.mv()`, `torch.mv()` | 消除维度 | +| `Tensor.names` | 查看文档 | +| `Tensor.narrow()`, `torch.narrow()` | 保留输入名称 | +| `Tensor.nbytes` | 无 | +| `Tensor.ndim` | 无 | +| `Tensor.ndimension()` | 无 | +| `Tensor.ne()`, `torch.ne()` | 统一输入名称 | +| `Tensor.neg()`, `torch.neg()` | 保留输入名称 | +| `Tensor.neg_()` | 无 | +| `torch.normal()` | 保留输入名称 | +| `Tensor.normal_()` | 无 | +| `Tensor.numel()`, `torch.numel()` | 无 | +| `torch.ones()` | 工厂函数 | +| `Tensor.pow()`, `torch.pow()` | 统一输入名称 | +| `Tensor.pow_()` | 无 | +| `Tensor.prod()`, `torch.prod()` | 移除维度 | +| `Tensor.rad2deg()`, `torch.rad2deg()` | 保留输入名称 | | `Tensor.rad2deg_()` | 无 | -| [`torch.rand()`](generated/torch.rand.html#torch.rand "torch.rand") | [工厂函数](#factory-doc) | -| [`torch.rand()`](generated/torch.rand.html#torch.rand "torch.rand") | [工厂函数](#factory-doc) | -| [`torch.randn()`](generated/torch.randn.html#torch.randn "torch.randn") | [工厂函数](#factory-doc) | -| [`torch.randn()`](generated/torch.randn.html#torch.randn "torch.randn") | [工厂函数](#factory-doc) | -| [`Tensor.random_()`](generated/torch.Tensor.random_.html#torch.Tensor.random_ "torch.Tensor.random_") | 无 | -| [`Tensor.reciprocal()`](generated/torch.Tensor.reciprocal.html#torch.Tensor.reciprocal "torch.Tensor.reciprocal"), [`torch.reciprocal()`](generated/torch.reciprocal.html#torch.reciprocal "torch.reciprocal") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.reciprocal_()`](generated/torch.Tensor.reciprocal_.html#torch.Tensor.reciprocal_ "torch.Tensor.reciprocal_") | 无 | -| [`Tensor.refine_names()`](named_tensor.html#torch.Tensor.refine_names "torch.Tensor.refine_names") | 查看文档 | -| [`Tensor.register_hook()`](generated/torch.Tensor.register_hook.html#torch.Tensor.register_hook "torch.Tensor.register_hook") | 无 | -| [`Tensor.register_post_accumulate_grad_hook()`](generated/torch.Tensor.register_post_accumulate_grad_hook.html#torch.Tensor.register_post_accumulate_grad_hook "torch.Tensor.register_post_accumulate_grad_hook") | 无 | -| [`Tensor.rename()`](named_tensor.html#torch.Tensor.rename "torch.Tensor.rename") | 查看文档 | -| [`Tensor.rename_()`](named_tensor.html#torch.Tensor.rename_ "torch.Tensor.rename_") | 查看文档 | -| [`Tensor.requires_grad`](generated/torch.Tensor.requires_grad.html#torch.Tensor.requires_grad "torch.Tensor.requires_grad") | 无 | -| [`Tensor.requires_grad_()`](generated/torch.Tensor.requires_grad_.html#torch.Tensor.requires_grad_ "torch.Tensor.requires_grad_") | 无 | -| [`Tensor.resize_()`](generated/torch.Tensor.resize_.html#torch.Tensor.resize_ "torch.Tensor.resize_") | 仅允许不改变形状的调整 | -| [`Tensor.resize_as_()`](generated/torch.Tensor.resize_as_.html#torch.Tensor.resize_as_ "torch.Tensor.resize_as_") | 仅允许不改变形状的调整大小 | -| [`Tensor.round()`](generated/torch.Tensor.round.html#torch.Tensor.round "torch.Tensor.round"), [`torch.round()`](generated/torch.round.html#torch.round "torch.round") | 保留输入名称 | -| [`Tensor.round_()`](generated/torch.Tensor.round_.html#torch.Tensor.round_ "torch.Tensor.round_") | 无 | -| [`Tensor.rsqrt()`](generated/torch.Tensor.rsqrt.html#torch.Tensor.rsqrt "torch.Tensor.rsqrt"), [`torch.rsqrt()`](generated/torch.rsqrt.html#torch.rsqrt "torch.rsqrt") | 保留输入名称 | -| [`Tensor.rsqrt_()`](generated/torch.Tensor.rsqrt_.html#torch.Tensor.rsqrt_ "torch.Tensor.rsqrt_") | 无 | -| [`Tensor.select()`](generated/torch.Tensor.select.html#torch.Tensor.select "torch.Tensor.select"), [`torch.select()`](generated/torch.select.html#torch.select "torch.select") | 移除维度 | -| [`Tensor.short()`](generated/torch.Tensor.short.html#torch.Tensor.short "torch.Tensor.short") | 保留输入名称 | -| [`Tensor.sigmoid()`](generated/torch.Tensor.sigmoid.html#torch.Tensor.sigmoid "torch.Tensor.sigmoid"), [`torch.sigmoid()`](generated/torch.sigmoid.html#torch.sigmoid "torch.sigmoid") | 保留输入名称 | -| [`Tensor.sigmoid_()`](generated/torch.Tensor.sigmoid_.html#torch.Tensor.sigmoid_ "torch.Tensor.sigmoid_") | 无 | -| [`Tensor.sign()`](generated/torch.Tensor.sign.html#torch.Tensor.sign "torch.Tensor.sign"), [`torch.sign()`](generated/torch.sign.html#torch.sign "torch.sign") | 保留输入名称 | -| [`Tensor.sign_()`](generated/torch.Tensor.sign_.html#torch.Tensor.sign_ "torch.Tensor.sign_") | 无 | -| [`Tensor.sgn()`](generated/torch.Tensor.sgn.html#torch.Tensor.sgn "torch.Tensor.sgn"), [`torch.sgn()`](generated/torch.sgn.html#torch.sgn "torch.sgn") | 保留输入名称 | -| [`Tensor.sgn_()`](generated/torch.Tensor.sgn_.html#torch.Tensor.sgn_ "torch.Tensor.sgn_") | 无 | -| [`Tensor.sin()`](generated/torch.Tensor.sin.html#torch.Tensor.sin "torch.Tensor.sin"), [`torch.sin()`](generated/torch.sin.html#torch.sin "torch.sin") | 保留输入名称 | -| [`Tensor.sin_()`](generated/torch.Tensor.sin_.html#torch.Tensor.sin_ "torch.Tensor.sin_") | 无 | -| [`Tensor.sinh()`](generated/torch.Tensor.sinh.html#torch.Tensor.sinh "torch.Tensor.sinh"), [`torch.sinh()`](generated/torch.sinh.html#torch.sinh "torch.sinh") | 保留输入名称 | -| [`Tensor.sinh_()`](generated/torch.Tensor.sinh_.html#torch.Tensor.sinh_ "torch.Tensor.sinh_") | 无 | -| [`Tensor.asinh()`](generated/torch.Tensor.asinh.html#torch.Tensor.asinh "torch.Tensor.asinh"), [`torch.asinh()`](generated/torch.asinh.html#torch.asinh "torch.asinh") | 保留输入名称 | -| [`Tensor.asinh_()`](generated/torch.Tensor.asinh_.html#torch.Tensor.asinh_ "torch.Tensor.asinh_") | 无 | -| [`Tensor.size()`](generated/torch.Tensor.size.html#torch.Tensor.size "torch.Tensor.size") | 无 | -| [`Tensor.softmax()`](generated/torch.Tensor.softmax.html#torch.Tensor.softmax "torch.Tensor.softmax"), [`torch.softmax()`](generated/torch.softmax.html#torch.softmax "torch.softmax") | 保留输入名称 | -| [`Tensor.split()`](generated/torch.Tensor.split.html#torch.Tensor.split "torch.Tensor.split"), [`torch.split()`](generated/torch.split.html#torch.split "torch.split") | 保留输入名称 | -| [`Tensor.sqrt()`](generated/torch.Tensor.sqrt.html#torch.Tensor.sqrt "torch.Tensor.sqrt"), [`torch.sqrt()`](generated/torch.sqrt.html#torch.sqrt "torch.sqrt") | 保留输入名称 | -| [`Tensor.sqrt_()`](generated/torch.Tensor.sqrt_.html#torch.Tensor.sqrt_ "torch.Tensor.sqrt_") | 无 | -| [`Tensor.squeeze()`](generated/torch.Tensor.squeeze.html#torch.Tensor.squeeze "torch.Tensor.squeeze"), [`torch.squeeze()`](generated/torch.squeeze.html#torch.squeeze "torch.squeeze") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.std()`](generated/torch.Tensor.std.html#torch.Tensor.std "torch.Tensor.std"), [`torch.std()`](generated/torch.std.html#torch.std "torch.std") | [移除维度](#removes-dimensions-doc) | -| [`torch.std_mean()`](generated/torch.std_mean.html#torch.std_mean "torch.std_mean") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.stride()`](generated/torch.Tensor.stride.html#torch.Tensor.stride "torch.Tensor.stride") | 无 | -| [`Tensor.sub()`](generated/torch.Tensor.sub.html#torch.Tensor.sub "torch.Tensor.sub"), [`torch.sub()`](generated/torch.sub.html#torch.sub "torch.sub") | [统一输入的名称](#unifies-names-from-inputs-doc) | -| [`Tensor.sub_()`](generated/torch.Tensor.sub_.html#torch.Tensor.sub_ "torch.Tensor.sub_") | [统一输入的名称](#unifies-names-from-inputs-doc) | -| [`Tensor.sum()`](generated/torch.Tensor.sum.html#torch.Tensor.sum "torch.Tensor.sum"), [`torch.sum()`](generated/torch.sum.html#torch.sum "torch.sum") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.tan()`](generated/torch.Tensor.tan.html#torch.Tensor.tan "torch.Tensor.tan"), [`torch.tan()`](generated/torch.tan.html#torch.tan "torch.tan") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.tan_()`](generated/torch.Tensor.tan_.html#torch.Tensor.tan_ "torch.Tensor.tan_") | 无 | -| [`Tensor.tanh()`](generated/torch.Tensor.tanh.html#torch.Tensor.tanh "torch.Tensor.tanh"), [`torch.tanh()`](generated/torch.tanh.html#torch.tanh "torch.tanh") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.tanh_()`](generated/torch.Tensor.tanh_.html#torch.Tensor.tanh_ "torch.Tensor.tanh_") | 无 | -| [`Tensor.atanh()`](generated/torch.Tensor.atanh.html#torch.Tensor.atanh "torch.Tensor.atanh"), [`torch.atanh()`](generated/torch.atanh.html#torch.atanh "torch.atanh") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.atanh_()`](generated/torch.Tensor.atanh_.html#torch.Tensor.atanh_ "torch.Tensor.atanh_") | 无 | -| [`torch.tensor()`](generated/torch.tensor.html#torch.tensor "torch.tensor") | [工厂函数](#factory-doc) | -| [`Tensor.to()`](generated/torch.Tensor.to.html#torch.Tensor.to "torch.Tensor.to") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.topk()`](generated/torch.Tensor.topk.html#torch.Tensor.topk "torch.Tensor.topk"), [`torch.topk()`](generated/torch.topk.html#torch.topk "torch.topk") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.transpose()`](generated/torch.Tensor.transpose.html#torch.Tensor.transpose "torch.Tensor.transpose"), [`torch.transpose()`](generated/torch.transpose.html#torch.transpose "torch.transpose") | [重新排列维度](#permutes-dimensions-doc) | -| [`Tensor.trunc()`](generated/torch.Tensor.trunc.html#torch.Tensor.trunc "torch.Tensor.trunc"), [`torch.trunc()`](generated/torch.trunc.html#torch.trunc "torch.trunc") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.trunc_()`](generated/torch.Tensor.trunc_.html#torch.Tensor.trunc_ "torch.Tensor.trunc_") | 无 | -| [`Tensor.type()`](generated/torch.Tensor.type.html#torch.Tensor.type "torch.Tensor.type") | 无 | -| [`Tensor.type_as()`](generated/torch.Tensor.type_as.html#torch.Tensor.type_as "torch.Tensor.type_as") | [保留输入名称](#keeps-input-names-doc) | -| [`Tensor.unbind()`](generated/torch.Tensor.unbind.html#torch.Tensor.unbind "torch.Tensor.unbind"), [`torch.unbind()`](generated/torch.unbind.html#torch.unbind "torch.unbind") | [移除维度](#removes-dimensions-doc) | -| [`Tensor.unflatten()`](generated/torch.Tensor.unflatten.html#torch.Tensor.unflatten "torch.Tensor.unflatten") | 查看文档 | -| [`Tensor.uniform_()`](generated/torch.Tensor.uniform_.html#torch.Tensor.uniform_ "torch.Tensor.uniform_") | 无 | -| [`Tensor.var()`](generated/torch.Tensor.var.html#torch.Tensor.var "torch.Tensor.var"), [`torch.var()`](generated/torch.var.html#torch.var "torch.var") | [删除维度](#removes-dimensions-doc) | -| [`torch.var_mean()`](generated/torch.var_mean.html#torch.var_mean "torch.var_mean") | [删除维度](#removes-dimensions-doc) | -| [`Tensor.zero_()`](generated/torch.Tensor.zero_.html#torch.Tensor.zero_ "torch.Tensor.zero_") | None | -| [`torch.zeros()`](generated/torch.zeros.html#torch.zeros "torch.zeros") | [工厂函数](#factory-doc) | +| `torch.rand()` | 工厂函数 | +| `torch.rand()` | 工厂函数 | +| `torch.randn()` | 工厂函数 | +| `torch.randn()` | 工厂函数 | +| `Tensor.random_()` | 无 | +| `Tensor.reciprocal()`, `torch.reciprocal()` | 保留输入名称 | +| `Tensor.reciprocal_()` | 无 | +| `Tensor.refine_names()` | 查看文档 | +| `Tensor.register_hook()` | 无 | +| `Tensor.register_post_accumulate_grad_hook()` | 无 | +| `Tensor.rename()` | 查看文档 | +| `Tensor.rename_()` | 查看文档 | +| `Tensor.requires_grad` | 无 | +| `Tensor.requires_grad_()` | 无 | +| `Tensor.resize_()` | 仅允许不改变形状的调整 | +| `Tensor.resize_as_()` | 仅允许不改变形状的调整大小 | +| `Tensor.round()`, `torch.round()` | 保留输入名称 | +| `Tensor.round_()` | 无 | +| `Tensor.rsqrt()`, `torch.rsqrt()` | 保留输入名称 | +| `Tensor.rsqrt_()` | 无 | +| `Tensor.select()`, `torch.select()` | 移除维度 | +| `Tensor.short()` | 保留输入名称 | +| `Tensor.sigmoid()`, `torch.sigmoid()` | 保留输入名称 | +| `Tensor.sigmoid_()` | 无 | +| `Tensor.sign()`, `torch.sign()` | 保留输入名称 | +| `Tensor.sign_()` | 无 | +| `Tensor.sgn()`, `torch.sgn()` | 保留输入名称 | +| `Tensor.sgn_()` | 无 | +| `Tensor.sin()`, `torch.sin()` | 保留输入名称 | +| `Tensor.sin_()` | 无 | +| `Tensor.sinh()`, `torch.sinh()` | 保留输入名称 | +| `Tensor.sinh_()` | 无 | +| `Tensor.asinh()`, `torch.asinh()` | 保留输入名称 | +| `Tensor.asinh_()` | 无 | +| `Tensor.size()` | 无 | +| `Tensor.softmax()`, `torch.softmax()` | 保留输入名称 | +| `Tensor.split()`, `torch.split()` | 保留输入名称 | +| `Tensor.sqrt()`, `torch.sqrt()` | 保留输入名称 | +| `Tensor.sqrt_()` | 无 | +| `Tensor.squeeze()`, `torch.squeeze()` | 移除维度 | +| `Tensor.std()`, `torch.std()` | 移除维度 | +| `torch.std_mean()` | 移除维度 | +| `Tensor.stride()` | 无 | +| `Tensor.sub()`, `torch.sub()` | 统一输入的名称 | +| `Tensor.sub_()` | 统一输入的名称 | +| `Tensor.sum()`, `torch.sum()` | 移除维度 | +| `Tensor.tan()`, `torch.tan()` | 保留输入名称 | +| `Tensor.tan_()` | 无 | +| `Tensor.tanh()`, `torch.tanh()` | 保留输入名称 | +| `Tensor.tanh_()` | 无 | +| `Tensor.atanh()`, `torch.atanh()` | 保留输入名称 | +| `Tensor.atanh_()` | 无 | +| `torch.tensor()` | 工厂函数 | +| `Tensor.to()` | 保留输入名称 | +| `Tensor.topk()`, `torch.topk()` | 移除维度 | +| `Tensor.transpose()`, `torch.transpose()` | 重新排列维度 | +| `Tensor.trunc()`, `torch.trunc()` | 保留输入名称 | +| `Tensor.trunc_()` | 无 | +| `Tensor.type()` | 无 | +| `Tensor.type_as()` | 保留输入名称 | +| `Tensor.unbind()`, `torch.unbind()` | 移除维度 | +| `Tensor.unflatten()` | 查看文档 | +| `Tensor.uniform_()` | 无 | +| `Tensor.var()`, `torch.var()` | 删除维度 | +| `torch.var_mean()` | 删除维度 | +| `Tensor.zero_()` | None | +| `torch.zeros()` | 工厂函数 | ## 保留输入名称 @@ -254,7 +254,7 @@ ('N', 'C') ``` ## 删除维度 -所有类似[`sum()`](generated/torch.Tensor.sum.html#torch.Tensor.sum "torch.Tensor.sum")的减少操作通过减少所需维度来删除维度。其他操作，如[`select()`](generated/torch.Tensor.select.html#torch.Tensor.select "torch.Tensor.select")和[`squeeze()`](generated/torch.Tensor.squeeze.html#torch.Tensor.squeeze "torch.Tensor.squeeze")会删除维度。 +所有类似`sum()`的减少操作通过减少所需维度来删除维度。其他操作，如`select()`和`squeeze()`会删除维度。 无论何时可以将整数维度索引传递给运算符，也可以传递维度名称。接受维度索引列表的函数也可以接受维度名称列表。 @@ -277,7 +277,7 @@ ('N', 'C', 'H', 'W') ``` ## 统一输入的名称[](#unifies-names-from-inputs "Permalink to this heading") -所有二元算术运算都遵循此规则。广播操作仍然从右侧按位置广播，以保持与未命名张量的兼容性。要通过名称执行显式广播，请使用[`Tensor.align_as()`](named_tensor.html#torch.Tensor.align_as "torch.Tensor.align_as")。 +所有二元算术运算都遵循此规则。广播操作仍然从右侧按位置广播，以保持与未命名张量的兼容性。要通过名称执行显式广播，请使用`Tensor.align_as()`。 + 检查名称：所有名称必须从右侧按位置匹配。即，在`tensor + other`中，对于所有`i`，`match(tensor.names[i], other.names[i])`必须为真，其中`i`在`(-min(tensor.dim(), other.dim()) + 1, -1]`中。 @@ -302,7 +302,7 @@ + `match(tensor.names[-2], tensor.names[-2])`为`True` -+ 因为我们在[`tensor`](generated/torch.tensor.html#torch.tensor "torch.tensor")中将`None`与`'C'`匹配，因此请确保`'C'`不存在于[`tensor`](generated/torch.tensor.html#torch.tensor "torch.tensor")中（它不存在）。 ++ 因为我们在`tensor`中将`None`与`'C'`匹配，因此请确保`'C'`不存在于`tensor`中（它不存在）。 + 检查确保`'N'`不存在于`other`中（不存在）。 @@ -334,9 +334,9 @@ across both lists. 注意 -在最后两个示例中，可以通过名称对齐张量，然后执行加法。使用[`Tensor.align_as()`](named_tensor.html#torch.Tensor.align_as "torch.Tensor.align_as")按名称对齐张量，或使用[`Tensor.align_to()`](named_tensor.html#torch.Tensor.align_to "torch.Tensor.align_to")按自定义维度顺序对齐张量。 ## 重新排列维度 +在最后两个示例中，可以通过名称对齐张量，然后执行加法。使用`Tensor.align_as()`按名称对齐张量，或使用`Tensor.align_to()`按自定义维度顺序对齐张量。 ## 重新排列维度 -一些操作，比如[`Tensor.t()`](generated/torch.Tensor.t.html#torch.Tensor.t "torch.Tensor.t")，会改变维度的顺序。维度名称附加到各个维度上，因此它们也会被重新排列。 +一些操作，比如`Tensor.t()`，会改变维度的顺序。维度名称附加到各个维度上，因此它们也会被重新排列。 如果运算符接受位置索引`dim`，也可以将维度名称作为`dim`。 @@ -350,7 +350,7 @@ across both lists. ('C', 'N') ```##收缩维度 -矩阵乘法函数遵循某种变体。让我们先看看[`torch.mm()`](generated/torch.mm.html#torch.mm "torch.mm")，然后推广批量矩阵乘法的规则。 +矩阵乘法函数遵循某种变体。让我们先看看`torch.mm()`，然后推广批量矩阵乘法的规则。 对于`torch.mm(tensor, other)`： @@ -367,7 +367,7 @@ across both lists. 从本质上讲，矩阵乘法在两个维度上执行点积，将它们折叠。当两个张量进行矩阵乘法时，收缩的维度消失，不会出现在输出张量中。 -[`torch.mv()`](generated/torch.mv.html#torch.mv "torch.mv")，[`torch.dot()`](generated/torch.dot.html#torch.dot "torch.dot")的工作方式类似：名称推断不检查输入名称，并移除参与点积的维度： +`torch.mv()`，`torch.dot()`的工作方式类似：名称推断不检查输入名称，并移除参与点积的维度： ```py >>> x = torch.randn(3, 3, names=('N', 'D')) @@ -378,7 +378,7 @@ across both lists. 现在，让我们看看`torch.matmul(tensor, other)`。假设`tensor.dim() >= 2`且`other.dim() >= 2`。 -+ 检查名称：检查输入的批量维度是否对齐且可广播。查看[从输入统一名称](#unifies-names-from-inputs-doc)以了解输入对齐的含义。 ++ 检查名称：检查输入的批量维度是否对齐且可广播。查看从输入统一名称以了解输入对齐的含义。 + 传播名称：结果名称通过统一批量维度并移除收缩维度来获得：`unify(tensor.names[:-2], other.names[:-2]) + (tensor.names[-2], other.names[-1])`。 @@ -393,7 +393,7 @@ across both lists. ('A', 'B', 'C', 'F') ``` -最后，许多matmul函数有融合的`add`版本。即，[`addmm()`](generated/torch.addmm.html#torch.addmm "torch.addmm")和[`addmv()`](generated/torch.addmv.html#torch.addmv "torch.addmv")。这些被视为对`mm()`和`add()`进行名称推断的组合。##工厂函数 +最后，许多 matmul 函数有融合的`add`版本。即，`addmm()`和`addmv()`。这些被视为对`mm()`和`add()`进行名称推断的组合。##工厂函数 工厂函数现在接受一个新的`names`参数，将每个维度与一个名称关联起来。 diff --git a/totrans/doc22_097.md b/totrans/doc22_097.md index 807fdb7d..cb0235c1 100644 --- a/totrans/doc22_097.md +++ b/totrans/doc22_097.md @@ -1,12 +1,12 @@ # torch.__config__ -> 原文：[https://pytorch.org/docs/stable/config_mod.html](https://pytorch.org/docs/stable/config_mod.html) +> 原文：[`pytorch.org/docs/stable/config_mod.html`](https://pytorch.org/docs/stable/config_mod.html) ```py torch.__config__.show()¶ ``` -返回一个包含PyTorch配置描述的易读字符串。 +返回一个包含 PyTorch 配置描述的易读字符串。 ```py torch.__config__.parallel_info()¶ diff --git a/totrans/doc22_098.md b/totrans/doc22_098.md index b9493811..16bedf17 100644 --- a/totrans/doc22_098.md +++ b/totrans/doc22_098.md @@ -1,8 +1,8 @@ # torch._logging -> 原文：[https://pytorch.org/docs/stable/logging.html](https://pytorch.org/docs/stable/logging.html) +> 原文：[`pytorch.org/docs/stable/logging.html`](https://pytorch.org/docs/stable/logging.html) -PyTorch具有可配置的日志系统，其中不同的组件可以具有不同的日志级别设置。例如，一个组件的日志消息可以完全禁用，而另一个组件的日志消息可以设置为最大详细程度。 +PyTorch 具有可配置的日志系统，其中不同的组件可以具有不同的日志级别设置。例如，一个组件的日志消息可以完全禁用，而另一个组件的日志消息可以设置为最大详细程度。 警告 @@ -10,14 +10,14 @@ PyTorch具有可配置的日志系统，其中不同的组件可以具有不同 警告 -此功能尚未扩展到控制PyTorch中所有组件的日志消息。 +此功能尚未扩展到控制 PyTorch 中所有组件的日志消息。 -有两种配置日志系统的方法：通过环境变量`TORCH_LOGS`或python API torch._logging.set_logs。 +有两种配置日志系统的方法：通过环境变量`TORCH_LOGS`或 python API torch._logging.set_logs。 -| [`set_logs`](generated/torch._logging.set_logs.html#torch._logging.set_logs "torch._logging.set_logs") | 设置各个组件的日志级别并切换各个日志艺术品类型。 | +| `set_logs` | 设置各个组件的日志级别并切换各个日志艺术品类型。 | | --- | --- | -环境变量`TORCH_LOGS`是一个由`[+-]`对组成的逗号分隔列表，其中``是下面指定的组件。前缀`+`将减少组件的日志级别，显示更多日志消息，而前缀`-`将增加组件的日志级别，并显示更少的日志消息。默认设置是当未在`TORCH_LOGS`中指定组件时的行为。除了组件外，还有艺术品。艺术品是与组件关联的特定调试信息片段，可以显示或不显示，因此用`+`或`-`前缀对艺术品进行操作将不起作用。由于它们与组件相关联，启用该组件通常也会启用该艺术品，除非该艺术品被指定为默认关闭。对于那些应该仅在显式启用时显示的艺术品，在_registrations.py中指定了此选项。以下组件和艺术品可通过`TORCH_LOGS`环境变量进行配置（请参阅torch._logging.set_logs以获取python API）： +环境变量`TORCH_LOGS`是一个由`[+-]`对组成的逗号分隔列表，其中``是下面指定的组件。前缀`+`将减少组件的日志级别，显示更多日志消息，而前缀`-`将增加组件的日志级别，并显示更少的日志消息。默认设置是当未在`TORCH_LOGS`中指定组件时的行为。除了组件外，还有艺术品。艺术品是与组件关联的特定调试信息片段，可以显示或不显示，因此用`+`或`-`前缀对艺术品进行操作将不起作用。由于它们与组件相关联，启用该组件通常也会启用该艺术品，除非该艺术品被指定为默认关闭。对于那些应该仅在显式启用时显示的艺术品，在 _registrations.py 中指定了此选项。以下组件和艺术品可通过`TORCH_LOGS`环境变量进行配置（请参阅 torch._logging.set_logs 以获取 python API）： 组件： @@ -27,15 +27,15 @@ PyTorch具有可配置的日志系统，其中不同的组件可以具有不同 动力 -TorchDynamo组件的日志级别。默认值：`logging.WARN` +TorchDynamo 组件的日志级别。默认值：`logging.WARN` AOT -AOTAutograd组件的日志级别。默认值：`logging.WARN` +AOTAutograd 组件的日志级别。默认值：`logging.WARN` 感应器 -TorchInductor组件的日志级别。默认值：`logging.WARN` +TorchInductor 组件的日志级别。默认值：`logging.WARN` your.custom.module @@ -45,57 +45,57 @@ your.custom.module 字节码 -是否生成TorchDynamo的原始和生成的字节码。默认值：`False` +是否生成 TorchDynamo 的原始和生成的字节码。默认值：`False` -AOT图 +AOT 图 -是否生成AOTAutograd生成的图形。默认值：`False` +是否生成 AOTAutograd 生成的图形。默认值：`False` -AOT联合图 +AOT 联合图 -是否生成AOTAutograd生成的联合前向-后向图。默认值：`False` +是否生成 AOTAutograd 生成的联合前向-后向图。默认值：`False` 已编译的自动微分 -是否从compiled_autograd发出日志。默认值：`False` +是否从 compiled_autograd 发出日志。默认值：`False` -ddp图 +ddp 图 -是否生成DDPOptimizer生成的图形。默认值：`False` +是否生成 DDPOptimizer 生成的图形。默认值：`False` 图 -是否以表格格式生成TorchDynamo捕获的图形。默认值：`False` +是否以表格格式生成 TorchDynamo 捕获的图形。默认值：`False` 图形代码 -是否生成TorchDynamo捕获的图形的Python源代码。默认值：`False` +是否生成 TorchDynamo 捕获的图形的 Python 源代码。默认值：`False` 图中断 -是否在TorchDynamo跟踪期间遇到唯一图形中断时发出消息。默认值：`False` +是否在 TorchDynamo 跟踪期间遇到唯一图形中断时发出消息。默认值：`False` 守卫 -是否为每个编译函数生成的TorchDynamo守卫。默认值：`False` +是否为每个编译函数生成的 TorchDynamo 守卫。默认值：`False` 重新编译 -是否在TorchDynamo重新编译函数时每次发出守卫失败原因和消息。默认值：`False` +是否在 TorchDynamo 重新编译函数时每次发出守卫失败原因和消息。默认值：`False` 输出代码 -是否生成TorchInductor输出代码。默认值：`False` +是否生成 TorchInductor 输出代码。默认值：`False` 时间表 -是否生成TorchInductor时间表。默认值：`False` +是否生成 TorchInductor 时间表。默认值：`False` 示例： -`TORCH_LOGS="+dynamo,aot"`将TorchDynamo的日志级别设置为`logging.DEBUG`，AOT设置为`logging.INFO` +`TORCH_LOGS="+dynamo,aot"`将 TorchDynamo 的日志级别设置为`logging.DEBUG`，AOT 设置为`logging.INFO` -`TORCH_LOGS="-dynamo,+inductor"`将TorchDynamo的日志级别设置为`logging.ERROR`，TorchInductor设置为`logging.DEBUG` +`TORCH_LOGS="-dynamo,+inductor"`将 TorchDynamo 的日志级别设置为`logging.ERROR`，TorchInductor 设置为`logging.DEBUG` `TORCH_LOGS="aot_graphs"` 将启用 `aot_graphs` artifact -- GitLab