קgbXddlZddlZddlZddlZddlmZddlmZmZddl m Z m Z m Z m Z mZmZmZmZmZddlZddlmZmZmZmZmZmZmZmZmZddlmZerddl m!Z!dd l"m#Z#dd l$m%Z%m&Z&gd Z'ej(e)Z*Gd d eZ+Gdde,Z-Gdde-Z.Gdde-Z/dddde0dee1dee1fdZ2e+j3e2_3e+j4e2_4dddde0dee1dee1fdZ5ej6GddZ7ej6Gdde7Z8ej6Gdd Z9ej6Gd!d"e7Z:ee8e:fZ;d#e;d$e e1e1ge d%fd&d'de e0ee1e1ffd(e ed)d*e ed%ed+e fd,e e0d-ffd.ZGd9d:Z?d;Z@dZBd>D z_Dim.__add__..R QYr+typeintNotImplementedErrorr$_deriveclsr@s `r,__add__z _Dim.__add__Ksn ;;c ! !%_E__s|___ {{....///r+c ||zSr=r*rHs r,__radd__z _Dim.__radd__T U{r+ctturtdd|jd|fdS)NzAttempted to subtract z from r;c|z Sr=r*r>s r,rAz_Dim.__sub__..^rBr+rCrHs `r,__sub__z _Dim.__sub__Wsn ;;c ! !%___cl___ {{....///r+c2td|jd)NzAttempted to negate zN. (Only increasing linear operations with integer coefficients are supported.))rFr$rHs r,__rsub__z _Dim.__rsub__`s0! [3< [ [ [   r+cttusdkrtdd|jd|fdS)NrzAttempted to multiply z with zu, where a positive integer was expected. (Only increasing linear operations with integer coefficients are supported.)c|zSr=r*r>s r,rAz_Dim.__mul__..mrBr+rCrHs `r,__mul__z _Dim.__mul__fsv ;;c ! !UaZZ%___cl___ {{....///r+c ||zSr=r*rHs r,__rmul__z _Dim.__rmul__orMr+cZddlm}t|||jS)Nr)sympify)sympyrYstrr$)rIfnrYs r, _derived_namez_Dim._derived_namers8!!!!!!22ggcl++,,---r+c\t||tf||dS)Nrootr\) _DerivedDimr]rE)rIr\s r,rGz _Dim._derivews,3,,R003&3b:Q:QRRRr+N)r$r%r&r' staticmethodr9rJrLrPrRrUrWr]rGr*r+r,r.r.6s 8 8\ 8000000   000... SSSSSr+r.c>eZdZdZedZedZdS) _StaticDimz Meta class for static :func:`Dim` types. This class is only for setting and checking static dim constraints, and the user should never interact with it. c|jSr=valueselfs r,minz_StaticDim.min zr+c|jSr=rfrhs r,maxz_StaticDim.maxrkr+N)r$r%r&r'propertyrjrmr*r+r,rdrd{sTXXr+rdcDeZdZdZedZedZdZdS)raa Metaclass for derived :func:`Dim` types. Currently we only support increasing linear expressions with integer coefficients. In other words, a derived Dim can always be written in the form Ax + B, where x is a regular Dim (i.e., non-derived Dim), A and B are integers, and A is positive. (In particular, the latter ensures that x < y => Ax + B < Ay + B.) These restrictions on the form of derived Dims makes the metatheory simpler: e.g., it simplifies computing ranges for derived Dims, solving for underlying regular Dims, deciding equalities between derived Dims, and so on. The function lambda x: Ax + B is expressed by `fn`, where x is a normal Dim, `root`. The range of a derived Dim is computed by mapping `fn` over the range of its `root`. c ddlm}ddlm}|jj| ur| S|||jj}|j}|dks#Jd|jd|jd|jdt|S)NrIntegerr0zExpected derived min value of z9 to be >= 0. Please specify an appropriate min value for (currently ).) rZrrr5r1r`rjr\r$rE)rirrr1 _min_symintr`s r,rjz_DerivedDim.mins "!!!!!555555 9=VG # #7Nggggdim4455 ya 'T] ' ';?= ' '( ' ' '  ;r+c Bddlm}ddlm}|jj|ur|S|||jj}|j}|tjdz ks3Jd|j dtjdz d|j d|jd t|S) Nrrqr0rzExpected derived max value of z to be <= z.. Please specify an appropriate max value for rsrt) rZrrr5r1r`rmr\sysmaxsizer$rE)rirrr1 _max_symintr`s r,rmz_DerivedDim.maxs "!!!!!555555 9=F " "Mggggdim4455 yckAo--- 'T] ' 'ckTUo ' ';?= ' '( ' ' '.-- ;r+crttfjfddS)Nc@|Sr=)r\)r?r\ris r,rAz%_DerivedDim._derive..s4771::r+r_)rar]rEr`)rir\s``r,rGz_DerivedDim._derivesH   r " " FY&>&>&>&>&> ? ?   r+N)r$r%r&r'rnrjrmrGr*r+r,rarasc    X &  X &     r+rarjrmr6rjrmcVddlm}|dn|}||n|}||ksJd|d||s Jd|t|tf||d}t t jt jddd d |_ |S) an :func:`Dim` constructs a type analogous to a named symbolic integer with a range. It can be used to describe multiple possible values of a dynamic tensor dimension. Note that different dynamic dimensions of the same tensor, or of different tensors, can be described by the same type. Args: name (str): Human-readable name for debugging. min (Optional[int]): Minimum possible value of given symbol (inclusive) max (Optional[int]): Maximum possible value of given symbol (inclusive) Returns: A type that can be used in dynamic shape specifications for tensors. rr0Nz(Cannot create Dim with inconsistent min=r4z)Dim name must be a valid identifier, got r|rr$__main__) r5r1 isidentifierr.rEgetattrinspect getmodulestackr%)r6rjrmr1_min_maxdims r,rrs 211111 11D[66cD $;;;S3SScSS;;;     RR RD R RRRR tcVT$77 8 8C'-//!,Q/00*jCN Jr+namesc>tfd|DS)z4 Util to create multiple :func:`Dim` types. c3<K|]}t|VdS)r|N)r).0r6rmrjs r, zdims..s2??Ts,,,??????r+)tuple)rjrmrs`` r,r r s, ???????? ? ??r+c(eZdZUdZeed<eed<dS)_ConstraintTargetz2 This represents input tensor dimensions. t_idrN)r$r%r&r'rE__annotations__r*r+r,rrs. III HHHHHr+rcdeZdZUdZeed<ded<ddZdZd Zd Z d Z d Z e d Z dS) _Constraintz This represents a Dim describing a constraint target. `name` is the name of the Dim. `constraint_range` contains the min/max bounds of the Dim. r6rconstraint_rangerNcddlm}ddlm}ddlm}||}||jj|||zd}t|j |j |j |S)Nrrr0 ValueRangeslowerupperFvr warn_only) %torch.fx.experimental.symbolic_shapesrr5r1torch.utils._sympy.value_rangesrrrrrrr6)rirrrr1rrs r,_clone_with_rangez_Constraint._clone_with_range sPPPPPP555555?????? =E11$'++E*O*O*OO    I H I     r+c.||S)Nrrrirs r,__ge__z_Constraint.__ge__!%%E%222r+c4||dzS)Nrrrrs r,__gt__z_Constraint.__gt__$%%EAI%666r+c.||S)Nrrrirs r,__le__z_Constraint.__le__'rr+c4||dz S)Nrrrrs r,__lt__z_Constraint.__lt__*rr+c td)NzCannot determine truth value of _Constraint. If you are trying to combine _Constraint's with logical connectives, you can specify them separately instead.) TypeErrorrhs r,__bool__z_Constraint.__bool__-s  7   r+c`|j|j|jjj|jjjdSN)rrrjrmrrrrrrrhs r,serializable_specz_Constraint.serializable_spec8s5I8(+1(+1    r+)rN)r$r%r&r'r[rrrrrrrrnrr*r+r,rrs III....    (333777333777       X    r+rc2eZdZUdZeed<ded<eed<dS) _PhantomRoota This represents the root of a derived Dim where the root does not directly specify the shape of any input dimension, but the derived Dim does. e.g., the input shapes 2*dim and dim + 1 are related via a "phantom" dim. The fields `name`, `constraint_range`, and `val` carried by a phantom root help create a symbol for it. Any derived dims with this phantom root are backed by expressions over this symbol. r6rrvalN)r$r%r&r'r[rrEr*r+r,rrIs:   III.... HHHHHr+rcbeZdZUdZeed<ded<eeefed<e ed<e dZ dS) _DerivedConstraintaC This represents a derived Dim, whose root is either a regular constraint target (which directly specifies the shape of some input dimension) or a phantom root (which does so indirectly). It can be thought of as a subclass of `_Constraint`, except that it does not support <, <=, >, >= operations. r6rrr`r\c`|j|j|jjj|jjjdSrrrhs r,rz$_DerivedConstraint.serializable_specks5I8(+1(+1    r+N) r$r%r&r'r[rrrrrrnrr*r+r,rr[sp III.... !</ 0000LLL   X   r+r constraint get_sourcesr shape_envr source_pairs)rrderived_equalities)rrphantom_symbolsrc~ ||j|j}|sdS|^ }| fd|Dt|ts`|j|vr?||j\} } || | }| fd|DdS|j|jf||j<dSt|jts'||jj|jjd} n|jj|vr||jj} n||jj tj j |jjtjjjjj|jj} | ||jj<|j} | | | fdS)z Updates `source_pairs`, `derived_equalities`, and `phantom_symbols` (which become fields of `EqualityConstraint`) based on a given input `constraint`. Nc3 K|]}|fV dSr=r*r other_sourcesources r,rz&_process_equalities..s(QQ<.QQQQQQr+c3 K|]}|fV dSr=r*rs r,rz&_process_equalities..s9  +7&      r+r)rr dynamic_dimconstraint_dim)rrextend isinstancerr6r`r create_symbolrtorch_dynamorConstantSourcefx experimentalsymbolic_shapes DimDynamicDYNAMICrr\append)rrrrrrrsources other_sources shared_t_id shared_dimr`r\rs @r,_process_equalitiesrysk*/:>::G $F]QQQQ=QQQQQQ j"4 5 56 ?e # #&+JO&< #K'K Z@@M       ;H        '1oz~%FE*/ " " "*/<88 =;z3Z_5HII!LDD#66&z';<!.."+ =/>>z?STT % 5 E P X#-?#C / 9=  45 ] !!64"455555r+ tree_namefunc.treedynamic_shapesrreturncN d fd t |g|Rd iS#t$rv}d|jdvra|s Jds Jdd fd  fd  t| \}}|D]"}t| \}} ||g#d }~wwxYw) a" Customized tree_map for mapping pytrees to dynamic_shapes. For built-in types (e.g., standard collections) this behaves exactly like tree_map. OTOH for a user-defined class C registered with pytree, we cannot assume that a C containing tensors can be mapped to a C containing dynamic shapes (i.e., C may not be a polymorphic container). In that case we use the flattened form of C instead. Thus a C(**tensors) that flattens to (**tensors) will map to (**dynamic_shapes). Args: func: function to apply to each (int, float, str, bool, None, torch.Tensor) tree: input pytree dynamic_shapes: zero or more (typically one) dynamic_shapes to match Returns: output pytree mapping func to each (int, float, str, bool, None, torch.Tensor) c.t|tvSr=)rr)ts r,is_leafz$_tree_map_with_path..is_leafs a  55r+ct|}|tvr5tt||dg|RdiS||g|RS)Nrr)rrr flatten_fn)pathrrtypfrrs r,rz_tree_map_with_path..fsQ / ! !&$//2215   4a1.111 1r+rmismatchrz2Cannot be a mismatch if there is no dynamic_shapesz7Must provide a tree_name when there might be a mismatchc|turt||S|ttfvr|Jt |St d|)NzDid not expect type )dictrlistrrAssertionError)type_contextis r,_keyz!_tree_map_with_path.._keysXD==%gaj111T5M))"???&q>>)$%CE%C%CDDDr+cFddlm}m}||jdd|d)Nr UserError UserErrorTypez,Detected mismatch between the structure of `z` and `dynamic_shapes`: dynamic_shapes_validation case_name)torch._dynamo.excrr INVALID_INPUT)msgrrrs r,raise_mismatch_errorz1_tree_map_with_path..raise_mismatch_errorsQFFFFFFFFi!/k9kkfikk9r+c t|}t|trdSt|tr d |d|jd|d|j|jkr# d |d|jd|d|j t |jt |jkr> d |dt |jd|dt |jd |jt urt|jt|jkr# d |d|jd|d|j t t|j|jfd |jD}n|j}tt|j|D].\}\}} ||| |j|j|gz/dS) N`z` is a z, but `dynamic_shapesz` is notz` has z elements, but `dynamic_shapesz elementsz ` has keys c g|] }| Sr*r*)rk_remaps r, z9_tree_map_with_path.._compare..s4U4U4U1VAY4U4U4Ur+) rrrrDlenchildren_specsrsortedrzip enumerate) rrr rendered_pathdynamic_shapes_children_specsrtree_dynamic_shapes_r_comparerrrs @r,rz%_tree_map_with_path.._compares!'t dH--Fnh77((FIF}FFTYFF.;FFF9 333((ZIZ}ZZTYZZ.;ZZDRDWZZt*++s>3P/Q/QQQ((qIq}qqC@S>>LAy, 9 9 %1*g%F%F"?OR8888 QHs$ B$A1BB$Fc$t|tr|}|sdt|tjjrt j|jnt j|}||ni}|j |i|j S|Sr=) rrmodulernnModuler signatureforwardbind arguments)rrkwargs_is_torch_jit_tracers r, _combine_argsr"-s!_%% HHJJ 9!UX_-- &G ai ( ( ("1%%  "-2y~t.v..88 Kr+c2eZdZdZdZdZdZdZddZdS) ShapesCollectionab Builder for dynamic_shapes. Used to assign dynamic shape specifications to tensors that appear in inputs. Example:: args = ({"x": tensor_x, "others": [tensor_y, tensor_z]}) dim = torch.export.Dim(...) dynamic_shapes = torch.export.ShapesCollection() dynamic_shapes[tensor_x] = (dim, dim + 1, 8) dynamic_shapes[tensor_y] = {0: dim * 2} # This is equivalent to the following (now auto-generated): # dynamic_shapes = {"x": (dim, dim + 1, 8), "others": [{0: dim * 2}, None]} torch.export(..., args, dynamic_shapes=dynamic_shapes) ci|_dSr=)_shapesrhs r,__init__zShapesCollection.__init__Os  r+ct|tjsJdt|t |}||jvr%|j|}||ksJd|d|dS||jt |<dS)Nz'Cannot assign shape to non-tensor type z1Shapes assigned to tensor do not match: expected z, got )rrTensorrDidr&)rirshaper_shapes r, __setitem__zShapesCollection.__setitem__Rs u|   ? ? >T!WW > > ? ? ?!uu 4<  \$'FX6XXQVXX #(DLA   r+cPt|}||jvr |j|SdSr=)r*r&)rirrs r, __getitem__zShapesCollection.__getitem__`s,!uu 4<  <% %4r+c*t|jSr=)rr&rhs r,__len__zShapesCollection.__len__gs4<   r+Nctfd}t|||}t||}tfdjDrt d|S)z* Generate dynamic_shapes. c|t|}|jvr"|j|SdSr=)r*r&add)rrrrit_idss r, find_shapez3ShapesCollection.dynamic_shapes..find_shapeqs<a55Dt|## $|D))tr+c3 K|]}|vV dSr=r*)rrr5s r,rz2ShapesCollection.dynamic_shapes..{s(::Tt5 ::::::r+zSome tensors that were assigned shapes were not found in args. Maybe such tensors were copied when passing them as args? Maybe such tensors are contained in classes that were not registered with pytree?)setr"ranyr&r)rimrr r6 combined_argsrr5s` @r,rzShapesCollection.dynamic_shapesjs       &av66 ,ZGG ::::T\::: : : d  r+r=) r$r%r&r'r'r-r/r1rr*r+r,r$r$=sn" ( ( (!!!r+r$c>d}t|dS)NzTUsing None as a dynamic shape dimension is deprecated. Please use Dim.STATIC instead)logwarning)rs r,%_warn_on_None_dynamic_shape_dimensionr?s& ( KKr+r;c ddlm m ddlm}|t |dkrdSt |ttfr*t|| }i fd fdt |tttfsJt |trt| }t| }t|t|kred|d|d }t |d kr1|d|vr't ||dtr|d z }n|d z } j|d  fd}t|||d|||}t!|\}} t#d|Dr,t#d|Dr jdd dSdS)z Checks the dynamic_shapes specification for correctness, using combined args + kwargs as reference for inputs structure. rr)_flatten_dynamic_shapesNc d|jvr|j\}}|j|ks |j|krgt|j||}t|j|j|j}jd|d|d|ddS|j|jf|j<dS)NzFound different definitions z and z! for the same symbolic dimension !)r$rjrmr.r9r)rr7r8this_that_rrboundss r,check_same_boundsz0_check_dynamic_shapes..check_same_boundss <6 ! ! -JD$w$#'T// clD$?? clCGSWEEi!/>5>>u>>7:>>>#2/%(GSW#5F3< r+c t|tr|D]\}}t|tr |&|t 7t|t t fs-jd|d|dt|d|d ddSt|ttfrt|D]\}}t|tr |&|t 7t|t t fs-jd|d|dt|d|d ddS|'jd |dt|d ddS) Nz%Unexpected dimension mapped to index z in input tensor shape  specified at `dynamic_shapeszB` (expected None, an int, a Dim, Dim.AUTO, or Dim.STATIC, but got z instead)rrzUnexpected dimension #zUnexpected input tensor shape z` (expected either a list/tuple of dimensions, or a dict mapping indices to dimensions, where each dimension is an int, a Dim, Dim.AUTO, or Dim.STATIC)) rritemsr.r?rEr#rrrrr )rtensorr+rrrrrGs r, check_symbolsz,_check_dynamic_shapes..check_symbolssh eT " "# ++--  3c4(( %%c****[9;;;;$S3/::#)%3jjjZ_jj7=d||jj[^jjj#>   t} - - #E**  3c4(( %%c****[9;;;;$S3/::#)%3jjj5jj7=d||jj[^jjj#>    )+TTTU[\`UaUaTTT6   r+zWWhen `dynamic_shapes` is specified as a dict, its top-level keys must be the arg names z of `inputs`, but here they are z. rzSince here `inputs` is a list/tuple enclosing a single dict, maybe you just forgot to enclose `dynamic_shapes` in a list/tuple?zwAlternatively, you could also ignore arg names entirely and specify `dynamic_shapes` as a list/tuple matching `inputs`.rrc t|tjr|||dS|.check_shapes a & &  M$= 1 1 1 1 1( &t i!/_m__Zg__*.q''__>K___9 )(r+inputsrc3@K|]}t|tVdSr=rr.rss r,rz(_check_dynamic_shapes..s, ? ?1:a   ? ? ? ? ? ?r+c36K|]}|tjkVdSr=)r#r(rSs r,rz(_check_dynamic_shapes..sBHH X]HHHHHHr+awSpecifying both `Dim.AUTO` and `Dim` or `DerivedDim` in `dynamic_shapes` is not well supported at the moment, and can easily lead to constraint violation errors or obscure errors in torch.export. Dim/DerivedDims expect all equal or related dimensions to be specified, and does not yet compose well with `Dim.AUTO`. We suggest using `Dim.AUTO` mixed with `None` for auto-dynamic + static shapes, plus torch._check(dim >= min), torch._check(dim <= max) calls in your program to specify min/max ranges, or `Dim`/`DerivedDim` mixed with `None` if you want to assert on the exact specification of your program's dynamic shapes behavior.)rrrtorch._export.non_strict_utilsrArrrrrDvaluesrkeysrrrrr9)r;rrAgot_keysexpected_arg_namesrrOflat_dynamic_shapesflatter_dynamic_shapesrrrrFrGrLs @@@@@r,_check_dynamic_shapesr]s;:::::::FFFFFF^!4!4!9!9.5$-00E,^,,]-A-A-C-CDD )+F 6 6 6 6 6 6 6$$$$$$$L ntUD&9 : ::::.$''++--..!-"4"4"6"677 (  v&899 9 9.);..!)...  M""a''&q)99}-?-BCTJJ:Y V)+S ? ? ???  CHH$:HHHEE  i  ' j 2         r+cfd|t|dkr |d}t|ttfr*t ||}dfd}t |||d}|S)a In the long run this might not be needed, but this exists because export.export() and _dynamo.export() historically have different semantics for how dynamic_shapes are specified, but go through the same process of producing constraints, and now both use assume_static_by_default=False. For _dynamo.export(), the semantics for dynamic_shapes are: - None: dynamic, allocated a symbol - Dim/DerivedDim: a strict assertion on the min/max range for this symbol, and require a specification for all dims governed by this symbol (i.e. relations, equality, linear relations, etc.) For export.export(), historically dynamism for unspecified dims has been undesirable, so the semantics are: - Dim.AUTO: dynamic, allocated a symbol - None/unspecified/Dim.STATIC: static - Dim/DerivedDims: also a strict assertion To allow both APIs to follow the same process for producing constraints, this function converts dynamic_shapes for export.export() to be compatible with _process_dynamic_shapes() and assume_static_by_default=False, turning them into essentially what they'd look like for _dynamo.export(). An example conversion might look like, for a 3-d input tensor: input spec: { 0: Dim.AUTO, 1: None, # or Dim.STATIC 2: Dim("dx"), } output spec: { 0: None, # None: dynamic by default 1: 32, # explicitly provide static shape 2: Dim("dx"), # remains the same } ct|x}tvrSt|j}||\}}t|tvr|ntj}fd|D}|||S)a If the user generally specifies dynamic_shapes=None for a pytree input, we'd like to convert this into a tree of Nones following the input spec, so we can explicitly specify static dims for all tensor dimensions. Non-builtin types for pytree (e.g. custom dataclasses) creates some difficulty, in which case the correct format is a list containing specs for each child attribute. c(g|]}|Sr*r*)rchild_tree_map_helperrs r,rzS_transform_shapes_for_default_dynamic.._tree_map_helper..Ds'LLLU$$UC00LLLr+)rrrrr unflatten_fn) rr node_typer child_pytreesrrcchildrenrbs ` r,rbz?_transform_shapes_for_default_dynamic.._tree_map_helper5s(-- -Io E EJ$Y/: !+D!1!1 w&"m33II  MLLLLmLLL| g   r+Nrcd}d}t|tri}t|jD]\}}||t j}|||s|t jkr1|t jkr tj ||rt|tr|||<t|tr|||<|t|||<|t jksJ|||<֐nt|ttfrDg}t|jD]\}}||}|||s|t jkrF|t jkr tj |||dpt|tr||t|tr|||$t|||t jksJ||t#||}nd|Jt|tjrDg}t|jD](\}}||||rdn|)|pd}nd}|S)Nc@|t|dtvS)N_dynamo_dynamic_indices)rr8)rKrs r,_marked_dynamiczX_transform_shapes_for_default_dynamic..transform_shapes.._marked_dynamicQs(A355III Ir+)rrr r+getr#r)r(rrmaybe_mark_dynamicr.rEr?rrrrDr))rrKr+rjoutrrrs r,transform_shapesz?_transform_shapes_for_default_dynamic..transform_shapesPs J J J7; eT " "2 C#FL11 ! !3ii8?33"?61--! 1E1Ehm++ 88CCCT** ! CFFS)) !!CFF[9;;; CFF(/1111 CFF) !*t} - - C#FL11 $ $3Ah"?61-- $ 1E1Ehm++ 88CCCJJt$$$$T** $JJsOOOOS))$JJsOOOO[9;;;JJsOOOO(/1111JJsOOOO$u++c""CC===&%,// ' 55LLFAsJJvq'A'AJttsKKKKkT r+cVt|tjr |||SdSr=rrr))rrrNrns r,transform_shapez>_transform_shapes_for_default_dynamic..transform_shapes6 a & & <##D!];; ; < >.5$-00E,^,,]-A-A-C-CDD 999v<<<<<!(F Mr+c ddlmm|t|dkrgSt |t t fr*t||}tt  i g  fd fd fd}t|||dg} D]%}|j j }| vr |d|_ & D]}| ||S) zT Reads the dynamic_shapes specification and produces a list of constraints. rrNc  ddl ddlm}ddlm ddlm}   fd}ttrj }|j vr.|j d}t|j |j }n`|j vrJt|j |||j|jd| }||j <n |j }t#t%j ||jjd|j} t|tr| ntt*rEt-t%j ||jjd} nDt-t%j ||jjd} | S) Nrr) try_solverc Fjjd}|} |j|}|t |dSjddjd|d|d ) NT)integerrzExpected shape[z] = z# of input Tensor to be of the form z, where z is an integer)rr`r$r\Eqr+rECONSTRAINT_VIOLATION) symbolexprsolutionrrrrrZrKrvs r, root_valuezB_process_dynamic_shapes..to_constraint..root_values\\#("3T\BBF66&>>D y$ Q!@!@&IIH#8A;'''i!6HaHHV\!_HH#'HH17HHHr+rFr)r6rr)rZrrtorch.utils._sympy.solvervrrrrar`r$rrrrrjrmrr*r\rrdrrg)rrKrrrr~dim_rootroot_constraintr`rrZrvrr%derived_constraints_with_phantom_root phantom_rootssymbolss``` @@r, to_constraintz._process_dynamic_shapes..to_constraints PPPPPP666666??????            c; ' '9 xH G++")(*;".update_symbols.._create_static_dims!c%jj3&7E2BCC Cr+) rrrJrEr.r$rrrr ) rrKr+rrrrrrs r,update_symbolsz/_process_dynamic_shapes..update_symbolssm D D D eT " " =++-- = =3cC;//=!#s++A00C@@!.sFA!>!>JCL)00<<<  = = t} - - =#E** = =3cC;//=!#s++A00C@@!.sFA!>!>JCL)00<<<  = = = =r+cZt|tjr|||dSdSr=rp)rrrNrs r, assoc_shapez,_process_dynamic_shapes..assoc_shapes; a & & 3 N4M 2 2 2 2 2 3 3r+rPr)rrrrrrrrDrWrrr`r6r)r;rr constraints$derived_constraint_with_phantom_rootphantom_root_name dynamic_dimsrrrrrrrs @@@@@@@r,_process_dynamic_shapesrs;:::::::^!4!4!9!9 .5$-00E,^,,]-A-A-C-CDD ,7t+<+..s*Q--r+rr)rrrEr.r$rar`)r name_to_dimrs r,_get_dim_name_mappingr(sK-- 6 6 ;  c3    #t$$$$$$' CL! c; ' ' 6-0XK) * r+rc ddl}ddlddlm}m}ddlm} |dd}n$#t$r}||j d|d}~wwxYwi|dD].}|}| d |x} r| d} d \} } | d |x} r"t| d} | d |x}r"t| d} t| | | | <|d\} }|}t!|jrt|| <)|| <0t%|t'}D]\}}t!|tt*t,jfsJt!|jrS||sJ||<|t3t5t7|jt!|t,r||jj̉D]\}}|vs||vsJifd}t?|||S)aU For working with export's dynamic shapes suggested fixes, and/or automatic dynamic shapes. Refines the given dynamic shapes spec, given a ConstraintViolation error message and the original dynamic shapes. For most cases behavior is straightforward - i.e. for suggested fixes that specialize or refine a Dim's range, or fixes that suggest a derived relation, the new dynamic shapes spec will be updated as such. e.g. Suggested fixes: dim = Dim('dim', min=3, max=6) -> this just refines the dim's range dim = 4 -> this specializes to a constant dy = dx + 1 -> dy was specified as an independent dim, but is actually tied to dx with this relation However, suggested fixes associated with derived dims can be more complicated. For example, if a suggested fix is provided for a root dim, the new derived dim value is evaluated based on the root. e.g. dx = Dim('dx') dy = dx + 2 dynamic_shapes = {"x": (dx,), "y": (dy,)} Suggested fixes: dx = 4 # specialization will lead to dy also specializing = 6 dx = Dim('dx', max=6) # dy now has max = 8 Derived dims suggested fixes can also be used to express divisibility constraints. This involves creating new root dims that aren't tied to a particular input shape. In this case the root dims won't appear directly in the new spec, but as a root of one of the dims. e.g. Suggested fixes: _dx = Dim('_dx', max=1024) # this won't appear in the return result, but dx will dx = 4*_dx # dx is now divisible by 4, with a max value of 4096 rNr)_is_supported_equivalencezSuggested fixes:rz`Suggested fixes not found in error message given to refine_dynamic_shapes_from_suggested_fixes() z(.*) = Dim\('(.*)'.*\))NNz!.* = Dim\('.*', min\=([0-9]+).*\)z.* = Dim\('.*'.*max\=([0-9]+)\)r|z = c(|t|tr|S|j vr |j}t| jrt | vr t |St t |j}|j vr |j}n|j vsJ |j} j j ||\}}|}|dkrt||z}|dkr|t|z}| t |<|S|St|trU|j j vrG|j vr |jS| |j j}| |j<|S|S)Nrr)rrEr$Exprr[nextiter free_symbolsr6polys polytoolsdivrar`r\) rrdummyfixr{r`modulus remainder_dimderived_dim_cacher shape_fixesrZs r, apply_fixesz?refine_dynamic_shapes_from_suggested_fixes..apply_fixess ;*S#..;J \[ ( (cl+C#uz** s88000,SXX66!$s'7"8"899F{k11*6;7%{k9999*6;7).)>)B)B3)O)O&GYC!||!'llS0 A~~!C NN225%c#hh/J [ ) ) ch.?;.N.N|000(66vvk#(*;<==26!#,/  r+) rerZrrrrrsplitstrip ExceptionrmatchgrouprErrYrNumberrr8rJr.rarr4r[rrrr`r$r)rrrrrrshape_fixes_msgexcrrr6rr match_min match_maxr|rootsrcrrrrrZs @@@@r,r!r!<sVVIIILLL::::::::OOOOOO))$677:@@BB i  ' n   K$$T**))iikkHH6<< <5 );;q>>D#JD$HH%I3OOOy /9??1--..HH%GMMMy /9??1--.. #Dd = = =K  5))JD$==&&D$ -- )$'II D!!%) D!!'77KeeE!!##''1!c4ejABBBBB a $ $ 7,,Q// / / /KN IIc$tAN334455 6 6 6 a % % ' IIafo & & &!!##..1K1::::13""""""""H {NN K KKs-A A+A&&A+)F)F dataclassesrloggingrw collectionsrenumrrtypingrrrr r r r r rrtorch.utils._pytreerrrrrrrrrexported_programrrZr torch._guardsrrrr__all__ getLoggerr$r=r#rDr.rdrar[rErr(r)r dataclassrrrrrrrr"r$r?r]rsrrr!r*r+r,rsS ######XXXXXXXXXXXXXXXXXXXXXX                       .-----W$$$$$$VVVVVVVV   g!!tBSBSBSBSBS4BSBSBSJ"@ @ @ @ @ $@ @ @ F,0dc8C=hsm: = _ ,0d@@@@8C=@hsm@@@@          D D D D D #D D D N         "      *   4; 22 3 56563*d8n455656 U38_$ % 56 u/01 56 U8U3E-F#PQR 56#x-(56565656x $ yyy 38 y yy} y  yyyyx  c3h     DDDDDDDDN@ S>@ $sCx.%*d3iEF@ @ @ @ FBS>B$sCx.%*d3iEFB 4S>5:tCy$ 67BBBBJPS>P$sCx.%*d3iEFP *PPPPf$sCx.%*d3iEF(HL HL$sCx.%*d3i?@HL 4S>5:tCy 01HLHLHLHLHLHLr+