torch.fx <a class="headerlink" href="/docs/2.5/fx.html#torch-fx" title="Permalink to this heading">¶

注意

保证此 API 的向后兼容性。

属性代码： str¶: 返回从底层 this 生成的 Python 代码。GraphGraphModule

delete_all_unused_submodules（）[来源]¶

从中删除所有未使用的子模块。self

如果满足以下任何一项条件，则认为 Module 是 “used” 的真： 1. 它有被使用的子项 2. 它的 forward 是通过节点直接调用的 3. 它具有从节点使用的非 Module 属性call_moduleget_attr

可以调用此方法来清理 without 手动调用每个未使用的 submodule。nn.Moduledelete_submodule

注意

保证此 API 的向后兼容性。

delete_submodule（目标）[来源]¶

从中删除给定的子模块。self

如果无效，则不会删除该模块目标。target

参数

target （str） – 新子模块的完全限定字符串名称（请参阅中的示例了解如何指定完全限定的字符串。nn.Module.get_submodule

返回

目标字符串是否引用了: sub模块。返回值表示不是对一个子模块。Falsetarget

返回类型

注意

保证此 API 的向后兼容性。

property graph：图形¶: 返回底层的 thisGraphGraphModule

print_readable（print_output=真，include_stride=假，include_device=假，彩色=假）[来源]¶: 返回为当前 GraphModule 及其子 GraphModule 生成的 Python 代码

警告

此 API 是实验性的，不向后兼容。

recompile（）[来源]¶

从其 attribute 中重新编译此 GraphModule。这应该是在编辑包含的的代码将过时。graphgraphGraphModule

注意

保证此 API 的向后兼容性。

返回类型: Python代码

to_folder（文件夹， module_name='FxModule'）[来源]¶

将模块转储到 with，以便它可以foldermodule_name

导入方式from <folder> import <module_name>

参数：

文件夹（Union[str， os.PathLike]）：要将代码写出到的文件夹

module_name （str）：用于 while 的顶级名称Module
写出代码

警告

此 API 是实验性的，不向后兼容。

类 torch.fx 中。Graph（owning_module=无，tracer_cls=无，tracer_extras=无）[来源]¶

Graph是 FX 中间表示中使用的主要数据结构。它由一系列 s 组成，每个 s 代表调用站点（或其他 syntactic constructs）的 Alpha Constructs）。这些列表加在一起构成了一个有效的 Python 函数。NodeNode

例如，以下代码

import torch
import torch.fx

class MyModule(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.param = torch.nn.Parameter(torch.rand(3, 4))
        self.linear = torch.nn.Linear(4, 5)

    def forward(self, x):
        return torch.topk(torch.sum(self.linear(x + self.linear.weight).relu(), dim=-1), 3)

m = MyModule()
gm = torch.fx.symbolic_trace(m)

将生成以下 Graph：

print(gm.graph)

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 = {})
    return topk_1

有关中表示的操作的语义，请参阅。Graph

注意

保证此 API 的向后兼容性。

__init__（owning_module=无，tracer_cls=无，tracer_extras=无）[来源]¶

构造一个空 Graph。

注意

保证此 API 的向后兼容性。

call_function（the_function， args=无， kwargs=无， type_expr=无）[来源]¶

将插入中。一个节点表示对 Python 可调用对象的调用，由 .call_functionNodeGraphcall_functionthe_function

参数

the_function （Callable[...， Any]） – 要调用的函数。可以是任何 PyTorch operator、Python 函数或 or 命名空间的成员。builtinsoperator
args （Optional[Tuple[Argument， ...]]） – 要传递的位置参数添加到被调用的函数中。
kwargs （Optional[Dict[str， Argument]]） – 要传递的关键字参数到被调用的函数
type_expr （Optional[Any]） – 一个可选的类型注释，表示 Python 类型，则此节点的输出将具有。

返回

新创建并插入的节点。call_function

返回类型

注意

相同的插入点和类型表达式规则适用于此方法作为 .

注意

保证此 API 的向后兼容性。

call_method（method_name， args=无， kwargs=无， type_expr=无）[来源]¶

将插入中。一个节点表示对的第 0 个元素上的给定方法的调用。call_methodNodeGraphcall_methodargs

参数

method_name （str） – 要应用于 self 参数的方法的名称。例如，如果 args[0] 是表示，然后调用该，将传递给。NodeTensorrelu()Tensorrelumethod_name
args （Optional[Tuple[Argument， ...]]） – 要传递的位置参数添加到被调用的方法中。请注意，这应该包括一个参数。self
kwargs （Optional[Dict[str， Argument]]） – 要传递的关键字参数添加到被调用的方法
type_expr （Optional[Any]） – 一个可选的类型注释，表示 Python 类型，则此节点的输出将具有。

