torch.fx ¶

注意

保證此 API 的向後相容性。

property code: str¶: 傳回從此 GraphModule 的底層 Graph 產生的 Python 程式碼。

delete_all_unused_submodules()[原始碼][原始碼]¶

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

如果以下任何一項為真，則 Module 會被視為「已使用」：1. 它有已使用的子節點 2. 它的 forward 透過 call_module 節點直接呼叫 3. 它有一個非 Module 屬性，該屬性從 get_attr 節點使用

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

注意

保證此 API 的向後相容性。

delete_submodule(target)[原始碼][原始碼]¶

從 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)[原始碼][原始碼]¶: 傳回為目前的 GraphModule 及其子 GraphModules 產生的 Python 程式碼

警告

此 API 是實驗性的，不具有回溯相容性。

recompile()[原始碼][原始碼]¶

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

注意

保證此 API 的向後相容性。

返回類型: PythonCode

to_folder(folder, module_name='FxModule')[原始碼][原始碼]¶

將模組轉儲到具有 module_name 的 folder，以便可以

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

參數

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

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

警告

此 API 是實驗性的，不具有回溯相容性。

class torch.fx.Graph(owning_module=None, tracer_cls=None, tracer_extras=None)[原始碼][原始碼]¶

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)

將產生以下 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 中表示的運算的語義，請參閱 Node。

注意

保證此 API 的向後相容性。

__init__(owning_module=None, tracer_cls=None, tracer_extras=None)[原始碼][原始碼]¶

建構一個空的 Graph。

注意

保證此 API 的向後相容性。

call_function(the_function, args=None, kwargs=None, type_expr=None)[原始碼][原始碼]¶

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

參數

the_function (Callable[..., Any]) – 要呼叫的函式。可以是任何 PyTorch 運算子、Python 函式，或 builtins 或 operator 命名空間的成員。
args (Optional[Tuple[Argument, ...]]) – 要傳遞給被呼叫函式的位置引數。
kwargs (Optional[Dict[str, Argument]]) – 要傳遞給被呼叫函式的關鍵字引數
type_expr (Optional[Any]) – 一個可選的型別註釋，代表此節點輸出將具有的 Python 型別。

返回

新建立並插入的 call_function 節點。

返回類型

注意

相同的插入點和型別表示式規則適用於此方法，如 Graph.create_node()。

注意

保證此 API 的向後相容性。

call_method(method_name, args=None, kwargs=None, type_expr=None)[原始碼][原始碼]¶

插入一個 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, ...]]) – 要傳遞給所呼叫方法的位置參數。請注意，這應該包含一個 self 參數。
kwargs (Optional[Dict[str, Argument]]) – 要傳遞給所呼叫方法的關鍵字參數
type_expr (Optional[Any]) – 一個可選的型別註釋，代表此節點輸出將具有的 Python 型別。

返回

新建立並插入的 call_method 節點。

返回類型

注意

相同的插入點和型別表示式規則適用於此方法，如 Graph.create_node()。

注意

保證此 API 的向後相容性。

call_module(module_name, args=None, kwargs=None, type_expr=None)[原始碼][原始碼]¶

插入一個 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, ...]]) – 要傳遞給所呼叫方法的位置參數。請注意，這不應該包含 self 參數。
kwargs (Optional[Dict[str, Argument]]) – 要傳遞給所呼叫方法的關鍵字參數
type_expr (Optional[Any]) – 一個可選的型別註釋，代表此節點輸出將具有的 Python 型別。

返回

新建立並插入的 call_module 節點。

返回類型

注意

相同的插入點和型別表示式規則適用於此方法，如 Graph.create_node()。

注意

保證此 API 的向後相容性。

create_node(op, target, args=None, kwargs=None, name=None, type_expr=None)[原始碼][原始碼]¶

建立一個 Node 並將其新增到 Graph 中目前插入點。請注意，可以使用 Graph.inserting_before() 和 Graph.inserting_after() 設定目前的插入點。

參數

