EiJ:SSKrSSKrSSKrSSKrSSKJr SSKJr SSKJ r J r SSK J r J r Jr SSKrSSKJrJrJrJrJrJrJrJrJrJrJrJr SSKJr \ (aSS KJ r SS K!J"r" SS K#J$r$J%r% /S Qr&\RN"\(5r)"S S\ 5r*\RV"SS55r,"SS5r-\-r."SS\-5r/"SS\-5r0SSS.S\1S\2S-S\2S-S\3\-S44Sjjr4\RV"SS55r5\RV"S S!\555r6\RV"S"S#55r7\RV"S$S%\555r8\RV"S&S'\555r9\6\8-\9-r:\RV"S(S)55r;S*\:S+\\2\2/\S,4S6jr?SS7.S8\S\ 4S9\ S:\ S;\1S-S\ 4 S<jjr@S\=\1\ 44S=jrA"S>S?5rB"S@SA5rCSBrDSC\=\1\ 4S:\=\1\ 4\3\ -\<\ -S-4SDjrESC\=\1\ 4S:\=\1\ 4\3\ -\<\ -S-S\<\:4SEjrFS:\=\1\ 4\3\ -\<\ -S-4SFjrGSG\1S:\=\1\ 4\3\ -\<\ -S\=\1\ 4\3\ -\<\ -4SHjrHg)IN) defaultdict)Callable)autoEnum)Any TYPE_CHECKINGUnion) _get_node_type BUILTIN_TYPESKeyPathkeystr MappingKey SequenceKeySUPPORTED_NODES tree_itertree_maptree_map_with_pathtree_structureTreeSpec)ExportedProgram)Symbol)Source)ShapeEnvStrictMinMaxConstraint) ConstraintDimdims*refine_dynamic_shapes_from_suggested_fixesAdditionalInputscB\rSrSrSr\"5r\"5r\"5rSr g) _DimHintType0z 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$X/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/export/dynamic_shapes.pyr"r"0s 6D VFfGr.r"c\rSrSr%Sr\\S'Sr\S-\S'Sr \S-\S'Sr \ S-\S'\ S 5r \ S 5r\ S 5rSSS jjrS rSrg)_DimHint=aN Internal class for dynamic shape hints. - min and max are optional. - _factory is for UX only, below example: auto_hint = _DimHint.AUTO() # _factory=True bounded_hint = auto_hint(min=10, max=100) # Returns new instance with _factory=False bounded_hint(min=5, max=50) # Will fail, non-factory instance cannot be called typeNminmaxT_factoryc4[[R5$N)r1r"r*r$r.r/r* _DimHint.AUTOMs ))**r.c4[[R5$r8)r1r"r,r$r.r/r,_DimHint.DYNAMICQs ,,--r.c4[[R5$r8)r1r"r+r$r.r/r+_DimHint.STATICUs ++,,r.cUR(d[S[U5S35eUbUS:a[SU35eUbUS:a[SU35eUbUbX:a[SUSU35e[ URXSS 9$) N'z' object is not callablerzmin must be non-negative, got zmax must be non-negative, got zmin must be <= max, got min=, max=F)r4r5r6)r6 TypeErrorr3AssertionErrorr1)selfr4r5s r/__call___DimHint.__call__Ys}}aT |+CDE E ?sQw #A#!GH H ?sQw #A#!GH H ?s39 #?uF3%!PQ Q seDDr.cURR/nURbURSUR35 URbURSUR35 SSR U5S3$)Nzmin=zmax=zDimHint(z, ))r3namer4appendr5join)rCpartss r/__repr___DimHint.__repr__dsm  88  LL4z* + 88  LL4z* +$))E*+1--r.r$NN)returnr1)r%r&r'r(r)r"__annotations__r4intr5r6bool staticmethodr*r,r+rDrLr-r$r.r/r1r1=s~ CtCt HdTk ++..-- E.r.r1c "\rSrSrSr\R 5r\R5r\R5rSSS.S\ S\ S-S\ S-4Sjjr SS jr SS jr SS jrSS jrSSjrSSjrS \ 4SjrSSjr\S\ S\ S\ S \ 4Sj5rSrSrg)rma 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 Nr4r5rHr4r5cSSKJn UcSOUnUcUOUnXe:d[SUSU35eUR5(d[SU35eXlXPlX`lg)Nrint_ooz(Cannot create Dim with inconsistent min=r@z)Dim name must be a valid identifier, got )torch.utils._sympy.numbersrYrB isidentifierr%r4r5)rCrHr4r5rY_min_maxs r/__init__ Dim.__init__sp5KqSv#  :3%vcUK   "" #LTF!ST T r.rOc^[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-$r8r$xothers r/Dim.__add__.. a%ir.r3rQNotImplementedErrorr%_deriverCres `r/__add__ Dim.__add__sK ;c !%#E7$t}}o>__ ||/00r.c X-$r8r$rls r/__radd__ Dim.__radd__ |r.c^[T5[La[STSURS35eUR U4Sj5$)NzAttempted to subtract z from rac>UT- $r8r$rcs r/rfDim.__sub__..rhr.rirls `r/__sub__ Dim.__sub__sL ;c !%(vdmm_E__ ||/00r.c4[SURS35e)NzAttempted to negate zN. (Only increasing linear operations with integer coefficients are supported.))rjr%rls 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-$r8r$rcs r/rfDim.__mul__..rhr.rirls `r/__mul__ Dim.__mul__sR ;c !UaZ%(vdmm_E__ ||/00r.c X-$r8r$rls r/__rmul__ Dim.__rmul__rrr.cPSSKJn [U"U"UR555$)Nr)sympify)sympyrstrr%)rCfnrs r/ _derived_nameDim._derived_names!2gdmm,-..r.c8[URU5X5$r8) _DerivedDimrrCrs r/rk 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`. rHrootrc(XlX lX0lgr8)r%rr)rCrHrrs r/r^_DerivedDim.__init__+s  r.c JSSKJn SSKJn URR U*LaU*$UR U"URR 55nURnUS:a3[SURSURSUR S35e[U5$)NrIntegerrXzExpected derived min value of z9 to be >= 0. Please specify an appropriate min value for (currently ).) rrrZrYrr4rrBr%rQ)rCrrY _min_symintrs r/r4_DerivedDim.min0s "5 99==VG #7Ngggdiimm45 yy ? 0@??C}}oN"hhZr+  ;r.c SSKJn SSKJn URR ULaU$UR U"URR 55nURnU[RS- :aG[SURS[RS- SURSUR S 3 5e[U5$) NrrrXrzExpected derived max value of z to be <= z.. Please specify an appropriate max value for rr) rrrZrYrr5rsysmaxsizerBr%rQ)rCrrY _max_symintrs r/r5_DerivedDim.maxEs "5 99==F "Mgggdiimm45 yy q ( 0z#++XY/IZ[??C}}oN"hhZr+  ;r.c\^^[TRT5TRUU4Sj5$)Nc2>T"TRU55$r8)r)rdrrCs r/rf%_DerivedDim._derive..asbnr.)rrrrs``r/rk_DerivedDim._deriveZs*   r " II $  r.cUR$r8)r%rs r/rL_DerivedDim.__repr__ds }}r.)r%rrN)r%r&r'r(r)rrrr^rr4r5rkrLr-r$r.r/rrsS S   (  ( r.rrVnamesr4r5rO.c2^^[UU4SjU55$)zX Util to create multiple :func:`Dim` types. Returns: A tuple of :func:`Dim` types. c3:># UHn[UTTS9v M g7f)rVN)r).0rHr5r4s r/ dims..qs?Ts,s)tuple)r4r5rs`` r/rrhs ?? ??r.c.\rSrSr%Sr\\S'\\S'Srg)_ConstraintTargetitz* This represents input tensor dimensions. t_iddimr$N)r%r&r'r(r)rQrPr-r$r.r/rrts I Hr.rcf\rSrSr%Sr\\S'S\S'SSjrSrS r S r S r S r \ S 5rSrg) _Constrainti~z 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. rHrconstraint_rangeNcSSKJn SSKJn SSKJn UcUnU"UR RU"XS9-SS9n[URURURU5$)NrrrX ValueRangeslowerupperFvr warn_only) %torch.fx.experimental.symbolic_shapesrrZrYtorch.utils._sympy.value_rangesrrrrrrrH)rCrrrrYrrs r/_clone_with_range_Constraint._clone_with_rangescP5? =E1$$''+E*OO  II HH II    r.c URUS9$)NrrrCrs r/__ge___Constraint.__ge__%%E%22r.c&URUS-S9$)Nrrrrs r/__gt___Constraint.__gt__%%EAI%66r.c URUS9$)NrrrCrs 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.)rArs r/__bool___Constraint.__bool__s  7  r.cURURURRRURRR S.$N)rrr4r5rrrrrrrs r/serializable_spec_Constraint.serializable_specsFII88((++11((++11   r.r$)rN)r%r&r'r(r)rrPrrrrrrrrr-r$r.r/rr~sF 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. rHrrvalr$N) r%r&r'r(r)rrPrQr-r$r.r/rrs  I.. Hr.rcX\rSrSr%Sr\\S'S\S'\\-\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. rHrrrrcURURURRRURRR S.$rrrs r/r$_DerivedConstraint.serializable_specsFII88((++11((++11   r.r$N) r%r&r'r(r)rrPrrrrrr-r$r.r/rrs6 I.. l **L   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 \ \-S-\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)rQrP dataclassesfieldrr1r-r$r.r/rrs. H&1&7&7UD&QHhnt#Qr.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 g7fr8r$r other_sourcesources r/r&_process_equalities..*sQ=<.=c3,># UH nTU4v M g7fr8r$r s r/rr/s ;H<&=rr)rr dynamic_dimconstraint_dim)rrextend isinstancerrHrrr create_symbolrtorch_dynamorConstantSourcefx experimentalsymbolic_shapes DimDynamicr,rrrIradd)rrrrrrrr sources other_sources shared_t_id shared_dimrrrs @r/_process_equalitiesr#s*//:>>: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%c ^^^^ ^ ^ ^ Sm U UU 4Sjm [T U/UQ7ST 06$![anSURS;avU(d [S5SeT(d [S5SeS m U4S jm S [S [S [ SS4UU U U4Sjjm[ UT S9nUHn[ UT 5nT"XWS5 M eSnAff=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[;$r8)r r )ts r/is_leaf$_tree_map_with_path..is_leafhs a 55r.c>[U5nU[;a)[T[URU5S/UQ7ST06$T"X/UQ76$)Nrr,)r rr flatten_fn)pathr+r(typfr&r,s r/r2_tree_map_with_path..foseQ / !&$//215   1.1 1r.r,mismatchrz2Cannot be a mismatch if there is no dynamic_shapesNz7Must provide a tree_name when there might be a mismatchcU[La [X5$U[[4;aUb[ SUSU35e[ U5$[ SU35e)Nz%expected context to be None for type , got zDid not expect type )dictrlistrrBr)type_contextis r/_key!_tree_map_with_path.._keysfD=%gj11T5M)*,CE7&QXPYZ'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@rA INVALID_INPUT)msgr@rAr%s r/raise_mismatch_error1_tree_map_with_path..raise_mismatch_errors2F!//B9+Mefiejk9r.treespecother_treespecr0rOc >[U5nUR5(agUR5(aT "ST USURSUS35 URUR:wa*T "ST USURSUSUR3 5 URUR:wa+T "ST USURSUSURS3 5 UR[La[ UR 5[ UR 5:wa*T "ST USUR SUSUR 3 5 [ [UR UR555nUR Vs/sHoTUPM nnOUR5n[[UR5U55H2unupT "UU UT "URUR U54-5 M4 gs snf) N`z` is a z, but `dynamic_shapesz` is notz` has z elements, but `dynamic_shapesz elementsz ` has keys ) r r,r3 num_childrenr7setr:zipchildren enumerate)rJrKr0 rendered_path_remapkother_childrenr;child other_child_comparer<rHr%s r/rY%_tree_map_with_path.._compares# !'t ##%%!))++(I;}oWX]]OL..;_HF==N$7$77(I;}oWX]]OL..;_GNDWDWCXZ((N,G,GG(I;}oVHC^C^B__hj==D(8++,N4J4J0KK, {=/XEUEUDVW22? NLbLbKce"N22N4K4K4MNF:B9I9I%J9IAQi9IN%JN%3%<%<%>N/8))+^<0+A+#X]]H4D4Da HJJ0&KsG>r,r$)r ValueErrorargsrBrr r) r&r'r%r(erJ other_treerKrYr<r2r,rHs ` ` @@@@@r/_tree_map_with_pathr`Os26 2U!!TLNLGLL S  ""$H$M E + "+ 4<+ DK+ + + Z&dG>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) c0Ulgr8_shapesrs r/r^ShapesCollection.__init__s  r.c*[U[R[45(d[ S[ U535e[ U5nX0R;a&URUnX$:wa[ SUSU35egX R[ U5'g)Nz:Cannot assign shape to non-tensor or non-_IntWrapper type z0Shapes assigned to input do not match: expected r6)rrTensorrrBr3idrp)rCr+shaper_shapes r/ __setitem__ShapesCollection.__setitem__s!ellK899 LTRSWIV  !u << \\$'F$FvhfUZT[\ #(LLA r.cr[U5nX R;a0URU'URU$r8)rtrp)rCr+rs r/ __getitem__ShapesCollection.__getitem__#s2!u || #!#DLL ||D!!r.c,[UR5$r8)lenrprs 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$gr8)rtrpr)r0r+rrCt_idss r/ find_shape3ShapesCollection.dynamic_shapes..find_shape3s5a5Dt||# $||D))r.c3,># UH oT;v M g7fr8r$)rrrs r/r2ShapesCollection.dynamic_shapes..=s:\T5 \rzSome 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?)rOrkr`anyrpr\)rCmr]rjr combined_argsr(rs` @r/r(ShapesCollection.dynamic_shapes,sY  &av6 ,ZG :T\\: : :d  r.ror8) r%r&r'r(r)r^rwrzr~r(r-r$r.r/rmrms!&P($" !r.rmc8\rSrSrSrSrS SjrS SjrSrSr g) r iFa  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/Ulgr8 _examplesrs r/r^AdditionalInputs.__init__as r.Nc[U5[La[SUS35eUb![U5[La[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)r3rrBr7rrI)rCr]rjs r/rAdditionalInputs.adddsg :U " #7v=M!NO O  $v,d": (0GH  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$r8)rrrsrru)r0r+s r/rf1AdditionalInputs.dynamic_shapes..zs%*Q 2M2Magg TST Tr.cd^[U4SjU55(d[ST4U-S35e[T[5(a@[T[5(d+[U4SjU55(ag[ R $[U4SjU55(d[ST4U-S35eg)Nc3P># UHn[T5[U5Lv M g7fr8)r3)rrevs r/rJAdditionalInputs.dynamic_shapes.._mark_dynamism..sD8%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 g7fr8r$rother_vrs r/rrs<8!|8rc3,># UH oT:Hv M g7fr8r$rs r/rrs@xGa._mark_dynamismsD8DDD <=>D8O;LAO !S!!*Q*=*=<8<<<;;&@x@@@$ABC@QQRTr.r,c$[U5[L$r8)r3rQ)r;s r/rfrs d1gnr.)rr`rkr)rCrr]rjr(other_dynamic_shapesrs r/r(AdditionalInputs.dynamic_shapesqs#' 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)rbrrexport_unlift#_check_input_constraints_for_module)rCepepmr]rjs r/verifyAdditionalInputs.verifys@ 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%r4r5rrrF)rrrthis_that_r@rAboundss 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)rBrCzExpected 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))rr7itemsrrrQr1rFr rr8r}rurR)r0tensorrur;rr@rArs 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.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`.rBrCc >[U[R5(a T"XU5 g[U[5(aW[U[5(a [ S5eUb3[U[ [45(d[S[U535eggUb3[U5nT"TRSUSUS[U5SUS3 SS 9eg) NzdUnable to specify input integers as dynamic through named Dims. Please use Dim.AUTO/DYNAMIC instead.zIexpected dynamic_shape to be None, int, or _DimHint for _IntWrapper, got zCannot associate shape rz` to non-tensor type z at `inputsz` (expected None)rBrC) rrrsr_Dimr\rQr1rBr3r rF)r0r+ dynamic_shaperSr@rArs r/ check_shape*_check_dynamic_shapes..check_shapes a & & $= 1 ; ' '-.. A(X22%_`der`s_tu2(( &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(d[3S [5T535e[-[%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%rEqrurQCONSTRAINT_VIOLATION) symbolexprsolutionr@rArr;rrrs r/ root_valueB_process_dynamic_shapes..to_constraint..root_valueXs\\#(("3"3T\BF66&>D $ Q!@&IH#8A;''!66%aSV\\!_,=>##'&Hr.rFr)rHrrzexpected dim to be Dim, got )rrrtorch.utils._sympy.solverrrrrrr%rrrrr4r5rrtrrIrrrrrBr3)rrr;rrrdim_rootroot_constraintrrrrr@rA%derived_constraints_with_phantom_root phantom_rootssymbolss``` @@r/ to_constraint._process_dynamic_shapes..to_constraintQsP6?   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$r8)r)rr;rs r/_create_static_dimN_process_dynamic_shapes.._parse_tensor_dim.._create_static_dims e$ $r.)rrQrr%rIr1r3r"r*rrmaybe_mark_dynamicr+ mark_staticr, mark_dynamicrrt)ridxrrr constraintsrrs r/_parse_tensor_dim2_process_dynamic_shapes.._parse_tensor_dims % 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 ggr8)rO_dynamo_weak_dynamic_indices_dynamo_dynamic_indices_dynamo_dynamic_range_dynamo_static_indices_dynamo_unbacked_indicesrr7rrr8rRranger)r0rrur;rrs 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!lggr8)rrrsrr)r0r+rrs r/ assoc_shape,_process_dynamic_shapes..assoc_shapes7 a & & 4M 2 ; ' ' 'J (r.rr$)rON)rEr@rAr}rrr8r3rrr`rrHr)rr(r$derived_constraint_with_phantom_rootphantom_root_name dynamic_dimsr@rArrrrrrrs @@@@@@@@@r/_process_dynamic_shapesr:s;^!4!9 .5$-00^,]-A-A-CD ,7t+.s :a;Mr.r[z!expected dim to be _DimHint, got ) rrrQrr%rrr1rBr3)r( name_to_dimrs r/_get_dim_name_mappingrsK1MN ;  c3    S ! !(+ %#{++14 HH--.,c8,,$'Hc %TUUO r.rGc ^^^^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(d[/SU<S[1U535e[!UTR,5(aWU"U5(d[/SUS35eUTU'UR3[5[7[9UR:5555 [!U[*5(dMUR3UR<R>5 M TH!nUT;dM UU;dM[/SU<S35e 0mUUUU4Sjn[AUX5$![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\('(.*)'.*\)rNz!.* = Dim\('.*', min\=([0-9]+).*\)z.* = Dim\('.*'.*max\=([0-9]+)\)rVz = 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 rootsc>Ub[U[5(aU$URT ;Ga!T URn[UT R5(a[ U5T ;aT [ U5$[ [ UR55nURT ;aT URnO9URT ;a[SUR<S35eT URnT RRRX45upgUnUS:wa[U5U-nUS:waU[U5-nUT [ U5'U$U$[U[5(arURRT ;aXURT ;aT UR$URT URR5nUT UR'U$U$)Nz symbol.name z not found in name_to_dimrr)rrQr%Exprrnextiter free_symbolsrHrBpolys polytoolsdivrrr) r0rdummyfixrrmodulus remainder_dimderived_dim_cacher shape_fixesrs r/ apply_fixes?refine_dynamic_shapes_from_suggested_fixes..apply_fixesas ;*S#..J \\[ (cll+C#uzz**s800,SX66!$s'7'7"89F{{k1*6;;7!;;k9"0".v{{o=V W# +6;;7).)>)>)B)B3)O&GC!|!'lS0 A~!C N225%c#h/J [ ) )chh.?.?;.N||00(66vvk#((*;*;<=26!#,,/  r.)!rerrEr@rArrsplitstrip ExceptionrFmatchgrouprQrrrNumberrrOrrrrBr3rrrrrrr%r`)rGr(rr@rArshape_fixes_msgexcr rrHr\r] match_min match_maxrrootsrUcrrrrrs @@@@r/rrs@: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@AA 'u,^_cde_f^gh  a $ $,Q//${1#5T%UVVKN IIc$tANN345 6 a % % IIaffoo &$ K AUN "1%'IJ 13&&P {N KK   ' ' n  s"K K& K!!K&)Irreloggingr collectionsrcollections.abcrenumrrtypingrrr rtorch.utils._pytreer r r r rrrrrrrrexported_programrrr torch._guardsrrrr__all__ getLoggerr%rr" dataclassr1rrrrrrQrrrrrrrrrr8r7rOr#r`rkrmr rrrrrr$r.r/r+s #$,,     .$V ! 4  ,.,.,.^S@S@l *J#J\$(4 @  @Dj @.1Dj @ 38_ @     D #D D N    "  *  4   *    - -0B B   R R R8$8$3*d8n458$8$ U38_$ % 8$ u/01 8$ U8U3E-F#PQR 8$#x-(8$]8$~! D 38 D DDTz D  DN 5d38n 5^^B^^BGXS>GXcNU3Z/$s);dBGXTpS>pcNU3Z/$s);dBp *pfcNU3Z/$s);dB(HL HLcNU3Z/$s);HL #s(^eCj 49,HLr.