o Zh*@sddlZddlZddlZddlZddlmZddlmZmZddl m Z m Z m Z m Z mZddlZddlmZmZmZmZmZmZmZmZmZddlmZe rbddlmZdd lmZdd l m!Z!m"Z"gd Z#e$e%Z&Gd d d eZ'Gddde(Z)Gddde)Z*Gddde)Z+dddde,de e-de e-fddZ.e'j/e._/e'j0e._0e'j1e._1dddde,de e-de e-de2e)dffddZ3ej4Gdd d Z5ej4Gd!d"d"e5Z6ej4Gd#d$d$Z7ej4Gd%d&d&e5Z8ej4Gd'd(d(e5Z9ee6e8e9fZ:d)e:d*e e-e-ge;d+fd,d-dedd7d8e de fd9e d:e d;e e,de f dTz_Dim.__add__..typeintNotImplementedErrorr_deriveclsr8r%r7r&__add__M z _Dim.__add__cCs||Sr4r%r@r%r%r&__radd__Vz _Dim.__radd__cr2)NzAttempted to subtract z from r3cs|Sr4r%r5r7r%r&r9`r:z_Dim.__sub__..r;r@r%r7r&__sub__YrCz _Dim.__sub__cCstd|jd)NzAttempted to negate zN. (Only increasing linear operations with integer coefficients are supported.))r>rr@r%r%r&__rsub__bs z _Dim.__rsub__cs>ttus dkrtdd|jd|fddS)NrzAttempted to multiply z with zu, where a positive integer was expected. (Only increasing linear operations with integer coefficients are supported.)cs|Sr4r%r5r7r%r&r9or:z_Dim.__mul__..r;r@r%r7r&__mul__hs z _Dim.__mul__cCs||Sr4r%r@r%r%r&__rmul__qrEz _Dim.__rmul__cCsddlm}t|||jS)Nr)sympify)sympyrJstrr)rAfnrJr%r%r& _derived_namets z_Dim._derived_namecCst||tf||dS)NrootrM) _DerivedDimrNr=)rArMr%r%r&r?ysz _Dim._deriveN)rrr r! staticmethodr1rBrDrFrGrHrIrNr?r%r%r%r&r'8s     r'c@s(eZdZdZeddZeddZdS) _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. cC|jSr4valueselfr%r%r&minz_StaticDim.mincCrTr4rUrWr%r%r&maxrZz_StaticDim.maxN)rrr r!propertyrYr[r%r%r%r&rS}s  rSc@s0eZdZdZeddZeddZddZdS) rQa 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`. cCsvddlm}ddlm}|jj| ur| S|||jj}|j}|dks7Jd|jd|jd|jdt|S)NrIntegerr(zExpected derived min value of z9 to be >= 0. Please specify an appropriate min value for (currently ).) rKr^r-r)rPrYrMrr=)rXr^r)Z _min_symintrPr%r%r&rYs    z_DerivedDim.minc Csddlm}ddlm}|jj|ur|S|||jj}|j}|tjdks>Jd|j dtjdd|j d|jd t |S) Nrr]r(rzExpected derived max value of z to be <= z.. Please specify an appropriate max value for r_r`) rKr^r-r)rPr[rMsysmaxsizerr=)rXr^r)Z _max_symintrPr%r%r&r[s   z_DerivedDim.maxcs&ttfjfdddS)Ncs|Sr4)rMr5rMrXr%r&r9sz%_DerivedDim._derive..rO)rQrNr=rP)rXrMr%rcr&r?s z_DerivedDim._deriveN)rrr r!r\rYr[r?r%r%r%r&rQs   rQrYr[r.rYr[cCsddlm}|dur dn|}|dur|n|}||ks$Jd|d||s/Jd|t|tf||d}tttddd 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. rr(Nz(Cannot create Dim with inconsistent min=r,z)Dim name must be a valid identifier, got rdrr__main__) r-r) isidentifierr'r=getattrinspect getmodulestackr)r.rYr[r)_min_maxdimr%r%r&rs rnamesreturn.cstfdd|DS)zh Util to create multiple :func:`Dim` types. Returns: A tuple of :func:`Dim` types. c3s|] }t|dVqdS)rdN)r).0r.r[rYr%r& szdims..)tuple)rYr[rnr%rqr&rs rc@s"eZdZUdZeed<eed<dS)_ConstraintTargetz2 This represents input tensor dimensions. t_idrmN)rrr r!r=__annotations__r%r%r%r&rts  rtc@s`eZdZUdZeed<ded<dddZd d Zd d Zd dZ ddZ ddZ e ddZ 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. r.rconstraint_rangerNcCs`ddlm}ddlm}ddlm}|dur|}||jj|||d@dd}t|j |j |j |S)Nrrr( ValueRangeslowerupperFvrZ warn_only) %torch.fx.experimental.symbolic_shapesrr-r)torch.utils._sympy.value_rangesr{rxrrwrurmr.)rXr}r~rr)r{rxr%r%r&_clone_with_ranges   z_Constraint._clone_with_rangecC |j|dS)Nr}rrXr}r%r%r&__ge__) z_Constraint.__ge__cCs|j|ddS)Nrrrrr%r%r&__gt__,z_Constraint.__gt__cCr)Nr~rrXr~r%r%r&__le__/rz_Constraint.__le__cCs|j|ddS)Nrrrrr%r%r&__lt__2rz_Constraint.__lt__cCstd)NzCannot determine truth value of _Constraint. If you are trying to combine _Constraint's with logical connectives, you can specify them separately instead.) TypeErrorrWr%r%r&__bool__5sz_Constraint.__bool__cC|j|j|jjj|jjjdSN)rurmrYr[rurmrxrr}r~rWr%r%r&serializable_spec@s  z_Constraint.serializable_spec)rN)rrr r!rLrvrrrrrrr\rr%r%r%r&rw s   rwc@s*eZdZUdZeed<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. r.rrxvalN)rrr r!rLrvr=r%r%r%r&rQs   rc@sFeZdZUdZeed<ded<eeefed<e ed<e ddZ d S) _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. r.rrxrPrMcCrrrrWr%r%r&rss z$_DerivedConstraint.serializable_specN) rrr r!rLrvr rtrrr\rr%r%r%r&rcs  rc@seZdZdZeddZdS)_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. cCs|j|jdS)NrurmrrWr%r%r&rsz$_RelaxedConstraint.serializable_specN)rrr r!r\rr%r%r%r&r~sr constraint get_sourcesr shape_envr source_pairs)rrderived_equalities)rrphantom_symbolsrrelaxed_sourcescsP||j|j}|s dS|^} |fdd| Dt|trJ|j|vr?||j\} } || | } |fdd| DdS|j|jf||j<dSt|trt|jtsa||jj|jjd} n,|jj|vrn||jj} n|j |jj t j j |jjt jjjjj|jjd} | ||jj<|j} || | fdSt|tr|dSdS)z Updates `source_pairs`, `derived_equalities`, and `phantom_symbols` (which become fields of `EqualityConstraint`) based on a given input `constraint`. Nc3|]}|fVqdSr4r%rpZ other_sourcesourcer%r&rrz&_process_equalities..c3rr4r%rrr%r&rrs r)rrZ dynamic_dimZconstraint_dim)rurmextend isinstancerwr.rrPrZ create_symbolrtorch_dynamorZConstantSourceZfxZ experimentalZsymbolic_shapesZ DimDynamicr$rxrMappendradd)rrrrnrrrrsourcesZ other_sourcesZ shared_t_idZ shared_dimrPrMr%rr&_process_equalitiess<          r tree_namefunctreedynamic_shapesrc sddfddz t|g|RdiWStyf}zAd|jdvra|s.Jds4Jd d d fd d fddt|d\}}|D]}t|\}}||gqQd}~ww)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) cSs t|tvSr4)r r )tr%r%r&is_leafs z$_tree_map_with_path..is_leafcsHt|}|tvrtt||dg|RdiS||g|RS)Nrr)r rrZ flatten_fn)pathrrtyp)frrr%r&rsz_tree_map_with_path..frZmismatchrz2Cannot be a mismatch if there is no dynamic_shapesz7Must provide a tree_name when there might be a mismatchcSsB|tur t||S|ttfvr|dusJt|Std|)NzDid not expect type )dictrlistrsrAssertionError)type_contextir%r%r&_keys    z!_tree_map_with_path.._keycs,ddlm}m}||jdd|dd)Nr UserError UserErrorTypez,Detected mismatch between the structure of `z` and `dynamic_shapes`: dynamic_shapes_validationZ case_name)torch._dynamo.excrr INVALID_INPUT)msgrrrr%r&raise_mismatch_errors z1_tree_map_with_path..raise_mismatch_errorc spt|}t|tr dSt|tr!d|d|jd|d|j|jkr;d|d|jd|d|j t|jt|jkr^d|dt|jd|dt|jd |jturt|jt|jkrd|d|jd|d|j tt |j|jfd d |jD}n|j}t t |j|D]\}\}}||||j|j|gqdS) N`z` is a z, but `dynamic_shapesz` is notz` has z elements, but `dynamic_shapesz elementsz ` has keys csg|]}|qSr%r%)rpkZ_remapr%r& 6sz9_tree_map_with_path.._compare..) r rr r<lenZchildren_specsrsortedrzip enumerate)rrr rendered_pathZdynamic_shapes_children_specsrZtree_Zdynamic_shapes_)_comparerrrrr&rs`      z%_tree_map_with_path.._comparerN)r ValueErrorargsr) rrrre_Z tree_specZ other_treeZother_tree_specr%)rrrrrrrr&_tree_map_with_paths$    +rFcCs`t|tr |}|s.t|tjjrt|jnt|}|dur#|ni}|j |i|j S|Sr4) rrmodulernnModulerh signatureforwardbind arguments)rrkwargsZ_is_torch_jit_tracerr%r%r& _combine_argsIs  rc@s:eZdZdZddZddZddZdd Zd d d Zd S)ShapesCollectionaD 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) cCs i|_dSr4)_shapesrWr%r%r&__init__p zShapesCollection.__init__cCslt|tjsJdt|t|}||jvr-|j|}||ks+Jd|d|dS||jt|<dS)Nz'Cannot assign shape to non-tensor type z1Shapes assigned to tensor do not match: expected z, got )rrTensorr<idr)rXrshaperu_shaper%r%r& __setitem__ss    zShapesCollection.__setitem__cCs&t|}||jvri|j|<|j|Sr4)rr)rXrrur%r%r& __getitem__s   zShapesCollection.__getitem__cCs t|jSr4)rrrWr%r%r&__len__rzShapesCollection.__len__NcsNtfdd}t|||}t||}tfddjDr%td|S)zu Generates the :func:`dynamic_shapes` pytree structure according to :func:`args` and :func:`kwargs`. cs*t|}|jvr|j|SdSr4)rrr)rrrurXt_idsr%r& find_shapes    z3ShapesCollection.dynamic_shapes..find_shapec3s|]}|vVqdSr4r%)rpru)rr%r&rrrz2ShapesCollection.dynamic_shapes..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?)setrranyrr)rXmrrr combined_argsrr%rr&rs  zShapesCollection.dynamic_shapesr4) rrr r!rrrrrr%r%r%r&rYsrcCsd}t|dS)NzTUsing None as a dynamic shape dimension is deprecated. Please use Dim.STATIC instead)logwarning)rr%r%r&%_warn_on_None_dynamic_shape_dimensionsrrcs2ddlmm|dust|dkrdSt|ttfr#t||}ifddfddt|t ttfs?Jt|t rt| }t| }t |t |krd|d |d }t|d kr{|d|vr{t||dt r{|d 7}n|d 7}j |ddfdd}t |||dddS)z Checks the dynamic_shapes specification for correctness, using combined args + kwargs as reference for inputs structure. rrNc s|jvr:|j\}}|j|ks|j|kr8t|j||}t|j|j|j}jd|d|d|ddS|j|jf|j<dS)NzFound different definitions z and z! for the same symbolic dimension !)rrYr[r'r1r)rmr/r0Zthis_Zthat_)rrboundsr%r&check_same_boundss  z0_check_dynamic_shapes..check_same_boundsc s2t|tr@|D]4\}}t|tr|q |durtq t|ttfs=jd|d|dt|d|d ddq dSt|t t frt |D]4\}}t|trY|qK|duratqKt|ttfsjd|d|dt|d |d ddqKdS|durjd |dt|d 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)rrzUnexpected 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)) rritemsr'rr=rrr rsrr)rtensorrrrm)rrrr%r& check_symbolssV     z,_check_dynamic_shapes..check_symbolszWWhen `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 s^t|tjr|||dS|dur-t|}jd|d|dt|d|d dddS)NzCannot associate shape rz` to non-tensor type z at `inputsz` (expected None)rr)rrrr rr<)rr dynamic_shaper)rrrr%r& check_shapes z*_check_dynamic_shapes..check_shapeinputsr)rrrrrrsrr<valuesrkeysrrr)rrZgot_keysZexpected_arg_namesrrr%)rrrrrr&_check_dynamic_shapessD(      rcsddlmm|dust|dkrgSt|ttfr#t||}t tiggfddfddfdd }t |||d d D]}|j j }|vr`|d|_ qOD]} |qeS) zT Reads the dynamic_shapes specification and produces a list of constraints. rrNc sxddlddlm}ddlmddlm}fdd}ttrj }|j vr> |j d}t |j |j }n#|j vr\t|j |||j|jddd |d }||j <n|j }ttj ||jjddd |j} t|tr| | Sttrttj ||jjddd } | SttsJttj ||jjddd } | S) Nrry) try_solverzc stjjjdd}|}|j|}|dur$t|dSjddjd|d|d ) NT)integerrzExpected shape[z] = z# of input Tensor to be of the form z, where z is an integer)rrPrrMEqrr=ZCONSTRAINT_VIOLATION)symbolexprZsolution)rrrmrrKrrr%r& root_value>s  zB_process_dynamic_shapes..to_constraint..root_valuer|Fr)r.rxr)rKrrZtorch.utils._sympy.solverrr{rrQrPrrtrurmrrYr[rrrMrrSrwrVr') rmrrrr{r Zdim_rootZroot_constraintrPr)rr%derived_constraints_with_phantom_root phantom_rootssymbols)rmrrKrrr& to_constraint7st          z._process_dynamic_shapes..to_constraintcs0dd}t|_t|_t|_t|_t|_t|tr|D]f\}}t|t t frFt|t r7||||}|||}|j  |q!t|t r||t jkrXtj||n|t jkretj||n |t jkrqtj|| tt||q!|durtj||q!dSt|ttfrt|D]f\}}t|t t frt|t r||||}|||}|j  |qt|t r|t jkrtj||n|t jkrtj||n |t jkrtj|| tt||q|durtj||qdS|durt|D] }tj||q dSdS)NcSstt|tfd|iS)NrV)rSrLr=)rrrVr%r%r&_create_static_dimszK_process_dynamic_shapes..update_symbols.._create_static_dim)rZ_dynamo_weak_dynamic_indicesZ_dynamo_dynamic_indicesZ_dynamo_dynamic_rangeZ_dynamo_static_indicesZ_dynamo_unbacked_indicesrrrr=r'rrrr"rrZmaybe_mark_dynamicr#Z mark_staticr$Z mark_dynamicrrrsrrrangerm)rrrrrrmr) constraintsr r r%r&update_symbolssb                z/_process_dynamic_shapes..update_symbolscs t|tjr|||dSdSr4)rrr)rrr)rr%r& assoc_shapes z,_process_dynamic_shapes..assoc_shaperr)rrrrrrsrr<rrrrPr.r)rrrZ$derived_constraint_with_phantom_rootZphantom_root_nameZ dynamic_dimsr%)rrrr r r r rr&_process_dynamic_shapes s*S 2  rcCsti}t|ddddD]+}|durq t|trq t|tr0|||j<t|tr/|j||jj<q t|ts7Jq |S)NcSs t|tSr4)rr'r5r%r%r&r9s z'_get_dim_name_mapping..rr)rrr=r'rrQrPr)r name_to_dimrmr%r%r&_get_dim_name_mappings$    rrc sddl}ddlddlm}m}ddlm}z |dd}Wnt y4}z||j d|d}~wwi|dD]\}|}| d |} r{| d} d \} } | d |} rbt | d} | d |}rqt | d} t| | | d | <q<|d\} }|}t|jrt || <q<|| <q.apply_fixes) rerKrrrrrsplitstrip Exceptionrmatchgroupr=rrJrNumberrrrr'rQrrrLrrrrPrr)rrr#rrrZshape_fixes_msgexcrr'r.rkrlZ match_minZ match_maxrrootsrcr"r%r!r&rs`          $r)F)G dataclassesrhloggingra collectionsrenumrrtypingrrrrr rZtorch.utils._pytreer r r r rrrrrZexported_programrrKrZ torch._guardsrrrr__all__ getLoggerrrrr<r'rSrQrLr=rr"r#r$rsr dataclassrtrwrrrrrrrrrrrrrrrrr%r%r%r&s ,     E&C    G   ?  |K  s  5