op (str) – 此節點的運算碼。為 ‘call_function’、‘call_method’、‘get_attr’、‘call_module’、‘placeholder’ 或 ‘output’ 之一。這些運算碼的語意在 Graph 文件字串中描述。
args (Optional[Tuple[Argument, ...]]) – 是此節點的引數元組。
kwargs (Optional[Dict[str, Argument]]) – 此節點的 kwargs
name (Optional[str]) – Node 的可選字串名稱。這將影響 Python 產生的程式碼中指派給的值的名稱。
type_expr (Optional[Any]) – 一個可選的型別註釋，代表此節點輸出將具有的 Python 型別。

返回

新建立並插入的節點。

返回類型

注意

保證此 API 的向後相容性。

eliminate_dead_code(is_impure_node=None)[原始碼][原始碼]¶

根據每個節點的使用者數量以及節點是否具有任何副作用，從圖表中移除所有無效程式碼。在呼叫之前，圖表必須經過拓撲排序。

參數

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 已被移除，而 forward 的其餘部分則保持不變。

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

警告

無效程式碼消除具有一些啟發法，可以避免移除具有副作用的節點（請參閱 Node.is_impure），但一般而言，覆蓋率非常差，因此您應該假設此方法不可靠，除非您知道您的 FX 圖表完全由功能性操作組成，或者您提供自己的自訂函式來偵測具有副作用的節點。

注意

保證此 API 的向後相容性。

erase_node(to_erase)[原始碼][原始碼]¶

從 Graph 中移除 Node。如果 Graph 中仍然存在該節點的使用者，則會拋出例外狀況。

參數: to_erase (Node) – 要從 Graph 中移除的 Node。

注意

保證此 API 的向後相容性。

find_nodes(*, op, target=None, sort=True)[原始碼][原始碼]¶

允許快速查詢節點

參數

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

返回

具有請求的操作和目標的可迭代節點。

警告

此 API 是實驗性的，不具有回溯相容性。

get_attr(qualified_name, type_expr=None)[原始碼][原始碼]¶

將 get_attr 節點插入圖表中。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)[原始碼][原始碼]¶

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

參數

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

返回

如果 g 擁有一個 output 節點，則 self 中目前的值會等同於 g 中的輸出值。否則為 None。

返回類型

Optional[Union[Tuple[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]], …], Sequence[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]]], Mapping[str, 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]]], slice, range, Node, str, int, float, bool, complex, dtype, Tensor, device, memory_format, layout, OpOverload, SymInt, SymBool, SymFloat]]

注意

保證此 API 的向後相容性。

inserting_after(n=None)[原始碼][原始碼]¶

設定 create_node 及相關方法將插入到圖 (graph) 中的位置。

當在 '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=None)[原始碼][原始碼]¶

設定 create_node 及相關方法將插入到圖 (graph) 中的位置。

當在 '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()[原始碼][原始碼]¶: 對此圖執行各種檢查，以確保其格式正確。特別是： - 檢查節點是否具有正確的所有權 (由該圖擁有) - 檢查節點是否以拓撲順序出現 - 如果此圖具有擁有的 GraphModule，則檢查目標是否存在於該 GraphModule 中

注意

保證此 API 的向後相容性。

node_copy(node, arg_transform=<function Graph.<lambda>>)[原始碼][原始碼]¶

將節點從一個圖複製到另一個圖。arg_transform 需要將參數從節點的圖轉換為 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]) – 一個函數，它將節點的 args 和 kwargs 中的 Node 參數轉換為 self 中的等效參數。在最簡單的情況下，這應該從將原始圖中的節點映射到 self 的表中檢索一個值。

返回類型

注意

保證此 API 的向後相容性。

property nodes: _node_list¶

取得構成此圖的節點列表。

請注意，此 Node 列表表示形式是雙向鏈結串列。迭代期間的變更 (例如，刪除節點、新增節點) 是安全的。

返回: 節點的雙向鏈結串列。請注意，可以在此列表上調用 reversed 以切換迭代順序。

