a di@sdZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZmZddlZddlmZddlmZddlmZmZmZmZddlmZddlmZddlmZdd l m!Z!m"Z"m#Z#dd lm$Z$dd l%m&Z&m'Z'dd lm(Z(m)Z)m*Z*m+Z+dd l,m-Z-m.Z.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6m7Z7m8Z8ddl9m:Z:e8a;e'eje&ejejd?Zchd@ZddAdBZeecejQjD]B\Z\Zfe\ad=r>q&e\eYjZvr&e\edvr&eWeYefjgeee\q&n2GdCd5d5ZTGdDd9d9ejQjZXGdEd<dr+r+r,__init__szOrderedDictWrapper.__init__cCsdd|DS)NcSsg|] \}}|qSr+r+.0kvr+r+r, z+OrderedDictWrapper.keys..itemsr?r+r+r,keysszOrderedDictWrapper.keyscCsdd|DS)NcSsg|] \}}|qSr+r+rAr+r+r,rErFz-OrderedDictWrapper.values..rGrIr+r+r,valuesszOrderedDictWrapper.valuescCs t|Sr1)lenrKrIr+r+r,__len__szOrderedDictWrapper.__len__cCs tddS)Nz6cannot delete methods or parameters of a script module RuntimeErrorr?rCr+r+r, __delitem__szOrderedDictWrapper.__delitem__cCs |jSr1)r>rHrIr+r+r,rHszOrderedDictWrapper.itemscCs(||vrtd||j||dS)NzKCan't add a new parameter after ScriptModule construction. Tried to add '{})rOformatr>setattrr?rCrDr+r+r, __setitem__szOrderedDictWrapper.__setitem__cCs |j|Sr1)r>containsrPr+r+r, __contains__szOrderedDictWrapper.__contains__cCs||vrt||j|Sr1)KeyErrorr>r4rPr+r+r, __getitem__szOrderedDictWrapper.__getitem__N) __name__ __module__ __qualname__r@rJrKrMrQrHrUrWrYr+r+r+r,r=sr=cs<eZdZfddZddZddZddZd d ZZS) OrderedModuleDictcsttj|||_dSr1)superr@torch_C ModuleDict_python_modules)r?moduleZ python_dictr7r+r,r@szOrderedModuleDict.__init__cCs|j}|Sr1)rbrHr?rr+r+r,rHs zOrderedModuleDict.itemscCs ||jvSr1rbrPr+r+r,rWszOrderedModuleDict.__contains__cCs8t|tr$|j||||j|<ntd||dS)NznCannot re-assign modules in a ScriptModule with non-scripted module, tried to replace existing module '{}': {}) isinstance ScriptModuler>rSrbrOrRrTr+r+r,rUs  zOrderedModuleDict.__setitem__cCs |j|Sr1rgrPr+r+r,rYszOrderedModuleDict.__getitem__) rZr[r\r@rHrWrUrY __classcell__r+r+rdr,r]s  r]cseZdZfddZZS) ScriptMetac si_ttdd_t|D]D}t|diD]\}}|j|<q4t|dt}j|_q t|D]*\}}t|t rrt ||j|j j <qrtddrt t|||Stddd tfd d }|_t t|||dS) NZ __constants__r+_methods_constants_set_disable_script_metaFr@cSsdSr1r+rIr+r+r,rFz%ScriptMeta.__init__..c stj}|g|Ri|tj|k}t|krdd}tjjj||| d|jd<|jj }| D]}t ||qn| D]\}}t ||qdD]}t ||qdS)NcSs6t|}t|dr*ddt|jDSt|SdS)NrlcSsg|] \}}|qSr+r+rAr+r+r,rE,rFzUScriptMeta.__init__..init_then_script..make_stubs..)r0r:sortedrlrHr )rcr*r+r+r, make_stubs)s zAScriptMeta.__init__..init_then_script..make_stubs)Z share_types_actual_script_module) _parameters_buffers_modules) rLrlr0r_jit _recursivecreate_script_moduler8rr_concrete_typeZget_attributesdelattrZ get_modules) r?argskwargsZ num_methodsZadded_methods_in_initrqZ concrete_typer5_r*Z original_initr+r,init_then_script!s       z-ScriptMeta.__init__..init_then_script)rlsetr4rmreversedrHunionrprhr rzZoriginal_methodrZr^rkr@ functoolswraps) r*r5basesattrsbaserCrDZbase_constantsrrdr~r,r@ s$     zScriptMeta.__init__rZr[r\r@rjr+r+rdr,rksrkc@seZdZddZdS)_CachedForwardcCs |dS)Nforward) __getattr__)r?objr*r+r+r,__get__Dsz_CachedForward.__get__N)rZr[r\rr+r+r+r,rCsrc@s eZdZdS) ScriptWarningNrZr[r\r+r+r+r,rHsrcCs0ts|Stjdd}t||jdd}t|||S)NZ frames_upri)Z self_name)r _jit_internal!createResolutionCallbackFromFramerrZr )fn_rcbastr+r+r, script_methodLs  rc@seZdZddZddZdS)ConstMapcCs ||_dSr1 const_mapping)r?rr+r+r,r@aszConstMap.__init__cCs |j|Sr1rr?attrr+r+r,rdszConstMap.__getattr__N)rZr[r\r@rr+r+r+r,r`sr)importerscript_module_idreturncCsHt|jtjjstdtj}tj||j|jt |j |}t |S)z Called by ``torch.package.PackageImporter``'s Pickler's ``persistent_load`` function. Performs work of loading and returning a ScriptModule from a ``torch.package`` archive. z{Loading ScriptObjects from a PackageImporter created from a directory is not supported. Use a package archive file instead.) rhZ zip_readerr_r`ZPyTorchFileReaderrOCompilationUnitZ_import_ir_module_from_packageZstorage_contextr!Zlast_map_locationr )rrZcu cpp_moduler+r+r,unpackage_script_modulehs r)__iter__rM__neg____mul__rW__add____sub____pow__ __truediv____mod____ne____eq____lt____gt____le____ge____and____or____xor__rYrU__call____int__ __float____bool____str__ __enter____exit__csPeZdZdZfddZfddZfddZdd Zd d Zd d Z Z S)RecursiveScriptClassa An analogue of RecursiveScriptModule for regular objects that are not modules. This class is a wrapper around a torch._C.ScriptObject that represents an instance of a TorchScript class and allows it to be used in Python. Attributes: _c [torch._C.ScriptObject]: The C++ object to which attribute lookups and method calls are forwarded. _props [Dict[str, property]]: A dictionary of properties fetched from self._c and exposed on this wrppaer. cs>td|jd<||_dd|jD|_d|jd<dS)NT _initializingcSsi|]}|jt|j|jqSr+)r5propertygettersetter)rBpropr+r+r, rFz1RecursiveScriptClass.__init__..F)r^r@r8r>Z _properties_props)r?Z cpp_classrdr+r,r@s   zRecursiveScriptClass.__init__csDd|jvr |jdr t|S||jvr8|j|St|j|SNr)r8r^rrfgetr4r>rrdr+r,rs   z RecursiveScriptClass.__getattr__csNd|jvr"|jdr"t||S||jvr<|j||St|j||dSr)r8r^ __setattr__rfsetrSr>r?rr/rdr+r,rs  z RecursiveScriptClass.__setattr__cOs*|j|st||}||i|Sr1)r> _has_method TypeErrorrr? method_namer{r| self_methodr+r+r,forward_magic_methods  z)RecursiveScriptClass.forward_magic_methodcCstddS)NzScriptClasses cannot be pickledr&rIr+r+r, __getstate__sz!RecursiveScriptClass.__getstate__cCs(|jdr|d|S|d|SdS)N__iadd__r)r>rr)r?otherr+r+r,rs  zRecursiveScriptClass.__iadd__) rZr[r\__doc__r@rrrrrrjr+r+rdr,rs rcOs|jtg|Ri|Sr1)rrr?r{r|r+r+r,method_templatesrcsveZdZUdZgdZfddZeZede fe d<fddZ fd d Z d d Z d dZedddZZS)riz A wrapper around C++ ``torch::jit::Module``. ``ScriptModule``\s contain methods, attributes, parameters, and constants. These can be accessed the same way as on a normal ``nn.Module``. )codecode_with_constantsgraph inlined_graph original_namecstdSr1r^r@rIrdr+r,r@sScriptModule.__init__.rcs"d|jvrt|St|j|S)Nrr)r8r^rr4rrrrdr+r,rs  zScriptModule.__getattr__csZd|jvrHt|tr:d|jjvr(i|j_|j|j|<|j}t||St |j ||dS)Nrr__annotations__) r8rhr.r7rr0r/r^rrSrrrrdr+r,rs    zScriptModule.__setattr__cCsJd|jvr|j|Stjdd}tj|}t||d|j | j <dS)Nrrr r) r8rrdefinerrr_r`Z_parse_source_defr rlr5)r?srcrcbrr+r+r,r s    zScriptModule.definecCs |jSr1)rr_replicate_for_data_parallelrIr+r+r,r"sz)ScriptModule._replicate_for_data_parallel)exportercCs&|}|j|jt|t|ffS)a} Called by ``torch.package.PackageExporter``'s Pickler's ``persistent_id`` when saving TorchScript objects. Performs act of saving a ScriptModule inside of a ``torch.package`` archive. Returns method to load the ScriptModule from a ``torch.package.PackageImporter``'s Pickler's ``persistent_load`` function. )Z get_unique_idZscript_module_serializer serializer>intr)r?rrr+r+r,__reduce_package__%s zScriptModule.__reduce_package__)rZr[r\rZ__jit_unused_properties__r@rrrrrrrrrrrrjr+r+rdr,ris    ri) metaclasscs,eZdZdZdZfddZeddZeddZd d Z e d d Z e d dZ e ddZ e ddZddZddZddZddZddZddZdd Ze d!d"Zd#d$Zfd%d&Zfd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Z fd7d8Z!d9d:Z"d;d<Z#Z$S)=RecursiveScriptModulea# The core data structure in TorchScript is the ``ScriptModule``. It is an analogue of torch's ``nn.Module`` and represents an entire model as a tree of submodules. Like normal modules, each individual module in a ``ScriptModule`` can have submodules, parameters, and methods. In ``nn.Module``\s methods are implemented as Python functions, but in ``ScriptModule``\s methods are implemented as TorchScript functions, a statically-typed subset of Python that contains all of PyTorch's built-in Tensor operations. This difference allows your ``ScriptModule``\s code to run without the need for a Python interpreter. ``ScriptModule``\s should not be created manually, instead use either :func:`tracing ` or :func:`scripting `. Tracing and scripting can be applied incrementally and :ref:`composed as necessary `. * Tracing records the tensor operations as executed with a set of example inputs and uses these operations to construct a computation graph. You can use the full dynamic behavior of Python with tracing, but values other than Tensors and control flow aren't captured in the graph. * Scripting inspects the Python code of the model and compiles it to TorchScript. Scripting allows the use of many `types`_ of values and supports dynamic control flow. Many, but not all features of Python are supported by the compiler, so changes to the source code may be necessary. Tcs(d|jd<||_tt|ddS)NTrZtraining)r8r>r^r@rz)r?rrdr+r,r@Ns  RecursiveScriptModule.__init__cCst|}||t||S)a Construct a RecursiveScriptModule that's ready for use. PyTorch code should use this to construct a RecursiveScriptModule instead of instead of calling `__init__` directly, as it makes sure the object is properly finalized (and in the future, we may take control of how the RecursiveScriptModule instance is created). Args: cpp_module: The C++ Module that will hold the actual state of this RecursiveScriptModule instance. init_fn: Lambda that initializes the RecursiveScriptModule passed to it. )r_finalize_scriptmodule)rinit_fn script_moduler+r+r, _constructWs z RecursiveScriptModule._constructcCsBttj|j|_ttj|j|_t|j|j |_ d|_ dS)NF) r=r_r` ParameterDictr>rs BufferDictrtr]rurrr+r+r,rms  z,RecursiveScriptModule._finalize_scriptmodulecCs||tjj|j|_i}tj|j D]\}}t |||<q6t |j||_ t tj|j|_t tj|j|_dd|j D|_d|jd<dS)z Re-construct an instance of RecursiveScriptModule using an instance of a C++ module. Args: cpp_module: The C++ module that this RecursiveScriptModule will be rebuilt around. cSs$i|]\}}t|tjjs||qSr+)rhr_r` ScriptMethodrAr+r+r,rsz6RecursiveScriptModule._reconstruct..FrN)r@r_r`ZConcreteModuleTypeZ from_jit_typer>_typeryrarHr r]rur=rrsrrtr8)r?rmodulesr5r+r+r, _reconstructzs z"RecursiveScriptModule._reconstructcCs|jdjS)z Returns a string representation of the internal graph for the ``forward`` method. See :ref:`interpreting-graphs` for details. r)r> _get_methodrrIr+r+r,rszRecursiveScriptModule.graphcCs|jjS)z Returns a string representation of the internal graph for the ``forward`` method. This graph will be preprocessed to inline all function and method calls. See :ref:`interpreting-graphs` for details. )rrrIr+r+r,rsz#RecursiveScriptModule.inlined_graphcCs|jjS)z Returns a pretty-printed representation (as valid Python syntax) of the internal graph for the ``forward`` method. See :ref:`inspecting-code` for details. )rrrIr+r+r,rszRecursiveScriptModule.codecCs|jj}|dt|dfS)a Returns a tuple of: [0] a pretty-printed representation (as valid Python syntax) of the internal graph for the ``forward`` method. See `code`. [1] a ConstMap following the CONSTANT.cN format of the output in [0]. The indices in the [0] output are keys to the underlying constant's values. See :ref:`inspecting-code` for details. rr )rrrrer+r+r,rs z)RecursiveScriptModule.code_with_constantscKs|jjt|fi|S)zx save(f, _extra_files={}) See :func:`torch.jit.save ` for details. )r>savestr)r?fr|r+r+r,rszRecursiveScriptModule.savecOs|jj|i|S)az _save_for_lite_interpreter(f) Add (or update) the bytecode session to the script model. The updated model is used in lite interpreter for mobile applications. Args: f: a string containing a file name. _extra_files: Map from filename to contents which will be stored as part of 'f'. )r>Z_save_for_mobilerr+r+r,_save_for_lite_interpreters z0RecursiveScriptModule._save_for_lite_interpretercOs|jj|i|Sr1)r>Z_save_to_buffer_for_mobilerr+r+r,$_save_to_buffer_for_lite_interpretersz:RecursiveScriptModule._save_to_buffer_for_lite_interpretercOs|jj|i|Sr1)r>save_to_bufferrr+r+r,rsz$RecursiveScriptModule.save_to_buffercOs |jSr1)r>get_debug_staterr+r+r,rsz%RecursiveScriptModule.get_debug_statecCs d|jS)Nzoriginal_name={})rRrrIr+r+r, extra_reprsz RecursiveScriptModule.extra_reprcOs|jj|g|Ri|Sr1)r graph_forrr+r+r,rszRecursiveScriptModule.graph_forcCs0t|t|jkrdSt|jS)N)r0rr>rr5rIr+r+r,rsz#RecursiveScriptModule.original_namecCs"tjdd}|j|j||dS)Nr r)rrr>Z_definery)r?rrr+r+r,rs zRecursiveScriptModule.definecsd|jvrtd|jr$t|S||jvr8|j|S|j|rP|j|S|j |rv|j |}||j|<|St|S)NrzKScriptModule has not been initialized, did you forget to call super's init?) r8rOrr^rrur>r:r4rr)r?rrrdr+r,rs         z!RecursiveScriptModule.__getattr__cs|jrt||S||jvr*||j|<nX|j|rF|j||nr:rSryZ get_constantsrJAttributeErrorrRrrdr+r,rs     z!RecursiveScriptModule.__setattr__cCstjjt|jSr1)r_rvrwr copyr>rIr+r+r,__copy__/szRecursiveScriptModule.__copy__cCstjjt|j|Sr1)r_rvrwr rdeepcopyr>)r?memor+r+r, __deepcopy__2sz"RecursiveScriptModule.__deepcopy__cOs4t||}t|ddtt|kr&t||i|S)N__func__)r4rNotImplementedErrorrr+r+r,r9s   z*RecursiveScriptModule.forward_magic_methodcCs |dS)NrrrIr+r+r,rAszRecursiveScriptModule.__iter__cCs |d|S)NrYr)r?idxr+r+r,rYDsz!RecursiveScriptModule.__getitem__cCs |dS)NrMrrIr+r+r,rMGszRecursiveScriptModule.__len__cCs |d|S)NrWr)r?keyr+r+r,rWJsz"RecursiveScriptModule.__contains__cs&|j}|jttdkr tS|S)N__dir__)rrr6rr^r?rrdr+r,rOs  zRecursiveScriptModule.__dir__cCs |j}|jttdkrdS|S)NrT)rrr6rr r+r+r,rZs zRecursiveScriptModule.__bool__cCsdd}t|j|S)NcSsdSr1r+rr+r+r,reszCRecursiveScriptModule._replicate_for_data_parallel..init_fn)rrr>r)r?rr+r+r,rbs z2RecursiveScriptModule._replicate_for_data_parallel)%rZr[r\rrnr@ staticmethodrrrrrrrrrrrrrrrrrrrrrrrrYrMrWrrrrjr+r+rdr,r2sL            r__csddlj|fdddS)Nrcs|p|Sr1) isfunctionismethodxinspectr+r,rorFz_get_methods..) predicate)r getmembersr)r+rr, _get_methods|s r>%Z named_modulesZload_state_dictchildrenrZregister_modulebuffersrZ _tracing_namedoubleZ_named_memberscpu parametersZ add_moduleZcudaZ state_dictapplyfloatZ_save_to_state_dictZtrainZ_load_from_state_dictZnamed_parametersZhalfZ named_bufferstoZregister_bufferZ zero_gradZ _slow_forwardZ _get_nameZ share_memory_applyZregister_parameterr0evalrZget_extra_stateZnamed_childrenZset_extra_statecsfdd}|S)NcstddS)Nz" is not supported on ScriptModulesrNrr5r+r,failsz_make_fail..failr+)r5r r+rr, _make_fails r!c@s eZdZdS)rNrr+r+r+r,rscseZdZdfdd ZZS)riNcstdSr1rr?argrdr+r,r@sr)Nrr+r+rdr,riscseZdZdfdd ZZS)rNcstdSr1rr"rdr+r,r@sr)Nrr+r+rdr,rscCst|tjjs|St|}||vr.|t|St|dr@|n|}|||<i}|jD]j\}}|dkr|D]\}}t ||||<qr|||<qZt|tjjrt|t st ||||<qZ|||<qZ|D]\}}||j|<q|S)N__prepare_scriptable__ru) rhr_nnridr:r$r8rH!call_prepare_scriptable_func_implri)rrZobj_idZ new_obj_dictr5Z sub_modulerCrDr+r+r,r's&    r'cCsi}t||Sr1)r')rrr+r+r,call_prepare_scriptable_funcsr(cCs tj|S)a Create a ``torch._C.ScriptDict`` instance with the data from ``obj``. Args: obj (dict): The Python dictionary that is used to initialize the ``ScriptDict`` returned by this function. Returns: An instance of ``torch._C.ScriptDict`` that has the same data as ``obj`` and can be passed between Python and TorchScript with reference semantics and zero copy overhead. )r_r`Z ScriptDict)rr+r+r,create_script_dicts r)cCs tj|S)a Create a ``torch._C.ScriptList`` instance with the data from ``obj``. Args: obj (dict): The Python list that is used to initialize the ``ScriptList`` returned by this function. Returns: An instance of ``torch._C.ScriptList`` that has the same data as ``obj`` and can be passed between Python and TorchScript with reference semantics and zero copy overhead. )r_r`Z ScriptList)rZ type_hintr+r+r,create_script_lists r*)example_inputscCsts|S|durtdt|tr(|St|tr6|St|trD|S|rtat rt t}t |ft|t r| D]\}}|D] }||qqvn&t|t r|D] } || qntdWdq1s0Yn tdt|tjjrt|}tjj|tjjjSt|tr&t|St|tr:t|St|rt|} t|tjjrltd |t|t!j"r~|St#|stdt$|%dkrtd|durt&'|d }t(||| |St)|st*|rt|} t+|d r|j,}t&-|}t+|d r(td |j.t/|t0|} | rB| St1||j2} |durbt&-|}tj34| | |t5|} |j6| _6|| _7t8|| | Stjj9|SdS) a Scripting a function or ``nn.Module`` will inspect the source code, compile it as TorchScript code using the TorchScript compiler, and return a :class:`ScriptModule` or :class:`ScriptFunction`. TorchScript itself is a subset of the Python language, so not all features in Python work, but we provide enough functionality to compute on tensors and do control-dependent operations. For a complete guide, see the :ref:`language-reference`. Scripting a dictionary or list copies the data inside it into a TorchScript instance than can be subsequently passed by reference between Python and TorchScript with zero copy overhead. ``torch.jit.script`` can be used as a function for modules, functions, dictionaries and lists and as a decorator ``@torch.jit.script`` for :ref:`torchscript-classes` and functions. Args: obj (Callable, class, or nn.Module): The ``nn.Module``, function, class type, dictionary, or list to compile. example_inputs (Union[List[Tuple], Dict[Callable, List[Tuple]], None]): Provide example inputs to annotate the arguments for a function or ``nn.Module``. Returns: If ``obj`` is ``nn.Module``, ``script`` returns a :class:`ScriptModule` object. The returned :class:`ScriptModule` will have the same set of sub-modules and parameters as the original ``nn.Module``. If ``obj`` is a standalone function, a :class:`ScriptFunction` will be returned. If ``obj`` is a ``dict``, then ``script`` returns an instance of `torch._C.ScriptDict`. If ``obj`` is a ``list``, then ``script`` returns an instance of `torch._C.ScriptList`. **Scripting a function** The ``@torch.jit.script`` decorator will construct a :class:`ScriptFunction` by compiling the body of the function. Example (scripting a function): .. testcode:: import torch @torch.jit.script def foo(x, y): if x.max() > y.max(): r = x else: r = y return r print(type(foo)) # torch.jit.ScriptFunction # See the compiled graph as Python code print(foo.code) # Call the function using the TorchScript interpreter foo(torch.ones(2, 2), torch.ones(2, 2)) .. testoutput:: :hide: ... ****Scripting a function using example_inputs** Example inputs can be used to annotate a function arguments. Example (annotating a function before scripting): .. testcode:: import torch def test_sum(a, b): return a + b # Annotate the arguments to be int scripted_fn = torch.jit.script(test_sum, example_inputs=[(3, 4)]) print(type(scripted_fn)) # torch.jit.ScriptFunction # See the compiled graph as Python code print(scripted_fn.code) # Call the function using the TorchScript interpreter scripted_fn(20, 100) .. testoutput:: :hide: ... **Scripting an nn.Module** Scripting an ``nn.Module`` by default will compile the ``forward`` method and recursively compile any methods, submodules, and functions called by ``forward``. If a ``nn.Module`` only uses features supported in TorchScript, no changes to the original module code should be necessary. ``script`` will construct :class:`ScriptModule` that has copies of the attributes, parameters, and methods of the original module. Example (scripting a simple module with a Parameter): .. testcode:: import torch class MyModule(torch.nn.Module): def __init__(self, N, M): super().__init__() # This parameter will be copied to the new ScriptModule self.weight = torch.nn.Parameter(torch.rand(N, M)) # When this submodule is used, it will be compiled self.linear = torch.nn.Linear(N, M) def forward(self, input): output = self.weight.mv(input) # This calls the `forward` method of the `nn.Linear` module, which will # cause the `self.linear` submodule to be compiled to a `ScriptModule` here output = self.linear(output) return output scripted_module = torch.jit.script(MyModule(2, 3)) Example (scripting a module with traced submodules): .. testcode:: import torch import torch.nn as nn import torch.nn.functional as F class MyModule(nn.Module): def __init__(self): super().__init__() # torch.jit.trace produces a ScriptModule's conv1 and conv2 self.conv1 = torch.jit.trace(nn.Conv2d(1, 20, 5), torch.rand(1, 1, 16, 16)) self.conv2 = torch.jit.trace(nn.Conv2d(20, 20, 5), torch.rand(1, 20, 16, 16)) def forward(self, input): input = F.relu(self.conv1(input)) input = F.relu(self.conv2(input)) return input scripted_module = torch.jit.script(MyModule()) To compile a method other than ``forward`` (and recursively compile anything it calls), add the :func:`@torch.jit.export ` decorator to the method. To opt out of compilation use :func:`@torch.jit.ignore ` or :func:`@torch.jit.unused `. Example (an exported and ignored method in a module):: import torch import torch.nn as nn class MyModule(nn.Module): def __init__(self): super().__init__() @torch.jit.export def some_entry_point(self, input): return input + 10 @torch.jit.ignore def python_only_fn(self, input): # This function won't be compiled, so any # Python APIs can be used import pdb pdb.set_trace() def forward(self, input): if self.training: self.python_only_fn(input) return input * 99 scripted_module = torch.jit.script(MyModule()) print(scripted_module.some_entry_point(torch.randn(2, 2))) print(scripted_module(torch.randn(2, 2))) Example ( Annotating forward of nn.Module using example_inputs):: import torch import torch.nn as nn from typing import NamedTuple class MyModule(NamedTuple): result: List[int] class TestNNModule(torch.nn.Module): def forward(self, a) -> MyModule: result = MyModule(result=a) return result pdt_model = TestNNModule() # Runs the pdt_model in eager model with the inputs provided and annotates the arguments of forward scripted_model = torch.jit.script(pdt_model, example_inputs={pdt_model: [([10, 20, ], ), ], }) # Run the scripted_model with actual inputs print(scripted_model([20])) Nz]`optimize` is deprecated and has no effect. Use `with torch.jit.optimized_execution() insteadzError: Unable to infer types. Please format the inputs to type `List[Tuple]` or `Dict[Callable, List[Tuple]]` to be run with MonkeyType.zWarning: monkeytype is not installed. Please install https://github.com/Instagram/MonkeyType to enable Profile-Directed Typing in TorchScript. Refer to https://github.com/Instagram/MonkeyType/blob/master/README.rst to install MonkeyType. zWType '{}' cannot be compiled since it inherits from nn.Module, pass an instance insteadzLTorchScript classes must be new-style classes. Please inherit from 'object'.rz\TorchScript classes does not support inheritance yet. Please directly inherit from 'object'.r Z__script_if_tracing_wrapper__script_unsupportedzTorchScript error: ):rwarningswarnrhrriScriptFunctionr$r2r"r#rrHr ValueErrorr_r%rr(rvrwrxr dictr)listr*risclassr issubclassrOrRenumEnumr<rLmrorrr r r r:Z __original_fn#createResolutionCallbackFromClosurer,"_check_directly_compile_overloadedrrrZr`Z_jit_script_compilerrZ_torchdynamo_inlinerZcreate_script_class)roptimizeZ _frames_uprr+Zmonkeytype_configrcZ example_inputZexampleZexamplesqualified_nameZmaybe_already_compiled_fnrrr+r+r,script sI       (                r<cCsB|D]4\}}||vs$|||krtjj|dj|dqdS)NzDefault parameters on overloads do not affect the runtime so they must equal to the default parameter on the implementation function. Found on parameter {name}r)rHr_rvZfrontendZ FrontendErrorrR)Z impl_defaultsoverload_defaultslocr5Zoverload_valuer+r+r,_check_overload_defaultsNsr?c Cszt||j}tjj|ddt|}t||j}t |}t |}t |}t ||| tj||||||} | Sr1)rrZdeclr_rv annotationsZ get_signaturerr rrr8r?ranger`Z_jit_script_compile_overload) overload_fn qual_nameZimpl_fnZ overload_declZoverload_signatureZimpl_astr=Zimplementation_defaultsrrr+r+r,_compile_function_with_overloadYs(   rEcCst|}t|}t|}|dur&|S||vr>ttd|g}|D]}|t|||qF|rj||}t||t ||S)Nfunction) rrr_get_fn_overloadsrOZ,get_overload_no_implementation_error_messageappendrErZ_clear_fn_overloads)rZexisting_compiled_fnsrDZuncompiled_overloadsZ compiled_fnsrCr+r+r,_get_overloadsps&    rIcCs,t|}t|st|r(td|dS)NzFunction {} cannot be directly compiled because it is overloaded. It must be used in a context of a function where its inputs can determine which overload to call.)rrrGrrOrR)rrDr+r+r,r9sr9cCst|stdt|s"tdt|tjjo>t| dk}|s\t| dkr\tdt |}t d}t ||j}tj||||}||_|S)Nz$interface must be applied to a classz1TorchScript interfaces must inherit from 'object'rzmTorchScript interface does not support inheritance yet. Please directly inherit from 'object' or 'nn.Module'.r )rr3rOr<r4r_r%rrLr7rrrrrZr`Z_jit_script_interface_compileZ__torch_script_interface__)rZis_module_interfacer;rrZmangled_classnamer+r+r, interfaces"   rKcCs,t|}tj||}t|}t|||Sr1)rr_r`Z CallStackrZ'createResolutionCallbackForClassMethodsr )rr>Z _qual_nameZ error_stackrr+r+r,_recursive_compile_classs rL spaddingoffsetcharcs<|t|kr|t|8}dfddt||D|S)Nrcsg|]}qSr+r+)rBr}rRr+r,rErFzpad..)rLjoinrBrNr+rSr,pads  rUc@s8eZdZd eeedddZeedddZd d Zd S) _ScriptProfileColumnr)header alignmentrQcCs||_||_||_i|_dSr1)rXrYrQrows)r?rXrYrQr+r+r,r@sz_ScriptProfileColumn.__init__)linenor/cCs||j|<dSr1)rZ)r?r[r/r+r+r,add_rowsz_ScriptProfileColumn.add_rowcstj}g}jD],\}}t|}|||ftt||}qjdkrj|jj8ndfdd|D}tjj |fS)Nrcs"g|]\}}|t|jfqSr+)rUrQ)rBrcellrPr?r+r,rErFz4_ScriptProfileColumn.materialize..) rLrXrZrHrrHmaxrYrUrQ)r? max_lengthrZrr/r]r+r^r, materializes   z _ScriptProfileColumn.materializeN)rWr) rZr[r\rrr@rr\rar+r+r+r,rVsrVc@s,eZdZeeeedddZddZdS)_ScriptProfileTablecols source_rangecCs||_||_dSr1rc)r?rdrer+r+r,r@sz_ScriptProfileTable.__init__c Csg}g}d}|jD]*}|\}}||7}||t|fq|||tdt|dd|jD]N}d}|D]6\}}||} | dur|tdt|7}qr|| 7}qr||qfd|S)Nrr= ) rdrarHr1rUrLregetrT) r?outputscellsZ header_buffercolrXrZlineZ row_bufferr]r+r+r, dump_strings$        z_ScriptProfileTable.dump_stringN)rZr[r\rrVrr@rmr+r+r+r,rbsrbc@s:eZdZddZddZddZeddd Zd d Zd S) _ScriptProfilecCstj|_dSr1)r%Z profilingrnprofilerIr+r+r,r@sz_ScriptProfile.__init__cCs|jdSr1)roenablerIr+r+r,rpsz_ScriptProfile.enablecCs|jdSr1)rodisablerIr+r+r,rqsz_ScriptProfile.disable)rcs"g}|jD]}|}|}tdd|Dfdd|D}|}|t|}t||}t d}t d} t d} t ddd } | } |D]V} | | | | | || || | }|dur| | | | | |qt|| | | gt|}||qd |S) NcSs"g|]}t|t|dqS)rM)rLlstriprBrlr+r+r,rE rFz._ScriptProfile.dump_string..csg|]}|dqSr1r+rsdedentr+r,rErFzLine #ZHitsz Time (ns)z Line Contentsrr z )roZ _dump_statssourcetext splitlinesminZstarting_linenorLrBrVZline_mapr\rhcountZ duration_nsrbr2rHrmrT)r?ri source_statsZ source_refZ source_linesZ start_lineZend_linerer[hitstime_nsZ line_contentsstatsrlstattabler+rtr,rms0      z_ScriptProfile.dump_stringcCst|dSr1)printrmrIr+r+r,dump$sz_ScriptProfile.dumpN) rZr[r\r@rprqrrmrr+r+r+r,rns rncCs|dusJd|S)NzUnwrapping null optionalr+rr+r+r,_unwrap_optional(srzaten::_unwrap_optionalzaten::is_scriptingzaten::has_torch_function)N)NrNN)rrM){rr collectionsr5rrr'r-typingrrrrrrrr_Ztorch._jit_internalrZ torch.utilsr Ztorch.jit._recursiver r r r Ztorch.nnrZtorch.jit._staterZtorch.jit._builtinsrZtorch.jit.frontendrrrrZtorch.jit._fuserrrrrrrZtorch.overridesrrrZ torch.packagerrZ_serializationr!Ztorch.jit._monkeytype_configr"r#r$Ztorch._classesr%r2r`rrr/r- __reduce__ namedtupler.r3r6r<r=r]r0rkrWarningrrrrr%rZ_magic_methodsrrrrSrirr8rHr5itemcallablerhr startswithr:rZ_compiled_methods_allowlistr!methodrZr'r(r)r*r<r?rErIr9rKrLrrrUrVrbrnrZ is_scriptingr+r+r+r,s$           K$1;; LB( "  C   *