a MSicE@sddlmZddlmZddlmZddlmZddlm Z ddl Z ddl m Z m Z mZmZmZmZddlZe d d Gd d d eZGd ddZeejjddddZe d d ee e eedddZdS)) GraphModule)Graph)Node)symbolic_trace) compatibilityN)CallableDictList NamedTupleOptionalSetT)is_backward_compatiblec@s&eZdZUeed<eeefed<dS)Matchanchor nodes_mapN)__name__ __module__ __qualname__r__annotations__r rrV/var/www/html/django/DPS/env/lib/python3.9/site-packages/torch/fx/subgraph_rewriter.pyr s rc@s>eZdZeddddZeedddZeeedd d ZdS) _SubgraphMatcherN)patternreturncCsR||_t|jdkrtdttt|j|_t|jjdksHJdi|_ dS)Nrz<_SubgraphMatcher cannot be initialized with an empty patternrz5Pattern matching on multiple outputs is not supported) rlennodes ValueErrornextiterreversedpattern_anchorall_input_nodesr)selfrrrr__init__sz_SubgraphMatcher.__init__)rrcCsi|_||j|S)z Checks if the whole pattern can be matched starting from ``anchor`` in the larger graph. Pattern matching is done by recursively comparing the pattern node's use-def relationships against the graph node's. )r _match_nodesr!)r#rrrrmatches_subgraph_from_anchor!sz-_SubgraphMatcher.matches_subgraph_from_anchorpngnrcsjvrj|kStttddd}||s8dS|j<jdkrPdSjdkrrtjt|jkrrdSjdkrtfdd |jD}n4tjt|jkotfd d tj|jD}|sj dSdS) Nr'cSs:|jdks|jdkr"|jdkr"dS|j|jko8|j|jkS)N placeholderoutputT)optarget)r(r)rrrattributes_are_equal4s z;_SubgraphMatcher._match_nodes..attributes_are_equalFr*Tr+c3s |]}jd|VqdS)rN)r%r").0gn_r(r#rr Lsz0_SubgraphMatcher._match_nodes..c3s|]\}}||VqdSN)r%)r/Zpn_r0)r#rrr2P) rrboolr,rr"anyallzippop)r#r(r)r.Z match_foundrr1rr%-s2          z_SubgraphMatcher._match_nodes) rrrrr$rr5r&r%rrrrrs r)gm replacementrcCs|t|tr|jtjjtt tjjddd}|jj D]~}|j dksZ|j dkrB|||j }|||j }|dur~qBqB|durt t||j }||j |qBtd|j d|j dqB|jdS) N)modr-rcSs*z||}|WSty$YdS0dSr3) get_submoduleAttributeError)r<r-Z mod_matchrrrtry_get_submodule_s   z._replace_submodules..try_get_submodule call_moduleget_attrzAttempted to create a "z-" node during subgraph rewriting with target z, but the referenced submodule does not exist in either the original GraphModule `gm` or the replacement GraphModule `replacement`)delete_all_unused_submodules isinstancergraphlinttorchnnModulestrr rr,r-copydeepcopygetattr add_submodule RuntimeError)r:r;r?nodeZ gm_submodZreplacement_submodZ new_submodrrr_replace_submodulesYs&     rP)r:rr;rc! sJ|j}t|j}t|j}t|}g}|jD]X}||r,tttftddd} | |jr,| t |t dd|j Ddq,t t} t tdfdd } |D]v| rqi} d d |jD} t| d ksJd d |jD}t| t|ksJddt|| D}j}tddfdd |jD]}|q<|D].}||}| j|j|}|| |<qP||||| }Wdn1s0Y|jdkrdd |jD}t|d ksJdd |jD}t|t|ks Jddt||D}j D]~\}}|jdkrBq*|jdkrRq*||ks`J||}t|j|jD].\}}j|}| |}|||| |<qvq*|jdksJn|f|_t|tr|di|_t|tsJt|jD],} t| jd kr| jdkr|| qq|t|tj j!rFt"|||S)a Matches all possible non-overlapping sets of operators and their data dependencies (``pattern``) in the Graph of a GraphModule (``gm``), then replaces each of these matched subgraphs with another subgraph (``replacement``). Args: ``gm``: The GraphModule that wraps the Graph to operate on ``pattern``: The subgraph to match in ``gm`` for replacement ``replacement``: The subgraph to replace ``pattern`` with Returns: List[Match]: A list of ``Match`` objects representing the places in the original graph that ``pattern`` was matched to. The list is empty if there are no matches. ``Match`` is defined as: .. code-block:: python class Match(NamedTuple): # Node from which the match was found anchor: Node # Maps nodes in the pattern subgraph to nodes in the larger graph nodes_map: Dict[Node, Node] Examples: .. code-block:: python import torch from torch.fx import symbolic_trace, subgraph_rewriter class M(torch.nn.Module): def __init__(self): super().__init__() def forward(self, x, w1, w2): m1 = torch.cat([w1, w2]).sum() m2 = torch.cat([w1, w2]).sum() return x + torch.max(m1) + torch.max(m2) def pattern(w1, w2): return torch.cat([w1, w2]).sum() def replacement(w1, w2): return torch.stack([w1, w2]) traced_module = symbolic_trace(M()) subgraph_rewriter.replace_pattern(traced_module, pattern, replacement) The above code will first match ``pattern`` in the ``forward`` method of ``traced_module``. Pattern-matching is done based on use-def relationships, not node names. For example, if you had ``p = torch.cat([a, b])`` in ``pattern``, you could match ``m = torch.cat([a, b])`` in the original ``forward`` function, despite the variable names being different (``p`` vs ``m``). The ``return`` statement in ``pattern`` is matched based on its value only; it may or may not match to the ``return`` statement in the larger graph. In other words, the pattern doesn't have to extend to the end of the larger graph. When the pattern is matched, it will be removed from the larger function and replaced by ``replacement``. If there are multiple matches for ``pattern`` in the larger function, each non-overlapping match will be replaced. In the case of a match overlap, the first found match in the set of overlapping matches will be replaced. ("First" here being defined as the first in a topological ordering of the Nodes' use-def relationships. In most cases, the first Node is the parameter that appears directly after ``self``, while the last Node is whatever the function returns.) One important thing to note is that the parameters of the ``pattern`` Callable must be used in the Callable itself, and the parameters of the ``replacement`` Callable must match the pattern. The first rule is why, in the above code block, the ``forward`` function has parameters ``x, w1, w2``, but the ``pattern`` function only has parameters ``w1, w2``. ``pattern`` doesn't use ``x``, so it shouldn't specify ``x`` as a parameter. As an example of the second rule, consider replacing .. code-block:: python def pattern(x, y): return torch.neg(x) + torch.relu(y) with .. code-block:: python def replacement(x, y): return torch.relu(x) In this case, ``replacement`` needs the same number of parameters as ``pattern`` (both ``x`` and ``y``), even though the parameter ``y`` isn't used in ``replacement``. After calling ``subgraph_rewriter.replace_pattern``, the generated Python code looks like this: .. code-block:: python def forward(self, x, w1, w2): stack_1 = torch.stack([w1, w2]) sum_1 = stack_1.sum() stack_2 = torch.stack([w1, w2]) sum_2 = stack_2.sum() max_1 = torch.max(sum_1) add_1 = x + max_1 max_2 = torch.max(sum_2) add_2 = add_1 + max_2 return add_2 )rrcSsdd|D}|D]l}|jdkr*q||jdkr:qt||jdkrjt||jdjdkrjq|jD]}||vrpdSqpqdS) NcSsi|]\}}||qSrr)r/kvrrr r4zAreplace_pattern..pattern_is_contained..r*r+rrFT)itemskeysr,ruserslist)rlookupnuserrrrpattern_is_containeds    z-replace_pattern..pattern_is_containedcSsi|]\}}||qSrr)r/keyvaluerrrrS+sz#replace_pattern..)rr)matchrcs<|jD],\}}|jdvrq |vr |jdkr dSq dS)N)r*r+r*TF)rrTr,)r^r(r))replaced_nodesrroverlaps_with_prev_match8s  z1replace_pattern..overlaps_with_prev_matchcSsg|]}|jdkr|qSr*r,r/rYrrr Hs z#replace_pattern..rcSsg|]}|jdkr|qSrarbrcrrrrdKs cSsi|]\}}||qSrrr/rprrrrSNr4N)rYrcs4|jvrdS|jD] }|q|dSr3)rvaluesr"add)rYn_mark_node_as_replacedr^r_rrrlUs   z.replace_pattern..mark_node_as_replacedr+cSsg|]}|jdkr|qSr+rbrcrrrrdws cSsg|]}|jdkr|qSrmrbrcrrrrdzs cSsi|]\}}||qSrrrerrrrS}r4r*)#rDrrrr&r rr5rappendrrJrTsetdictrr8rr"getinserting_before graph_copyr,replace_all_uses_withargsrC _input_nodesr rV erase_node recompilerFrGrHrP)!r:rr;original_graphZ pattern_graphZreplacement_graphmatchermatchesrr[Zmatch_changed_noder`val_mapZpattern_placeholdersZreplacement_placeholdersZplaceholder_mapZsubgraph_output input_nodeZreplacement_nodeZ pattern_nodeZoriginal_graph_nodeZ copied_outputZpattern_outputsZreplacement_outputsZ outputs_mapr(r)rnZpn_inputZrn_inputZgn_inputZrn_input_in_original_graphrOrrkrreplace_patternst            $        r) graph_modulerrDrrOr_symbolic_tracer_compatibilityrrJtypingrr r r r r rFrrrGrHrPrrrrrs      G-