torch.fx #

注意

此 API 的向後相容性已得到保證。

property code: str#: 返回從此 GraphModule 底層的 Graph 生成的 Python 程式碼。

delete_all_unused_submodules()[source]#

從 self 中刪除所有未使用的子模組。

當滿足以下任一條件時，模組被認為是“已使用”：1. 它有已使用的子模組 2. 它的 forward 被直接透過 call_module 節點呼叫 3. 它有一個非 Module 屬性，該屬性從 get_attr 節點使用。

此方法可用於清理 nn.Module，而無需手動對每個未使用的子模組呼叫 delete_submodule。

注意

此 API 的向後相容性已得到保證。

delete_submodule(target)[source]#

從 self 中刪除給定的子模組。

如果 target 不是有效目標，則不會刪除該模組。

引數

target (str) – 新子模組的完全限定名稱（請參閱 nn.Module.get_submodule 中的示例，瞭解如何指定完全限定名稱）。

返回

目標字串是否引用了: 我們要刪除的子模組。返回值為 False 意味著 target 不是對子模組的有效引用。

返回型別

注意

此 API 的向後相容性已得到保證。

property graph: Graph#: 返回此 GraphModule 底層的 Graph。

print_readable(print_output=True, include_stride=False, include_device=False, colored=False, *, fast_sympy_print=False, expanded_def=False)[source]#

返回當前 GraphModule 及其子 GraphModule 生成的 Python 程式碼。

警告

此 API 是實驗性的，並且不向後相容。

recompile()[source]#

從其 graph 屬性重新編譯此 GraphModule。在編輯了包含的 graph 之後應呼叫此方法，否則此 GraphModule 的生成程式碼將過時。

注意

此 API 的向後相容性已得到保證。

返回型別: PythonCode

to_folder(folder, module_name='FxModule')[source]#

將模組轉儲到 folder 中，使用 module_name，以便可以

使用 from <folder> import <module_name> 匯入。

引數 (Args)

folder (Union[str, os.PathLike]): 要將程式碼寫入的資料夾。

module_name (str): 在
寫出程式碼時用於 Module 的頂級名稱。

警告

此 API 是實驗性的，並且不向後相容。

class torch.fx.Graph(owning_module=None, tracer_cls=None, tracer_extras=None)[source]#

Graph 是 FX 中間表示使用的主要資料結構。它由一系列 Node 組成，每個 Node 代表一個呼叫點（或其他語法結構）。Node 的列表共同構成一個有效的 Python 函式。

例如，以下程式碼：

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)

將產生以下圖：

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 中操作語義的資訊，請參閱 Node。

注意

此 API 的向後相容性已得到保證。

__init__(owning_module=None, tracer_cls=None, tracer_extras=None)[source]#

構造一個空的 Graph。

注意

此 API 的向後相容性已得到保證。

call_function(the_function, args=None, kwargs=None, type_expr=None, name=None)[source]#

將 call_function Node 插入到 Graph 中。call_function 節點表示對由 the_function 指定的 Python 可呼叫物件的呼叫。

引數

the_function (Callable[..., Any]) – 要呼叫的函式。可以是任何 PyTorch 運算子、Python 函式或 builtins 或 operator 名稱空間中的成員。
args (Optional[Tuple[Argument, ...]]) – 要傳遞給被呼叫函式的 positional 引數。
kwargs (Optional[Dict[str, Argument]]) – 要傳遞給被呼叫函式的 keyword 引數。
type_expr (Optional[Any]) – 一個可選的型別註解，表示此節點輸出將具有的 Python 型別。
name (Optional[str]) – 節點的名稱。如果未指定，則設定為 None。

返回

新建立並插入的 call_function 節點。

返回型別

注意

此方法的插入點和型別表示式規則與 Graph.create_node() 相同。

注意

此 API 的向後相容性已得到保證。

call_method(method_name, args=None, kwargs=None, type_expr=None)[source]#

將 call_method Node 插入到 Graph 中。call_method 節點表示對 args 的第 0 個元素上的給定方法進行的呼叫。

引數

method_name (str) – 要應用於 self 引數的方法名稱。例如，如果 args[0] 是表示 Tensor 的 Node，那麼要在該 Tensor 上呼叫 relu()，請將 relu 傳遞給 method_name。
args (Optional[Tuple[Argument, ...]]) – 要傳遞給被呼叫方法的 positional 引數。請注意，這應該包含一個 self 引數。
kwargs (Optional[Dict[str, Argument]]) – 要傳遞給被呼叫方法的 keyword 引數。
type_expr (Optional[Any]) – 一個可選的型別註解，表示此節點輸出將具有的 Python 型別。

