tj< ddlZddlZddlZddlZddlmZddlmZddlm Z m Z ddl m Z m Z mZddlZddlmZmZmZmZmZmZmZmZmZmZmZmZddlmZe rdd lm Z dd l!m"Z"dd l#m$Z$m%Z%gd Z&ej'e(Z)Gd de Z*ej+GddZ,GddZ-e-Z.Gdde-Z/Gdde-Z0dddde1de2dzde2dzde3e-dffdZ4ej+GddZ5ej+Gd d!e5Z6ej+Gd"d#Z7ej+Gd$d%e5Z8ej+Gd&d'e5Z9e6e8ze9zZ:ej+Gd(d)Z;d*e:d+ee2e2ged,fd6Z?dd7d8ede fd9e d:e d;e1dzde f d<Z@de=e1e ffd=ZAGd>d?ZBGd@dAZCdBZDdCe=e1e fd:e=e1e fe3e zerEr*r+r,r.r.=s CtCt HdTk   ++\+..\.--\- E E E E E.....r+r.c $eZdZdZeZeZeZddddede dzde dzfdZ dd Z dd Z dd Z dd Zdd ZddZdefdZddZedede de defdZdZdS)raS The ``Dim`` class allows users to specify dynamism in their exported programs. By marking a dimension with a ``Dim``, the compiler associates the dimension with a symbolic integer containing a dynamic range. The API can be used in 2 ways: Dim hints (i.e. automatic dynamic shapes: ``Dim.AUTO``, ``Dim.DYNAMIC``, ``Dim.STATIC``), or named Dims (i.e. ``Dim("name", min=1, max=2)``). Dim hints provide the lowest barrier to exportability, with the user only needing to specify if a dimension if dynamic, static, or left for the compiler to decide (``Dim.AUTO``). The export process will automatically infer the remaining constraints on min/max ranges and relationships between dimensions. Example:: class Foo(nn.Module): def forward(self, x, y): assert x.shape[0] == 4 assert y.shape[0] >= 16 return x @ y x = torch.randn(4, 8) y = torch.randn(8, 16) dynamic_shapes = { "x": {0: Dim.AUTO, 1: Dim.AUTO}, "y": {0: Dim.AUTO, 1: Dim.AUTO}, } ep = torch.export(Foo(), (x, y), dynamic_shapes=dynamic_shapes) Here, export would raise an exception if we replaced all uses of ``Dim.AUTO`` with ``Dim.DYNAMIC``, as ``x.shape[0]`` is constrained to be static by the model. More complex relations between dimensions may also be codegened as runtime assertion nodes by the compiler, e.g. ``(x.shape[0] + y.shape[1]) % 4 == 0``, to be raised if runtime inputs do not satisfy such constraints. You may also specify min-max bounds for Dim hints, e.g. ``Dim.AUTO(min=16, max=32)``, ``Dim.DYNAMIC(max=64)``, with the compiler inferring the remaining constraints within the ranges. An exception will be raised if the valid range is entirely outside the user-specified range. Named Dims provide a stricter way of specifying dynamism, where exceptions are raised if the compiler infers constraints that do not match the user specification. For example, exporting the previous model, the user would need the following ``dynamic_shapes`` argument:: s0 = Dim("s0") s1 = Dim("s1", min=16) dynamic_shapes = { "x": {0: 4, 1: s0}, "y": {0: s0, 1: s1}, } ep = torch.export(Foo(), (x, y), dynamic_shapes=dynamic_shapes) Named Dims also allow specification of relationships between dimensions, up to univariate linear relations. For example, the following indicates one dimension is a multiple of another plus 4:: s0 = Dim("s0") s1 = 3 * s0 + 4 Nr0r1rAr0r1cddlm}|dn|}||n|}||kstd|d||std|||_||_||_dS)Nrint_ooz(Cannot create Dim with inconsistent min=r:z)Dim name must be a valid identifier, got )torch.utils._sympy.numbersrOr< isidentifierr#r0r1)r=rAr0r1rO_min_maxs r,__init__z Dim.__init__s555555KqqSvv#t  K3KKcKK   "" U !ST!S!STT T r+r7ctturtdd|jd|fdS)NzAttempted to add z to m, where an integer was expected. (Only increasing linear operations with integer coefficients are supported.)c|zSr4r*xothers r,zDim.__add__.. a%ir+r/rHNotImplementedErrorr#_deriver=rZs `r,__add__z Dim.__add__sn ;;c ! !%_E__t}___ ||////000r+c ||zSr4r*r`s r,__radd__z Dim.__radd__ e|r+ctturtdd|jd|fdS)NzAttempted to subtract z from rVc|z Sr4r*rXs r,r[zDim.__sub__..r\r+r]r`s `r,__sub__z Dim.__sub__sn ;;c ! !%___dm___ ||////000r+c2td|jd)NzAttempted to negate zN. (Only increasing linear operations with integer coefficients are supported.))r^r#r`s r,__rsub__z Dim.__rsub__s0! [4= [ [ [   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|zSr4r*rXs r,r[zDim.__mul__..r\r+r]r`s `r,__mul__z Dim.__mul__sv ;;c ! !UaZZ%___dm___ ||////000r+c ||zSr4r*r`s r,__rmul__z Dim.__rmul__rdr+cZddlm}t|||jS)Nr)sympify)sympyrpstrr#)r=fnrps r, _derived_namezDim._derived_names8!!!!!!22ggdm,,--...r+cJt||||Sr4) _DerivedDimrtr=rss r,r_z Dim._derives"4--b114<<>D  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`. rArootrsc0||_||_||_dSr4)r#rrs)r=rArrss r,rTz_DerivedDim.__init__+s  r+c ddlm}ddlm}|jj| ur| S|||jj}|j}|dkr(td|jd|jd|jdt|S)NrIntegerrNzExpected derived min value of z9 to be >= 0. Please specify an appropriate min value for (currently ).) rqrrPrOrr0rsr<r#rH)r=rrO _min_symintrs r,r0z_DerivedDim.min0s "!!!!!555555 9=VG # #7Nggggdim4455 y ?? +++?C}++"h+++  ;r+c Lddlm}ddlm}|jj|ur|S|||jj}|j}|tjdz kr8td|j dtjdz d|j d|jd t|S) NrrrNrzExpected derived max value of z to be <= z.. Please specify an appropriate max value for rr) rqrrPrOrr1rssysmaxsizer<r#rH)r=rrO _max_symintrs r,r1z_DerivedDim.maxEs "!!!!!555555 9=F " "Mggggdim4455 y q ( ( +++#+XY/++?C}++"h+++  ;r+c`tjfdS)Nc@|Sr4)rs)rYrsr=s r,r[z%_DerivedDim._derive..asbbnnr+)rvrtrrws``r,r_z_DerivedDim._deriveZs=   r " " I $ $ $ $ $   r+c|jSr4)r#r~s r,rEz_DerivedDim.__repr__ds }r+N) r#r$r%r&rrrrrTrr0r1r_rEr*r+r,rvrvs  S   X (  X (   r+rvrLnamesr0r1r7.c>tfd|DS)zh Util to create multiple :func:`Dim` types. Returns: A tuple of :func:`Dim` types. c3<K|]}t|VdS)rLN)r).0rAr1r0s r, zdims..qs2??Ts,,,??????r+)tuple)r0r1rs`` r,rrhs, ???????? ? ??r+c(eZdZUdZeed<eed<dS)_ConstraintTargetz2 This represents input tensor dimensions. t_iddimN)r#r$r%r&rHrGr*r+r,rrts. 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. rArconstraint_rangerNcddlm}ddlm}ddlm}||}||jj|||zd}t|j |j |j |S)NrrrN ValueRangeslowerupperFvr warn_only) %torch.fx.experimental.symbolic_shapesrrPrOtorch.utils._sympy.value_rangesrrrrrrrA)r=rrrrOrrs r,_clone_with_rangez_Constraint._clone_with_rangesPPPPPP555555?????? =E11$'++E*O*O*OO    I H I     r+c.||S)Nrrr=rs r,__ge__z_Constraint.__ge__%%E%222r+c4||dzS)Nrrrrs r,__gt__z_Constraint.__gt__%%EAI%666r+c.||S)Nrrr=rs 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.)r;r~s r,__bool__z_Constraint.__bool__s  7   r+c`|j|j|jjj|jjjdSN)rrr0r1rrrrrrr~s r,serializable_specz_Constraint.serializable_specs5I8(+1(+1    r+)rN)r#r$r%r&rrrGrrrrrrrrr*r+r,rr~s 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. rArrvalN)r#r$r%r&rrrGrHr*r+r,rrs:   III.... HHHHHr+rcXeZdZUdZeed<ded<eezed<eed<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. rArrrrsc`|j|j|jjj|jjjdSrrr~s r,rz$_DerivedConstraint.serializable_specs5I8(+1(+1    r+N) r#r$r%r&rrrGrrrrrr*r+r,rrsj III.... l ****LLL   X   r+rc(eZdZdZedZdS)_RelaxedConstrainta This represents a dim marked with Dim.AUTO/DYNAMIC (i.e. mark_dynamic() or maybe_mark_dynamic()), which leaves relations & min/max ranges for inference, instead of requiring explicit specification. The intention is for constraint violations to not be raised if produce_guards() finds equalities or relations between a _RelaxedConstraint and another type of _Constraint. c |j|jdS)Nrrrr~s r,rz$_RelaxedConstraint.serializable_specsI8   r+N)r#r$r%r&rrr*r+r,rrs9  X   r+rcXeZdZUdZeed<ejddZe ezdzed<dS) _IntWrapperz Dummy wrapper class to wrap around integer inputs so that when we parse the dynamic_shapes structure, we can mark if any of the integers were marked as dynamic. rFN)initdefaultdynamism) r#r$r%r&rHrG dataclassesfieldrr.r*r+r,rrsR HHH&7k&7UD&Q&Q&QHhnt#QQQQQr+r constraint get_sourcesr shape_envr source_pairs)rrderived_equalities)rrphantom_symbolsrrelaxed_sourcesc||j|j}|sdS|^} |fd| Dt|tr`|j|vr?||j\} } || | } |fd| DdS|j|jf||j<dSt|t r t|jts'||jj|jjd} n|jj|vr||jj} n| |jj tj j |jjtjjjjj|jj} | ||jj<|j} || | fdSt|t.r|dSdS)z Updates `source_pairs`, `derived_equalities`, and `phantom_symbols` (which become fields of `EqualityConstraint`) based on a given input `constraint`. Nc3 K|]}|fV dSr4r*r other_sourcesources r,rz&_process_equalities..*s(QQ<.QQQQQQr+c3 K|]}|fV dSr4r*rs r,rz&_process_equalities../s9  +7&      r+r)rr dynamic_dimconstraint_dim)rrextend isinstancerrArrr create_symbolrtorch_dynamorConstantSourcefx experimentalsymbolic_shapes DimDynamicr)rrsrBradd)rrrrrrrrsources other_sources shared_t_id shared_dimrrsrs @r,_process_equalitiesrs8k*/:>::G $F]QQQQ=QQQQQQ*k**!$ ?e # #&+JO&< #K'K Z@@M       ;H        '1oz~%FE*/ " " " J 2 3 3$*/<88 =;z3Z_5HII!LDD#66&z';<!.."+ =/>>z?STT % 5 E P X#-?#C / 9=  45 ] !!64"455555 J 2 3 3$F#####$$r+ tree_namefunctreedynamic_shapesrc  d fd t |g|Rd iS#t$r}d|jdvr|stddstddd fd  d td td t ddf fd t | }|D]}t | }||d 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|tvSr4)r r )ts r,is_leafz$_tree_map_with_path..is_leafhs a  55r+ct|}|tvr5tt||dg|RdiS||g|RS)Nrr)r rr flatten_fn)pathrrtypfrrs r,rz_tree_map_with_path..fosQ / ! !&$//2215   4a1.111 1r+rmismatchrz2Cannot be a mismatch if there is no dynamic_shapesNz7Must provide a tree_name when there might be a mismatchc|turt||S|ttfvr&|t d|d|t |St d|)Nz%expected context to be None for type , got zDid not expect type )dictrlistrr<r)type_contextis r,_keyz!_tree_map_with_path.._keys}D==%gaj111T5M))*,ZEZZQXZZ'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+treespecother_treespecrr7c t|}|rdS|r d |d|jd|d|j|jkr# d |d|jd|d|j |j|jkr$ d |d|jd|d|jd |jturt |jt |jkr# d |d|jd|d|j t t|j|fd |jD}n|}tt||D].\}\}} ||| |j|j|fz/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..s%J%J%JAfQi%J%J%Jr+) r rr/ num_childrenrsetr zipchildren enumerate) rrr rendered_pathother_childrenr child other_childr_comparer rrs @r,r*z%_tree_map_with_path.._compares !'t ##%%F!))++((FIF}FFX]FF.;FFF=N$777((ZIZ}ZZX]ZZ.;ZZDRDWZZ(N,GGG((jIj}jjH%>N/8))++^<<00+A+{H#X]H4Da H HJJr+rr*)r ValueErrorargsr<rr r) rrrrer other_treerr*r rrrs ` ` @@@@@r,_tree_map_with_pathr0Os2666 2 2 2 2 2 2 2U!!TLNLLLGLLL SSS  " "" $H $M E E E     + "+ 4<+ DK+ + + + + + + + + + Z&dG<<26666 gSs$ CBB==Cct|tr|}t|tjjrt j|jnt j|}||ni}|j |i|j Sr4) rrmodulernnModuleinspect signatureforwardbind arguments)rr-kwargsr6s r, _combine_argsr;s!_%% HHJJ a ) ) "!)$$$  q ! ! )VVrF 9>4 *6 * * 44r+c2eZdZdZdZdZdZdZddZdS) ShapesCollectiona* Builder for dynamic_shapes. Used to assign dynamic shape specifications to tensors that appear in inputs. This is useful particularly when :func:`args` is a nested input structure, and it's easier to index the input tensors, than to replicate the structure of :func:`args` in the :func:`dynamic_shapes` specification. 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) To specify dynamism for integers, we need to first wrap the integers using _IntWrapper so that we have a "unique identification tag" for each integer. Example:: args = {"x": tensor_x, "others": [int_x, int_y]} # Wrap all ints with _IntWrapper mapped_args = pytree.tree_map_only(int, lambda a: _IntWrapper(a), args) dynamic_shapes = torch.export.ShapesCollection() dynamic_shapes[tensor_x] = (dim, dim + 1, 8) dynamic_shapes[mapped_args["others"][0]] = Dim.DYNAMIC # This is equivalent to the following (now auto-generated): # dynamic_shapes = {"x": (dim, dim + 1, 8), "others": [Dim.DYNAMIC, None]} torch.export(..., args, dynamic_shapes=dynamic_shapes) ci|_dSr4)_shapesr~s r,rTzShapesCollection.__init__s  r+c8t|tjtfst dt |t |}||jvr*|j|}||krt d|d|dS||jt |<dS)Nz:Cannot assign shape to non-tensor or non-_IntWrapper type z0Shapes assigned to input do not match: expected r)rrTensorrr<r/idr?)r=rshaper_shapes r, __setitem__zShapesCollection.__setitem__s!elK899  VTRSWWVV  !uu 4<  \$'F$\v\\UZ\\ #(DLA   r+c`t|}||jvr i|j|<|j|Sr4)rBr?)r=rrs r, __getitem__zShapesCollection.__getitem__#s3!uu t| # #!#DL |D!!r+c*t|jSr4)lenr?r~s r,__len__zShapesCollection.__len__)s4<   r+Nctfd}t|||}t||}tfdjDrt d|S)zu Generates the :func:`dynamic_shapes` pytree structure according to :func:`args` and :func:`kwargs`. c|t|}|jvr"|j|SdSr4)rBr?r)rrrr=t_idss r, find_shapez3ShapesCollection.dynamic_shapes..find_shape3s<a55Dt|## $|D))tr+c3 K|]}|vV dSr4r*)rrrMs 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?)r"r;r0anyr?r,)r=mr-r:rN combined_argsrrMs` @r,rzShapesCollection.dynamic_shapes,s       &av66 ,ZGG ::::T\::: : : d  r+r4) r#r$r%r&rTrErGrJrr*r+r,r=r=so&&P((($""" !!!r+r=c.eZdZdZdZddZddZdZdS)r aQ Infers dynamic_shapes based on additional inputs. This is useful particularly for deployment engineers who, on the one hand, may have access to ample testing or profiling data that can provide a fair sense of representative inputs for a model, but on the other hand, may not know enough about the model to guess which input shapes should be dynamic. Input shapes that are different than the original are considered dynamic; conversely, those that are the same as the original are considered static. Moreover, we verify that the additional inputs are valid for the exported program. This guarantees that tracing with them instead of the original would have generated the same graph. Example:: args0, kwargs0 = ... # example inputs for export # other representative inputs that the exported program will run on dynamic_shapes = torch.export.AdditionalInputs() dynamic_shapes.add(args1, kwargs1) ... dynamic_shapes.add(argsN, kwargsN) torch.export(..., args0, kwargs0, dynamic_shapes=dynamic_shapes) cg|_dSr4) _examplesr~s r,rTzAdditionalInputs.__init__as r+Nct|turtd|d|)t|turtd|d|j||fdS)zC Additional input :func:`args` and :func:`kwargs`. zRepresentative args z must be a tupleNzRepresentative kwargs z must be None or a dict)r/rr<rrUrB)r=r-r:s r,rzAdditionalInputs.addds ::U " " !N!N!N!NOO O  $v,,d":": HHHH  tVn-----r+cbfd||fg|jD^}}d}t||g|RddiS)z Infers a :func:`dynamic_shapes` pytree structure by merging shapes of the original input :func:`args` and :func:`kwargs` and of each additional input args and kwargs. c Vg|]%\}}tdt||&S)cbt|tjrt|jn|Sr4)rrrArrC)rrs r,r[z..zs$*Q 2M2M TagSTr+)r0r;)rr-r:rQs r,r z3AdditionalInputs.dynamic_shapes..xsN1 1 1 f TTav..  1 1 1 r+cvtfd|Dstdf|zdttr>tts)tfd|DrdSt jStfd|Dstdf|zddS)Nc3TK|]"}tt|uV#dSr4)r/)rrZvs r,rzJAdditionalInputs.dynamic_shapes.._mark_dynamism..s4DD%tAww$u++-DDDDDDr+z^The following inputs were found to have differing types, so they cannot be marked as dynamic: .c3$K|] }|kV dSr4r*rother_vr\s r,rzJAdditionalInputs.dynamic_shapes.._mark_dynamism..s'<<w!|<<<<<._mark_dynamism..s'@@G7a<@@@@@@r+z`The following inputs were found to have differing values, but they cannot be marked as dynamic: )allr,rrHrIrr))r\other_vss` r,_mark_dynamismz7AdditionalInputs.dynamic_shapes.._mark_dynamismsDDDD8DDDDD  O=>D8OOOO !S!! *Q*=*= <<<<8<<<<<'4;&@@@@x@@@@@$TBCTTTtr+rc.t|tuSr4)r/rH)r s r,r[z1AdditionalInputs.dynamic_shapes..sd1ggnr+)rUr)r=rQr-r:rother_dynamic_shapesrds ` r,rzAdditionalInputs.dynamic_shapesqs1 1 1 1 #' A$. A 1 1 1 --   (   "   -,    r+c|}|jD]-\}}tjj|||pi.dS)zW Verifies that an exported program is valid for each additional input. N)r2rUrexport_unlift#_check_input_constraints_for_module)r=epepmr-r:s r,verifyzAdditionalInputs.verifys] iikk N  LD& L D DT6d}t|dS)NzTUsing None as a dynamic shape dimension is deprecated. Please use Dim.STATIC instead)logwarning)rs r,%_warn_on_None_dynamic_shape_dimensionrqs& ( KKr+rRch ddlmm|t|dkrdSt |t t fr*t||}ifd  fd t |tt t fstdt|t |trt | }t | }t|t|kred|d|d }t|d kr1|d|vr't ||dtr|d z }n|d z }j |d  fd}t|||ddS)z Checks the dynamic_shapes specification for correctness, using combined args + kwargs as reference for inputs structure. rrNc 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#r0r1rr|r)rrxrythis_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+ct|tr|D]\}}t|tr |&|t 7t|t t fs-jd|d|dt|d|d ddSt|ttfr t|t|j krTjd|dt|d |j d t|j d t|d dt|D]\}}t|tr |&|t 7t|t t fs-jd |d|dt|d |d ddS|'jd|dt|dddS)Nz%Unexpected dimension mapped to index z in input tensor shape  specified at `dynamic_shapeszP` (expected None, an int, a Dim, Dim.AUTO, Dim.STATIC, or Dim.DYNAMIC, but got z instead)rrzExpected dynamic shape spec z5` to have the same length as the actual tensor shape z (expected z , but got zUnexpected dimension #zO` (expected None, an int, a Dim, Dim.AUTO, Dim.STATIC, or Dim.DYNAMIC, but got 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, Dim.STATIC, or Dim.DYNAMIC))rritemsrrqrHr.rr rr rIrCr%)rtensorrCr rrrrxs r, check_symbolsz,_check_dynamic_shapes..check_symbolss  eT " "- ++--  3c3'' %%c****[9;;;;$S3/::#)%3555Z_557=d||55%(555#>   t} - - 5zzS....i!/T5TTW]^bWcWcTTJP,TT!$V\!2!2TT>A%jjTTT: $E**  3c3'' %%c****[9;;;;$S3/::#)%34445447=d||44$'444#>    )+aaaU[\`UaUaaaa6   r+z8expected dynamic_shapes to be dict, tuple, or list, got 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|||dSt|tret|trt d|;t|t tfs!tdt|dSdS|.check_shapesN a & &  M$= 1 1 1 1 1 ; ' ' -..  A(X22(%u`der`s`suu)(((( &t i!/_m__Zg__*.q''__>K___9 )(r+inputsr)rrrrIrrr r/valuesrr<keyssortedrr0) rRrgot_keysexpected_arg_namesrrrrrwrxr}s @@@@@r,_check_dynamic_shapesrs`;:::::::^!4!4!9!9.5$-00E,^,,]-A-A-C-CDD )+F 6 6 6 6 6 6 6.......` ntUD&9 : :  ]tNG[G[ ] ]   .$''++--..!-"4"4"6"677 (  v&899 9 9.);..!)...  M""a''&q)99}-?-BCTJJ:Y V)+S.to_constraint..root_valueXs\\#("3T\BBF66&>>D y$ Q!@!@&IIH#8A;'''i!6HaHHV\!_HH#'HH17HHHr+rFr)rArrzexpected dim to be Dim, got )rqrrtorch.utils._sympy.solverrrrrvrr#rrrrr0r1rrBrsrBrrrrr<r/)rr|r rrrdim_rootroot_constraintrrrqrrr%derived_constraints_with_phantom_root phantom_rootssymbolss``` @@r, to_constraintz._process_dynamic_shapes..to_constraintQs PPPPPP666666??????            c; ' '= xH G++")(*;"._parse_tensor_dim.._create_static_dimse$$ $r+)rrHrr#rBr.r/r"r'rrmaybe_mark_dynamicr( mark_staticr) mark_dynamicrrB)r|idxrrr constraintsrrs r,_parse_tensor_dimz2_process_dynamic_shapes.._parse_tensor_dimsi % % % cC: & & 3#s## ;((c::&sFC88J CL ! ( ( 4 4 4 4 4 X & & 3x<,,, 00====\000 ))&#6666\111 **63777   1"V**cBB C C C C C [ M % %fc 2 2 2 2 2[r+c,t|_t|_t|_t|_t|_t |tr)|D]\}}|||dSt |ttfr$t|D]\}}|||dS|1t| D]}||ddSdSr4)r"_dynamo_weak_dynamic_indices_dynamo_dynamic_indices_dynamo_dynamic_range_dynamo_static_indices_dynamo_unbacked_indicesrrr{rr r%ranger)rr|rCr rrs r,update_symbolsz/_process_dynamic_shapes..update_symbolss0/2ee+),&'*uu$(+%*-%%' eT " " 3++-- 2 23!!&!S1111 2 2 t} - - 3#E** 2 23!!&!S1111 2 2 ]6::<<(( 3 3!!&!T2222] 3 3r+ct|tjr|||dSt|tr ||_dSdSr4)rrrArr)rrrrs r, assoc_shapez,_process_dynamic_shapes..assoc_shapesZ a & & ' N4M 2 2 2 2 2 ; ' ' ' 'AJJJ  ' 'r+rr)r7N)rrrrIrrr r/rrr0rrAr)rRrr$derived_constraint_with_phantom_rootphantom_root_name dynamic_dimsrrrrrrrrrs @@@@@@@@@r,_process_dynamic_shapesr:s;:::::::^!4!4!9!9 .5$-00E,^,,]-A-A-C-CDD ,7t+<+.s:a;M;Mr+r+z!expected dim to be _DimHint, got ) rrrHrr#rvrr.r<r/)r name_to_dimrs r,_get_dim_name_mappingrsK1M1MNNN V V ;  c3   V  S ! ! V(+K %#{++ :14 CH-.c8,, V$%Tc%T%TUUU V 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!|ttt*jfs"t/d|dt1|t!|jrd||st/d|d||<|t5t7t9|jt!|t*r||jjD]}|vr||vrt/d|difd}tA|||S)a When exporting with :func:`dynamic_shapes`, export may fail with a ConstraintViolation error if the specification doesn't match the constraints inferred from tracing the model. The error message may provide suggested fixes - changes that can be made to :func:`dynamic_shapes` to export successfully. Example ConstraintViolation error message:: 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 This is a helper function that takes the ConstraintViolation error message and the original :func:`dynamic_shapes` spec, and returns a new :func:`dynamic_shapes` spec that incorporates the suggested fixes. Example usage:: try: ep = export(mod, args, dynamic_shapes=dynamic_shapes) except torch._dynamo.exc.UserError as exc: new_shapes = refine_dynamic_shapes_from_suggested_fixes( exc.msg, dynamic_shapes ) ep = export(mod, args, dynamic_shapes=new_shapes) rNr)_is_supported_equivalencezSuggested fixes:rz`Suggested fixes not found in error message given to refine_dynamic_shapes_from_suggested_fixes() z(.*) = Dim\('(.*)'.*\)rFz!.* = Dim\('.*', min\=([0-9]+).*\)z.* = Dim\('.*'.*max\=([0-9]+)\)rLz = zexpected shape_fixes[z2] to be int, Dim, _DerivedDim, or sympy.Expr, got z sympy.Expr z is not a supported equivalencezshape_fixes key z" not found in name_to_dim or rootscT|t|tr|S|j vr |j}t| jrt | vr t |St t |j}|j vr |j}n.|j vrtd|jd |j} j j ||\}}|}|dkrt||z}|dkr|t|z}| t |<|S|St|trU|jj vrG|j vr |jS| |jj}| |j<|S|S)Nz symbol.name z not found in name_to_dimrr)rrHr#Exprrrnextiter free_symbolsrAr<polys polytoolsdivrvrrs) rrdummyfixrrmodulus remainder_dimderived_dim_cacher shape_fixesrqs r, apply_fixesz?refine_dynamic_shapes_from_suggested_fixes..apply_fixesas ;*S#..;J \[ ( (cl+C#uz** s88000,SXX66!$s'7"8"899F{k11*6;7!;k99"0 Wv{ W W W## +6;7).)>)B)B3)O)O&GYC!||!'llS0 A~~!C NN225%c#hh/J [ ) ) ch.?;.N.N|000(66vvk#(*;<==26!#,/  r+)!rerqrrrrrsplitstrip ExceptionrmatchgrouprHrrprNumberrr"r{rvrr<r/rrrrrrrr#r0)rrrrrrshape_fixes_msgexcrrrArRrS match_min match_maxrrootsrcrrrrrqs @@@@r,rrs@IIILLL::::::::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!c3 UZ@AA  hhh_cde_f_fhh  a $ $ 7,,Q// W$%U1%U%U%UVVVKN IIc$tAN334455 6 6 6 a % % ' IIafo & & & K  AUNN J1JJJ  13&&&&&&&&P {NN K KKs-A A+A&&A+)Irr5loggingr collectionsrcollections.abcrenumrrtypingrrr rtorch.utils._pytreer r r r rrrrrrrrexported_programrrqr torch._guardsrrrr__all__ getLoggerr#ror" dataclassr.rrrrvrrrHrrrrrrrrrr rr"rr0r;r=r rqrrrrr*r+r,rs ######$$$$$$,,,,,,,,,,                             .-----W$$$$$$VVVVVVVV   g!!     4    ,.,.,.,.,.,.,.,.^S@S@S@S@S@S@S@S@l *JJJJJ#JJJ\$(4 @ @ @  @Dj @.1Dj @ 38_ @ @ @ @          D D D D D #D D D N         "      *   4       *     - -0B B   R R R R R R R R8$8$3*d8n458$8$ U38_$ % 8$ u/01 8$ U8U3E-F#PQR 8$#x-(8$]8$8$8$8$~! DDD 38 D DDTz D  DDDDN 5d38n 5 5 5 5^^^^^^^^B^^^^^^^^BGXS>GXcNU3Z/$s);dBGXGXGXGXTpS>pcNU3Z/$s);dBp *ppppfcNU3Z/$s);dB(HL HLcNU3Z/$s);HL #s(^eCj 49,HLHLHLHLHLHLr+