返回

新创建并插入的节点。call_method

返回类型

注意

相同的插入点和类型表达式规则适用于此方法作为 .

注意

保证此 API 的向后兼容性。

call_module（module_name， args=无， kwargs=无， type_expr=无）[来源]¶

将插入中。一个节点表示对层次结构中 a 的 forward（）函数的调用。call_moduleNodeGraphcall_moduleModuleModule

参数

module_name （str） – 要调用的层次结构中的限定名称。例如，如果被跟踪的子模块名为，该子模块具有一个名为的子模块，该限定名称应传递给调用该模块。ModuleModuleModulefoobarfoo.barmodule_name
args （Optional[Tuple[Argument， ...]]） – 要传递的位置参数添加到被调用的方法中。请注意，这不应包含参数。self
kwargs （Optional[Dict[str， Argument]]） – 要传递的关键字参数添加到被调用的方法
type_expr （Optional[Any]） – 一个可选的类型注释，表示 Python 类型，则此节点的输出将具有。

返回

新创建并插入的节点。call_module

返回类型

注意

相同的插入点和类型表达式规则适用于此方法作为 .

注意

保证此 API 的向后兼容性。

create_node（op， target， args=无， kwargs=无， name=无， type_expr=没有）[来源]¶

创建一个并将其添加到当前插入点。请注意，当前的插入点可以通过和来设置。NodeGraph

参数

op （str） – 此 Node 的操作码。'call_function'、'call_method'、'get_attr' 之一， 'call_module'、'placeholder' 或 'output'。这些操作码的语义是在文档字符串中描述。Graph
args （Optional[Tuple[Argument， ...]]） – 是此节点的参数元组。
kwargs （Optional[Dict[str， Argument]]） – 此节点的 kwargs
name （Optional[str]） – . 这将影响在 Python 生成的代码。Node
type_expr （Optional[Any]） – 一个可选的类型注释，表示 Python 类型，则此节点的输出将具有。

返回

新创建并插入的节点。

返回类型

注意

保证此 API 的向后兼容性。

eliminate_dead_code（is_impure_node=无）[来源]¶

根据每个节点的 users，以及节点是否有任何副作用。图形必须为在调用之前进行拓扑排序。

参数

is_impure_node （Optional[Callable[[Node]， bool]]） – 返回
None（节点是否不纯。如果是）–
to （则默认行为为） –
Node.is_impure。（使用） –

返回

图形是否因传递而更改。

返回类型

例：

在消除死代码之前，下面 a = x + 1 中的 a 没有用户因此可以从图形中消除而不会产生影响。

def forward(self, x):
    a = x + 1
    return x + self.attr_1

消除死代码后，a = x + 1 已被删除，其余的的前进遗骸。

def forward(self, x):
    return x + self.attr_1

警告

死代码消除有一些启发式方法可以避免删除副作用节点（参见 Node.is_impure），但一般覆盖很糟糕，所以你应该假设这个方法不健全调用，除非您知道您的 FX 图表完全由的功能性操作，或者您提供自己的自定义检测副作用节点的功能。

注意

保证此 API 的向后兼容性。

erase_node（to_erase）[来源]¶

从中擦除。如果出现在 .NodeGraphGraph

参数: to_erase （Node）（Node）（（Node）） – 要从中擦除的 .NodeGraph

注意

保证此 API 的向后兼容性。

find_nodes（*， op， target=None， sort=True）[来源]¶

允许快速查询节点

参数

op （str） – 操作的名称
target （Optional[Target]） – 节点的目标。对于call_function，目标是必需的。对于其他操作，目标是可选的。
sort （bool） – 是否按节点出现的顺序返回节点在图表上。

返回

具有请求的 op 和 target 的节点的可迭代。

警告

此 API 是实验性的，不向后兼容。

get_attr（qualified_name， type_expr=无）[来源]¶

在 Graph 中插入节点。A 表示从层次结构中获取属性。get_attrget_attrNodeModule

参数

qualified_name （str） – 要检索的属性的完全限定名称。例如，如果跟踪的 Module 有一个名为的子模块，该子模块有一个子模块，该子模块具有一个名为、的合格 name 应作为 .foobarbazfoo.bar.bazqualified_name
type_expr （Optional[Any]） – 一个可选的类型注释，表示 Python 类型，则此节点的输出将具有。