on_generate_code(make_transformer)[原始碼][原始碼]¶

註冊在產生 Python 代碼時的轉換器函數

參數

make_transformer (Callable[[Optional[TransformCodeFunc]], TransformCodeFunc])
一個傳回要註冊的代碼轉換器的函數。此函數由 on_generate_code 呼叫以取得代碼轉換器。

此函數也作為其輸入提供當前註冊的代碼轉換器 (如果沒有註冊任何內容，則為 None)，以防不希望覆寫它。這對於將代碼轉換器鏈接在一起很有用。

返回
一個上下文管理器，當在 with 語句中使用時，會自動還原先前註冊的代碼轉換器。

範例
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)[原始碼][原始碼]¶

將 output Node 插入到 Graph 中。 output 節點表示 Python 代碼中的 return 語句。 result 是應傳回的值。

參數

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

注意

此方法套用與 Graph.create_node 相同的插入點和類型表達式規則。

注意

保證此 API 的向後相容性。

output_node()[原始碼][原始碼]¶

警告

此 API 是實驗性的，不具有回溯相容性。

返回類型: Node

placeholder(name, type_expr=None, default_value)[原始碼][原始碼]¶

將 placeholder 節點插入到圖中。 placeholder 表示函數輸入。

參數

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

返回類型

注意

此方法套用與 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, colored=False)[原始碼][原始碼]¶

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

參數: root_module (str) – 在其上查找限定名稱目標的根模組的名稱。這通常是 ‘self’。
返回: src：表示物件的 Python 原始碼 globals：src 中全域名稱的字典 -> 它們引用的物件。
返回類型: 一個 PythonCode 物件，由兩個欄位組成

注意

保證此 API 的向後相容性。

set_codegen(codegen)[原始碼][原始碼]¶

警告

此 API 是實驗性的，不具有回溯相容性。

class torch.fx.Node(graph, name, op, target, args, kwargs, return_type=None)[原始碼][原始碼]¶

Node 是一種資料結構，表示 Graph 內的個別操作。在大多數情況下，節點表示對各種實體（例如運算符、方法和模組）的調用點（某些例外情況包括指定函式輸入和輸出的節點）。每個 Node 都有一個由其 op 屬性指定的函式。每個 op 值的 Node 語義如下

placeholder 表示一個函式輸入。name 屬性指定此值將採用的名稱。 target 類似地是引數的名稱。 args 包含：1) 沒有任何內容，或 2) 表示函式輸入的預設參數的單個引數。 kwargs 是無關緊要的。佔位符對應於圖形列印輸出中的函式參數（例如 x）。
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 輸入的所有 Node。這等同於迭代 args 和 kwargs 並僅收集作為 Node 的值。

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

append(x)[source][source]¶

將 x 插入到圖形中節點列表中的此節點之後。等同於 self.next.prepend(x)

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

注意

保證此 API 的向後相容性。

property args: Tuple[Optional[Union[Tuple[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]], ...], Sequence[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]]], Mapping[str, 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]]], slice, range, Node, str, int, float, bool, complex, dtype, Tensor, device, memory_format, layout, OpOverload, SymInt, SymBool, SymFloat]], ...]¶

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

允許賦值給此屬性。所有使用和使用者的帳戶都會在賦值時自動更新。

format_node(placeholder_names=None, maybe_return_typename=None)[source][source]¶

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

此方法可以在沒有參數的情況下用作偵錯工具。

此函式也在 Graph 的 __str__ 方法中於內部使用。總而言之，placeholder_names 和 maybe_return_typename 中的字串構成了此 Graph 周圍的 GraphModule 中自動生成的 forward 函式的簽名。placeholder_names 和 maybe_return_typename 不應以其他方式使用。

參數

placeholder_names (Optional[List[str]]) – 一個列表，將儲存表示生成的 forward 函式中佔位符的格式化字串。僅供內部使用。
maybe_return_typename (Optional[List[str]]) – 一個單元素列表，將儲存表示生成的 forward 函式輸出的格式化字串。僅供內部使用。

