PhW ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddlm Z m Z mZmZmZmZmZmZmZmZddlZddlmcmZddlmcmZddlmZddl m!Z!ddl"m#Z#ddlm$Z$m%Z%m&Z&m'Z'erddl(m)Z)gd Z*d d l+m,Z,m-Z-m.Z.d d l/m0Z0m1Z1e ej0jdgee!fZ3ejhGd dZ5Gdde6Z7 d8dZ8ejhGdde5e7Z9dejtde;fdZ<Gdde6Z=dddde>dee;dee;fdZ?dddde>dee;dee;fd Z@ d9ddd!d"d#d$e d%ee d&fd'eee>e fd(eee9d)eeee>e fee fd*eAd+ee>d&fd,e,fd-ZBddd.d/e,d$ee>ejejfd0eee>e fd1eee>e;fd,df d2ZEddd3d$ee>ejejfd0eee>e fd4eee>e;fd,e,fd5ZFd6ee d,dfd7ZGy):N)autoEnum) AnyCallableDictIteratorListOptionalTupleType TYPE_CHECKINGUnion) compatibility) PassResult) PassManager) FlattenFuncFromDumpableContextFnToDumpableContextFn UnflattenFuncStrictMinMaxConstraint) ConstraintDimExportBackwardSignatureExportGraphSignatureExportedProgramModuleCallEntryModuleCallSignaturedims dynamic_dimexportloadregister_dataclasssave)rrr)rrc0eZdZUdZeed<eed<eed<y)_ConstraintTargetz{ This represents input tensor dimensions. Don't create this class directly; instead, use :func:`dynamic_dim`. w_tensort_iddimN)__name__ __module__ __qualname____doc__r__annotations__int`C:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\torch/export/__init__.pyr'r'Es M I Hr2r'c,eZdZdZdZ dfd ZxZS)_ConstraintFactoryzN Metaclass that ensures a private constructor for :class:`Constraint` cLt|jd|jd)N.zO has no public constructor. Please use torch.export.dynamic_dim() to create one) TypeErrorr,r-)clsargskwargss r3__call__z_ConstraintFactory.__call__Ws2~~a 0 012B C  r2c,t|||||||SN)superr<)r9r(r)r*constraint_rangeshared debug_name __class__s r3_createz_ConstraintFactory._create]s%w dC!16:  r2NN)r+r,r-r.r<rD __classcell__)rCs@r3r5r5Rs MQ  r2r5c6tj||||||Sr>)rrD)r(r)r*r@rArBs r3_create_constraintrHes    hc3CVZ XXr2ceZdZUdZded<dZeeed<dZee ed<de jfdZ d Z d Zd Zd Zd ZedZdZy)rz .. warning:: Do not construct :class:`Constraint` directly, use :func:`dynamic_dim` instead. This represents constraints on input tensor dimensions, e.g., requiring them to be fully polymorphic or within some range. rr@NrArBcddlm}ddlm}||jj |||zd}t |j|j|j||j|jS)Nrr) ValueRanges)lowerupperFvr warn_only) %torch.fx.experimental.symbolic_shapesrtorch.utils._sympy.value_rangesrLr@rPrHr(r)r*rArB)selfrMrNrrLr@s r3_clone_with_rangezConstraint._clone_with_range~sfP?1$$''+E*OO " MM II HH  KK OO   r2c&|j|S)NrMrUrTrMs r3__ge__zConstraint.__ge__%%E%22r2c,|j|dzS)Nr%rWrXrYs r3__gt__zConstraint.__gt__%%EAI%66r2c&|j|S)NrNrXrTrNs r3__le__zConstraint.__le__r[r2c,|j|dz S)Nr%r`rXras r3__lt__zConstraint.__lt__r^r2ctd)NzCannot determine truth value of Constraint. If you are trying to combine Constraint's with logical connectives, you can specify them separately instead.)r8rTs r3__bool__zConstraint.__bool__s  7  r2c(|j|j|jjj|jjj |j ddS|j j|j jddS)N)r)r*)r)r*minmaxrA)r)r*r@rPrMrNrArfs r3serializable_speczConstraint.serializable_specsII88((++11((++11;;&  !KK,,;;??  r2c t|tstdt|dddlm}||j j|j jzd}|j |j}n3|j|j|jk(sJ|j}t|j|j|j|t|j|j|j|S)NzPA dynamic dim can be specified equal only to another dynamic dim. Equality with z is not supported.rrFrO)rArB) isinstancerr8typerRrr@rPrBrHr(r)r*r')rTotherrr@rBs r3__eq__zConstraint.__eq__s%,!!%e -?A  Q1$$''%*@*@*C*CC  ?? "))J##+t%BRBR/R RRJ! MM II HH $U^^UZZK!   r2)r+r,r-r.r/rAr r'rBstrmathinfrUrZr]rbrdrgpropertyrkrpr1r2r3rrkso/.+/FH& '. $J $&'txx $3737    . r2r) metaclasstindexc ddlm}|||S)a" .. warning:: (This feature is DEPRECATED. See :func:`Dim` instead.) :func:`dynamic_dim` constructs a :class:`Constraint` object that describes the dynamism of a dimension ``index`` of tensor ``t``. :class:`Constraint` objects should be passed to ``constraints`` argument of :func:`export`. Args: t (torch.Tensor): Example input tensor that have dynamic dimension size(s) index (int): Index of dynamic dimension Returns: A :class:`Constraint` object that describes shape dynamism. It can be passed to :func:`export` so that :func:`export` does not assume static size of specified tensor, i.e. keeping it dynamic as a symbolic size rather than specializing according to size of example tracing input. Specifically :func:`dynamic_dim` can be used to express following types of dynamism. - Size of a dimension is dynamic and unbounded:: t0 = torch.rand(2, 3) t1 = torch.rand(3, 4) # First dimension of t0 can be dynamic size rather than always being static size 2 constraints = [dynamic_dim(t0, 0)] ep = export(fn, (t0, t1), constraints=constraints) - Size of a dimension is dynamic with a lower bound:: t0 = torch.rand(10, 3) t1 = torch.rand(3, 4) # First dimension of t0 can be dynamic size with a lower bound of 5 (inclusive) # Second dimension of t1 can be dynamic size with a lower bound of 2 (exclusive) constraints = [ dynamic_dim(t0, 0) >= 5, dynamic_dim(t1, 1) > 2, ] ep = export(fn, (t0, t1), constraints=constraints) - Size of a dimension is dynamic with an upper bound:: t0 = torch.rand(10, 3) t1 = torch.rand(3, 4) # First dimension of t0 can be dynamic size with a upper bound of 16 (inclusive) # Second dimension of t1 can be dynamic size with a upper bound of 8 (exclusive) constraints = [ dynamic_dim(t0, 0) <= 16, dynamic_dim(t1, 1) < 8, ] ep = export(fn, (t0, t1), constraints=constraints) - Size of a dimension is dynamic and it is always equal to size of another dynamic dimension:: t0 = torch.rand(10, 3) t1 = torch.rand(3, 4) # Sizes of second dimension of t0 and first dimension are always equal constraints = [ dynamic_dim(t0, 1) == dynamic_dim(t1, 0), ] ep = export(fn, (t0, t1), constraints=constraints) - Mix and match all types above as long as they do not express conflicting requirements r)r ) torch._exportr )rvrwr s r3r r sJ* q%  r2c eZdZdZedZy)_Dimz* Metaclass for :func:`Dim` types. c|dk(rd}|tjdz k(rd}||d|dS| d|d|dS| d|d|dSd|d|d|dS) NrJr%zDim('z')z', max=)z', min=, max=)sysmaxsize)namemin_max_s r3readablez _Dim.readable+s 19D 3;;? "D zdims..Ws?Ts,,s)tuple)rirjrs`` r3rrSs ?? ??r2Tr1) constraintsdynamic_shapesstrictpreserve_module_call_signaturefr:.r;rrrrreturncNddlm}m}||||||||S|||||||S)a :func:`export` takes an arbitrary Python callable (an nn.Module, a function or a method) along with example inputs, and produces a traced graph representing only the Tensor computation of the function in an Ahead-of-Time (AOT) fashion, which can subsequently be executed with different inputs or serialized. The traced graph (1) produces normalized operators in the functional ATen operator set (as well as any user-specified custom operators), (2) has eliminated all Python control flow and data structures (with certain exceptions), and (3) records the set of shape constraints needed to show that this normalization and control-flow elimination is sound for future inputs. **Soundness Guarantee** While tracing, :func:`export()` takes note of shape-related assumptions made by the user program and the underlying PyTorch operator kernels. The output :class:`ExportedProgram` is considered valid only when these assumptions hold true. Tracing makes assumptions on the shapes (not values) of input tensors. Such assumptions must be validated at graph capture time for :func:`export` to succeed. Specifically: - Assumptions on static shapes of input tensors are automatically validated without additional effort. - Assumptions on dynamic shape of input tensors require explicit specification by using the :func:`Dim` API to construct dynamic dimensions and by associating them with example inputs through the ``dynamic_shapes`` argument. If any assumption can not be validated, a fatal error will be raised. When that happens, the error message will include suggested fixes to the specification that are needed to validate the assumptions. For example :func:`export` might suggest the following fix to the definition of a dynamic dimension ``dim0_x``, say appearing in the shape associated with input ``x``, that was previously defined as ``Dim("dim0_x")``:: dim = Dim("dim0_x", max=5) This example means the generated code requires dimension 0 of input ``x`` to be less than or equal to 5 to be valid. You can inspect the suggested fixes to dynamic dimension definitions and then copy them verbatim into your code without needing to change the ``dynamic_shapes`` argument to your :func:`export` call. Args: f: The callable to trace. args: Example positional inputs. kwargs: Optional example keyword inputs. constraints: [DEPRECATED: use ``dynamic_shapes`` instead, see below] An optional list of constraints on the dynamic arguments that specify their possible range of shapes. By default, shapes of input torch.Tensors are assumed to be static. If an input torch.Tensor is expected to have dynamic shapes, please use :func:`dynamic_dim` to define :class:`Constraint` objects that specify the dynamics and the possible range of shapes. See :func:`dynamic_dim` docstring for examples on how to use it. dynamic_shapes: Should either be: 1) a dict from argument names of ``f`` to their dynamic shape specifications, 2) a tuple that specifies dynamic shape specifications for each input in original order. If you are specifying dynamism on keyword args, you will need to pass them in the order that is defined in the original function signature. The dynamic shape of a tensor argument can be specified as either (1) a dict from dynamic dimension indices to :func:`Dim` types, where it is not required to include static dimension indices in this dict, but when they are, they should be mapped to None; or (2) a tuple / list of :func:`Dim` types or None, where the :func:`Dim` types correspond to dynamic dimensions, and static dimensions are denoted by None. Arguments that are dicts or tuples / lists of tensors are recursively specified by using mappings or sequences of contained specifications. strict: When enabled (default), the export function will trace the program through TorchDynamo which will ensure the soundness of the resulting graph. Otherwise, the exported program will not validate the implicit assumptions baked into the graph and may cause behavior divergence between the original model and the exported one. This is useful when users need to workaround bugs in the tracer, or simply want incrementally enable safety in their models. Note that this does not affect the resulting IR spec to be different and the model will be serialized in the same way regardless of what value is passed here. WARNING: This option is experimental and use this at your own risk. Returns: An :class:`ExportedProgram` containing the traced callable. **Acceptable input/output types** Acceptable types of inputs (for ``args`` and ``kwargs``) and outputs include: - Primitive types, i.e. ``torch.Tensor``, ``int``, ``float``, ``bool`` and ``str``. - Dataclasses, but they must be registered by calling :func:`register_dataclass` first. - (Nested) Data structures comprising of ``dict``, ``list``, ``tuple``, ``namedtuple`` and ``OrderedDict`` containing all above types. r)r! export__RC__)rr)rrr)ryr!r) rr:r;rrrrr!rs r3r!r!ZsNP3   +I     )+I   r2 extra_files opset_versioneprrc(ddlm}|||||y)a# .. warning:: Under active development, saved files may not be usable in newer versions of PyTorch. Saves an :class:`ExportedProgram` to a file-like object. It can then be loaded using the Python API :func:`torch.export.load `. Args: ep (ExportedProgram): The exported program to save. f (Union[str, pathlib.Path, io.BytesIO): A file-like object (has to implement write and flush) or a string containing a file name. extra_files (Optional[Dict[str, Any]]): Map from filename to contents which will be stored as part of f. opset_version (Optional[Dict[str, int]]): A map of opset names to the version of this opset Example:: import torch import io class MyModule(torch.nn.Module): def forward(self, x): return x + 10 ep = torch.export.export(MyModule(), (torch.randn(5),)) # Save to file torch.export.save(ep, 'exported_program.pt2') # Save to io.BytesIO buffer buffer = io.BytesIO() torch.export.save(ep, buffer) # Save with extra files extra_files = {'foo.txt': b'bar'.decode('utf-8')} torch.export.save(ep, 'exported_program.pt2', extra_files=extra_files) r)r$rN)ryr$)rrrrr$s r3r$r$sh#QK}Er2rexpected_opset_versionrc$ddlm}||||S)a .. warning:: Under active development, saved files may not be usable in newer versions of PyTorch. Loads an :class:`ExportedProgram` previously saved with :func:`torch.export.save `. Args: ep (ExportedProgram): The exported program to save. f (Union[str, pathlib.Path, io.BytesIO): A file-like object (has to implement write and flush) or a string containing a file name. extra_files (Optional[Dict[str, Any]]): The extra filenames given in this map would be loaded and their content would be stored in the provided map. expected_opset_version (Optional[Dict[str, int]]): A map of opset names to expected opset versions Returns: An :class:`ExportedProgram` object Example:: import torch import io # Load ExportedProgram from file ep = torch.export.load('exported_program.pt2') # Load ExportedProgram from io.BytesIO object with open('exported_program.pt2', 'rb') as f: buffer = io.BytesIO(f.read()) buffer.seek(0) ep = torch.export.load(buffer) # Load with extra files. extra_files = {'foo.txt': ''} # values will be replaced with data ep = torch.export.load('exported_program.pt2', extra_files=extra_files) print(extra_files['foo.txt']) print(ep(torch.randn(5))) r)r"r)ryr")rrrr"s r3r"r"sf#  {;Q r2r9cddlm}||S)a Registers a dataclass as a valid input/output type for :func:`torch.export.export`. Args: cls: the dataclass type to register Example:: @dataclass class InputDataClass: feature: torch.Tensor bias: int class OutputDataClass: res: torch.Tensor torch.export.register_dataclass(InputDataClass) torch.export.register_dataclass(OutputDataClass) def fn(o: InputDataClass) -> torch.Tensor: res = res=o.feature + o.bias return OutputDataClass(res=res) ep = torch.export.export(fn, (InputDataClass(torch.ones(2, 2), 1), )) print(ep) r)!register_dataclass_as_pytree_node)torch._export.utilsr)r9rs r3r#r#Ks:F ,S 11r2rEr>)Hrcopy dataclassesriorrpathlibrtypingenumrrrrrrr r r r r rtorchtorch.fx._pytreefx_pytree fx_pytreetorch.utils._pytreeutilspytreetorch.fx._compatibilityrtorch.fx.passes.infra.pass_baser"torch.fx.passes.infra.pass_managerrrrrrrRr__all__exported_programrrrgraph_signaturerr GraphModulePassType dataclassr'rnr5rHrTensorr0r r{rqrrboolr!PathBytesIOr$r"r#r1r2r3rs       $$$$16:M "TSJ UXX))*HZ,@@ A        (DHY  m ".@m m `G!5<<G!G!T848(,0dc8C=hsm2,0d@@8C=@hsm@(,{ /3BF68{ { S/{  T#s(^ ${ $z*+ { U4S>5:#=>? {  { %*#s(O{ { D-1.2 6F6F S',, *+6F$sCx.) 6F DcN+ 6F  6Fx-17; 7 S',, *+7$sCx.)7%T#s(^4 7  7t2DI2$2r2