返回

新建立並插入的 call_method 節點。

返回型別

注意

此方法的插入點和型別表示式規則與 Graph.create_node() 相同。

注意

此 API 的向後相容性已得到保證。

call_module(module_name, args=None, kwargs=None, type_expr=None)[source]#

將一個call_module Node 插入到Graph 中。call_module 節點表示在Module 層次結構中呼叫Module 的 forward() 函式。

引數

module_name (str) – 要呼叫的Module 在Module 層次結構中的限定名稱。例如，如果跟蹤的Module 包含一個名為foo 的子模組，該子模組又包含一個名為bar 的子模組，則應將限定名稱foo.bar 作為module_name 傳遞，以呼叫該模組。
args (Optional[Tuple[Argument, ...]]) – 要傳遞給被呼叫方法的 positional 引數。請注意，這不應包含self 引數。
kwargs (Optional[Dict[str, Argument]]) – 要傳遞給被呼叫方法的 keyword 引數。
type_expr (Optional[Any]) – 一個可選的型別註解，表示此節點輸出將具有的 Python 型別。

返回

新建立並插入的call_module 節點。

返回型別

注意

此方法的插入點和型別表示式規則與 Graph.create_node() 相同。

注意

此 API 的向後相容性已得到保證。

create_node(op, target, args=None, kwargs=None, name=None, type_expr=None)[source]#

建立一個Node 並將其插入到當前插入點的Graph 中。請注意，當前插入點可以透過Graph.inserting_before() 和Graph.inserting_after() 來設定。

引數

op (str) – 此 Node 的操作碼。可以是 ‘call_function’、‘call_method’、‘get_attr’、‘call_module’、‘placeholder’ 或 ‘output’。這些操作碼的語義在Graph 文件字串中有所描述。
args (Optional[Tuple[Argument, ...]]) – 是此節點的引數元組。
kwargs (Optional[Dict[str, Argument]]) – 此 Node 的 kwargs。
name (Optional[str]) – Node 的可選字串名稱。這會影響在生成的 Python 程式碼中分配給該值的名稱。
type_expr (Optional[Any]) – 一個可選的型別註解，表示此節點輸出將具有的 Python 型別。

返回

新建立並插入的節點。

返回型別

注意

此 API 的向後相容性已得到保證。

eliminate_dead_code(is_impure_node=None)[source]#

從圖中刪除所有死程式碼，基於每個節點的 use 數量以及節點是否具有任何 side effects。呼叫前必須對圖進行拓撲排序。

引數

is_impure_node (Optional[Callable[[Node], bool]]) – 一個返回
None (節點是否為 impure。如果是) –
to (則預設行為是) –
Node.is_impure. (使用) –

返回

圖是否因該過程而改變。

返回型別

示例

在消除死程式碼之前，下面 a = x + 1 中的 a 沒有 use，因此可以從圖中消除而不產生任何影響。

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

消除死程式碼後，a = x + 1 已被刪除，其餘的 forward 保持不變。

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

警告

死程式碼消除有一些啟發式方法來避免刪除具有 side effects 的節點 (參見 Node.is_impure)，但總的來說覆蓋率非常差，因此您應該假定呼叫此方法不是安全的，除非您知道您的 FX 圖完全由函式式操作組成，或者您提供了自己的自定義函式來檢測具有 side effects 的節點。

注意

此 API 的向後相容性已得到保證。

erase_node(to_erase)[source]#

從Graph 中刪除一個Node。如果該節點在Graph 中仍有 use，則會引發異常。

引數: to_erase (Node) – 要從Graph 中刪除的Node。

注意

此 API 的向後相容性已得到保證。

find_nodes(*, op, target=None, sort=True)[source]#

允許快速查詢節點。

引數

op (str) – 操作的名稱。
target (Optional[Target]) – 節點的 target。對於 call_function，target 是必需的。對於其他 op，target 是可選的。
sort (bool) – 是否按節點在圖上出現的順序返回節點。

返回

具有請求的操作和 target 的節點的可迭代物件。

警告

此 API 是實驗性的，並且不向後相容。

get_attr(qualified_name, type_expr=None)[source]#

