9i"SSKrSSKrSSKrSSKrSSKJr SSKJrJr SSK J r J r J r J r Jr SSKrSSKJrJrJrJrJrJrJrJrJrJr SSKJr \ (aSSKJr SS KJ r SS K!J"r"J#r# /S Qr$\RJ"\&5r'"S S \5r(\RR"SS55r*"SS5r+\+r,"SS\+5r-"SS\+5r.SSS.S\/S\ \0S\ \0S\1\+S44Sjjr2\RR"SS55r3\RR"SS \355r4\RR"S!S"55r5\RR"S#S$\355r6\RR"S%S&\355r7\\4\6\74r8\RR"S'S(55r9S)\8S*\ \0\0/\:S+4S,S-S\;\/\1\0\044S.\:\1S/S0\:\1S+\S1\ 4S2\;\/S34S4\S\;\/\ 44S<jr?"S=S>5r@"S?S@5rASArBSB\;\/\ 4S9\\;\/\ 4\1\ \:\ S44SCjrCSB\;\/\ 4S9\\;\/\ 4\1\ \:\ S4S\:\84SDjrDS9\\;\/\ 4\1\ \:\ S44SEjrESF\/S9\\;\/\ 4\1\ \:\ 4S\\;\/\ 4\1\ \:\ 44SGjrFg)HN) defaultdict)autoEnum)AnyCallableOptional TYPE_CHECKINGUnion) _get_node_type BUILTIN_TYPESkeystrLeafSpec MappingKey SequenceKeySUPPORTED_NODES tree_flattentree_maptree_map_with_path)ExportedProgram)Symbol)Source)ShapeEnvStrictMinMaxConstraint) ConstraintDimdims*refine_dynamic_shapes_from_suggested_fixesAdditionalInputscB\rSrSrSr\"5r\"5r\"5rSr g) _DimHintType-z Enum for dynamic shape hints. - AUTO means automatic inference of shape (static or dynamic). - STATIC means static shape (always specialized). - DYNAMIC means dynamic, will error out if specialized. N) __name__ __module__ __qualname____firstlineno____doc__rAUTOSTATICDYNAMIC__static_attributes__r#[/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/torch/export/dynamic_shapes.pyr!r!-s 6D VFfGr-r!c\rSrSr%\\S'Sr\\\S'Sr \\\S'Sr \\ \S'\ S5r \ S 5r\ S 5rS SS jjrS rg)_DimHint:typeNminmaxT_factoryc4[[R5$N)r0r!r)r#r-r.r) _DimHint.AUTOAs ))**r-c4[[R5$r7)r0r!r+r#r-r.r+_DimHint.DYNAMICEs ,,--r-c4[[R5$r7)r0r!r*r#r-r.r*_DimHint.STATICIs ++,,r-cUR(d[S[U5S35eUb US:dS5eUb US:dS5eUbUb X::dS5e[URXSS9$) N'z' object is not callablerzmin must be non-negativezmax must be non-negativezmin must be <= maxF)r3r4r5)r5 TypeErrorr2r0)selfr3r4s r.__call___DimHint.__call__Ms|}}aT |+CDE E{cQhB(BB&{cQhB(BB&{ckSZM9MM7 seDDr-r#NN)returnr0)r$r%r&r'r!__annotations__r3rintr4r5bool staticmethodr)r+r*rAr,r#r-r.r0r0:sx C#C##Hhtn#++..--EEr-r0c "\rSrSrSr\R 5r\R5r\R5rSSS.S\ S\ \ S\ \ 4Sjjr SS jr SS jrSS jrSS jrSSjrSSjrS \ 4SjrSSjr\S\ S\ S\ S \ 4Sj5rSrSrg)rVa 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 Nr3r4namer3r4cSSKJn UcSOUnUcUOUnXe:d SUSU35eUR5(d SU35eXlXPlX`lg)Nrint_ooz(Cannot create Dim with inconsistent min=, max=z)Dim name must be a valid identifier, got )torch.utils._sympy.numbersrO isidentifierr$r3r4)r@rLr3r4rO_min_maxs r.__init__ Dim.__init__sn 6KqSv#{WFse6RUQVWW{  ""V&OPTv$VV" r-rDc^[T5[La[STSURS35eUR U4Sj5$)NzAttempted to add z to m, where an integer was expected. (Only increasing linear operations with integer coefficients are supported.)c>UT-$r7r#xothers r.Dim.__add__.. a%ir-r2rFNotImplementedErrorr$_deriver@r\s `r.__add__ Dim.__add__sK ;c !%#E7$t}}o>__ ||/00r-c X-$r7r#rcs r.__radd__ Dim.__radd__ |r-c^[T5[La[STSURS35eUR U4Sj5$)NzAttempted to subtract z from rXc>UT- $r7r#rZs r.r]Dim.__sub__..r_r-r`rcs `r.__sub__ Dim.__sub__sL ;c !%(vdmm_E__ ||/00r-c4[SURS35e)NzAttempted to negate zN. (Only increasing linear operations with integer coefficients are supported.))rar$rcs r.__rsub__ Dim.__rsub__s&!"4==/2[ [  r-c^[T5[LdTS::a[STSURS35eUR U4Sj5$)NrzAttempted to multiply z with zu, where a positive integer was expected. (Only increasing linear operations with integer coefficients are supported.)c>UT-$r7r#rZs r.r]Dim.__mul__..r_r-r`rcs `r.__mul__ Dim.__mul__sR ;c !UaZ%(vdmm_E__ ||/00r-c X-$r7r#rcs r.__rmul__ Dim.__rmul__rir-cPSSKJn [U"U"UR555$)Nr)sympify)sympyr{strr$)r@fnr{s r. _derived_nameDim._derived_names!2gdmm,-..r-c8[URU5X5$r7) _DerivedDimrr@r~s r.rb Dim._derives4--b14<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`. rLrootr~c(XlX lX0lgr7)r$rr~)r@rLrr~s r.rU_DerivedDim.__init__s  r-cBSSKJn SSKJn URR U*LaU*$UR U"URR 55nURnUS:d/SURSURSUR S35e[U5$)NrIntegerrNzExpected derived min value of z9 to be >= 0. Please specify an appropriate min value for (currently ).) r|rrQrOrr3r~r$rF)r@rrO _min_symintrs r.r3_DerivedDim.mins "5 99==VG #7Ngggdiimm45 yya ,T]]O<;;?==/J((2 '  ;r-c SSKJn SSKJn URR ULaU$UR U"URR 55nURnU[RS- ::dCSURS[RS- SURSUR S 3 5e[U5$) NrrrNrzExpected derived max value of z to be <= z.. Please specify an appropriate max value for rr) r|rrQrOrr4r~sysmaxsizer$rF)r@rrO _max_symintrs r.r4_DerivedDim.max+s "5 99==F "Mgggdiimm45 yyckkAo- ,T]]O:ckkTUoEVW;;?==/J((2 ' - ;r-c\^^[TRT5TRUU4Sj5$)Nc2>T"TRU55$r7)r~)r[r~r@s r.r]%_DerivedDim._derive..Fsbnr-)rrrrs``r.rb_DerivedDim._derive?s*   r " II $  r-cUR$r7)r$rs r.r_DerivedDim.__repr__Is }}r-)r$r~rN)r$r%r&r'r(r}rrrUrr3r4rbrr,r#r-r.rrsS S   &  & r-rrKnamesr3r4rD.c2^^[UU4SjU55$)zX Util to create multiple :func:`Dim` types. Returns: A tuple of :func:`Dim` types. c3:># UHn[UTTS9v M g7f)rKN)r).0rLr4r3s r. dims..Vs?Ts,s)tuple)r3r4rs`` r.rrMs ?? ??r-c.\rSrSr%Sr\\S'\\S'Srg)_ConstraintTargetiYz* This represents input tensor dimensions. t_iddimr#N)r$r%r&r'r(rFrEr,r#r-r.rrYs I Hr-rcf\rSrSr%Sr\\S'S\S'SSjrSrS r S r S r S r \ S 5rSrg) _Constrainticz 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. rLrconstraint_rangeNcSSKJn SSKJn SSKJn UcUnU"UR RU"XS9-SS9n[URURURU5$)NrrrN ValueRangeslowerupperFvr warn_only) %torch.fx.experimental.symbolic_shapesrrQrOtorch.utils._sympy.value_rangesrrrrrrrL)r@rrrrOrrs r._clone_with_range_Constraint._clone_with_rangeoscP5? =E1$$''+E*OO  II HH II    r-c URUS9$)Nrrr@rs r.__ge___Constraint.__ge__%%E%22r-c&URUS-S9$)Nrrrrs r.__gt___Constraint.__gt__%%EAI%66r-c URUS9$)Nrrr@rs r.__le___Constraint.__le__rr-c&URUS- S9$)Nrrrrs r.__lt___Constraint.__lt__rr-c[S5e)NzCannot determine truth value of _Constraint. If you are trying to combine _Constraint's with logical connectives, you can specify them separately instead.)r?rs r.__bool___Constraint.__bool__s  7  r-cURURURRRURRR S.$N)rrr3r4rrrrrrrs r.serializable_spec_Constraint.serializable_specsFII88((++11((++11   r-r#)rN)r$r%r&r'r(r}rErrrrrrrrr,r#r-r.rrcsF I.. (3737      r-rc8\rSrSr%Sr\\S'S\S'\\S'Srg) _PhantomRootia 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. rLrrvalr#N) r$r%r&r'r(r}rErFr,r#r-r.rrs  I.. Hr-rc\\rSrSr%Sr\\S'S\S'\\\ 4\S'\ \S'\ S5r S r g ) _DerivedConstraintia+ 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. rLrrrr~cURURURRRURRR S.$rrrs r.r$_DerivedConstraint.serializable_specsFII88((++11((++11   r-r#N)r$r%r&r'r(r}rEr rrrrrr,r#r-r.rrs< I.. !</ 00L   r-rc(\rSrSrSr\S5rSrg)_RelaxedConstraintias 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. c4URURS.$)Nrrrrs r.r$_RelaxedConstraint.serializable_specsII88  r-r#N)r$r%r&r'r(rrr,r#r-r.rrs  r-rc`\rSrSr%Sr\\S'\R"SSS9r \ \ \ \4\S'Sr g) _IntWrapperiz 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)initdefaultdynamismr#)r$r%r&r'r(rFrE dataclassesfieldrrr r0r,r#r-r.rrs8 H/:/@/@ D0HhuXs]+,r-r constraint get_sourcesr shape_envr source_pairs)rrderived_equalities)rrphantom_symbolsrrelaxed_sourcesc^U"URUR5nU(dgUtmn URU4SjU 55 [U[5(aiUR U;a4X0R upU"X5n URU4SjU 55 gURUR4X0R 'g[U[ 5(Gaj[UR[5(d5U"URRURR5Sn OURR U;aX`RR n OURURR[RRRURR 5[RR R"R$R&URR(S9n XURR 'UR*n UR-TX45 g[U[.5(aUR1T5 gg)z Updates `source_pairs`, `derived_equalities`, and `phantom_symbols` (which become fields of `EqualityConstraint`) based on a given input `constraint`. Nc3,># UH nTU4v M g7fr7r#r other_sourcesources r.r&_process_equalities..sQ=<.=c3,># UH nTU4v M g7fr7r#rs r.rr s ;H<&=r r)rr dynamic_dimconstraint_dim)rrextend isinstancerrLrrr create_symbolrtorch_dynamorConstantSourcefx experimentalsymbolic_shapes DimDynamicr+rr~appendradd)rrrrrrrrsources other_sources shared_t_id shared_dimrr~rs @r._process_equalitiesrs*//:>>:G $F]Q=QQ*k** ??e #&+OO&< #K' @M    ;H  '1ooz~~%FE// " J 2 3 3*//<88z33Z__5H5HI!LD##6&';';<!.."++ ==//>>z?S?ST % 5 5 E E P P X X#-??#C#C / 9=  4 45 ]] !!64"45 J 2 3 3F# 4r- tree_namefunctreedynamic_shapesr cH^^^ ^ ^ ^ ^ Sm U UU 4Sjm [T U/UQ7ST 06$![asnSURS;aZU(dS5eT(dS5eSm U4S jm U U U U4S jm [UT S 9upVUHn[UT 5upXT "Xh/5 M eS nAff=f) 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&[U5[;$r7)r r )ts r.is_leaf$_tree_map_with_path..is_leafOs a 55r-c>[U5nU[;a)[T[URU5S/UQ7ST06$T"X/UQ76$)Nrr')r rr flatten_fn)pathr&r#typfr!r's r.r-_tree_map_with_path..fVseQ / !&$//215   1.1 1r-r'mismatchrz2Cannot be a mismatch if there is no dynamic_shapesz7Must provide a tree_name when there might be a mismatchcU[La [X5$U[[4;aUbe[ U5$[ SU35e)NzDid not expect type )dictrlistrrAssertionError)type_contextis r._key!_tree_map_with_path.._keynsID=%gj11T5M)"?*?&q>)$';E7%CDDr-cD>SSKJnJn U"URSTSU3SS9e)Nr UserError UserErrorTypez,Detected mismatch between the structure of `z` and `dynamic_shapes`: dynamic_shapes_validation case_name)torch._dynamo.excr;r< INVALID_INPUT)msgr;r<r s r.raise_mismatch_error1_tree_map_with_path..raise_mismatch_errorws2F!//B9+Mefiejk9r-c 6>[U5n[U[5(ag[U[5(aT "ST USURSUS35 URUR:wa*T "ST USURSUSUR3 5 [ UR 5[ UR 5:wa=T "ST US[ UR 5SUS[ UR 5S3 5 UR[ La[UR5[UR5:wa*T "ST USURSUSUR3 5 [ [URUR 55nURVs/sHoTUPM nnO UR n[[UR U55H2unupT "UU UT "URURU5/-5 M4 gs snf) N`z` is a z, but `dynamic_shapesz` is notz` has z elements, but `dynamic_shapesz elementsz ` has keys ) r rrr2lenchildren_specsr1sortedr5zip enumerate)r"r#r+ rendered_path_remapkdynamic_shapes_children_specsr6tree_dynamic_shapes__comparer7rCr s r.rR%_tree_map_with_path.._compares$!'t dH--nh77(I;}oWTYYKH..;_HF99 3 33(I;}oWTYYKH..;_GNDWDWCXZt**+s>3P3P/QQ(I;}oVC@S@S WW W9 E ) ) V(g>LA, %1*g%F"R8- QHs$ B!A.BB!cP[U[5(aUR5n[U[RR 5(a [ R"UR5O[ R"U5nUbUO0nUR"U0UD6R$r7) rrmodulernnModuleinspect signatureforwardbind arguments)r-rVkwargsrbs r. _combine_argsrgs!_%% HHJ a ) ) !))$   q ! )VrF >>4 *6 * 4 44r-c:\rSrSrSrSrSrSrSrS Sjr S r g) ShapesCollectionia 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) c0Ulgr7_shapesrs r.rUShapesCollection.__init__s  r-c[U[R[45(dS[ U535e[ U5nX0R ;a"UR UnX$:Xd SUSU35egX R [ U5'g)Nz:Cannot assign shape to non-tensor or non-_IntWrapper type z0Shapes assigned to input do not match: expected z, got )rrTensorrr2idrl)r@r&shaper_shapes r. __setitem__ShapesCollection.__setitem__s!ellK899 Ha R 9 !u << \\$'F? B6(&QVPWX ?#(LLA r-cr[U5nX R;a0URU'URU$r7)rprl)r@r&rs r. __getitem__ShapesCollection.__getitem__s2!u || #!#DLL ||D!!r-c,[UR5$r7)rGrlrs r.__len__ShapesCollection.__len__s4<<  r-Nc^^[5mUU4Sjn[XU5n[XE5n[U4SjTR55(a [ S5eU$)ze Generates the :func:`dynamic_shapes` pytree structure according to :func:`args` and :func:`kwargs`. c|>[U5nUTR;a TRU5 TRU$gr7)rprlr)r+r&rr@t_idss r. find_shape3ShapesCollection.dynamic_shapes..find_shape s5a5Dt||# $||D))r-c3,># UH oT;v M g7fr7r#)rrr}s r.r2ShapesCollection.dynamic_shapes..s:\T5 \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?)setrgr\anyrlrU)r@mrVrfr~ combined_argsr#r}s` @r.r#ShapesCollection.dynamic_shapessY  &av6 ,ZG :T\\: : :d  r-rkr7) r$r%r&r'r(rUrsrvryr#r,r#r-r.riris!&P( " !r-ric8\rSrSrSrSrS SjrS SjrSrSr g) ri a  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) c/Ulgr7 _examplesrs r.rUAdditionalInputs.__init__;s r-Nc[U5[Ld SUS35eUb[U5[Ld SUS35eURR X45 g)z3 Additional input :func:`args` and :func:`kwargs`. zRepresentative args z must be a tupleNzRepresentative kwargs z must be None or a dict)r2rr1rr)r@rVrfs r.rAdditionalInputs.add>sf DzU"Q&:4&@P$QQ"~f!5 $VH,C D 5 tn-r-c X#4/URQVVs/sHup#[S[XU55PM snntpESn[UU/UQ7SS06$s snnf)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. cn[U[R5(a[UR5$U$r7)rrrorrq)r+r&s r.r]1AdditionalInputs.dynamic_shapes..Rs%*Q 2M2Magg TST Tr-cd^[U4SjU55(d[ST4U-S35e[T[5(a@[T[5(d+[U4SjU55(ag[ R $[U4SjU55(d[ST4U-S35eg)Nc3R># UHn[T5[U5:Hv M g7fr7)r2)rr\vs r.rJAdditionalInputs.dynamic_shapes.._mark_dynamism..YsD8%tAw$u+-8s$'z^The following inputs were found to have differing types, so they cannot be marked as dynamic: .c3,># UH oT:Hv M g7fr7r#rother_vrs r.rr`s<8!|8r c3,># UH oT:Hv M g7fr7r#rs r.rres@xGa._mark_dynamismXsD8DDD <=>D8O;LAO !S!!*Q*=*=<8<<<;;&@x@@@$ABC@QQRTr-r'c$[U5[L$r7)r2rF)r6s r.r]rps d1gnr-)rr\rgr)r@rrVrfr#other_dynamic_shapesrs r.r#AdditionalInputs.dynamic_shapesIs#' A$.. A 1 !B  Tav. !B 1 - (   " -   91 s#AcUR5nURH8up4[RRR X#U=(d 05 M: g)zG Verifies that an exported program is valid for each additional input. N)r^rrexport_unlift#_check_input_constraints_for_module)r@epepmrVrfs r.verifyAdditionalInputs.verifyss@ iik NNLD LL D D6URT;aTURupURU:wdURU:war[R URX5n[R URURUR5nT"TR SUSUSUS35egURUR4TUR'g)NzFound different definitions z and z! for the same symbolic dimension !)r$r3r4rrrA)rrrthis_that_r;r<boundss r.check_same_bounds0_check_dynamic_shapes..check_same_boundss <<6 ! -JDww$#''T/ cllD? cllCGGSWWE!//25'ugF77:e1>#2%(GGSWW#5F3<< r-c>[U[5(aUR5Hwup4[U[5(a T"U5 M$Uc [ 5 M3[U[ [ 45(aMPT"TRSUSUS[U5SU<S3 SS9e g[U[[45(a[U5[UR5:waQT"TRSUS[U5S URS [UR5S [U5S3 SS9e[U5Hwup4[U[5(a T"U5 M$Uc [ 5 M3[U[ [ 45(aMPT"TRS USUS[U5S U<S3 SS9e gUb"T"TRSUS[U5S3SS9eg)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)r=r>zExpected 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))rr1itemsrrrFr0rAr rr2rGrqrK)r+tensorrqr6rr;r<rs r. check_symbols,_check_dynamic_shapes..check_symbolss eT " "++-c3''%c*[9;$S3/::#%33?sBYZ_Y`a77=d|nE$$'7)5#>  (t} - -5zS..!//25'9VW]^bWcVdeJJP,,X!!$V\\!2 3:c%j\T: $E*c3''%c*[9;$S3/::#%3303J5'R77=d|nE##&'4#>  + ++07TU[\`UaTbc`a6  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`.r=r>c r>[U[R5(a T"XU5 g[U[5(aB[U[5(a [ S5eUb[U[ [45(deggUb3[U5nT"TRSUSUS[U5SUS3 SS9eg) NzdUnable to specify input integers as dynamic through named Dims. Please use Dim.AUTO/DYNAMIC instead.zCannot associate shape rz` to non-tensor type z at `inputsz` (expected None)r=r>) rrror_DimrUrFr0r rAr2)r+r& dynamic_shaperLr;r<rs r. check_shape*_check_dynamic_shapes..check_shapes a & & $= 1 ; ' '-.. A!(J}sHo,V,V VV,V(( &t !//-m_^^^^ ^ SSKm SSKJn SSKJm SSKJn U U UUU UU 4Sjn[T[5(Ga)TRnURT;a3TURSn[URUR5nOgURT;aH[URU"U"URUR S9SS9U"5S 9nUTUR'OTURn[#[%T5TTRU"U"TRTR S9SS9UTR&5n [U[5(aTR)U 5 U $[T[*5(aA[-[%T5TTRU"U"TR.TR.S9SS95n U $[T[05(de[-[%T5TTRU"U"TRTR S9SS95n U $) Nrr) try_solverc 6>TRTRRSS9nTRU5nT "TR UTR T5U5nUb[ US5$T"TRSTSTR TSUSUS3 5e) NT)integerrzExpected shape[z] = z# of input Tensor to be of the form z, where z is an integer)rrr$r~EqrqrFCONSTRAINT_VIOLATION) symbolexprsolutionr;r<rr6r|rrs r. root_valueB_process_dynamic_shapes..to_constraint..root_value(s\\#(("3"3T\BF66&>D $ Q!@&IH#8A;''!66%aSV\\!_,=>##'&Hr-rFr)rLrr)r|rrtorch.utils._sympy.solverrrrrrr$rrrrr3r4rrpr~rrrrr)rrr6rrrdim_rootroot_constraintrrr|rr;r<%derived_constraints_with_phantom_root phantom_rootssymbolss``` @@r. to_constraint._process_dynamic_shapes..to_constraint!sP6?   c; ' 'xxH  G+")(*;*;"Sn[U[[45(aF[U[5(a U"XU5nT"X U5nTURR U5 g[U[ 5(aUR [R:Xa [RRX5 O{UR [R:Xa [RRX5 O=UR [R:Xa[RRX5 TR [![#U5U55 gUc [RRX5 gg)Nc[U5$r7)r)rr6rs r._create_static_dimN_process_dynamic_shapes.._parse_tensor_dim.._create_static_dimws e$ $r-)rrFrr$rr0r2r!r)rrmaybe_mark_dynamicr* mark_staticr+ mark_dynamicrrp)ridxrrr constraintsrrs r._parse_tensor_dim2_process_dynamic_shapes.._parse_tensor_dimvs % cC: & &#s##(c:&sC8J CLL ! ( ( 4 X & &xx<,,, 00=\000 ))&6\111 **67   1"V*cB C [ MM % %f 2r-c>[5Ul[5Ul[5Ul[5Ul[5Ul[ U[5(a#UR5Hup4T"XU5 M g[ U[[45(a[U5Hup4T"XU5 M gUc*[UR55H nT"XS5 M ggr7)r_dynamo_weak_dynamic_indices_dynamo_dynamic_indices_dynamo_dynamic_range_dynamo_static_indices_dynamo_unbacked_indicesrr1rrr2rKranger)r+rrqr6rrs r.update_symbols/_process_dynamic_shapes..update_symbolss/2e+),&'*u$(+%*-%' eT " "++-!&S1( t} - -#E*!&S1+ ]6::<(!&T2)r-c>[U[R5(a T"XU5 g[U[5(aX!lggr7)rrrorr)r+r&rrs r. assoc_shape,_process_dynamic_shapes..assoc_shapes7 a & & 4M 2 ; ' ' 'J (r-rr)rDN)r@r;r<rGrrr2r2rrr\rrLr)rr#r$derived_constraint_with_phantom_rootphantom_root_name dynamic_dimsr;r<rrrrrrrs @@@@@@@@@r._process_dynamic_shapesr s;^!4!9 .5$-00^,]-A-A-CD ,7t+.s *Q,r-rTr)rrrFrr$rrr0)r# name_to_dimrs r._get_dim_name_mappingrsK,  ;  c3    S ! !(+ %#{++14 HH--.,c8,, ,,  r-rBc ^^^^SSKnSSKmSSKJnJn SSKJn URS5SR5n0mURS5GH nUR5nURS U5=n (aU RS5n S upURS U5=n (a[U RS55n URS U5=n(a[URS55n [XU S 9TU 'MURS5upTRU5n[!UTR"5(a[U5TU 'GMUTU 'GM [%U5m['5nTR)5Hunn[!U[[[*TR,45(de[!UTR,5(aJU"U5(deUTU'UR/[1[3[5UR65555 [!U[*5(dMUR/UR8R:5 M TR)5HunnUT;aMUU;aMe 0mUUUU4Sjn[=UX5$![anU"URS5UeSnAff=f)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\('(.*)'.*\)rCz!.* = Dim\('.*', min\=([0-9]+).*\)z.* = Dim\('.*'.*max\=([0-9]+)\)rKz = c~>Ub[U[5(aU$URT ;Ga T URn[UT R5(a[ U5T ;aT [ U5$[ [ UR55nURT ;aT URnO!URT ;deT URnT RRRX45upgUnUS:wa[U5U-nUS:waU[U5-nUT [ U5'U$U$[U[5(arURRT ;aXURT ;aT UR$URT URR5nUT UR'U$U$)Nrr)rrFr$Exprr}nextiter free_symbolsrLpolys polytoolsdivrrr~) r+rdummyfixrrmodulus remainder_dimderived_dim_cacher shape_fixesr|s r. apply_fixes?refine_dynamic_shapes_from_suggested_fixes..apply_fixes+s ;*S#..J \\[ (cll+C#uzz**s800,SX66!$s'7'7"89F{{k1*6;;7%{{k999*6;;7).)>)>)B)B3)O&GC!|!'lS0 A~!C N225%c#h/J [ ) )chh.?.?;.N||00(66vvk#((*;*;<=26!#,,/  r-)rer|r@r;r<rrsplitstrip ExceptionrAmatchgrouprFrr{rNumberrrrrrrr}rrrrr$r\)rBr#rr;r<rshape_fixes_msgexcrrrLrSrT match_min match_maxrrootsrNcr r rr r|s @@@@r.rrsk@:O))$67:@@BK$$T*iikHH6< <5 <;;q>D#JDHH%I3OOyO9??1-.HH%GMMyM9??1-. #D =K 5)JD==&D$ --$'I D!%) D!%+((7KeE!!#1!c3 UZZ@AAAA a $ $,Q// //KN IIc$tANN345 6 a % % IIaffoo &$!!#1K1:--$13""H {N KKi   ' ' n  s"J K*J>>K)Grraloggingr collectionsrenumrrtypingrrrr r rtorch.utils._pytreer r r rrrrrrrexported_programrr|r torch._guardsrrrr__all__ getLoggerr$rr! dataclassr0rrrrr}rFrrrrrrrrrr2r1rrr\rgrirrrrrrr#r-r.r%s #@@    .$V ! 4  EEE6Q@Q@h *H#HX'+ @  @sm @19# @ 38_ @     D #D D N    "  *  4   *    ; 24FF G     8$8$3*d8n458$8$ U38_$ % 8$ u/01 8$ U8U3E-F#PQR 8$#x-(8$]8$~ $ y 38 y yy} y  yx 5d38n 5\\~\\~XS>X$sCx.%*d3iEFXDoS>o$sCx.%*d3iEFo *od$sCx.%*d3iEF,}L }L$sCx.%*d3i?@}L 4S>5:tCy 01}Lr-