返回

新创建并插入的节点。get_attr

返回类型

注意

相同的插入点和类型表达式规则适用于此方法如。Graph.create_node

注意

保证此 API 的向后兼容性。

graph_copy（g， val_map， return_output_node=False）[来源]¶

将给定图形中的所有节点复制到中。self

参数

g （Graph）（图形） – 要从中复制节点的源图形。
val_map （Dict[Node， Node]） – 将填充映射的字典从中的节点到中的节点。请注意，可以传递 in 中，以覆盖某些值的复制。gselfval_map

返回

其中的值现在等效于中的输出值。如果有一个节点。否则。selfggoutputNone

返回类型

可选[Union[Tuple[Any， ...]， List[Any]， Dict[str， Any]，切片，范围， Node， str， int， float， bool， complex， dtype， Tensor、设备、 memory_format、布局、 OpOverload、 SymInt、 SymBool、 SymFloat]]

注意

保证此 API 的向后兼容性。

inserting_after（n=无）[来源]¶

设置 create_node 和 Companion 方法将插入到图形中的点。

当在 'with' 语句中使用时，这将临时设置插入点和然后在 with 语句退出时恢复它：

with g.inserting_after(n):
    ... # inserting after node n
... # insert point restored to what it was previously
g.inserting_after(n) #  set the insert point permanently

参数：

n （Optional[Node]）：要插入的节点。如果为 None，则将在
整个图形的开头。

返回：: 将恢复上的插入点的资源管理器。__exit__

注意

保证此 API 的向后兼容性。

inserting_before（n=无）[来源]¶

设置 create_node 和 Companion 方法将插入到图形中的点。

当在 'with' 语句中使用时，这将临时设置插入点和然后在 with 语句退出时恢复它：

with g.inserting_before(n):
    ... # inserting before node n
... # insert point restored to what it was previously
g.inserting_before(n) #  set the insert point permanently

参数：

n （Optional[Node]）：要插入的节点。如果为 None，则将在
整个图形的开头。

返回：: 将恢复上的插入点的资源管理器。__exit__

注意

保证此 API 的向后兼容性。

lint（）[来源]¶: 对此 Graph 运行各种检查，以确保其格式正确。在特定： - 检查节点是否具有正确的所有权（由此图表拥有） - 检查节点按拓扑顺序显示 - 如果此 Graph 具有拥有的 GraphModule，则检查目标存在于该 GraphModule 中

注意

保证此 API 的向后兼容性。

node_copy（node， arg_transform=<function Graph.<lambda>>）[来源]¶

将节点从一个图形复制到另一个图形中。需要将参数从 Node 的 Graph 到 self 的 Graph。例：arg_transform

# Copying all the nodes in `g` into `new_graph`
g : torch.fx.Graph = ...
new_graph = torch.fx.graph()
value_remap = {}
for node in g.nodes:
    value_remap[node] = new_graph.node_copy(node, lambda n : value_remap[n])

参数

node （Node） – 要复制到的节点。self
arg_transform （Callable[[node]， Argument]） – 一个函数，用于将 node 中的参数转换为等效参数。在最简单的情况下，这应该从表映射原始节点中检索值 graph 设置为 .Nodeargskwargsselfself

返回类型

注意

保证此 API 的向后兼容性。

属性节点：_node_list¶

获取构成此 Graph 的 Node 的列表。

请注意，此列表表示形式是一个双向链表。突变在迭代期间（例如，删除 Node、添加 Node）是安全的。Node

返回: 节点的双向链表。请注意，可以调用此列表用于切换迭代顺序。reversed

on_generate_code（make_transformer）[来源]¶

生成 python 代码时注册 transformer 函数

参数：

make_transformer （Callable[[Optional[TransformCodeFunc]]， TransformCodeFunc]）：

返回要注册的代码转换器的函数。 on_generate_code 调用此函数以获取代码转换器。

此函数也作为其当前注册代码转换器（如果未注册任何内容，则为 None），以防不希望覆盖它。这对于将 CODE 转换器链接在一起。

返回：

一个上下文管理器，当在 with 语句中使用时，它会自动恢复以前注册的 Code Transformer。

例：

gm: fx.GraphModule = ...

# This is a code transformer we want to register. This code
# transformer prepends a pdb import and trace statement at the very
# beginning of the generated torch.fx code to allow for manual
# debugging with the PDB library.
def insert_pdb(body):
    return ["import pdb; pdb.set_trace()\n", *body]