將一個get_attr 節點插入到 Graph 中。get_attr Node 表示從Module 層次結構中獲取一個屬性。

引數

qualified_name (str) – 要檢索的屬性的完全限定名稱。例如，如果跟蹤的 Module 包含一個名為foo 的子模組，該子模組包含一個名為bar 的子模組，該子模組有一個名為baz 的屬性，則應將限定名稱foo.bar.baz 作為qualified_name 傳遞。
type_expr (Optional[Any]) – 一個可選的型別註解，表示此節點輸出將具有的 Python 型別。

返回

新建立並插入的get_attr 節點。

返回型別

注意

此方法與Graph.create_node 具有相同的插入點和型別表示式規則。

注意

此 API 的向後相容性已得到保證。

graph_copy(g, val_map, return_output_node=False)[source]#

將給定圖中的所有節點複製到self 中。

引數

g (Graph) – 要從中複製 Nodes 的源圖。
val_map (Dict[Node, Node]) – 一個字典，將填充從g 中的節點到self 中的節點的對映。請注意，可以傳入帶有值的val_map 來覆蓋某些值的複製。

返回

self 中與g 中的輸出值等效的值，如果g 有一個output 節點。否則為None。

返回型別

Optional[Union[tuple[‘Argument’, …], Sequence[Argument], Mapping[str, Argument], slice, range, Node, str, int, float, bool, complex, dtype, Tensor, device, memory_format, layout, OpOverload, SymInt, SymBool, SymFloat]]

注意

此 API 的向後相容性已得到保證。

inserting_after(n=None)[source]#

設定 create_node 和伴隨方法將插入到圖中的點。

在 `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

引數 (Args)

n (Optional[Node]): 在其之前插入的節點。如果為 None，則將在圖的開頭之後插入。
整個圖的開頭。

返回: 一個資源管理器，它將在 `__exit__` 時恢復插入點。

注意

此 API 的向後相容性已得到保證。

inserting_before(n=None)[source]#

設定 create_node 和伴隨方法將插入到圖中的點。

在 `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

引數 (Args)

n (Optional[Node]): 在其之前插入的節點。如果為 None，則將在圖的開頭之前插入。
整個圖的開頭。

返回: 一個資源管理器，它將在 `__exit__` 時恢復插入點。

注意

此 API 的向後相容性已得到保證。

lint()[source]#: 執行此 Graph 的各種檢查，以確保其結構良好。特別是： - 檢查 Nodes 是否具有正確的歸屬（屬於此圖） - 檢查 Nodes 是否按拓撲順序出現 - 如果此 Graph 具有擁有它的 GraphModule，則檢查 target 是否在該 GraphModule 中存在。

注意

此 API 的向後相容性已得到保證。

node_copy(node, arg_transform=<function Graph.<lambda>>)[source]#

將一個節點從一個圖複製到另一個圖。`arg_transform` 需要將引數從 node 的圖轉換為 self 的圖。示例

# 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 的 `args` 和 `kwargs` 中的 `Node` 引數轉換為 `self` 中等效的引數。在最簡單的情況下，這應該從一個將原始圖中的 Nodes 對映到 `self` 的表中檢索一個值。

返回型別

注意

此 API 的向後相容性已得到保證。

property nodes: list['Node']#

獲取構成此 Graph 的 Nodes 列表。

注意，這個 `Node` 列表表示是一個雙向連結串列。在迭代過程中進行修改（例如，刪除一個 Node，新增一個 Node）是安全的。

返回: Nodes 的雙向連結串列。注意，可以對此列表呼叫 `reversed` 來切換迭代順序。

on_generate_code(make_transformer)[source]#

在生成 Python 程式碼時註冊一個 transformer 函式。

引數 (Args)

make_transformer (Callable[[Optional[TransformCodeFunc]], TransformCodeFunc])
一個返回程式碼 transformer 的函式，用於註冊。此函式由 `on_generate_code` 呼叫以獲取程式碼 transformer。

此函式也作為輸入提供當前註冊的程式碼 transformer（如果未註冊，則為 None），以防不希望覆蓋它。這對於連結程式碼 transformer 很有用。

返回
一個上下文管理器，當在 `with` 語句中使用時，會自動恢復先前註冊的程式碼 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
此函式還可以用作上下文管理器，其優點是可以自動恢復先前註冊的程式碼 transformer。
# ... 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)[source]#

將一個 `output` Node 插入到Graph 中。`output` 節點表示 Python 程式碼中的 `return` 語句。`result` 是應返回的值。