返回

如果 1) 我們將 format_node 用作內部輔助函式: 在 Graph 的 __str__ 方法中，且 2) self 是一個佔位符 Node，則傳回 None。否則，傳回目前 Node 的描述性字串表示形式。

返回類型

str

注意

保證此 API 的向後相容性。

insert_arg(idx, arg)[source][source]¶

使用給定的索引將一個位置參數插入到參數列表中。

參數

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

注意

保證此 API 的向後相容性。

is_impure()[原始碼][原始碼]¶

返回此操作是否為 impure，也就是說，如果其操作是一個 placeholder 或 output，或者如果是一個 impure 的 call_function 或 call_module。

返回: 操作是否為 impure。
返回類型: bool

警告

此 API 是實驗性的，不具有回溯相容性。

property kwargs: Dict[str, Optional[Union[Tuple[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]], ...], Sequence[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]]], Mapping[str, 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]]], slice, range, Node, str, int, float, bool, complex, dtype, Tensor, device, memory_format, layout, OpOverload, SymInt, SymBool, SymFloat]]]¶

此 Node 的關鍵字引數字典。引數的解釋取決於節點的 opcode。請參閱 Node docstring 以取得更多資訊。

允許賦值給此屬性。所有使用和使用者的帳戶都會在賦值時自動更新。

property next: Node¶

返回 Nodes 鏈結串列中的下一個 Node。

返回: Nodes 鏈結串列中的下一個 Node。

normalized_arguments(root, arg_types=None, kwarg_types=None, normalize_to_only_use_kwargs=False)[原始碼][原始碼]¶

返回 Python targets 的正規化引數。這意味著 args/kwargs 將與 module/functional 的簽名匹配，並且如果 normalize_to_only_use_kwargs 為 true，則僅以位置順序返回 kwargs。也會填入預設值。不支援僅限位置的參數或變數參數。

支援模組呼叫。

可能需要 arg_types 和 kwarg_types 才能消除過載的歧義。

參數

root (torch.nn.Module) – 用於解析模組目標的模組。
arg_types (Optional[Tuple[Any]]) – args 的 arg 類型 Tuple
kwarg_types (Optional[Dict[str, Any]]) – kwargs 的 arg 類型 Dict
normalize_to_only_use_kwargs (bool) – 是否正規化為僅使用 kwargs。

返回

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

返回類型

Optional[ArgsKwargsPair]

警告

此 API 是實驗性的，不具有回溯相容性。

prepend(x)[原始碼][原始碼]¶

將 x 插入到圖中節點列表中的此節點之前。範例

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

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

注意

保證此 API 的向後相容性。

property prev: Node¶

返回 Nodes 鏈結串列中的前一個 Node。

返回: Nodes 鏈結串列中的前一個 Node。

replace_all_uses_with(replace_with, delete_user_cb=<function Node.<lambda>>, *, propagate_meta=False)[原始碼][原始碼]¶

用 Node replace_with 替換圖中所有對 self 的使用。

參數

replace_with (Node) – 用於替換所有 self 使用的節點。
delete_user_cb (Callable) – 呼叫的回調以確定是否應刪除 self 節點的給定使用者。
propagate_meta (bool) – 是否將原始節點 .meta 欄位上的所有屬性複製到替換節點上。為了安全起見，僅當替換節點尚未具有現有的 .meta 欄位時，此操作才有效。

返回

對其進行此更改的 Nodes 列表。

返回類型

List[Node]

注意

保證此 API 的向後相容性。

replace_input_with(old_input, new_input)[原始碼][原始碼]¶

迴圈遍歷 self 的輸入節點，並用 new_input 替換所有 old_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 會將最內層的 frame 放在字串的結尾。

update_arg(idx, arg)[原始碼][原始碼]¶

更新現有的位置引數，使其包含新的值 arg。呼叫後，self.args[idx] == arg。

參數

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

注意

保證此 API 的向後相容性。

update_kwarg(key, arg)[原始碼][原始碼]¶

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

參數

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

注意

