o Xi@sRUdZddlmZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZmZmZmZddlmmZddlmZedZGdd d eeZGd d d ejeeZGd d d eZGdddeZGdddeejZGdddeZ ee!e"eee!ee"eefZ#GdddeZ$dUddZ%GdddZ&e&dZ'e&edZ(Gdd d Z)dVd$d%Z*e'a+de,d&<ej-dWd(d)Z.Gd*d+d+Z/Gd,d-d-Z0Gd.d/d/e/Z1Gd0d1d1e/Z2Gd2d3d3e/Z3e3Z4Gd4d5d5e/Z5Gd6d7d7e/Z6Gd8d9d9e/Z7   dXdYdAdBZ8dZdEdFZ9d[dMdNZ:GdOdPdPZ;d\dSdTZz#_to_attr_pattern..css|]}t|tVqdSr)rdrrgrrrrjsz9Only lists of int/float/str can be used as an AttrPatternCannot convert z to AttrPattern)rdr5Var check_method ValueErrorrPr8r7rerfrrWr all TypeErrorrY)r'rrr_to_attr_patterns"    rrc@sXeZdZdZd d!d d Zd"d d Zd#ddZd$ddZd%ddZd&ddZ d'ddZ dS)(OpsetPatternBuilderaRepresents an opset pattern and a pattern builder. (i) It is used to create a NodePattern (via OpPatternBuilder). Example usage: :: z = op.Matmul(x, y) Here, `op` is an instance of OpsetPatternBuilder and `op.Matmul` is an instance of OpPatternBuilder, and `op.Matmul(x, y)` is an instance of NodePattern. (ii) It contains a domain pattern matched against the actual opset domain used in the input model. FdomainStringPattern | strrecordrrr1cCs0t|tr t|}||_|rg|_dSd|_dSr)rdrr&_domain_pattern_nodes)rrtrvrrrr,s   zOpsetPatternBuilder.__init__rcCr.r)rwr rrrdomain_patternr/z"OpsetPatternBuilder.domain_patternop_namerOpPatternBuildercCs t||Sr)r{)rrzrrr __getattr__r-zOpsetPatternBuilder.__getattr__r8cCst|t|S)z?This method is used to match against submodule ops with prefix.)r{r0)rr8rrr submodulezOpsetPatternBuilder.submodulecCr_r)rrwr rrrr!r-zOpsetPatternBuilder.__str__node NodePatterncCs|jdur |j|dSdSr)rxappend)rrrrradd_nodes zOpsetPatternBuilder.add_nodeSequence[NodePattern]cCs|jdur td|jS)NzNodes were not recorded.)rxror rrrnodess zOpsetPatternBuilder.nodesN)F)rtrurvrrr1)rr)rzrrr{)r8rrr{r#)rrrr1)rr) rrrrr,ryr|r}r!rrrrrrrss     rsz pkg.torchc@s4eZdZdZddd Zd d d d d d d dddZd S)r{a;A utility class to build a NodePattern. It is used primarily to create a NodePattern. Example usage: :: z = op.Matmul(x, y) Here, `op` is an instance of OpsetPatternBuilder and `op.Matmul` is an instance of OpPatternBuilder, and `op.Matmul(x, y)` is an instance of NodePattern. pattern_builderrsrzstr | Pattern[str]rr1cCr:r)rrz)rrrzrrrr,s zOpPatternBuilder.__init__N)_domain_version_outputs_allow_other_attributes_allow_other_inputs_checkrr9r int | Nonerint | list[str | None]r bool | NonerrCallable | Nonec Os|durtd|dur|j} nt|trt|} ntdt|tr/ddt|D}nt|t r=t dd|DsAtddd|D} d d | D} t | |j | | ||||d } |j| | j} t| d krq| d S| S)NzzThe pattern builder does not support '_version' keyword argument. Version restrictions should be handled by rewrite rules.z_domain must be a string.cSsg|]}dqSrr)rh_rrr sz-OpPatternBuilder.__call__..css"|] }t|ttdfVqdSr)rdrrYrhxrrrrj s z,OpPatternBuilder.__call__..z,_outputs must be an int or a list[str|None].cSg|]}t|qSr_to_value_patternrrrrrcSsi|] \}}|t|qSr)rr)rhr8r'rrr sz-OpPatternBuilder.__call__..allow_other_attributesallow_other_inputscheckrr)rorryrdrr&rqreranger rpitemsrrzroutputslen)rrrrrrrargskwargs opset_patterninputs attributes node_pattern output_valuesrrr__call__s@       zOpPatternBuilder.__call__)rrsrzrrr1) rr9rrrrrrrrrr)rrrrr,rrrrrr{s  r{r,ValuePattern | int | float | Callable | NoneValuePattern | NonecCs|dus t|tr |St|ttfrt|St|tr,tdd|Dr(t|Stdt|r6td|dSt dt |d)a_Promotes an input-value used to construct a NodePattern to a ValuePattern. Example usage: :: x = op.MatMul(a, b) z = op.Add(x, 0) In this example, `a, `b`, and `x` are ValuePatterns used to construct a NodePattern. `0` is a constant (int) value, and is automatically promoted to a ValuePattern. Note that this is a shorthand for creating a Constant pattern. The user can more explicitly write this as: :: z = op.Add(x, op.Constant(0)) If a callable is provided, it will be converted to a ValuePattern with the callable as the check attribute. Ncsrbrrcrgrrrrj?rkz$_to_value_pattern..z5Only lists of int/float can be used as a ValuePatternrrlz to ValuePattern) rd ValuePatternrerfConstantr rprocallablerqrY)rrrrr&s  r_pattern_builderbuilderccst}|adV|adSr)r)r prev_builderrrrrKs rc@seZdZdZddddddZed?ddZed@ddZ dAddZ dBddZ dCd#d$Z dDd&d'Z d(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9ZdDd:d;ZdS)ErzBase class for all patterns that match against IR values. This is used primarily to provide operator overloadings for arithmetic operations, so that we can write patterns like `x + 1` and `1 + x`. NFrr7r8r9rrr7rrr1cCs||_||_||_g|_dSr)r;rr<_usesrr8rr7rrrr,[s zValuePattern.__init__node_mapdict[NodePattern, NodePattern]cCs~t|j|jdS)Nr)rr;rrrrrrclonedszValuePattern.clonecCr.rr>r rrrr8hr?zValuePattern.namecCr.rrr rrrrnlr?zValuePattern.check_methodcCr.)z7Indicates whether this variable can match a None input.r@r rrrr7prAzValuePattern.can_match_noneNodePattern | NonecCrrrr rrrproducerurEzValuePattern.producer!Sequence[tuple[NodePattern, int]]cCr.r)rr rrrusesxr/zValuePattern.usesrrindexrecCs|j||fdSr)rr)rrrrrr append_use{rUzValuePattern.append_usercCsd|jdS)Nz ValuePattern()r>r rrr__repr__~szValuePattern.__repr__cC t||SrrAddrotherrrr__add__r3zValuePattern.__add__cC t||Srrrrrr__radd__r3zValuePattern.__radd__cCrrrSubrrrr__sub__r3zValuePattern.__sub__cCrrrrrrr__rsub__r3zValuePattern.__rsub__cCrrrMulrrrr__mul__r3zValuePattern.__mul__cCrrrrrrr__rmul__r3zValuePattern.__rmul__cCrrrDivrrrr __truediv__r3zValuePattern.__truediv__cCrrrrrrr __rtruediv__r3zValuePattern.__rtruediv__cCrr)rPowrrrr__pow__r3zValuePattern.__pow__cCrFrGrHr rrrr!rJzValuePattern.__str__r8r9rrr7rrr1)rrrrrLrrrM)rr)rr)rrrrer#)rrrrr,rrOr8rnr7rrrrrrrrrrrrrr!rrrrrTs2        rc@sdeZdZdZddd,ddZd-ddZd.ddZed-ddZed/ddZ d0d$d%Z d1d*d+Z dS)2ra)Represents a pattern that matches against a Node. This differs from a NodeOutputPattern in that it matches against a node (which may produce 1 or more outputs), whereas a NodeOutputPattern matches against a specific output of a node. Args: domain: pattern to match against the domain of the node. op: pattern or string constant to match against the op_type of the node. inputs: sequence of ValuePatterns (or constants) to match against the inputs of the node. attributes: dictionary of attribute patterns to match against the attributes of the node. outputs: specifies pattern-variable-name for outputs (or None) allow_other_attributes: specifies whether other attributes (not mentioned in `attributes`) are allowed in the node. Nrrtroprr+Sequence[int | float | ValuePattern | None]rdict[str, AttrPattern]rSequence[str | None]rrrrrc s|durd}|dur d}|_t|trt|n|_dd|D_|_|_|_|_ t|trDt|trDd} | || f_ nd_ fddt |D_ t jD]\} } | durf| | qXdS)NTFcSrrrrrrrrrz(NodePattern.__init__..rcsg|] \}}t||qSr)NodeOutputPattern)rhrir8r rrrs)rtrdrr&rrrrrrr'_op_identifier enumeraterr) rrtrrrrrrroverloadrr'rr rr,s0  zNodePattern.__init__rrcCsddd|jD}ddd|jD}ddd|jD}t|j}t|j}|r6|d|n|}|rA|d|n|}|d|d|d S) N, cs|]}t|VqdSrrrhvrrrrjz&NodePattern.__str__..csrrrrrrrrjrcss"|] \}}|d|VqdS)=Nrrhkrrrrrjs .z = z (r)joinrrrrrrrt)rrrrrrt qualified_opinputs_and_attributesrrrr!s  zNodePattern.__str__ir.OperatorIdentifier | NonecCr.r)rr rrr op_identifierr/zNodePattern.op_identifiercCr_r)rrr rrrop_type zNodePattern.op_typecCr.rrr rrrrnr?zNodePattern.check_methodrir.Nodematch_basics.MatchResultc Cs&|j|js|d|jd|jd|S|j|js,|d|jd|jd|S|jD]E\}}|j|}|durO|jsN|d|d|Sn||sf|d|d|d|d|S|j durv| |j |sv|Sq1|j s|jD]}||jvr|d|d |Sq}|S) zMatches the pattern represented by self against a node. This is purely a local node-level match, and does not consider the subgraph rooted at the node. We check the domain, op_type, and attributes of the node, but not the inputs. zOpType mismatch: expected z, got rzDomain mismatch: expected Nz Attribute z not found in node.z mismatch: expected z not expected in node.) rrrfailrtrrgetr7r8bindr)rrrr8 attr_pattern attr_valuerrrrs:     zNodePattern.matchesrrswaprc s|fdd|jD}|rt|dksJd|d|dg}dd|jD}t|j|j||j||j|j|j d}||<|S) Ncs"g|] }|dur |ndqSrrrrrrrs"z%NodePattern.clone..z:0yE>r'-int | float | Sequence[int] | Sequence[float]rel_tolrfabs_tolrr1cs4tdt|trt|n||_||_||_dSr)rRr,rdr listr*_rel_tol_abs_tol)rr'r rrSrrr,es  zConstant.__init__rrcCs~t|j|j|jSr)rr*rrrrrrrpszConstant.clone%int | float | list[int] | list[float]cCr.rr)r rrrr'tr?zConstant.valuercCr_rr`r rrrr!xr-zConstant.__str__)r r )r'r r rfrrfrr1)rrrr)rrr#) rrrrr,rrOr'r!rVrrrSrrbs  rcsJeZdZdZ  ddfd d Zedd d ZdddZdddZZ S)OpIdDispatchOrz`Represents a (restricted) form of value pattern disjunction that enables deterministic matching.N op_to_pattern8Mapping[ir.OperatorIdentifier, tuple[Any, ValuePattern]]r8r9tag_varrr1cst|||_||_dS)a Initialize an OpIdDispatchOr pattern. Args: op_to_pattern: A dictionary mapping operator identifiers to tuples of tag values and patterns. The keys are operator identifiers, and the values are tuples containing a tag value and a pattern to match against. name: An optional variable name for the pattern. Defaults to None. If present, this name will be bound to the value matched by the pattern. tag_var: An optional variable name for the tag. Defaults to None. If present, it will be bound to a value indicating which alternative was matched. N)rRr,_op_to_pattern_tag_var)rrr8rrSrrr,s  zOpIdDispatchOr.__init__cCr.z=Returns the tag variable associated with the OrValue pattern.rr rrrrrAzOpIdDispatchOr.tag_varrrcs$tfdd|jD|j|jS)Ncs(i|]\}}||d|dfqS)rrrrrrrrs(z(OpIdDispatchOr.clone..)rrrr8rrrrrrs zOpIdDispatchOr.cloner'ir.Valuetuple[Any, ValuePattern] | NonecCs8|}|dur|}|dur||jvr|j|SdS)z=Returns the pattern that should be tried for the given value.N)rrr)rr'rrIrrr get_patterns  zOpIdDispatchOr.get_pattern)NN)rrr8r9rr9rr1rL)rrrr)r'rrr) rrrrr,rOrrrrVrrrSrr|s  rcsBeZdZdZ   ddfd d ZedddZdddZZS)BacktrackingOrzMRepresents an unrestricted form of OR pattern implemented using backtracking.NvaluesSequence[ValuePattern]r8r9r tag_valuesSequence[Any] | Nonerr1csdt||dur|durtdt|t|krtdnttt|}||_||_||_dS)a Initialize a BacktrackingOr pattern. Args: values: A sequence of value patterns to match against. name: An optional variable name for the pattern. Defaults to None. If present, this name will be bound to the value matched by the pattern. tag_var: An optional variable name for the tag. Defaults to None. If present, it will be bound to a value (from tag_values) indicating which alternative was matched. tag_values: An optional sequence of values to bind to the tag_var. Defaults to None. If present, the length of tag_values must match the number of alternatives in values. In a successful match, tag-var will be bound to the i-th value in tag_values if the i-th alternative pattern matched. If omitted, the default value of (0, 1, 2, ...) will be used. N4tag_var must be specified if tag_values is provided.Ctag_values must have the same length as the number of alternatives.) rRr,rorr^rr _tag_values_values)rrr8rr!rSrrr,s  zBacktrackingOr.__init__cCr.rrr rrrrrAzBacktrackingOr.tag_varrrcs$tfdd|jD|j|j|jS)Ncg|]}|qSrrrrrrrz(BacktrackingOr.clone..)rr&r8rr%rrrrrs zBacktrackingOr.cloneNNN) rr r8r9rr9r!r"rr1rL)rrrr) rrrrr,rOrrrVrrrSrrs# rrr r8r9rr!r"csvdurdur tdttkrtdntttdfdd }|}|p:tr8ndS) aO Creates an OR pattern. Args: values: A sequence of value patterns to match against. name: An optional variable name for the pattern. Defaults to None. If present, this name will be bound to the value matched by the pattern. tag_var: An optional variable name for the tag. Defaults to None. If present, it will be bound to a value (from tag_values) indicating which alternative was matched. tag_values: An optional sequence of values to bind to the tag_var. Defaults to None. If present, the length of tag_values must match the number of alternatives in values. In a successful match, tag-var will be bound to the i-th value in tag_values if the i-th alternative pattern matched. If omitted, the default value of (0, 1, 2, ...) will be used. Nr#r$rOpIdDispatchOr | Nonecshi}tD]'\}}t|tsdS|}|}|dus"||vr%dS||f||<qt|Sr)rrdrrrr)mappingri alternativerrIr8r!rrrrmake_op_id_or_patterns  z&OrValue..make_op_id_or_pattern)rr*)rorr^rr)rr8rr!r.optimized_patternrr-rOrValues r0rlist[NodePattern]cs(gdfdd |S) zFReturns all nodes used in a pattern, given the outputs of the pattern.value_patternsSequence[ValuePattern | None]rr1cs<|D]}t|tr|}|vr||jqdSr)rdrrrr)r2 value_patternr node_patternsvisitrrr7s   z _nodes_in_pattern..visitN)r2r3rr1)reverse)rrr5r_nodes_in_patterns r9rbackward_sliceset[NodePattern]backward_slice_valuesset[ValuePattern]r1cCsZ||vrdS|||jD]}t|trt|||qt|ttfr*||qdS)zAdds all nodes in the backward slice of given node to the set `backward_slice`. The backward slice of a node is the set of all nodes that are reachable from the node in a backward traversal from the given node. N)addrrdr_add_backward_slicerrr)rr:r<r4rrrr? s      r?c@seZdZdZd+d d Zed,d d Zd-ddZd.ddZd.ddZ ed/ddZ ed/ddZ d0ddZ d0ddZ ed1d d!Zed.d"d#Zd2d%d&Zd3d(d)Zd*S)4 GraphPatternzr?rrNotImplementedErrorr output_nodes) rrrrrDcoveredchoice_values_returnedcovered_choice_valuesr4 candidaterrrr,9s4      zGraphPattern.__init__rcCs t|jdkr td|jdS)Nrz.GraphPattern does not have unique output node.r)rrDror rrr output_node`s zGraphPattern.output_noderrecCs |j|Sr)rx)rrrrrrfr-zGraphPattern.nodecCr_r)rrxr rrr num_nodesir-zGraphPattern.num_nodescCs|Sr)rJr rrr__len__lszGraphPattern.__len__cCr.r)rAr rrrror?zGraphPattern.inputscCr.r)rr rrrrsr?zGraphPattern.outputsIterator[NodePattern]cCr_r)iterrxr rrr__iter__wr-zGraphPattern.__iter__cCr_r)reversedrxr rrr __reversed__zr-zGraphPattern.__reversed__rcCst|jdkS)Nr)rrDr rrrhas_single_output_node}r~z#GraphPattern.has_single_output_nodecCr_r)rrr rrr num_outputsrzGraphPattern.num_outputsSequence[GraphPattern]csDdddfddjD}dfd d fd dtj|DS)NrrrIterable[bool]cSs&|dks |dkrddgSdgS)N)rrr)rrrFT)r)rrrr commute_nodesz*GraphPattern.commute..commute_nodecg|]}|qSrr)rhr)rUrrrrz(GraphPattern.commute.. swap_listr@cs^t|sSifddjD}fddtj|D}fddjD}t|||S)Ncr'rrrrrrrr(z.copy_graph..csg|] \}}||qSrr)rhrrrrrrscr'rrrrrrrr()anyrAziprxrr@)rW new_inputs new_nodes new_outputsr rr copy_graphs   z(GraphPattern.commute..copy_graphcrVrr)rhrW)r]rrrr)rrrrT)rWrTrr@)rx itertoolsproduct)riteration_spacer)rUr]rrcommutes   zGraphPattern.commutercCsZddd|jD}ddd|jD}ddd|jD}d|d|d |d S) Nrcsrrrrrrrrjrz'GraphPattern.__str__..csrrrrrrrrjrz csrrr)rhnrrrrjrz pattern (z) { z return z })rrArrx)rrrrrrrr!szGraphPattern.__str__N)rr rr rrrr1r)rrerrr)rr )rrLrM)rrSr#)rrrrr,rOrIrrJrKrrrNrPrQrRrar!rrrrr@6s( '           r@pattern_constructorrcCst|j}dd|Ddd}tddd}t|||g|R}Wdn1s.wYt|tr;|g}t|||S)aConvert a pattern-construction function to a GraphPattern. A pattern-construction function will return values as below: :: def pattern(op, x: Var, shape1: Var, shape2: Var): ... return outputs We create a pattern graph by creating pattern-variables for each parameter of the function, and calling the function. The returned values are normalized to a list of ValuePatterns, which represent the outputs of the pattern graph. Args: pattern_constructor: Callable Returns: GraphPattern: A representation of the pattern that can be matched against a subgraph. cSrr)rmrrrrrrz%_to_graph_pattern..rNrT)rv) inspect signature parametersrsrrdrr@r)rc _pattern_varspattern_inputsrpattern_outputsrrr_to_graph_patterns    rj)r'rarr5)rrrr)rrsr)) rr r8r9rr9r!r"rr)rr rr1)rrr:r;r<r=rr1)rcrrr@)=r __future__rr$ contextlibrdr^collections.abcrtypingrrrrrr r r onnxscript.rewriter._basicsrewriter_basics onnxscriptr r rABCrrr&r0Attrr5rPrerfrXrWrrrsonnxoptorch_module_opr{rr__annotations__contextmanagerrrrrrmr  ANY_VALUErrrr0r9r?r@rjrrrrsl  (    0  I " L  /6 0 s