引數

result (Argument) – 要返回的值。
type_expr (Optional[Any]) – 一個可選的型別註解，表示此節點輸出將具有的 Python 型別。

注意

此方法與Graph.create_node 具有相同的插入點和型別表示式規則。

注意

此 API 的向後相容性已得到保證。

output_node()[source]#

警告

此 API 是實驗性的，並且不向後相容。

返回型別: Node

placeholder(name, type_expr=None, default_value)[source]#

將一個 `placeholder` 節點插入到 Graph 中。`placeholder` 表示函式輸入。

引數

name (str) – 輸入值的名稱。這對應於此 `Graph` 所代表的函式的 positional 引數的名稱。
type_expr (Optional[Any]) – 一個可選的型別註解，表示此節點輸出的 Python 型別。在某些情況下，這對於正確的程式碼生成是必需的（例如，當函式隨後在 TorchScript 編譯中使用時）。
default_value (Any) – 此函式引數應採用的預設值。注意：為了允許將 `None` 作為預設值，應將 `inspect.Signature.empty` 作為此引數傳遞，以指定該引數*沒有*預設值。

返回型別

注意

此方法與Graph.create_node 具有相同的插入點和型別表示式規則。

注意

此 API 的向後相容性已得到保證。

print_tabular()[source]#: 以表格格式列印圖的中間表示。請注意，此 API 需要安裝 `tabulate` 模組。

注意

此 API 的向後相容性已得到保證。

process_inputs(*args)[source]#: 處理 args，以便可以將其傳遞給 FX 圖。

警告

此 API 是實驗性的，並且不向後相容。

process_outputs(out)[source]#: 警告

此 API 是實驗性的，並且不向後相容。

python_code(root_module, *, verbose=False, include_stride=False, include_device=False, colored=False, expanded_def=False)[source]#

將此 `Graph` 轉換為有效的 Python 程式碼。

引數: root_module (str) – 用於查詢限定名稱 target 的根模組的名稱。通常是 ‘self’。
返回: src：表示物件的 Python 原始碼 globals：`src` 中的全域性名稱字典 -> 它們引用的物件。
返回型別: 一個 PythonCode 物件，包含兩個欄位。

注意

此 API 的向後相容性已得到保證。

set_codegen(codegen)[source]#

警告

此 API 是實驗性的，並且不向後相容。

class torch.fx.Node(graph, name, op, target, args, kwargs, return_type=None)[source]#

`Node` 是表示 `Graph` 中單個操作的資料結構。在大多數情況下，Nodes 表示對各種實體的呼叫，例如運算子、方法和 Modules（一些例外包括指定函式輸入和輸出的節點）。每個 `Node` 都有一個由其 `op` 屬性指定的函式。`op` 每個值的 `Node` 語義如下：

`placeholder` 表示函式輸入。`name` 屬性指定該值將採用的名稱。`target` 同樣是引數的名稱。`args` 持有：1) 空，或 2) 一個表示函式輸入的預設引數的單個引數。`kwargs` 是不關心的。
`get_attr` 從模組層次結構中檢索引數。`name` 同樣是分配給獲取結果的名稱。`target` 是引數在模組層次結構中的位置的完全限定名稱。`args` 和 `kwargs` 是不關心的。
`call_function` 將一個自由函式應用於某些值。`name` 同樣是分配給該值的名稱。`target` 是要應用的函式。`args` 和 `kwargs` 表示函式的引數，遵循 Python 呼叫約定。
`call_module` 將模組層次結構中的模組的 `forward()` 方法應用於給定引數。`name` 同上。`target` 是要呼叫的模組在模組層次結構中的完全限定名稱。`args` 和 `kwargs` 表示呼叫模組的引數，*不包括 self 引數*。
`call_method` 呼叫一個值上的方法。`name` 同上。`target` 是應用於 `self` 引數的方法的字串名稱。`args` 和 `kwargs` 表示呼叫模組的引數，*包括 self 引數*。
`output` 在其 `args[0]` 屬性中包含跟蹤函式的輸出。這對應於 Graph 列印輸出中的“return”語句。

注意

此 API 的向後相容性已得到保證。

property all_input_nodes: list['Node']#

返回作為此 Node 輸入的所有 Nodes。這相當於迭代 `args` 和 `kwargs` 並僅收集是 Nodes 的值。

返回: 出現在此 `Node` 的 `args` 和 `kwargs` 中的 `Nodes` 列表，按該順序。