保證此 API 的向後相容性。

class torch.fx.Tracer(autowrap_modules=(math,), autowrap_functions=())[原始碼][原始碼]¶

Tracer 類別實作 torch.fx.symbolic_trace 的符號追蹤功能。呼叫 symbolic_trace(m) 相當於 Tracer().trace(m)。

可以將 Tracer 子類化，以覆寫追蹤程序的各種行為。可以覆寫的不同行為在本類別的方法的 docstring 中說明。

注意

保證此 API 的向後相容性。

call_module(m, forward, args, kwargs)[原始碼][原始碼]¶

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

預設行為是透過 is_leaf_module 檢查呼叫的模組是否為葉模組。如果是，則發出 call_module 節點，指向 Graph 中的 m。否則，正常呼叫 Module，並追蹤其 forward 函式中的運算。

可以覆寫此方法，例如建立巢狀追蹤的 GraphModule，或在跨 Module 邊界追蹤時的任何其他所需行為。

參數

m (Module) – 要發出呼叫的模組
forward (Callable) – 要叫用的 Module 的 forward() 方法
args (Tuple) – 模組呼叫位置的 args
kwargs (Dict) – 模組呼叫位置的 kwargs

返回

Module 呼叫的回傳值。如果發出了 call_module 節點，則這是 Proxy 值。否則，它是 Module 叫用所傳回的任何值。

返回類型

注意

保證此 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) – 要作為 Graph 中的 Argument 發出的值。
返回: 將值 a 轉換成適當的 Argument
返回類型: Argument (引數)

注意

保證此 API 的向後相容性。

create_args_for_root(root_fn, is_module, concrete_args=None)[source][source]¶: 建立對應於 root Module 簽名的 placeholder 節點。此方法會檢視 root 的簽名並相應地發出這些節點，同時支援 *args 和 **kwargs。

警告

此 API 是實驗性的，不具有回溯相容性。

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

根據目標 (target)、引數 (args)、關鍵字引數 (kwargs) 和名稱 (name) 插入圖形節點。

可以覆寫此方法來對節點建立中使用的值進行額外的檢查、驗證或修改。例如，可能希望禁止記錄原地 (in-place) 操作。

注意

保證此 API 的向後相容性。

返回類型: Node

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

從給定的引數建立一個 Node，然後回傳包裝在 Proxy 物件中的 Node。

如果 kind = ‘placeholder’，則我們正在建立一個代表函式參數的 Node。如果我們需要編碼預設參數，我們使用 args tuple。args 對於 placeholder Node 來說通常是空的。

注意

保證此 API 的向後相容性。

get_fresh_qualname(prefix)[source][source]¶

取得 prefix 的新名稱並回傳。此函式確保它不會與圖形上的現有屬性衝突。

注意

保證此 API 的向後相容性。

返回類型: str

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

此方法指定當我們在呼叫 nn.Module 實例時呼叫 getattr 時，此 Tracer 的行為。

預設行為是回傳屬性的 proxy 值。它還將 proxy 值儲存在 parameter_proxy_cache 中，以便未來的呼叫將重複使用該 proxy，而不是建立新的 proxy。

可以覆寫此方法，例如，在查詢參數時不回傳 proxy。

參數

attr (str) – 要查詢的屬性的名稱
attr_val (Any) – 屬性的值
parameter_proxy_cache (Dict[str, Any]) – 從屬性名稱到 proxy 的快取

返回

從 getattr 呼叫回傳的值。

警告

此 API 是實驗性的，不具有回溯相容性。

is_leaf_module(m, module_qualified_name)[source][source]¶

一種指定給定的 nn.Module 是否為「葉節點 (leaf)」module 的方法。

葉節點 modules 是 IR 中出現的最小單位，由 call_module 呼叫引用。預設情況下，PyTorch 標準函式庫命名空間 (torch.nn) 中的 Modules 是葉節點 modules。除非透過此參數另行指定，否則所有其他 modules 都會被追蹤，並且記錄其組成的操作。

參數