# Registers `insert_pdb`, and overwrites the current registered
# code transformer (given by `_` to the lambda):
gm.graph.on_generate_code(
    lambda _: insert_pdb
)

# Or alternatively, registers a code transformer which first
# runs `body` through existing registered transformer, then
# through `insert_pdb`:
gm.graph.on_generate_code(
    lambda current_trans: (
        lambda body: insert_pdb(
            current_trans(body) if current_trans
            else body
        )
    )
)

gm.recompile()
gm(*inputs)  # drops into pdb

此功能还可以用作上下文管理器，其优点是自动恢复以前注册的代码转换器：

# ... continue from previous example

with gm.graph.on_generate_code(lambda _: insert_pdb):
    # do more stuff with `gm`...
    gm.recompile()
    gm(*inputs)  # drops into pdb

# now previous code transformer is restored (but `gm`'s code with pdb
# remains - that means you can run `gm` with pdb here too, until you
# run next `recompile()`).

警告

此 API 是实验性的，不向后兼容。

output（result， type_expr=None）[来源]¶

将插入中。一个节点表示 Python 代码中的语句。的值应该被退回。outputNodeGraphoutputreturnresult

参数

result （Argument） – 要返回的值。
type_expr （Optional[Any]） – 一个可选的类型注释，表示 Python 类型，则此节点的输出将具有。

注意

相同的插入点和类型表达式规则适用于此方法如。Graph.create_node

注意

保证此 API 的向后兼容性。

placeholder（name， type_expr=None， default_value）[来源]¶

在 Graph 中插入节点。A 表示函数输入。placeholderplaceholder

参数

name （str） – 输入值的名称。这与名称的 position 参数传递给 this 表示的函数。Graph
type_expr （Optional[Any]） – 一个可选的类型注释，表示 Python 类型，则此节点的输出将具有。这在一些正确生成代码的情况（例如，当使用函数时随后在 TorchScript 编译中）。
default_value （Any） – 此函数参数应采用的默认值上。注意：要允许 None 作为默认值，请检查。Signature.empty 应作为此参数传递，以指定该参数 _not_ 具有默认值。

返回类型

注意

相同的插入点和类型表达式规则适用于此方法如。Graph.create_node

注意

保证此 API 的向后兼容性。

print_tabular（）[来源]¶: 以表格形式打印图形的中间表示格式。请注意，此 API 要求模块为安装。tabulate

注意

保证此 API 的向后兼容性。

process_inputs（*args）[来源]¶: 处理 args，以便它们可以传递到 FX 图。

警告

此 API 是实验性的，不向后兼容。

process_outputs（out）[来源]¶: 警告

此 API 是实验性的，不向后兼容。

python_code（root_module， *， verbose=False， include_stride=False， include_device=False， 彩色=False）[来源]¶

将此代码转换为有效的 Python 代码。Graph

参数: root_module （str） – 要查找的根模块的名称限定名称目标。这通常是 “self”。
返回: src：表示对象的 Python 源代码 globals：src 中的全局名称字典 ->它们引用的对象。
返回类型: 一个 PythonCode 对象，由两个字段组成

注意

保证此 API 的向后兼容性。

set_codegen（codegen）[来源]¶

警告

此 API 是实验性的，不向后兼容。

类 torch.fx 中。Node（graph， name， op， target， args， kwargs， return_type=None）[来源]¶

Node是表示一个。在大多数情况下，节点表示各种实体的调用点，例如运算符、方法和模块（一些例外包括指定函数输入和输出）。每个 API 都有一个指定的函数通过其属性。每个值的语义如下：GraphNodeopNodeop

placeholder表示函数输入。该属性指定此值将采用的名称。同样是参数的名称。包含：1）什么都没有，或 2）单个参数表示函数 input 的默认参数。是 don't-care。占位符对应于图形打印输出中的函数参数（例如）。nametargetargskwargsx
get_attr从 Module 层次结构中检索参数。同样，名称是 fetch 被分配给。是参数在模块层次结构中的位置的完全限定名称。他们不在乎nametargetargskwargs
call_function将 free 函数应用于某些值。同样是要赋值的值的名称自。是要应用的函数。并表示函数的参数，遵循 Python 调用约定nametargetargskwargs
call_module将 Module 层次结构的方法中的 Module 应用于给定的参数。是如前所述。是模块层次结构中要调用的模块的完全限定名称。并表示要调用模块的参数，不包括 self 参数。forward()nametargetargskwargs
call_method对值调用方法。也一样。是方法的字符串名称以应用于参数。并表示要调用模块的参数，包括 self 参数nametargetselfargskwargs
output在其属性中包含 traced 函数的输出。这对应于 “return” 语句在 Graph 打印输出中。args[0]

