sh"bSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK J r SSK J r J r SSKJrJrJrJrJr SSKrSSKJs Jr SSKJr SSKJr SSKJr SSKJr SS KJ r J!r!J"r"J#r# \(a SS K$J%r% SS K&J'r' /S Qr(SSK)rS SK*J+r+ S SK,J-r-J.r.J/r/J0r0 S SK1J2r2J3r3J4r4J5r5 S SK6J7r7J8r8 S SK9J:r:J9r9J;r; \\RxRz/\\4r>S3SSSS.S\R~RS\A\S4S\\B\C\4S\\\B\C\4\A\\D\4S\ES\A\CS4S\34SjjjrFS3SSSSS.S\R~RS\A\S4S\\B\C\4S\\\B\C\4\A\\D\4S\ES\A\CS4S \\BS!\\4S\34S"jjjrGS3SSSS.S\R~RS\A\S4S\\B\C\4S\\\B\C\4\A\\D\4S\ES\A\CS4S\34S#jjjrHS$rISS\IS%.S&\3S'\S(\\B\C\4S)\\B\C\J4S*\JSS4 S+jjrKSSS,.S'\S(\\B\C\4S-\\B\C\J4S\34S.jjrLSS/.S0\M\S1\\CSS4S2jjrNg)4N)Iterator)autoEnum)AnyCallableOptional TYPE_CHECKINGUnion) compatibility) PassResult) PassManager)FileLike) FlattenFuncFromDumpableContextFnToDumpableContextFn UnflattenFunc) OpOverload)StrictMinMaxConstraint) ConstraintDimExportBackwardSignatureExportGraphSignatureExportedProgramCustomDecompTableModuleCallEntryModuleCallSignaturedefault_decompositionsdimsexportexport_for_trainingexport_for_inferenceloadregister_dataclasssave unflattenFlatArgsAdapterUnflattenedModule)r)rrrShapesCollection)rrrr)rr)r&r%r'Tdynamic_shapesstrictpreserve_module_call_signaturemodargs.kwargsr,r-r.returnc SSKJn [U[RR 5(d[ S[U5S35e[U[RR5(a [ S5eU"UUUUUUS9$)a :func:`export_for_training` takes any nn.Module 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 all 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. This API is intended for PT2 quantization training use cases and will soon be the default IR of torch.export.export in the near future. To read further about the motivation behind this change, please refer to https://dev-discuss.pytorch.org/t/why-pytorch-does-not-need-a-new-standardized-operator-set/2206 With this API, and :func:`run_decompositions()`, you should be able to get inference IR with your custom decomposition behaviour. **Soundness Guarantee** See :func:`export()` docstring for more details. Args: mod: We will trace the forward method of this module. args: Example positional inputs. kwargs: Optional example keyword inputs. dynamic_shapes: An optional argument where the type 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()_export_for_training;Expected `mod` to be an instance of `torch.nn.Module`, got .Exporting a ScriptModule is not supported. Maybe try converting your ScriptModule to an ExportedProgram using `TS2EPConverter(mod, args, kwargs).convert()` instead.)r-r.) _tracer4 isinstancetorchnnModule ValueErrortypejit ScriptModule)r/r0r1r,r-r.r4s i/Users/tiagomarins/Projetos/claudeai/copy_bank/venv/lib/python3.13/site-packages/torch/export/__init__.pyr r KsR- c588?? + +I$s)TU V  #uyy--.. K    'E  )r,r-r. decomp_tablerCrc <[UUUUUUS9nURUS9$)a :func:`export_for_inference` takes any nn.Module 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 ATen operator set (as well as any user-specified custom operators) which is customizable via decomp_table, (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. This API is for convenience use as it combines :func:`export_for_training` and :func:`run_decompositions`. **Soundness Guarantee** See :func:`export()` docstring for more details. Args: mod: We will trace the forward method of this module. args: Example positional inputs. kwargs: Optional example keyword inputs. dynamic_shapes: An optional argument where the type 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. decomp_table: See :func:`run_decompositions` for more details. 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+)rC)r run_decompositions)r/r0r1r,r-r.rCep_for_trainings rAr!r!s7R*  %'E O  - -< - HHrBc SSKJn [U[RR 5(d[ S[U5S35e[U[RR5(a [ S5eU"UUUUUUSS9$)a :func:`export` takes any nn.Module 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: mod: We will trace the forward method of this module. args: Example positional inputs. kwargs: Optional example keyword inputs. dynamic_shapes: An optional argument where the type 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()_exportr5r6r7T)r-r. pre_dispatch) r8rHr9r:r;r<r=r>r?r@)r/r0r1r,r-r.rHs rArrsz c588?? + +I$s)TU V  #uyy--.. K    'E rB) extra_files opset_versionpickle_protocolepfrKrLrMc [U[5(d"[S[U5RS35eSSKJn SSKJnJ n U"XU5n[U[[R45(a[R"U5n[R"US5n [UR ["5(deU R%SUR 5 U R%SUR&5 U R%S UR(5 U R%S UR*5 U R%S S R-[/[U555 U(a?UR15H+upU R3S 5n U R%SU 3U 5 M- SSS5 g!,(df  g=f)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 (str | os.PathLike[str] | IO[bytes]) 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 pickle_protocol: can be specified to override the default protocol 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) zBThe 'ep' parameter must be an instance of 'ExportedProgram', got 'z ' instead.rSCHEMA_VERSION) serializeSerializedArtifactw serialized_exported_program.jsonserialized_state_dict.ptserialized_constants.ptserialized_example_inputs.ptversionr6utf-8z extra_files/N)r9r TypeErrorr>__name__torch._export.serde.schemarRtorch._export.serde.serializerSrTstrosPathLikefspathzipfileZipFileexported_programbyteswritestr state_dict constantsexample_inputsjoinmapitemsencode) rNrOrKrLrMrRrSrTartifactzipfextra_file_namecontentencoded_contents rAr$r$vsXl b/ * *PQUVXQYQbQbPccm n  :K#,R#PH!c2;;'(( IIaL C D(33U;;;; 8(:S:ST 0(2E2EF /1C1CD 4h6M6MN i#c>*B!CD ,7,=,=,?(").."9 _,=>P-@ ! s !DF11 F?)rKexpected_opset_versionruc[U[[R45(a[R"U5nU=(d 0n[ R "US5nURS5R5RS5nSSK J n [U5[U5:XdeUS[US5:wa[SUSUS35eSSKJnJn S nS n S n S n UR#5GHn URU R$5n U R$S :XaU nM3U R$S :Xa[&R("S 5 U n M]U R$S :Xa[&R("S 5 U n MU R$S:XaU n MU R$S:XaU n MU R$S:XaU n MU R$R+S5(dMU R$RSS5SnU RS5X'GM UceU ceU ceU ceU"UU U U 5nU"X5nUsS S S 5 $!,(df  g =f)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: f (str | os.PathLike[str] | IO[bytes]): 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))) rrZr6rrQzSerialized version z+ does not match our current schema version ) deserializerTNrVzserialized_state_dict.jsonz"This version of file is deprecatedzserialized_constants.jsonrWrXrYrK/r(r[)r9r`rarbrcrdrereaddecodesplitr^rRlen RuntimeErrorr_rxrTinfolistfilenamewarningswarn startswith)rOrKrurqrZrRrxrTserialized_exported_programserialized_state_dictserialized_constantsserialized_example_inputs file_info file_contentrrprNs rAr"r"sAb!c2;;'(( IIaL#K C D))I&--/55c:=7|s>2222 1:^A./ /%gY/""0!14  R8<#150459!I99Y%7%78L!!%GG.:+##'CC BC(4%##'BB BC'3$##'AA(4%##'@@'3$##'EE,8)##..}==$--33C;A>(4(;(;G(D %')*+666$000#///(444'9 ' ! % (  :q ! sE7IAI Iserialized_type_nameclsrcSSKJn U"XS9$)a Registers a dataclass as a valid input/output type for :func:`torch.export.export`. Args: cls: the dataclass type to register serialized_type_name: The serialized name for the dataclass. This is required if you want to serialize the pytree TreeSpec containing this dataclass. Example:: import torch from dataclasses import dataclass @dataclass class InputDataClass: feature: torch.Tensor bias: int @dataclass class OutputDataClass: res: torch.Tensor torch.export.register_dataclass(InputDataClass) torch.export.register_dataclass(OutputDataClass) class Mod(torch.nn.Module): def forward(self, x: InputDataClass) -> OutputDataClass: res = x.feature + x.bias return OutputDataClass(res=res) ep = torch.export.export(Mod(), (InputDataClass(torch.ones(2, 2), 1), )) print(ep) r)!register_dataclass_as_pytree_noder)torch._export.utilsr)rrrs rAr#r#;sRF ,  rB)N)Obuiltinscopy dataclassesinspectrasystypingrrdcollections.abcrenumrrrrrr r r:torch.utils._pytreeutils_pytreepytreetorch.fx._compatibilityr torch.fx.passes.infra.pass_baser "torch.fx.passes.infra.pass_managerr torch.typesrrrrr torch._opsr%torch.fx.experimental.symbolic_shapesr__all__torch.export.custom_ops decomp_utilsrr,rrrr)rfrrrrgraph_signaturerrr%r&r'fx GraphModulePassTyper;r<tupledictr`listboolr r!rDEFAULT_PICKLE_PROTOCOLintr$r"r>r#r*rBrArs  $@@ $$16: &L .+CC KDD UXX))*HZ,@@ A (,\ NR68\ \ S/\ T#s(^ $\ U4S>5:tCy#HIJ \  \%*#s(O\\D(,RI NR68EIRI RI S/RI T#s(^ $RI U4S>5:tCy#HIJ RI  RI%*#s(ORI4 hx.@ @ABRIRIp(,q NR68q q S/q T#s(^ $q U4S>5:tCy#HIJ q  q%*#s(Oqqh-1.22 QQQQQQ$sCx.) QQ DcN+ QQ  QQ QQn-17; nn$sCx.)n%T#s(^4 n  nh+/- c-#3-- -rB