append(x)[source]#

在圖節點列表中在此節點之後插入 `x`。等同於 `self.next.prepend(x)`。

引數: x (Node) – 要放在此節點之後的節點。必須是同一圖的成員。

注意

此 API 的向後相容性已得到保證。

property args: tuple[Union[tuple['Argument', ...], collections.abc.Sequence['Argument'], collections.abc.Mapping[str, 'Argument'], slice, range, torch.fx.node.Node, str, int, float, bool, complex, torch.dtype, torch.Tensor, torch.device, torch.memory_format, torch.layout, torch._ops.OpOverload, torch.SymInt, torch.SymBool, torch.SymFloat, NoneType], ...]#

此 `Node` 的引數元組。引數的解釋取決於節點的 op。有關更多資訊，請參閱 Node 文件字串。

允許對此屬性進行賦值。所有 use 和 users 的計數都會在賦值時自動更新。

format_node(placeholder_names=None, maybe_return_typename=None, *, include_tensor_metadata=False)[source]#

返回 `self` 的描述性字串表示。

此方法可作為除錯實用程式使用，無需引數。

此函式還在 `Graph` 的 `__str__` 方法中用作內部助手。`placeholder_names` 和 `maybe_return_typename` 中的字串共同構成了此 Graph 外部 GraphModule 中自動生成的 `forward` 函式的簽名。`placeholder_names` 和 `maybe_return_typename` 不得在其他地方使用。

引數

placeholder_names (Optional[list[str]]) – 一個列表，將儲存表示生成的 `forward` 函式中 placeholder 的格式化字串。僅內部使用。
maybe_return_typename (Optional[list[str]]) – 一個單元素列表，將儲存表示生成的 `forward` 函式輸出的格式化字串。僅內部使用。
include_tensor_metadata (bool) – 是否包含張量元資料。

返回

如果 1) 我們正在使用 `format_node` 作為內部助手: 在 `Graph` 的 `__str__` 方法中，並且 2) `self` 是一個 placeholder Node，則返回 `None`。否則，返回當前 Node 的描述性字串表示。

返回型別

str

注意

此 API 的向後相容性已得到保證。

insert_arg(idx, arg)[source]#

將一個 positional 引數插入到具有給定索引的引數列表中。

引數

idx (int) – 要插入之前的 `self.args` 中的元素的索引。
arg (Argument) – 要插入 `args` 中的新引數值。

注意

此 API 的向後相容性已得到保證。

is_impure(impure_random=True)[source]#

返回此 op 是否為 impure，即如果其 op 是 placeholder 或 output，或者是一個 impure 的 call_function 或 call_module。

引數: impure_random (bool) – 是否將 rand op 視為 impure。
返回: op 是 impure 還是不是。
返回型別: 布林值

警告

此 API 是實驗性的，並且不向後相容。

property kwargs: dict[str, Union[tuple['Argument', ...], collections.abc.Sequence['Argument'], collections.abc.Mapping[str, 'Argument'], slice, range, torch.fx.node.Node, str, int, float, bool, complex, torch.dtype, torch.Tensor, torch.device, torch.memory_format, torch.layout, torch._ops.OpOverload, torch.SymInt, torch.SymBool, torch.SymFloat, NoneType]]#

此 `Node` 的關鍵字引數字典。引數的解釋取決於節點的 op。有關更多資訊，請參閱 Node 文件字串。

允許對此屬性進行賦值。所有 use 和 users 的計數都會在賦值時自動更新。

property next: Node#

返回連結串列中下一個 `Node`。

返回: 連結串列中下一個 `Node`。

normalized_arguments(root, arg_types=None, kwarg_types=None, normalize_to_only_use_kwargs=False)[source]#

返回 Python target 的標準化引數。這意味著 `args/kwargs` 將與 module/functional 的簽名匹配，並且如果 `normalize_to_only_use_kwargs` 為 true，則將僅按位置返回 kwargs。還將填充預設值。不支援僅 positional 引數或 varargs 引數。

支援模組呼叫。

可能需要 `arg_types` 和 `kwarg_types` 來區分過載。

引數

root (torch.nn.Module) – 用於解析模組 target 的模組。
arg_types (Optional[Tuple[Any]]) – arg 的 arg 型別元組。
kwarg_types (Optional[Dict[str, Any]]) – kwargs 的 arg 型別字典。
normalize_to_only_use_kwargs (bool) – 是否規範化為僅使用 kwargs。

