/usr/local/lib64/python3.6/site-packages/torch/fx/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/fx/__pycache__/graph.cpython-36.pyc (40932B)
3
Egʿ @ s U d dl mZmZmZmZmZmZ ddljj Z
d dl m Z d dl
mZ ddlmZmZmZmZmZmZmZmZmZmZmZ ddlm Z ddl m Z ddl Z ddl Z ddl!Z!ddl"Z"ddl#Z#ddl$Z$ddl%Z%erd d l&m'Z' d d
l(m)Z) e*ee+ee,ee-ee.eiZ/G d d d eZ0i Z1ee2e0f 1e2e2ed
ddZ3e3dde$j4 e3dde$j5 e3dde6d e3dde e3dde j7 e3dde e3d d e
e2e8d d d Z9e2e2d!d"d#Z:ee8d$d%d&Z;G d'd( d(Z
e2e2e2d1d2d3Z?G d4d5 d5Z@G d6d7 d7ZAG d8d9 d9eZBed)d*G d:d; d;ZCdd?d@d@dAdBdCdDdEdFdGdHdIdJZDe+dKdLdMdNdOdPdQdRdSdT feDZEdS )U )NodeArgumentTargetmap_arg
_type_repr_get_qualified_name N)_pytree)
compatibility)
TYPE_CHECKINGCallableAnyListDict
NamedTupleOptionalTupleSet FrozenSetType) dataclass)contextmanager) GraphModule)Tracerc @ s e Zd ZU dZeedS )_CustomBuiltinzAdditional objs that we add to every graph's globals.
The repr() for some standard library objects is not valid Python code without
an import. For common objects of this sort, we bundle them in the globals of
every FX graph.
N)__name__
__module__ __qualname____doc__str
import_strr
obj r" r" :/usr/local/lib64/python3.6/site-packages/torch/fx/graph.pyr s
r )namer r! c C s t ||t| < d S )N)r _custom_builtins)r$ r r! r" r" r# _register_custom_builtin/ s r& infzfrom math import infnanzfrom math import nanZNoneTypezNoneType = type(None)torchz import torchdevicezfrom torch import device fx_pytreez$import torch.fx._pytree as fx_pytreepytreez$import torch.utils._pytree as pytree)xreturnc C s | j do| jdS )N__)
startswithendswith)r- r" r" r# _is_magic< s r2 )sr. c C sL g }d}x8| D ]0}|r(|j r(|jd |j|j |j }qW dj|S )z
Transforms the given string ``s`` to a Python-style variable name
Examples:
``mod.snake_case`` -> ``mod.snake_case``
``mod.pascalCase``-> ``mod.pascal_case``
``mod.ALL_CAPS`` -> ``mod.all_caps``
F_ )isupperappendlowerislowerjoin)r3 charsZ
prev_lowercr" r" r# _snake_case@ s
r= )r! r. c C st t | dd }|d k r*|jdd }|dkS t | dd }|d k rp|dkrpx(ttjjgD ]}t ||d | krTdS qTW dS )Nr .r r) r TF)getattr partitionr) nnZ
functional)r! module_name base_moduler$ guessr" r" r# _is_from_torchS s rE c @ sP e Zd ZdZdd Zeee edddZeeddd Z eee
d
d d Z d
S )
_Namespacea A context for associating names uniquely with objects.
The following invariants are enforced:
- Each object gets a single name.
- Each name is unique within a given namespace.
- Names generated do not shadow builtins, unless the object is indeed that builtin.
c C s0 i | _ t | _i | _tjd| _tjd| _d S )Nz[^0-9a-zA-Z_]+z (.*)_(\d+)$) _obj_to_nameset_unassociated_names _used_namesrecompile_illegal_char_regex_name_suffix_regex)selfr" r" r# __init__k s
z_Namespace.__init__) candidater! r. c C s |dk r || j kr | j | S | jjd|}|d j r@d| }| jj|}|dkr^|}d}n|jdd\}}t|}|dkr|n | d| }|r|nd}x0|| jks| j ||r|d7 }| d| }qW | jj
| |dkr| j j | n
|| j |< |S )zCreate a unique name.
Arguments:
candidate: used as the basis for the unique name, relevant to the user.
obj: If not None, an object that will be associated with the unique name.
Nr4 r r )
rG rM subisdigitrN matchgroupintrJ _is_illegal_name
setdefaultrI add)rO rQ r! rU basenumZnum_strr" r" r# create_names s*
z_Namespace.create_name)r$ r! c C s6 || j kst|| jks t|| j |< | jj| dS )zpAssociate a unique name with an object.
Neither `name` nor `obj` should be associated already.
N)rG AssertionErrorrI remove)rO r$ r! r" r" r# associate_name_with_obj s
z"_Namespace.associate_name_with_obj)r$ r! r. c C s@ |t jkrdS |tjkr&|tj| k S |tkr<|t| jk S dS )NTF)keywordkwlistbuiltins__dict__r% r! )rO r$ r! r" r" r# rX s
z_Namespace._is_illegal_nameN) r r r r rP r r r
r] r` boolrX r" r" r" r# rF c s
&
rF T)is_backward_compatiblec @ s" e Zd ZU dZeeeef dS )
PythonCodezZ
Represents all the information necessary to exec or save a graph as Python code.
N) r r r r r srcr r
globalsr" r" r" r# rg s
rg .)argskwargsr. c C sJ dj dd | D }dj dd |j D }|rB|rB| d| S |pH|S )Nz, c s s | ]}t |V qd S )N)repr).0ar" r" r# s z _format_args..c s s$ | ] \}}| d t | V qdS )z = N)rl )rm kvr" r" r# ro s )r: items)rj rk Zargs_sZkwargs_sr" r" r# _format_args s
rs )r[ targetr. c C sJ |j d}| }x6|D ].}|j s4d| d| d}q| d| }qW |S )Nr> zgetattr(z, "z"))split isidentifier)r[ rt elemsrer" r" r# _format_target s
rz c @ s$ e Zd Zdd Zdd Zdd ZdS ) _InsertPointc C s || _ |j| | _|_d S )N)graph_insert orig_insert)rO r| Z
new_insertr" r" r# rP s z_InsertPoint.__init__c C s d S )Nr" )rO r" r" r# __enter__ s z_InsertPoint.__enter__c C s | j | j_d S )N)r~ r| r} )rO typevaluetbr" r" r# __exit__ s z_InsertPoint.__exit__N)r r r rP r r r" r" r" r# r{ s r{ c @ s6 e Zd Zd
dedddZdd Zdd Zd
d Zd S )
_node_list_nextGraph)r| directionc C s |dks t || _|| _d S )Nr _prev)r r )r^ r| r )rO r| r r" r" r# rP s z_node_list.__init__c C s | j jS )N)r| _len)rO r" r" r# __len__ s z_node_list.__len__c c sB | j j| j }}t||}x"||k r<|js0|V t||}q W d S )N)r| _rootr r? _erased)rO rootr curr" r" r# __iter__ s
z_node_list.__iter__c C s t | j| jdkrdndS )Nr r )r r| r )rO r" r" r# __reversed__ s z_node_list.__reversed__N)r )r r r r rP r r r r" r" r" r# r s r c @ s* e Zd ZU dZee ej e
ej dS ) _PyTreeInfoz=
Contains extra info stored when we're using Pytrees
N) r r r r r r orig_argsr, ZTreeSpecZin_specr out_specr" r" r" r# r s
r c
@ s( e Zd ZdZedddRed eed ddd Zed
d Z e j
ed d d
d Z ee dddZ edddSd e
eef ddddZdTd dddZedddUedeedV ee
edf ee ee edd d Zeddd d Zeddd d! Zeddedd"d#d$ZedddWee d%d&d'ZedddXee d%d(d)ZedddYeee ed*d+d,ZedddZeee ed-d.d/Zeddd[eeed\ ee
edf ee ed0d1d2Z eddd]eeed^ ee
edf ee ed3d4d5Z eddd_e def eed` ee
edf ee ed6d7d8Z eddd9d: fee egdf ed;dd?d@Z!e"edAdBdCZ#eddee$dDdEdFZ%ee&e$dGdHdIZ'eddJdKZ(edddLdM Z)edddNdO Z*edddPdQ Z+dS )br aK
``Graph`` is the main data structure used in the FX Intermediate Representation.
It consists of a series of ``Node`` s, each representing callsites (or other
syntactic constructs). The list of ``Node`` s, taken together, constitute a
valid Python function.
For example, the following code
.. code-block:: 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)
Will produce the following Graph::
print(gm.graph)
.. code-block:: text
graph(x):
%linear_weight : [#users=1] = self.linear.weight
%add_1 : [#users=1] = call_function[target=operator.add](args = (%x, %linear_weight), kwargs = {})
%linear_1 : [#users=1] = call_module[target=linear](args = (%add_1,), kwargs = {})
%relu_1 : [#users=1] = call_method[target=relu](args = (%linear_1,), kwargs = {})
%sum_1 : [#users=1] = call_function[target=torch.sum](args = (%relu_1,), kwargs = {dim: -1})
%topk_1 : [#users=1] = call_function[target=torch.topk](args = (%sum_1, 3), kwargs = {})
return topk_1
For the semantics of operations represented in the ``Graph``, please see :class:`Node`.
T)rf Nr r )
owning_module
tracer_clsc C sN t | dddf i | _i | _| jj| _d| _t | _d| _|| _ || _
d| _ dS )z+
Construct an empty Graph.
r5 r r N) r r rJ prependr} r rF _graph_namespace_owners_owning_module _tracer_cls _pytree_info)rO r r r" r" r# rP $ s
zGraph.__init__c C s | j S )z
Return the module that owns this ``GraphModule``, if there is one,
``None`` if there is no owning module or if there are multiple owning
modules.
)r )rO r" r" r# r 3 s zGraph.owning_module)modc C s& |r"| j s|nd | _| j d7 _ d S )Nr )r r )rO r r" r" r# r < s )r. c C s t | S )av
Get the list of Nodes that constitute this Graph.
Note that this ``Node`` list representation is a doubly-linked list. Mutations
during iteration (e.g. delete a Node, add a Node) are safe.
Returns:
A doubly-linked list of Nodes. Note that ``reversed`` can be called on
this list to switch iteration order.
)r )rO r" r" r# nodesB s
z Graph.nodesFzOptional[Argument])gval_mapr. c sh xb|j D ]X}| krq|jdkrHt|jd fdd}|s@|S ||fS | j| fdd |< qW dS )aM
Copy all nodes from a given graph into ``self``.
Args:
g (Graph): The source graph from which to copy Nodes.
val_map (Dict[Node, Node]): a dictionary that will be populated with a mapping
from nodes in ``g`` to nodes in ``self``. Note that ``val_map`` can be passed
in with values in it already to override copying of certain values.
Returns:
The value in ``self`` that is now equivalent to the output value in ``g``,
if ``g`` had an ``output`` node. ``None`` otherwise.
outputr c s | S )Nr" )n)r r" r# g s z"Graph.graph_copy..c s | S )Nr" )r )r r" r# r i s N)r opr rj node_copy)rO r r return_output_nodenodervr" )r r#
graph_copyQ s
zGraph.graph_copyc C sX |r|ni }t | jd}|j| |dd}t|ts6t|\}}|j|t|ddd |S )a
Explicitly implement __deepcopy__ to prevent excessive recursion depth
from the default implementation. This uses graph_copy to copy the nodes
in an iterative way, rather than recursive. It also populates the
memoization table to prevent unnecessary copies (e.g. references to
nodes or other parts of the Graph from a custom GraphModule implementation.
)r T)r r r N) type_expr)r r r
isinstancetupler^ r r? )rO memor Z output_valsZ
output_valZold_output_valr" r" r# __deepcopy__l s zGraph.__deepcopy__r r .)r rt rj rk r$ r r. c C s |d ks t |dkrf n|}|dkr(i n|}t|ts>t dt|tsPt d |dk r\|n| j|}| jj|d}t| ||||||}| jj|| | j | | j
d
7 _
|S ) a&
Create a ``Node`` and add it to the ``Graph`` at the current insert-point.
Note that the current insert-point can be set via :meth:`Graph.inserting_before`
and :meth:`Graph.inserting_after`.
Args:
op (str): the opcode for this Node. One of 'call_function', 'call_method', 'get_attr',
'call_module', 'placeholder', or 'output'. The semantics of these opcodes are
described in the ``Graph`` docstring.
args (Optional[Tuple[Argument, ...]]): is a tuple of arguments to this node.
kwargs (Optional[Dict[str, Argument]]): the kwargs of this Node
name (Optional[str]): an optional string name for the ``Node``.
This will influence the name of the value assigned to in the
Python generated code.
type_expr (Optional[Any]): an optional type annotation representing the
Python type the output of this node will have.
Returns:
The newly-created and inserted node.
call_function call_methodget_attr call_module placeholderr Nzargs must be a tuplezkwargs must be a dictr )r r r r r r ) r^ r r dict_target_to_strr r] r r` r} r ) rO r rt rj rk r$ r rQ r r" r" r# create_node| s
zGraph.create_nodec G s t j|\}}|S )N)r, Z tree_flatten)rO rj Z flat_argsZ args_specr" r" r# flatten_inps s zGraph.flatten_inpsc C s> | j d kr|S t|ts |g}| j jd k s.ttj|| j jS )N)r r listr r^ r, Ztree_unflatten)rO outr" r" r# unflatten_outs s
zGraph.unflatten_outs)to_eraser. c C s t |jdkr2td| dt |j d|j d|j d|_| jd8 _t|jdd }t|t slt
||_t|j d
d }t|t st
||_ d S ) z
Erases a ``Node`` from the ``Graph``. Throws an exception if
there are still users of that node in the ``Graph``.
Args:
to_erase (Node): The ``Node`` to erase from the ``Graph``.
r zTried to erase Node z but it still had z users in the graph: !Tr c S s d S )Nr" )r r" r" r# r s z"Graph.erase_node..c S s d S )Nr" )r r" r" r# r s N)
lenusers RuntimeErrorZ_remove_from_listr r r rj r r r^ rk r )rO r Znew_argsZ
new_kwargsr" r" r#
erase_node s
$zGraph.erase_node)r c C s2 |dkr| j | jS |j| ks&tdt| |jS )a Set the point at which create_node and companion methods will insert into the graph.
When used within a 'with' statement, this will temporary set the insert point and
then restore it when the with statement exits::
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]): The node before which to insert. If None this will insert before
the beginning of the entire graph.
Returns:
A resource manager that will restore the insert point on ``__exit__``.
Nz&Node to insert before is not in graph.)inserting_afterr r| r^ r{ r )rO r r" r" r# inserting_before s zGraph.inserting_beforec C s2 |dkr| j | jS |j| ks&tdt| |jS )a Set the point at which create_node and companion methods will insert into the graph.
When used within a 'with' statement, this will temporary set the insert point and
then restore it when the with statement exits::
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]): The node before which to insert. If None this will insert after
the beginning of the entire graph.
Returns:
A resource manager that will restore the insert point on ``__exit__``.
Nz%Node to insert after is not in graph.)r r r| r^ r{ r7 )rO r r" r" r# r s zGraph.inserting_after)r$ r r. c C s | j d||dS )a
Insert a ``placeholder`` node into the Graph. A ``placeholder`` represents
a function input.
Args:
name (str): A name for the input value. This corresponds to the name
of the positional argument to the function this ``Graph`` represents.
type_expr (Optional[Any]): an optional type annotation representing the
Python type the output of this node will have. This is needed in some
cases for proper code generation (e.g. when the function is used
subsequently in TorchScript compilation).
.. note::
The same insertion point and type expression rules apply for this method
as ``Graph.create_node``.
r )r )r )rO r$ r r" r" r# r s zGraph.placeholder)qualified_namer r. c C sD t jjttddd}| jr4|| j| r4tjd | jd||dS )a
Insert a ``get_attr`` node into the Graph. A ``get_attr`` ``Node`` represents the
fetch of an attribute from the ``Module`` hierarchy.
Args:
qualified_name (str): the fully-qualified name of the attribute to be retrieved.
For example, if the traced Module has a submodule named ``foo``, which has a
submodule named ``bar``, which has an attribute named ``baz``, the qualified
name ``foo.bar.baz`` should be passed as ``qualified_name``.
type_expr (Optional[Any]): an optional type annotation representing the
Python type the output of this node will have.
Returns:
The newly-created and inserted ``get_attr`` node.
.. note::
The same insertion point and type expression rules apply for this method
as ``Graph.create_node``.
)r r r. c S s |j d\}}}y| j|}W n& tk
rD tjd| d dS X t||sTdS t||}t|tj j
rt|tj j r||j krdS dS )Nr> zFailed to fetch module r FT)
rpartition
get_submoduleAttributeErrorwarningswarnhasattrr? r r) rA Module Parameter_buffers)r r module_pathr4 r$ Zsubmodresr" r" r# _get_attr_reference_exists1 s
z2Graph.get_attr.._get_attr_reference_existsa
Attempted to insert a get_attr Node with no underlying reference in the owning GraphModule! Call GraphModule.add_submodule to add the necessary submodule, GraphModule.add_parameter to add the necessary Parameter, or nn.Module.register_buffer to add the necessary bufferr )r ) r) rA r r re r r r r )rO r r r r" r" r# r s
zGraph.get_attr)rB rj rk r r. c C s4 | j r | j j|dkr tjd | jd||||dS )a
Insert a ``call_module`` ``Node`` into the ``Graph``. A ``call_module`` node
represents a call to the forward() function of a ``Module`` in the ``Module``
hierarchy.
Args:
module_name (str): The qualified name of the ``Module`` in the ``Module``
hierarchy to be called. For example, if the traced ``Module`` has a
submodule named ``foo``, which has a submodule named ``bar``, the
qualified name ``foo.bar`` should be passed as ``module_name`` to
call that module.
args (Optional[Tuple[Argument, ...]]): The positional arguments to be passed
to the called method. Note that this should *not* include a ``self`` argument.
kwargs (Optional[Dict[str, Argument]]): The keyword arguments to be passed
to the called method
type_expr (Optional[Any]): an optional type annotation representing the
Python type the output of this node will have.
Returns:
The newly-created and inserted ``call_module`` node.
.. note::
The same insertion point and type expression rules apply for this method
as :meth:`Graph.create_node`.
NzAttempted to insert a call_module Node with no underlying reference in the owning GraphModule! Call GraphModule.add_submodule to add the necessary submoduler )r )r r r r r )rO rB rj rk r r" r" r# r S s $
zGraph.call_module) method_namerj rk r r. c C s | j d||||dS )aj
Insert a ``call_method`` ``Node`` into the ``Graph``. A ``call_method`` node
represents a call to a given method on the 0th element of ``args``.
Args:
method_name (str): The name of the method to apply to the self argument.
For example, if args[0] is a ``Node`` representing a ``Tensor``,
then to call ``relu()`` on that ``Tensor``, pass ``relu`` to ``method_name``.
args (Optional[Tuple[Argument, ...]]): The positional arguments to be passed
to the called method. Note that this *should* include a ``self`` argument.
kwargs (Optional[Dict[str, Argument]]): The keyword arguments to be passed
to the called method
type_expr (Optional[Any]): an optional type annotation representing the
Python type the output of this node will have.
Returns:
The newly created and inserted ``call_method`` node.
.. note::
The same insertion point and type expression rules apply for this method
as :meth:`Graph.create_node`.
r )r )r )rO r rj rk r r" r" r# r s !zGraph.call_method) the_functionrj rk r r. c C s | j d||||dS )a/
Insert a ``call_function`` ``Node`` into the ``Graph``. A ``call_function`` node
represents a call to a Python callable, specified by ``the_function``. ``the_function``
can be
Args:
the_function (Callable[..., Any]): The function to be called. Can be any PyTorch
operator, Python function, or member of the ``builtins`` or ``operator``
namespaces.
args (Optional[Tuple[Argument, ...]]): The positional arguments to be passed
to the called function.
kwargs (Optional[Dict[str, Argument]]): The keyword arguments to be passed
to the called function
type_expr (Optional[Any]): an optional type annotation representing the
Python type the output of this node will have.
Returns
The newly created and inserted ``call_function`` node.
.. note::
The same insertion point and type expression rules apply for this method
as :meth:`Graph.create_node`.
r )r )r )rO r rj rk r r" r" r# r s "zGraph.call_functionc C s | S )Nr" )r- r" r" r# r s zGraph.)r
arg_transformr. c C sb t |j|}t |j|}t|ts&tt|ts4t| j|j|j |||j
|j }t j |j
|_
|S )ay
Copy a node from one graph into another. ``arg_transform`` needs to transform arguments from
the graph of node to the graph of self. Example::
# 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])
Args:
node (Node): The node to copy into ``self``.
arg_transform (Callable[[Node], Argument]): A function that transforms
``Node`` arguments in node's ``args`` and ``kwargs`` into the
equivalent argument in ``self``. In the simplest case, this should
retrieve a value out of a table mapping Nodes in the original
graph to ``self``.
)r rj rk r r r^ r r r rt r$ r copymeta)rO r r rj rk Z result_noder" r" r# r s zGraph.node_copy)resultr c C s | j dd|f|dS )a5
Insert an ``output`` ``Node`` into the ``Graph``. An ``output`` node represents
a ``return`` statement in Python code. ``result`` is the value that should
be returned.
Args:
result (Argument): The value to be returned.
type_expr (Optional[Any]): an optional type annotation representing the
Python type the output of this node will have.
.. note::
The same insertion point and type expression rules apply for this method
as ``Graph.create_node``.
r )r rt rj r )r )rO r r r" r" r# r s z Graph.output)rt r. c C sB t |r|j}n&t|ts t|}t|r6|dd }t|}|S )NrR )callabler r r r^ r2 r= )rO rt r r" r" r# r s zGraph._target_to_str) root_moduler. c
sN t td fdd ttdfdd }|| | j| S Q R X dS )a
Turn this ``Graph`` into valid Python code.
Args:
root_module (str): The name of the root module on which to look-up
qualified name targets. This is usually 'self'.
Returns:
A PythonCode object, consisting of two fields:
src: the Python source code representing the object
globals: a dictionary of global names in `src` -> the objects that they reference.
)r c s j | j| S )N)r] r$ )r ) namespacer" r# node_repr1 s z$Graph.python_code..node_repr)r| c 3 sP i }x | j D ]}|j||< |_q W z
d V W d x| j D ]}|| |_q8W X d S )N)r Z_repr_fn)r| Z
orig_repr_fnsr )r r" r# override_node_repr4 s
z-Graph.python_code..override_node_reprN)rF r r r _python_code)rO r r r" )r r r# python_code s $
zGraph.python_code)r r r. c
sN g g i i dgt tdfdd x"tj D ]\}\}} || q6W td fdd i i ttd fd d
x>t
jD ]0tjfd d tj fd
d qW td fdd }td
fdd }x
jD ]| | qW t
dkr.j d
j d k r
j j
}|d dk} | r`jdd t
dkrjddj ddj| d n}t
dkrΈ dtjj
dj
fd d D }
nd}
t
|dks|d dkr|jdd dj} djd d | jdD } d|
d dj| d!d d"| } t| S )#Nr5 ) name_hintr! c sN t |r|tjkrt|S j| |}| krB | |ks>t|S | |< |S )a Add an obj to be tracked as a global.
We call this for names that reference objects external to the
Graph, like functions or types.
Returns: the global name that should be used to reference 'obj' in generated source.
)rE r) r* r r] r^ )r r! global_name)globals_r r" r#
add_globalM s z&Graph._python_code..add_global)oc sp | f kr dS t | }t| drftj| j| j} t ||}fdd| jD }| ddj| dS || S )Nz()
__origin__c s g | ] } |qS r" r" )rm arg) type_reprr" r#
u s z9Graph._python_code..type_repr..[,])r r _origin_type_mapgetr __args__r: )r typenameZ origin_typeZorigin_typenamerj )r r r" r# r h s
z%Graph._python_code..type_repr)r userc s& | kr"| | < j |g j| d S )N)rY r7 )r r )node_to_last_useuser_to_last_usesr" r# register_last_uses s z.Graph._python_code..register_last_usesc s
| S )Nr" )r )r r r" r# r s z$Graph._python_code..c s
| S )Nr" )r )r r r" r# r s )r c sv | j dkrdS | j dkr& jd dS j| g }t|rhdjdd |D dg } jd | d n
jd dS )
z
Delete values after their last use. This ensures that values that are
not used in the remainder of the code are freed and the memory usage
of the code is optimal.
r Nr
z = c S s g | ] }t |qS r" )rl )rm r r" r" r# r s zDGraph._python_code..delete_unused_values..Nonez; )r r7 r r r: )r Znodes_to_deleteZ
to_delete_str)bodyr r" r# delete_unused_values s
z0Graph._python_code..delete_unused_values)r c
s | j d krdnd| j }| jdkrt| jts8t| jsBdndt| jd }j| j | | | jj dd}|t| krjt| d| d d S | jdkrt| jtstjt| | dt
t| jd | j d t | jd
d | j d d S | jd krtt
| js*t| jjd
kr| jjtkrt| jtsXtjt| | dt| jj jdd | jD d S t| j} || j}|dkr(t| jtr(t| jd
tr(| jd
j r(t| jdkr(jt| | dt
t| jd | jd
d S jt| | d| d t | j| j d | jjddrpj| d S | jdkrt| jtstjt| | dt
| j d t | j| j d d S | jdkrt| jtstjt| | dt
| j d S | jdkr| j d k r>d| j d< jd krfjdt| jd n jdt| jd d d S td| j d | j d S ) Nr5 z : r z = r *r r (r )r _operatorc s s | ]}t |V qd S )N)rl )rm rn r" r" r# ro s z8Graph._python_code..emit_node..r? rR Z
is_wrappedFr r r z -> zreturn z return pytree.tree_unflatten(z, self._out_spec)znode: )r r r rt r r^ rj rl r7 replacerz rs rk r r r
magic_methodsr formatr rv r r r rY r NotImplementedError)r Zmaybe_type_annotationZmaybe_default_argraw_namer r )r r free_varsmaybe_return_annotationr rO r wrapped_fnsr" r# emit_node sb
D 6
2.
6 $ z%Graph._python_code..emit_noder zpass
rO z, z!, = fx_pytree.tree_flatten_spec([z], self._in_spec)
wrapr c s g | ]} d | dqS )z("z")r" )rm r$ ) wrap_namer" r# r s z&Graph._python_code..c s s | ]}d | V qdS )z Nr" )rm liner" r" r# ro s z%Graph._python_code..z
def forward(r z:
)r r
r% rr r reversedr r rj rk r r7 r r insertr: r) Zfxr ru rg )
rO r r r$ r4 r! r r r Z
has_orig_selfZ
wrap_stmtscodeZfn_coder" )r r r r r r r r r r rO r r r r r# r D sP :
&
&zGraph._python_codec s` g dg} fdd| j D }dj }d| d|d d}x |D ]}|rD|d | 7 }qDW |S )
zl
Return a human-readable (not machine-readable) string representation
of this Graph
r5 c s g | ]}|j qS r" )Z format_node)rm r )placeholder_namesr" r# r s z!Graph.__str__..z, zgraph(r r :z
)r r: )rO Zmaybe_return_typenameZ node_strsZ param_strr3 Znode_strr" )r r# __str__ s
z
Graph.__str__c C s\ yddl m } W n tk
r, td Y nX dd | jD }t||dddd d
gd d S )
z
Prints the intermediate representation of the graph in tabular
format. Note that this API requires the ``tabulate`` module to be
installed.
r )tabulatez`print_tabular` relies on the library `tabulate`, which could not be found on this machine. Run `pip install tabulate` to install the library.c S s$ g | ] }|j |j|j|j|jgqS r" )r r$ rt rj rk )rm r r" r" r# r s z'Graph.print_tabular..opcoder$ rt rj rk )headersN)r ImportErrorprintr )rO r Z
node_specsr" r" r#
print_tabular s
zGraph.print_tabularc s d t tt ddfdd
t }t xjD ]jd krXtd d j d
jk rrtd dtj fdd tj fdd j
j |krtdj d
|j
j q2W j rxjD ]jdkr,t
js`td dj dtjj dn4tjts`td dj dtjj djd krjjd}j }xt|D ] \}}t||d}dj|d| }|dkrtd dj d| d| jdkr t|tjj r td dj d| d| d nhjd krt|tjj rt|tjj r||jkrt j d dj d| d| d n|}qW qW dS )!aJ
Runs various checks on this Graph to make sure it is well-formed. In
particular:
- Checks Nodes have correct ownership (owned by this graph)
- Checks Nodes appear in topological order
- If this Graph has an owning GraphModule, checks that targets
exist in that GraphModule
N)r r r. c s^ |rd| dnd}| j k r8td| d| d | krZtd| d| d d S )Nz
of Node 'z' r z
Argument ''zdoes not belong to this Graph, but was used as an argument! If you are copying nodes from another graph, make sure to use ``arg_transform`` on node_copy() to remap values
zdwas used before it has been defined! Please check that Nodes in the graph are topologically ordered
)r| r )r r Z context_str) seen_valuesrO r" r# check_arg1 s
z Graph.lint..check_argr r r r r r zNode z had unknown opcode r zNode 'z ' does not belong to this Graph!c s
| S )Nr" )r )r r r" r# r B s z Graph.lint..c s
| S )Nr" )r )r r r" r# r C s zNode redefined name z target z
has type z but a Callable is expectedz but a str is expectedr> z" references nonexistent attribute z of r z does not reference an nn.Modulezj does not reference an nn.Module, nn.Parameter, or buffer, which is what 'get_attr' Nodes typically target)N)r r r r r r )r r ) r r rH r r r r| r rj rk rZ r$ r r rt
ValueErrorr) r r r ru enumerater? r: rA r r r r r )rO Z
seen_namesZ target_atomsZm_itriZatomZ new_m_itrZ
seen_qualnamer" )r r r rO r# lint% sL
(&
" & (z
Graph.lintc C sJ | j d}x8t| jD ]*}|j rt|jdkr| j| d}qW |S )a7
Remove all dead code from the graph, based on each node's number of
users, and whether the nodes have any side effects. The graph must be
topologically sorted before calling.
Returns:
bool: Whether the graph was changed as a result of the pass.
Example:
Before dead code is eliminated, `a` from `a = x + 1` below has no users
and thus can be eliminated from the graph without having an effect.
.. code-block:: python
def forward(self, x):
a = x + 1
return x + self.attr_1
After dead code is eliminated, `a = x + 1` has been removed, and the rest
of `forward` remains.
.. code-block:: python
def forward(self, x):
return x + self.attr_1
Fr T)r r r Z is_impurer r r )rO changedr r" r" r# eliminate_dead_codel s
zGraph.eliminate_dead_code)NN)F)N)NNNN)r .)N)N)N)N)NNN)r .)NNN)r .)NNN)r .)N),r r r r r
r r rP propertyr setterr r r r r r r r r
r r r r r r r r r r r r r r r r rg r rF r r r r r r" r" r" r# r sj + :* : 2( 2 : & = >Gr z{} + {}z{} - {}z{} * {}z{} // {}z{} / {}z{} % {}z{} ** {}z{} << {}z{} >> {}z{} & {}z{} | {}z{} ^ {}z{}[{}]z{} @ {})rZ rS mulfloordivtruedivdivr powlshiftrshiftand_or_xorgetitemmatmulz{} == {}z{} != {}z{} < {}z{} > {}z{} <= {}z{} >= {}z+{}z-{}z~{}) eqneltgtlegeposneginvert)Fr r r r r r r Ztorch.utils._pytreeutilsr r, r5 r+ Z_compatibilityr
typingr r r
r r r r r r r r Z dataclassesr
contextlibr r r) ra rK rc mathr Z graph_moduler Z_symbolic_tracer r r rH frozensetr r r r% r r& r' r( r r* re r2 r= rE rF rg rs rz r{ r r r Zreflectable_magic_methodsr r" r" r" r# s 4 P "
*