DŽg6bddlmZddlmZddlmZddlmZddlm Z ddl Z ddl m Z dd l mZmZmZmZmZmZmZmZmZddlZerdd lmZgd Ze d GddeZe d e GddZdedej:j<ddfdZe d dedeeefdeeefdeefdZ e d  ddedeeeefdeeeefdeeedeege!fde!deef dZ" ddedeeeefdeeeefdeeedeege!fde!deef dZ#y)) GraphModule)Graph)Node)symbolic_trace) compatibilityN) dataclass) AnyCallableDictList NamedTupleOptionalSetUnion TYPE_CHECKING) InternalMatch)Matchreplace_patternreplace_pattern_with_filtersReplacedPatternsT)is_backward_compatiblec,eZdZUeed<eeefed<y)ranchor nodes_mapN)__name__ __module__ __qualname__r__annotations__r b/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/torch/fx/subgraph_rewriter.pyrrs LD$Jr!rFc<eZdZUeed<eeefed<eeed<y)rrr replacementsN)rrrrrr r r r!r"rrs" LD$Jt*r!rgm replacementreturnc|jt|tr|jj dt j jdtdttfd}|jjD]}|jdk(s|jdk(s"|||j}|||j}|K|ntj|}t|t j jr|j!|j|t#||j|t%d|jd|jd |jj y) Nr%targetr'c|jd\}}} |j|}t||d}|S#t$rYywxYw)N.) rpartition get_submoduleAttributeErrorgetattr)r%r) module_path_ attr_namemodattrs r" try_get_attrz)_replace_attributes..try_get_attr(sW$*$5$5c$:! Q  #%#3#3K#@CsIt,   s7 AA call_moduleget_attrzAttempted to create a "z-" node during subgraph rewriting with target zL, but the referenced attribute does not exist in the replacement GraphModule)delete_all_unused_submodules isinstancergraphlinttorchnnModulestrrr nodesopr)copydeepcopy add_submodulesetattr RuntimeError)r%r&r5nodegm_attrreplacement_attrnew_attrs r"_replace_attributesrK"s?##%+{+ #(3-K 77m #tww*'<"2t{{3G+KE  ""-==)9:.@$$T[[(;B X6 ## None: 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 )rr)_replace_patternrrr)r%rLr&match_and_replacementsms r"rrRs7n.b';GCY ZaEQ[[ 9 ZZ Zs(= match_filtersrignore_literalsc t|||||S)a See replace_pattern for documentation. This function is an overload with an additional match_filter argument. Args: ``match_filters``: A list of functions that take in (match: InternalMatch, original_graph: Graph, pattern_graph: Graph) and return a boolean indicating whether the match satisfies the condition. See matcher_utils.py for definition of InternalMatch. )rN)r%rLr&rQrRs r"rrs$ Bm_ UUr!c ddlm}m}|g}|jt |t r |jn(t |t r|nt|jt |t r |j}n(t |t r|}nt|j}|ddd|}|j} | D cgc] t fd|Dr } } |jD cgc]} | jdk(s| } } i} g}| D]}t|jt| k(sJi}t| |jD]\}}t |tr| j!||||<|||k7s4|jj#|}| ||j|<t%|j&j)t%|j&j+j#|}| ||j&|<|||<t-}|j.D]} |j1| j2|sJdt|d k(rt5t7|}njD] } | |vs| }nj95j;||}dddt tr|f}|j+Dcgc]}||jvs|}}t|j.t|k(sJt|j.|D]\}}|j=||| |<t?jD]L}|jdk7s|jd k7s#|j&|}|jjA|N|jCtE|jFd|j&| |jIt |tJjLjNr tQ|||Scc} wcc} w#1swYxYwcc}w) Nr)SubgraphMatcherrFT) match_outputmatch_placeholderremove_overlapping_matchesrRc32K|]}|yw)Nr ).0 match_filterrPoriginal_graph pattern_graphs r" z#_replace_pattern..s"2A~}=2s placeholderz6The returning_nodes should have at least one user noderoutput)rrr$))#torch.fx.passes.utils.matcher_utilsrUrr:r9rrrmatchallr@rAlenplaceholder_nodesziprgetindexlistrkeysvaluessetreturning_nodesupdateusersnextiterinserting_before graph_copyreplace_all_uses_withreversed erase_nodeappendranchors recompiler<r=r>rK)r%rLr&rQrRrUrreplacement_graphmatcher_matchesrPnreplacement_placeholdersmatch_changed_noderOrbval_maprngngn_indmap_key user_nodesfirst_user_nodecopied_returning_nodesvreplacement_nodes copied_noderGr\r]s ` @@r"rNrNs6S HHN';' GU # &w/55 +{+'-- K ''*;7==m%SX9=`G$+MM.$AH 2#02 2 H ,=+B+B\aaddmF[\\,.?  5**+s3K/LLLL$&2E4K4KL !FB"d#044R< $"44::2>F6H6LE++F3"5??#7#7#9:4@V@V@X;Y;_;_`b;cdG/A"/EEOOG,   !!$ && 'A   agg & 'SSSz z?a "4 #34O$))  ?&'O   , ,_ = [%3%>%>?PRY%Z " [ ,d 3&<%? "5rKrboolrrNr r!r"rs%+) !]]] L Zd+ J , e,  --K-ehhoo-$-`d+w[w[ 8[( )w[x,-w[ %[ w[,w[ve, VZ! VV 8UK/ 0Vx 34VD?E5*I4*O!PQR V  V   V-V0VZ! y"y" 8UK/ 0y"x 34y"D?E5*I4*O!PQR y"  y"   y"r!