返回

返回 NamedTuple ArgsKwargsPair，如果未成功則返回 `None`。

返回型別

Optional[ArgsKwargsPair]

警告

此 API 是實驗性的，並且不向後相容。

prepend(x)[source]#

在圖節點列表中在此節點之前插入 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)[source]#

將 Graph 中 `self` 的所有 use 替換為 Node `replace_with`。

引數

replace_with (Node) – 用於替換 `self` 的所有 use 的節點。
delete_user_cb (Callable) – 用於確定是否應刪除 self 節點的給定 use 的回撥函式。
propagate_meta (bool) – 是否將原始節點的 .meta 欄位中的所有屬性複製到替換節點。為安全起見，僅當替換節點尚不具有 .meta 欄位時才有效。

返回

在此更改被執行的 Nodes 列表。

返回型別

list[‘Node’]

注意

此 API 的向後相容性已得到保證。

replace_input_with(old_input, new_input)[source]#

遍歷 `self` 的輸入節點，並將 `old_input` 的所有例項替換為 `new_input`。

引數

old_input (Node) – 要被替換的舊輸入節點。
new_input (Node) – 用於替換 `old_input` 的新輸入節點。

注意

此 API 的向後相容性已得到保證。

property 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)[source]#

使用新值 `arg` 更新現有 positional 引數。呼叫後，`self.args[idx] == arg`。

引數

idx (int) – 要更新的元素在 `self.args` 中的索引。
arg (Argument) – 要寫入 `args` 中的新引數值。

注意

此 API 的向後相容性已得到保證。

update_kwarg(key, arg)[source]#

使用新值 `arg` 更新現有關鍵字引數。呼叫後，`self.kwargs[key] == arg`。

引數

key (str) – 要更新的元素在 `self.kwargs` 中的鍵。
arg (Argument) – 要寫入 `kwargs` 中的新引數值。

注意

此 API 的向後相容性已得到保證。

class torch.fx.Tracer(autowrap_modules=(math,), autowrap_functions=())[source]#

`Tracer` 是實現 `torch.fx.symbolic_trace` 的符號跟蹤功能的類。呼叫 `symbolic_trace(m)` 等同於 `Tracer().trace(m)`。

Tracer 可以被子類化以覆蓋跟蹤過程的各種行為。可以覆蓋的不同行為在此類方法的文件字串中進行了描述。

注意

此 API 的向後相容性已得到保證。

call_module(m, forward, args, kwargs)[source]#

指定此 `Tracer` 在遇到對 `nn.Module` 例項的呼叫時行為的方法。

預設情況下，行為是檢查被呼叫的模組是否為葉子模組（透過 `is_leaf_module`）。如果是，則在 `Graph` 中發出一個指向 `m` 的 `call_module` 節點。否則，正常呼叫 `Module`，跟蹤其 `forward` 函式中的操作。

可以覆蓋此方法來實現，例如，建立巢狀的跟蹤 GraphModules，或在跟蹤跨越 `Module` 邊界時執行任何其他所需行為。

引數

m (Module) – 正在發出呼叫的模組。
forward (Callable) – 要呼叫的 `Module` 的 forward() 方法。
args (Tuple) – 模組呼叫處的 args。
kwargs (Dict) – 模組呼叫處的 kwargs。

返回

來自 Module 呼叫的返回值。在發出 `call_module` 節點的情況下，這是一個 `Proxy` 值。否則，它是從 `Module` 呼叫返回的任何值。

返回型別

注意

此 API 的向後相容性已得到保證。

create_arg(a)[source]#

用於指定此 `Tracer` 在準備作為 `Graph` 中節點引數的值時的行為的方法。

預設行為包括：

迭代集合型別（例如，tuple、list、dict），並遞迴呼叫 `create_args` 來處理元素。
給定 Proxy 物件，返回對底層 IR `Node` 的引用。
給定非 Proxy Tensor 物件，為各種情況發出 IR。
- 對於 Parameter，發出指向該 Parameter 的 `get_attr` 節點。
- 對於非 Parameter Tensor，將該 Tensor 儲存在一個特殊的屬性中，該屬性指向該屬性。

可以覆蓋此方法以支援更多型別。

引數: a (Any) – 將作為 `Argument` 發出到 `Graph` 中的值。
返回: `a` 轉換為適當 `Argument` 的值。
返回型別: Argument

注意