注意

保证此 API 的向后兼容性。

属性 all_input_nodes：List[Node]¶

返回作为此节点输入的所有节点。这相当于迭代并且仅收集是 Node 的节点。argskwargs

返回: 按此顺序出现在和 of this 中的列表。NodesargskwargsNode

append（x）[来源]¶

在图形中的节点列表中的此节点后插入。相当于xself.next.prepend(x)

参数: x （Node）（节点） – 要放在此节点之后的节点。必须是同一图形的成员。

注意

保证此 API 的向后兼容性。

属性参数： Tuple[Optional[Union[Tuple[Any， ...]、List[Any]、Dict[str， Any]、切片、范围， Node， str， int， float， bool， complex、 dtype、Tensor、device、memory_format、layout、OpOverload、SymInt、SymBool、SymFloat]]、...]¶

this 的参数元组。论点的解释取决于节点的操作码。有关更多信息，请参阅文档字符串信息。Node

允许分配此属性。所有使用和用户的会计在分配时自动更新。

format_node（placeholder_names=无，maybe_return_typename=无）[来源]¶

返回的描述性字符串表示形式。self

此方法可以在没有参数的情况下用作调试效用。

此函数也在方法内部使用之。这些字符串一起构成了 autogenerated 函数 GraphModule 的不应以其他方式使用。__str__Graphplaceholder_namesmaybe_return_typenameforwardplaceholder_namesmaybe_return_typename

参数

placeholder_names （Optional[List[str]]） – 将存储格式化字符串的列表表示生成的函数中的占位符。仅供内部使用。forward
maybe_return_typename （Optional[List[str]]） – 将存储一个格式化字符串，表示 generated 函数。仅供内部使用。forward

返回

如果 1）我们用作内部帮助程序format_node: 在的方法中，并且 2）是一个占位符 Node，返回。否则返回当前节点。__str__GraphselfNone

返回类型

str

注意

保证此 API 的向后兼容性。

insert_arg（idx， arg）[来源]¶

将位置参数插入到具有给定索引的参数列表中。

参数

idx （int） - 要插入的元素 in 的索引。self.args
arg （Argument） – 要插入的新参数值args

注意

保证此 API 的向后兼容性。

is_impure（）[来源]¶

返回此 op 是否为 impure，即其 op 是否为占位符或输出，或者如果call_function或不纯call_module。

返回: 操作是否不纯。
返回类型: 布尔

警告

此 API 是实验性的，不向后兼容。

属性 kwargs： Dict[str， Optional[Union[Tuple[Any， ...]、List[Any]、Dict[str， Any]、切片、范围， Node， str， int， float， bool， complex、 dtype、Tensor、device、memory_format、布局、OpOverload、SymInt、SymBool、SymFloat]]]¶

此的关键字参数的 dict 。论点的解释取决于节点的操作码。有关更多信息，请参阅文档字符串信息。Node

允许分配此属性。所有使用和用户的会计在分配时自动更新。

property next：节点¶

返回 Node 链表中的 next。Node

返回: 节点链表中的下一个。Node

normalized_arguments（root， arg_types=无， kwarg_types=无， normalize_to_only_use_kwargs=False）[来源]¶

将规范化参数返回给 Python 目标。这意味着 args/kwargs 将与 module/functional 的 signature 并按位置顺序独占返回 kwargs 如果 normalize_to_only_use_kwargs 为 true。同时填充默认值。不支持仅位置 parameters 或 varargs 参数。

支持模块调用。

可能需要 arg_types 和 kwarg_types 以消除重载的歧义。

参数

root （torch.nn.Module） – 解析模块目标所依据的模块。
arg_types （Optional[Tuple[Any]]） – args 的 arg 类型元组
kwarg_types （Optional[Dict[str， Any]]） – kwargs 的 arg 类型字典
normalize_to_only_use_kwargs （bool） – 是否标准化为仅使用 kwargs。

返回

返回 NamedTuple ArgsKwargsPair，如果不成功，则返回 None。

返回类型

可选[ArgsKwargsPair]

警告

此 API 是实验性的，不向后兼容。

prepend（x）[来源]¶

在图形的节点列表中的此节点之前插入 x。例：

Before: p -> self
        bx -> x -> ax
After:  p -> x -> self
        bx -> ax

