/usr/local/lib64/python3.6/site-packages/torch/fx/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/fx/__pycache__/node.cpython-36.pyc (22170B)
3
Egae @ s U d dl mZmZmZmZmZmZmZmZm Z ddl
m Z ddl m
Z
mZ d dlZd dlZd dlZd dlmZmZmZ erddlmZ eeeeeej ej ej ej f Z e j!Z"eedef ef Z#eeeedf ee eeef e$d e f Z%ej&ej'j(j)ej'j(j*hZ+e e +edef ed
d d Z,d
d Z-edef edddZ.edddZ/e ddG dd d Z0e dde%ee0ge%f e%dddZ1e dde%ee%ge%f e%ddd Z2dS ) )
TYPE_CHECKINGUnionCallableAnyTupleListOptionalDictSet )
compatibility)immutable_dictimmutable_listN)normalize_functionnormalize_moduleArgsKwargsPair)Graph.Node) orig_methodreturnc C sV | j }| j}|d k r|S x*ttjjgD ]}t||d | kr&|j S q&W td| d S )Nzcannot find module for )__name__
__module__torchnnZ
functionalgetattr RuntimeError)r namemoduleguess r 9/usr/local/lib64/python3.6/site-packages/torch/fx/node.py_find_module_of_method s
r! c C s\ t | tr6| jdkr6| jdkr$| jS | j d| j S | dkrBdS t | tjrT| jS t| S )a: Return the repr() of an object, special-casing types (internal helper).
If obj is a type, we return a shorter version than the default
type.__repr__, based on the module and qualified name, which is
typically enough to uniquely identify a type. For everything
else, we fall back on repr(obj).
typingbuiltins..z...)
isinstancetyper __qualname__types FunctionTyper repr)objr r r
_type_repr, s
r, )funcr c C s@ t t| jd | kr| jS | j}t| }|jdd}| d| S )Nz
torch._opsz torch.opsr$ )r r# r r! replace)r- r r r r r _get_qualified_nameA s r/ )r c C s t | tr*djdd | D }d| dS t | trldjdd | D }t| dkrXdnd }d
| | d S t | trdjd d | j D }d
| dS t | trdt| S t| S d S )Nz, c s s | ]}t |V qd S )N) _format_arg).0ar r r
L s z _format_arg..[]c s s | ]}t |V qd S )N)r0 )r1 r2 r r r r3 O s r , ()c s s$ | ] \}}| d t | V qdS )z: N)r0 )r1 kvr r r r3 S s {}%) r% listjointuplelendictitemsr str)argrD Z maybe_commaZ items_strr r r r0 J s
r0 T)is_backward_compatiblec @ st e Zd ZdZedddBdeededC eedf ee dd d
d Z
e d d d
dZ e d d ddZ
eddd ddddZeddd ddddZdd Ze eedf d ddZejeedf dddZe eeef d d d Zejeeef d d d Ze ed d d d!Zeddeedd"d#d$Zeddeedd%d&d'Ze ee d d(d)Zejee d*d+d)ZedD eedf d,d-d.Zed d/d0Z d1d2 Z edddEee ee ee d3d4d5Z eddd ed d6d7d8Z ed9dd:d; Z ed9ddFe!j"j#eee eeee f e$ee% d<d=d>Z&eddd d d?d@dAZ'dS )Gr ao
``Node`` is the data structure that represents individual operations within
a ``Graph``. For the most part, Nodes represent callsites to various entities,
such as operators, methods, and Modules (some exceptions include nodes that
specify function inputs and outputs). Each ``Node`` has a function specified
by its ``op`` property. The ``Node`` semantics for each value of ``op`` are as follows:
- ``placeholder`` represents a function input. The ``name`` attribute specifies the name this value will take on.
``target`` is similarly the name of the argument. ``args`` holds either: 1) nothing, or 2) a single argument
denoting the default parameter of the function input. ``kwargs`` is don't-care. Placeholders correspond to
the function parameters (e.g. ``x``) in the graph printout.
- ``get_attr`` retrieves a parameter from the module hierarchy. ``name`` is similarly the name the result of the
fetch is assigned to. ``target`` is the fully-qualified name of the parameter's position in the module hierarchy.
``args`` and ``kwargs`` are don't-care
- ``call_function`` applies a free function to some values. ``name`` is similarly the name of the value to assign
to. ``target`` is the function to be applied. ``args`` and ``kwargs`` represent the arguments to the function,
following the Python calling convention
- ``call_module`` applies a module in the module hierarchy's ``forward()`` method to given arguments. ``name`` is
as previous. ``target`` is the fully-qualified name of the module in the module hierarchy to call.
``args`` and ``kwargs`` represent the arguments to invoke the module on, *including the self argument*.
- ``call_method`` calls a method on a value. ``name`` is as similar. ``target`` is the string name of the method
to apply to the ``self`` argument. ``args`` and ``kwargs`` represent the arguments to invoke the module on,
*including the self argument*
- ``output`` contains the output of the traced function in its ``args[0]`` attribute. This corresponds to the "return" statement
in the Graph printout.
T)rG Nr TargetArgument.)graphr optargetargskwargs return_typer c
C s || _ || _|dkst|| _|dkrXt|std| d | d
| d tj| d n2t|t std| d | d
| d tj| d
|| _
i | _ | j t
|dd t
|dd i | _|| _| | _| | _d| _d| _d| _i | _dS )a}
Instantiate an instance of ``Node``. Note: most often, you want to use the
Graph APIs, i.e. ``Graph.call_module``, ``Graph.call_method``, etc. rather
than instantiating a ``Node`` directly.
Args:
graph (Graph): The ``Graph`` to which this ``Node`` should belong.
name (str): The name to which the output of this ``Node`` should be assigned
op (str): The opcode for this ``Node``. Can be one of 'placeholder',
'call_method', 'call_module', 'call_function', 'get_attr',
'output'
target ('Target'): The target this op should call. See the broader
``Node`` docstring for more details.
args (Tuple['Argument']): The args to be passed to ``target``
kwargs (Dict[str, 'Argument']): The kwargs to be passed to ``target``
return_type (Optional[Any]): The python type expression representing the
type of the output of this node. This field can be used for
annotation of values in the generated code or for other types
of analyses.
placeholder call_method call_module
call_functionget_attroutputrootzNode [graph = z
, name = 'z
'] target z
has type z but a Callable is expectedz but a str is expectedc S s | S )Nr )xr r r s z Node.__init__..FN)rP rQ rR rS rT rU rV )rJ r AssertionErrorrK callable
ValueErrorr typenamer% rE rL _input_nodes_Node__update_args_kwargsmap_argusersr& _prev_nextZ_erased_repr_fn _stack_tracemeta)selfrJ r rK rL rM rN rO r r r __init__x s( *
( z
Node.__init__)r c C s | j S )z
Returns the next ``Node`` in the linked list of Nodes.
Returns:
The next ``Node`` in the linked list of Nodes.
)rb )rf r r r next s z Node.nextc C s | j S )z
Returns the previous ``Node`` in the linked list of Nodes.
Returns:
The previous ``Node`` in the linked list of Nodes.
)ra )rf r r r prev s z Node.prev)rW r c C sB | j |j kstd|j | j}|| |_|_| | |_| _dS )aD
Insert x before this node in the list of nodes in the graph. Example::
Before: p -> self
bx -> x -> ax
After: p -> x -> self
bx -> ax
Args:
x (Node): The node to put before this node. Must be a member of the same graph.
z0Attempting to move a Node into a different GraphN)rJ rY _remove_from_listra rb )rf rW pr r r prepend s
z Node.prependc C s | j j| dS )z
Insert x after this node in the list of nodes in the graph.
Equvalent to ``self.next.prepend(x)``
Args:
x (Node): The node to put after this node. Must be a member of the same graph.
N)rb rl )rf rW r r r append s z Node.appendc C s | j | j }}|| |_|_ d S )N)ra rb )rf rk nr r r rj s zNode._remove_from_listc C s | j S )a@
The tuple of arguments to this ``Node``. The interpretation of arguments
depends on the node's opcode. See the :class:`Node` docstring for more
information.
Assignment to this property is allowed. All accounting of uses and users
is updated automatically on assignment.
)_args)rf r r r rM s
z Node.args)r2 c C s | j t|dd | j dS )z
Set the tuple of arguments to this Node. The interpretation of arguments
depends on the node's opcode. See the ``fx.Graph`` docstring for more
information.
c S s | S )Nr )rW r r r rX s zNode.args..N)r^ r_ _kwargs)rf r2 r r r rM s c C s | j S )aG
The dict of keyword arguments to this ``Node``. The interpretation of arguments
depends on the node's opcode. See the :class:`Node` docstring for more
information.
Assignment to this property is allowed. All accounting of uses and users
is updated automatically on assignment.
)rp )rf r r r rN s
z Node.kwargs)r: c C s | j | jt|dd dS )z
Set the dict of kwargs to this Node. The interpretation of arguments
depends on the node's opcode. See the ``fx.Graph`` docstring for more
information.
c S s | S )Nr )rW r r r rX , s z Node.kwargs..N)r^ ro r_ )rf r: r r r rN # s c C s t | jj S )aE
Return all Nodes that are inputs to this Node. This is equivalent to
iterating over ``args`` and ``kwargs`` and only collecting the values that
are Nodes.
Returns:
List of ``Nodes`` that appear in the ``args`` and ``kwargs`` of this
``Node``, in that order.
)r? r] keys)rf r r r all_input_nodes. s zNode.all_input_nodes)idxrF r c C s t | j}|||< t|| _dS )a3
Update an existing positional argument to contain the new value
``arg``. After calling, ``self.args[idx] == arg``.
Args:
idx (int): The index into ``self.args`` of the element to update
arg (Argument): The new argument value to write into ``args``
N)r? rM rA )rf rs rF rM r r r
update_arg< s
zNode.update_arg)keyrF r c C s t | j}|||< || _dS )a2
Update an existing keyword argument to contain the new value
``arg``. After calling, ``self.kwargs[key] == arg``.
Args:
key (str): The key in ``self.kwargs`` of the element to update
arg (Argument): The new argument value to write into ``kwargs``
N)rC rN )rf ru rF rN r r r update_kwargK s
zNode.update_kwargc C s | j S )a#
Return the Python stack trace that was recorded during tracing, if any.
This property is usually populated by `Tracer.create_proxy`. To record
stack traces during tracing for debug purposes, set
`record_stack_traces = True` on the `Tracer` instance.
)rd )rf r r r stack_traceZ s zNode.stack_trace)tracec C s
|| _ d S )N)rd )rf rx r r r rw d s )new_args
new_kwargsc s~ | _ | _x jj D ]}|jj qW i _t j fdd t j fdd x jj D ]}|jj qfW dS )zB
This API is internal. Do *not* call it directly.
c s j j| S )N)r]
setdefault)rn )rf r r rX s s z+Node.__update_args_kwargs..c s j j| S )N)r] r{ )rn )rf r r rX t s N)ro rp r] rq r` popr_ r{ )rf ry rz Zold_useZnew_user )rf r Z__update_args_kwargsh s zNode.__update_args_kwargsc C s | j r| j | S | jS )N)rc r )rf r r r __repr__y s
z
Node.__repr__c C s^ t |tr|S t|drVt|ds*t|S |jdkr@d|j S |jdkrVd|j S t|S )z
Make target printouts more user-friendly.
1) builtins will be printed as `builtins.xyz`
2) operators will be printed as `operator.xyz`
3) other callables will be printed with qualfied name, e.g. torch.add
r r r# z builtins. _operatorz operator.)r% rE hasattrr/ r r )rf rL r r r _pretty_print_target~ s
zNode._pretty_print_target)placeholder_namesmaybe_return_typenamer c C s | j dkrt| jtst| j}|| jr<|dt| j nd7 }|rT|j| dS | jrjt| j dnd}| jrdt| jd d nd}d | j d
| d t
| j d | j d
| j d| S | j dkr"| jdk rt| j dnd}d | j d
| d t
| j d | j d
| j | j d S | j dkr`| jrP|rPdt| j |d< d| jd S | jdk r|t| j dnd}d | j d
| d t
| j d | j d
| j | j dt
| j dt
| j dS dS )a
Return a descriptive string representation of ``self``.
This method can be used with no arguments as a debugging
utility.
This function is also used internally in the ``__str__`` method
of ``Graph``. Together, the strings in ``placeholder_names``
and ``maybe_return_typename`` make up the signature of the
autogenerated ``forward`` function in this Graph's surrounding
GraphModule. ``placeholder_names`` and ``maybe_return_typename``
should not be used otherwise.
Args:
placeholder_names: A list that will store formatted strings
representing the placeholders in the generated
``forward`` function. Internal use only.
maybe_return_typename: A single-element list that will store
a formatted string representing the output of the
generated ``forward`` function. Internal use only.
Returns:
str: If 1) we're using ``format_node`` as an internal helper
in the ``__str__`` method of ``Graph``, and 2) ``self``
is a placeholder Node, return ``None``. Otherwise,
return a descriptive string representation of the
current Node.
rP z: r7 N z (default=r r9 r> z : z[#users=z] = z[target=r5 rT rU z -> zreturn z ](args = z , kwargs = )rK r% rL rE rY r& r, rm rM r rB r` r r0 rN )rf r r Zarg_strZmaybe_typenameZ default_valr r r format_node s&
"
4 6 zNode.format_node) replace_withr c s t j}xb|D ]Z}ttd fdd }t|j|}t|j|}t|tsPtt|t s^t|j
|| qW t jdkst|S )a
Replace all uses of ``self`` in the Graph with the Node ``replace_with``.
Args:
replace_with (Node): The node to replace all uses of ``self`` with.
Returns:
The list of Nodes on which this change was made.
)rn r c s | kr S | S d S )Nr )rn )r rf r r maybe_replace_node s z6Node.replace_all_uses_with..maybe_replace_noder ) r? r` r r_ rM rN r% rA rY rC r^ rB )rf r Z
to_processZuse_noder ry rz r )r rf r replace_all_uses_with s
zNode.replace_all_uses_withFc C sx | j d krdS | j dkr"| jtkS | j dkrt| jjdk s@td| jjj| j}|dk shtd| j t|d d
S d
S ) z
Returns whether this op is impure, i.e. if its op is a placeholder or
output, or if a call_function or call_module which is impure.
Returns:
bool: If the op is impure or not.
rP rU TrS rR Nz1self.graph.owning_module not set for purity checkz'Did not find expected submodule target Z
_is_impureF> rP rU )rK rL _side_effectful_functionsrJ Z
owning_modulerY Z
get_submoduler )rf Z
target_modr r r is_impure s
zNode.is_impure)rV arg_types kwarg_types normalize_to_only_use_kwargsr c C s` | j dkr.t| jstt| j| j| j||S | j dkr\t| jtsHtt || j| j| jS dS )a
Returns normalized arguments to Python targets. This means that
`args/kwargs` will be matched up to the module/functional's
signature and return exclusively kwargs in positional order
if `normalize_to_only_use_kwargs` is true.
Also populates default values. Does not support positional-only
parameters or varargs parameters.
Supports module calls.
May require `arg_types` and `kwarg_types` in order to disambiguate overloads.
Args:
root (torch.nn.Module): Module upon which to resolve module targets.
arg_types (Optional[Tuple[Any]]): Tuple of arg types for the args
kwarg_types (Optional[Dict[str, Any]]): Dict of arg types for the kwargs
normalize_to_only_use_kwargs (bool): Whether to normalize to only use kwargs.
Returns:
Returns NamedTuple ArgsKwargsPair, or `None` if not successful.
rS rR N)
rK rZ rL rY r rM rN r% rE r )rf rV r r r r r r normalized_arguments s
zNode.normalized_arguments) old_input new_inputc sZ t t d fdd }t| j|}t| j|}t|ts.maybe_replace_nodeN) r r_ rM rN r% rA rY rC r^ )rf r r r ry rz r )r r r replace_input_with, s zNode.replace_input_with)N)rI .)rI .)NN)NNF)(r r r' __doc__r rE r r r r rg propertyrh ri rl rm rj rI rM setterrN r rr intrt rv rw r^ r} r r r r r r Moduleboolr r r r r r r r [ sZ 0M
"5 6 )r2 fnr c s" t stdt| fddS )zi
Apply fn to each Node appearing arg. arg may be a list, tuple, slice, or dict with string keys.
z.torch.fx.map_arg(a, fn): fn must be a callablec s t | tr | S | S )N)r% r )rW )r r r rX G s zmap_arg..)rZ rY
map_aggregate)r2 r r )r r r_ A s r_ c s t | tr t fdd| D S t | tr@t fdd| D S t | trdt fdd| j D S t | trtt| j t| j
t| j S | S dS )zi
Apply fn to each Node appearing arg. arg may be a list, tuple, slice, or dict with string keys.
c 3 s | ]}t | V qd S )N)r )r1 elem)r r r r3 O s z map_aggregate..c 3 s | ]}t | V qd S )N)r )r1 r )r r r r3 Q s c 3 s | ]\}}|t | fV qd S )N)r )r1 r: r; )r r r r3 S s N) r% rA r? r rC r
rD slicer startstopstep)r2 r r )r r r I s
$r )3r" r r r r r r r r r
Z_compatibilityr Zimmutable_collectionsr
r r r# r( Ztorch.fx.operator_schemasr r r rJ r rE r floatr ZdtypeZTensorZdeviceZ
memory_formatZBaseArgumentTypes__args__Z
base_typesrH r rI Z_assertopsZprofilerZ_record_function_enterZ_record_function_exitr r! r, r/ r0 r r_ r r r r r sB ,
i