此 API 的向後相容性已得到保證。

create_args_for_root(root_fn, is_module, concrete_args=None)[source]#: 建立與根模組（`root` Module）的簽名對應的 `placeholder` 節點。此方法內省 root 的簽名並相應地發出這些節點，還支援 `*args` 和 `**kwargs`。

警告

此 API 是實驗性的，並且不向後相容。

create_node(kind, target, args, kwargs, name=None, type_expr=None)[source]#

根據目標、引數、關鍵字引數和名稱插入圖節點。

可以覆蓋此方法以執行額外的檢查、驗證或修改用於節點建立的值。例如，有人可能希望不允許記錄就地操作。

注意

此 API 的向後相容性已得到保證。

返回型別: Node

create_proxy(kind, target, args, kwargs, name=None, type_expr=None, proxy_factory_fn=None)[source]#

根據給定的引數建立 Node，然後將 Node 包裝在 Proxy 物件中返回。

如果 kind = ‘placeholder’，那麼我們正在建立一個表示函式引數的 Node。如果需要編碼預設引數，我們使用 `args` 元組。對於 `placeholder` Nodes，`args` 否則為空。

注意

此 API 的向後相容性已得到保證。

get_fresh_qualname(prefix)[source]#

為字首獲取一個新名稱並返回它。此函式確保它不會與圖上的現有屬性衝突。

注意

此 API 的向後相容性已得到保證。

返回型別: str

getattr(attr, attr_val, parameter_proxy_cache)[source]#

指定此 `Tracer` 在呼叫 `nn.Module` 例項上的 getattr 時行為的方法。

預設情況下，行為是返回屬性的代理值。它還將代理值儲存在 `parameter_proxy_cache` 中，以便將來的呼叫將重用該代理而不是建立新代理。

可以覆蓋此方法來實現，例如，在查詢引數時不返回代理。

引數

attr (str) – 查詢的屬性名稱。
attr_val (Any) – 屬性的值。
parameter_proxy_cache (Dict[str, Any]) – 屬性名到代理的快取。

返回

來自 getattr 呼叫的返回值。

警告

此 API 是實驗性的，並且不向後相容。

is_leaf_module(m, module_qualified_name)[source]#

指定給定 `nn.Module` 是否為“葉子”模組的方法。

葉子模組是 IR 中出現的原子單元，由 `call_module` 呼叫引用。預設情況下，PyTorch 標準庫名稱空間（torch.nn）中的模組是葉子模組。所有其他模組都將被跟蹤並記錄其組成的 op，除非透過此引數另有指定。

引數

m (Module) – 查詢的模組。
module_qualified_name (str) – 到此模組根的路徑。例如，如果模組層次結構中的子模組 `foo` 包含子模組 `bar`，該子模組又包含子模組 `baz`，則該模組將在此處顯示為限定名稱 `foo.bar.baz`。

返回型別

注意

此 API 的向後相容性已得到保證。

iter(obj)[source]#

在迭代代理物件時呼叫，例如: 在控制流中使用時。通常我們不知道該怎麼做，因為我們不知道代理的值，但是自定義跟蹤器可以透過 create_node 將更多資訊附加到圖節點，並可以選擇返回一個迭代器。

注意

此 API 的向後相容性已得到保證。

返回型別: 迭代器。

keys(obj)[source]#

在代理物件呼叫 keys() 方法時呼叫。: 這就是當對代理物件執行 ** 時發生的情況。這應該返回一個迭代器，如果 ** 在您的自定義跟蹤器中工作的話。

注意

此 API 的向後相容性已得到保證。

返回型別: 任何

path_of_module(mod)[源]#

輔助方法，用於查詢 root 的 Module 層次結構中 mod 的限定名稱。例如，如果 root 有一個名為 foo 的子模組，而 foo 又有一個名為 bar 的子模組，則將 bar 傳遞給此函式將返回字串 “foo.bar”。

引數: mod (str) – 要為其檢索限定名稱的 Module。
返回型別: str

注意

此 API 的向後相容性已得到保證。

proxy(node)[源]#

注意

此 API 的向後相容性已得到保證。

返回型別: 代理

to_bool(obj)[源]#

當代理物件被轉換為布林值時呼叫，例如: 在控制流中使用時。通常我們不知道該怎麼做，因為我們不知道代理的值，但是自定義跟蹤器可以使用 create_node 向圖節點附加更多資訊，並可以選擇返回值。

注意