参数: x （Node） – 要放在此节点之前的节点。必须是同一图形的成员。

注意

保证此 API 的向后兼容性。

property prev：节点¶

返回 Node 链表中的上一个。Node

返回: 节点链表中的上一个。Node

replace_all_uses_with（replace_with， delete_user_cb=<function Node.<lambda>>， *， propagate_meta=False）[来源]¶

将 Graph 中的所有使用替换为 Node .selfreplace_with

参数

replace_with （Node）（节点） – 要将的所有使用替换为的节点。self
delete_user_cb （Callable） – 为确定而调用的回调是否应删除 self 节点的给定用户。
propagate_meta （bool） – 是否复制所有属性在原始节点的 .meta 字段上。为了安全起见，这仅在替换节点还没有现有的 .meta 字段。

返回

进行了此更改的 Node 的列表。

返回类型

列表[Node]

注意

保证此 API 的向后兼容性。

replace_input_with（old_input， new_input）[来源]¶

遍历的输入节点，并将的所有实例替换为。selfold_inputnew_input

参数

old_input （Node）（（Node）（节点）） – 要替换的旧输入节点。
new_input （Node）（（Node）（节点）） – 要替换的新输入节点。old_input

注意

保证此 API 的向后兼容性。

属性stack_trace：Optional[str]¶

返回在跟踪期间记录的 Python 堆栈跟踪（如果有）。使用 fx.Tracer 中，此属性通常由 Tracer.create_proxy 填充。要在跟踪期间记录堆栈跟踪以进行调试，请执行以下操作：在 Tracer 实例上设置 record_stack_traces = True。使用 dynamo 进行追踪时，默认情况下，此属性将由 OutputGraph.create_proxy 填充。

stack_trace 将在字符串的末尾具有最内层的帧。

update_arg（idx， arg）[来源]¶

更新现有位置参数以包含新值。调用后，.argself.args[idx] == arg

参数

idx （int） – 要更新的元素的索引self.args
arg （Argument） – 要写入的新参数值args

注意

保证此 API 的向后兼容性。

update_kwarg（key， arg）[来源]¶

更新现有关键字参数以包含新值。调用后，.argself.kwargs[key] == arg

参数

key （str） – 要更新的元素的 key inself.kwargs
arg （Argument） – 要写入的新参数值kwargs

注意

保证此 API 的向后兼容性。

类 torch.fx 中。Tracer（autowrap_modules=（math，）， autowrap_functions=（））[来源]¶

Tracer是实现符号跟踪功能的类之。对的调用是等效的自。torch.fx.symbolic_tracesymbolic_trace(m)Tracer().trace(m)

Tracer 可以被子类化以覆盖跟踪的各种行为过程。描述了可以覆盖的不同行为在此类上方法的文档字符串中。

注意

保证此 API 的向后兼容性。

call_module（m， forward， args， kwargs）[来源]¶

指定 this 在遇到对实例的调用。Tracernn.Module

默认情况下，行为是检查被调用的模块是否为叶模块通过。如果是，则发出一个引用 .否则，请 normally 调用 tracethrough 其函数中的操作。is_leaf_modulecall_modulemGraphModuleforward

例如，可以覆盖此方法以创建嵌套跟踪 GraphModules 或跨边界跟踪时所需的任何其他行为。Module

参数

m （Module） – 要发出调用的模块
forward （Callable） - 要调用的 forward（）方法Module
args （Tuple） – 模块 callsite 的 args
kwargs （Dict） – 模块 callsite 的 kwargs

返回

Module 调用的返回值。如果发出了节点，则这是一个值。否则，它就是任何东西值。call_moduleProxyModule

返回类型

注意

保证此 API 的向后兼容性。

create_arg（a）[来源]¶

在将值准备为用作 .Graph

默认情况下，行为包括：

迭代集合类型（例如 tuple、list、dict）和递归调用元素。create_args
给定一个 Proxy 对象，返回对基础 IR 的引用Node
给定一个非 Proxy Tensor 对象，针对各种情况发出 IR：
- 对于 Parameter（参数），发出引用该 Parameter 的节点get_attr
- 对于非 Parameter Tensor，请将 Tensor 存储在特殊的属性引用该属性。

可以重写此方法以支持更多类型。

参数: a （Any） – 要在 .ArgumentGraph
返回: 该值转换为适当的aArgument
返回类型: 论点

注意

保证此 API 的向后兼容性。