m (Module) – 正在查詢的 module
module_qualified_name (str) – 此 module 的根路徑。例如，如果您有一個 module 階層，其中子 module foo 包含子 module bar，而 bar 包含子 module baz，則該 module 將以限定名稱 foo.bar.baz 出現在此處。

返回類型

注意

保證此 API 的向後相容性。

iter(obj)[source]¶

當 proxy 物件被迭代時呼叫，例如: 當用於控制流程時。通常我們不知道該怎麼做，因為我們不知道 proxy 的值，但自訂的追蹤器可以使用 create_node 將更多資訊附加到圖形節點，並且可以選擇傳回一個迭代器。

注意

保證此 API 的向後相容性。

返回類型: 迭代器

keys(obj)[原始碼]¶

當 proxy 物件呼叫 keys() 方法時呼叫。: 當在 proxy 上呼叫 ** 時會發生這種情況。如果 ** 要在您的自訂追蹤器中運作，則應傳回一個迭代器。

注意

保證此 API 的向後相容性。

返回類型: Any

path_of_module(mod)[原始碼][原始碼]¶

輔助方法，用於尋找 mod 在 root 的 Module 階層中的合格名稱。例如，如果 root 有一個名為 foo 的子模組，而 foo 有一個名為 bar 的子模組，則將 bar 傳遞到此函數將傳回字串 “foo.bar”。

參數: mod (str) – 要檢索合格名稱的 Module。
返回類型: str

注意

保證此 API 的向後相容性。

proxy(node)[原始碼]¶

注意

保證此 API 的向後相容性。

返回類型: Proxy

to_bool(obj)[原始碼]¶

當 proxy 物件被轉換為布林值時呼叫，例如: 當用於控制流程時。通常我們不知道該怎麼做，因為我們不知道 proxy 的值，但自訂的追蹤器可以使用 create_node 將更多資訊附加到圖形節點，並且可以選擇傳回一個值。

注意

保證此 API 的向後相容性。

返回類型: bool

trace(root, concrete_args=None)[原始碼][原始碼]¶

追蹤 root 並傳回對應的 FX Graph 表示形式。 root 可以是 nn.Module 實例或 Python callable。

請注意，在此呼叫之後，self.root 可能與此處傳入的 root 不同。例如，當將自由函數傳遞給 trace() 時，我們將建立一個 nn.Module 實例以用作 root 並將嵌入的常數新增至其中。

參數

root (Union[Module, Callable]) – 要追蹤的 Module 或函數。保證此參數的向後相容性。
concrete_args (Optional[Dict[str, any]]) – 不應視為 Proxies 的具體引數。此參數是實驗性的，並且不保證其向後相容性。

返回

代表傳入的 root 語意的 Graph。

返回類型

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) – 是否在 Module 執行過程中，於數值最後一次使用後將其刪除。這可確保執行期間的最佳記憶體使用量。可以停用此功能，例如，透過查看 Interpreter.env 屬性來檢查執行中的所有中間數值。
graph (Optional[Graph]) – 如果傳入，interpreter 將執行此圖，而不是 module.graph，並使用提供的 module 引數來滿足任何狀態請求。

注意

保證此 API 的向後相容性。

boxed_run(args_list)[source][source]¶: 透過解釋來執行 module 並傳回結果。這使用 “boxed” 呼叫慣例，您傳遞一個引數列表，該列表將由 interpreter 清除。這確保了輸入張量會及時釋放。

注意

保證此 API 的向後相容性。

call_function(target, args, kwargs)[source][source]¶

執行 call_function 節點並傳回結果。

參數

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

返回類型

傳回: Any: 函式調用傳回的值

注意

保證此 API 的向後相容性。

call_method(target, args, kwargs)[source][source]¶

執行 call_method 節點並傳回結果。

參數

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

返回類型

傳回: Any: 方法調用傳回的值

注意

保證此 API 的向後相容性。

call_module(target, args, kwargs)[source][source]¶

執行 call_module 節點並傳回結果。

參數

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

返回類型