此 API 的向後相容性已得到保證。

返回型別: 布林值

trace(root, concrete_args=None)[源]#

跟蹤 root 並返回相應的 FX Graph 表示。 root 可以是 nn.Module 例項或 Python 可呼叫物件。

請注意，呼叫此方法後，self.root 可能與此處傳入的 root 不同。例如，當將一個自由函式傳遞給 trace() 時，我們將建立一個 nn.Module 例項作為根並新增嵌入的常量。

引數

root (Union[Module, Callable]) – 要透過跟蹤的 Module 或函式。此引數向後相容。
concrete_args (Optional[Dict[str, any]]) – 不應被視為代理的具體引數。此引數是實驗性的，其向後相容性不有保證。

返回

一個 Graph，表示傳入的 root 的語義。

返回型別

Graph

注意

此 API 的向後相容性已得到保證。

class torch.fx.Proxy(node, tracer=None)[源]#

Proxy 物件是 Node 的包裝器，它們在符號跟蹤期間在程式中流動，並將它們觸及的所有操作（torch 函式呼叫、方法呼叫、運算子）記錄到不斷增長的 FX Graph 中。

如果您正在進行圖變換，您可以將自己的 Proxy 方法包裝在原始 Node 上，以便可以使用過載運算子將其他內容新增到 Graph 中。

Proxy 物件不能迭代。換句話說，如果 Proxy 在迴圈中使用或作為 *args/**kwargs 函式引數使用，符號跟蹤器將丟擲錯誤。

通常有兩種方法可以解決此問題：1. 將無法跟蹤的邏輯提取到一個頂級函式中，並對其使用 fx.wrap。 2. 如果控制流是靜態的（即迴圈次數取決於某個超引數），則可以將程式碼保留在原始位置並重構為類似

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

有關 Proxy 內部機制的更詳細說明，請參閱 torch/fx/README.md 中的“Proxy”部分。

注意

此 API 的向後相容性已得到保證。

class torch.fx.Interpreter(module, garbage_collect_values=True, graph=None)[源]#

Interpreter 按節點逐個執行 FX 圖。這種模式可用於許多用途，包括編寫程式碼轉換和分析傳遞。

可以覆蓋 Interpreter 類中的方法來定製執行行為。可覆蓋方法的呼叫層次圖

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

示例

假設我們要將所有 torch.neg 例項與 torch.sigmoid 相互替換（包括它們的 Tensor 方法等效項）。我們可以像這樣繼承 Interpreter

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(target, args, kwargs)

    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(target, args, kwargs)


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) – 是否在模組執行期間刪除其最後一個使用的值。這可確保在執行過程中實現最佳記憶體使用。例如，可以透過檢視 Interpreter.env 屬性來停用此項，以檢查執行中的所有中間值。
graph (Optional[Graph]) – 如果已傳遞，直譯器將執行此圖而不是 module.graph，並使用提供的 module 引數來滿足任何狀態請求。

注意

此 API 的向後相容性已得到保證。

boxed_run(args_list)[源]#: 透過解釋執行 module 並返回結果。這使用了“boxed”呼叫約定，您需要傳遞一個引數列表，該列表將被直譯器清除。這確保輸入張量能被及時釋放。

注意

此 API 的向後相容性已得到保證。

call_function(target, args, kwargs)[源]#

執行 call_function 節點並返回結果。

引數

target (Target) – 此節點的呼叫目標。有關語義的詳細資訊，請參閱 Node
args (Tuple) – 此呼叫的位置引數元組
kwargs (Dict) – 此呼叫的關鍵字引數字典

返回型別

Return: Any: 函式呼叫返回的值

注意

此 API 的向後相容性已得到保證。

call_method(target, args, kwargs)[源]#

執行 call_method 節點並返回結果。

引數

target (Target) – 此節點的呼叫目標。有關語義的詳細資訊，請參閱 Node
args (Tuple) – 此呼叫的位置引數元組
kwargs (Dict) – 此呼叫的關鍵字引數字典

返回型別

Return: Any: 方法呼叫返回的值

注意

此 API 的向後相容性已得到保證。

call_module(target, args, kwargs)[源]#

執行 call_module 節點並返回結果。

引數

target (Target) – 此節點的呼叫目標。有關語義的詳細資訊，請參閱 Node
args (Tuple) – 此呼叫的位置引數元組
kwargs (Dict) – 此呼叫的關鍵字引數字典

返回型別