create_args_for_root（root_fn， is_module， concrete_args=无）[来源]¶: 创建与 Module 的签名对应的节点。此方法内省 root 的签名并发出节点，也支持和。placeholderroot*args**kwargs

警告

此 API 是实验性的，不向后兼容。

create_node（kind， target， args， kwargs， name=None， type_expr=无)¶

插入给定 target、args、kwargs 和 name 的图形节点。

可以重写此方法以执行额外的检查、验证或修改节点创建中使用的值。例如，一个人可能会想要禁止记录就地操作。

注意

保证此 API 的向后兼容性。

返回类型: 节点

create_proxy（kind， target， args， kwargs， name=无， type_expr=无， proxy_factory_fn=没有)¶

从给定的参数创建一个 Node，然后返回 Node 包装在 Proxy 对象中。

如果 kind = 'placeholder'，那么我们将创建一个 Node，该 Node 表示函数的参数。如果我们需要编码一个默认参数，我们使用 Tuples。是否则，对于 Nodes 为空。argsargsplaceholder

注意

保证此 API 的向后兼容性。

get_fresh_qualname（前缀）[来源]¶

获取前缀的新名称并返回它。此功能可确保它不会与图形上的现有属性冲突。

注意

保证此 API 的向后兼容性。

返回类型: str

getattr（attr， attr_val， parameter_proxy_cache）[来源]¶

指定调用 getattr 时 this 行为的方法在调用实例时。Tracernn.Module

默认情况下，该行为是返回属性的代理值。它还将 proxy 值存储在中，以便将来 calls 将重用代理，而不是创建新代理。parameter_proxy_cache

例如，在以下情况下，可以覆盖此方法以不返回代理查询参数。

参数

attr （str） – 正在查询的属性的名称
attr_val （Any） – 属性的值
parameter_proxy_cache （Dict[str， Any]） – 代理的 attr 名称缓存

返回

getattr 调用的返回值。

警告

此 API 是实验性的，不向后兼容。

is_leaf_module（m， module_qualified_name）[来源]¶

指定 given 是否为 “leaf” 模块的方法。nn.Module

叶模块是出现在 IR，由调用引用。默认情况下， PyTorch 标准库命名空间（torch.nn）中的模块是叶模块。所有其他模块都通过和进行跟踪除非另有说明，否则将记录其组成操作通过此参数。call_module

参数

m （Module） – 被查询的模块
module_qualified_name （str） – 此模块的根路径。例如如果你的模块层次结构中 submodule 包含 submodule ，其中包含 submodule ，该模块将在此处显示 qualified name 。foobarbazfoo.bar.baz

返回类型

注意

保证此 API 的向后兼容性。

iter（OBJ)¶

在迭代代理对象时调用，例如: 在 Control Flow 中使用时。通常我们不知道该怎么做，因为我们不知道代理的值，但自定义跟踪器可以附加更多信息添加到图形节点中create_node，并且可以选择返回迭代器。

注意

保证此 API 的向后兼容性。

返回类型: 迭代

keys（对象)¶

当代理对象被调用时调用了 keys（）方法。: 这就是在代理上调用 ** 时发生的情况。这应该会返回一个 iterator it ** 应该在您的自定义跟踪器中工作。

注意

保证此 API 的向后兼容性。

返回类型: 任何

path_of_module（mod）[来源]¶

在 Module 层次结构中查找的限定名称的 Helper 方法之。例如，如果有一个名为的子模块，该子模块具有传入此函数的名为的子模块将返回字符串 “foo.bar”。modrootrootfoobarbar

参数: mod （str） – 要检索其限定名称的。Module
返回类型: str

注意

保证此 API 的向后兼容性。

proxy（节点)¶

注意

保证此 API 的向后兼容性。

返回类型: 代理

to_bool（OBJ）)¶

当代理对象转换为布尔值（如: 在 Control Flow 中使用时。通常我们不知道该怎么做，因为我们不知道代理的值，但自定义跟踪器可以附加更多信息添加到图形节点中create_node，并且可以选择返回一个值。

注意

保证此 API 的向后兼容性。

返回类型: 布尔

trace（root， concrete_args=None）[来源]¶

跟踪并返回相应的 FX 表示形式。可以是实例或 Python 可调用对象。rootGraphrootnn.Module

注意，此调用后，可能与传递的在这里。例如，当 free 函数传递给时，我们将创建用作根的实例并添加嵌入的常量自。self.rootroottrace()nn.Module

参数

root （Union[Module， Callable]） – 一个或一个函数追踪。此参数的向后兼容性为保证。Module
concrete_args （Optional[Dict[str， any]]） – 应该不被视为代理。此参数是实验性的，并且 不保证其向后兼容性。

返回

A 表示传入的 .Graphroot

返回类型

图

注意

保证此 API 的向后兼容性。

类 torch.fx 中。代理（node， tracer=None）[来源]¶

Proxy对象是流经编程并记录所有操作（函数调用、方法调用、运算符）进入不断增长的 FX Graph。Nodetorch

如果你正在执行图形转换，则可以将自己的方法包装在 raw 周围，以便可以使用重载的运算符向 .ProxyNodeGraph

Proxy对象无法迭代。换句话说，象征性的如果在循环中使用 a 或 AS / 函数参数。Proxy*args**kwargs

有两种主要方法可以解决这个问题： 1. 将不可追踪的 logic 分解为顶级函数，然后使用。 2. 如果控制流是静态的（即循环跳闸计数为基于某些超参数），代码可以保留在其原始 position 并重构为如下内容：fx.wrap

for i in range(self.some_hyperparameter):
    indexed_item = proxied_value[i]

有关 Proxy 内部结构的更详细说明，请查看 torch/fx/README.md 中的 “Proxy” 部分

注意

保证此 API 的向后兼容性。

类 torch.fx 中。Interpreter（module， garbage_collect_values=True， graph=None）[来源]¶

解释器逐个节点执行 FX 图。此模式可用于许多事情，包括编写代码转换以及分析通道。

可以重写 Interpreter 类中的方法以自定义执行行为。可覆盖方法的映射在调用层次结构方面：

run()
    +-- run_node
        +-- placeholder()
        +-- get_attr()
        +-- call_function()
        +-- call_method()
        +-- call_module()
        +-- output()

例

假设我们想要交换 with 的所有实例，反之亦然（包括它们的方法等价物）。我们可以像这样子类化 Interpreter：torch.negtorch.sigmoidTensor

class NegSigmSwapInterpreter(Interpreter):
    def call_function(self, target : Target,
                      args : Tuple, kwargs : Dict) -> Any:
        if target == torch.sigmoid:
            return torch.neg(*args, **kwargs)
        return super().call_function(n)

    def call_method(self, target : Target,
                    args : Tuple, kwargs : Dict) -> Any:
        if target == 'neg':
            call_self, *args_tail = args
            return call_self.sigmoid(*args_tail, **kwargs)
        return super().call_method(n)

def fn(x):
    return torch.sigmoid(x).neg()

gm = torch.fx.symbolic_trace(fn)
input = torch.randn(3, 4)
result = NegSigmSwapInterpreter(gm).run(input)
torch.testing.assert_close(result, torch.neg(input).sigmoid())

参数

module （torch.nn.Module） – 要执行的模块
garbage_collect_values （bool） – 是否删除最后一个值 use 在 Module 的执行中。这可确保在执行。例如，可以禁用此选项以检查所有中间值。Interpreter.env
graph （Optional[Graph]） – 如果通过，解释器将执行此 graph 而不是 module.graph，使用提供的 module 参数来满足对 state 的任何请求。

注意

保证此 API 的向后兼容性。

boxed_run（args_list）[来源]¶: 通过解释运行 module 并返回结果。这将使用 “boxed” 调用约定，其中传递参数列表，该列表将被清除由口译员。这可确保及时释放 input 张量。

注意

保证此 API 的向后兼容性。

call_function（target， args， kwargs）[来源]¶

执行一个节点并返回结果。call_function

参数

target （Target） – 此节点的调用目标。请参阅 Node for 有关语义的详细信息
args （Tuple） – 此调用的位置 args 元组
kwargs （Dict） – 此调用的关键字参数的 Dict

返回类型

返回: Any：函数调用返回的值

注意

保证此 API 的向后兼容性。

call_method（target， args， kwargs）[来源]¶

执行一个节点并返回结果。call_method

参数

target （Target） – 此节点的调用目标。请参阅 Node for 有关语义的详细信息
args （Tuple） – 此调用的位置 args 元组
kwargs （Dict） – 此调用的关键字参数的 Dict

返回类型

返回: Any：方法调用返回的值

注意

保证此 API 的向后兼容性。

call_module（target， args， kwargs）[来源]¶

执行一个节点并返回结果。call_module

参数

target （Target） – 此节点的调用目标。请参阅 Node for 有关语义的详细信息
args （Tuple） – 此调用的位置 args 元组
kwargs （Dict） – 此调用的关键字参数的 Dict

返回类型