YTh SSKrSSKJr SSKJr SSKJr SSKrSSK J r J r J r J r JrJrJrJrJrJrJrJr SSKJrJr SSKJrJrJr SSKJr SS KJ r J!r!J"r" SS K#J$r$J%r%J&r&J'r' SS K(J)r) SS K*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6 SS K7J8r8J9r9J:r:J;r; SSKr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrH SSKIJJrJ /SQrK\rL\rM\'rNSrO\RRrR\J"\RS5 S\RlSS\RlTSrUSrVSrW"SS5rX\S\S4Sj5rYS\Z4Sjr[Sr\C\RR5(d\^"S5eg)N)Iterator)contextmanager)Any) _Await_drop_IgnoreContextManager _isinstance _overload_overload_methodexportFinalFutureignore is_scriptingunused)forkwait) _awaitable_awaitable_nowait_awaitable_wait)_register_decomposition)freezeoptimize_for_inferencerun_frozen_optimizations)fuserlast_executed_optimized_graphoptimized_executionset_fusion_strategy) _InsertPoint) _ScriptProfile_unwrap_optional AttributeCompilationUnit interfaceRecursiveScriptClassRecursiveScriptModulescript script_methodScriptFunction ScriptModule ScriptWarning)jit_module_from_flatbufferloadsavesave_jit_module_to_flatbuffer) _flatten_get_trace_graph_script_if_tracing_unique_state_dict is_tracingONNXTracedModuleTopLevelTracedModuletrace trace_module TracedModule TracerWarningTracingCheckError) set_module)r"r#Errorrr)r*annotateenable_onednn_fusionr export_opnamesrrr$r isinstancer-onednn_fusion_enabledrr.r'script_if_tracingr strict_fusionr7r8rrcT[RRUR5$)z Generate new bytecode for a Script module. Returns what the op list would be for a Script Module based off the current code base. If you have a LiteScriptModule and want to get the currently present list of ops call _export_operator_list instead. )torch_C_export_opnames_c)ms J/var/www/auris/envauris/lib/python3.13/site-packages/torch/jit/__init__.pyr@r@ls 88 # #ADD ))z torch.jitr=cU$)aUse to give type of `the_value` in TorchScript compiler. This method is a pass-through function that returns `the_value`, used to hint TorchScript compiler the type of `the_value`. It is a no-op when running outside of TorchScript. Though TorchScript can infer correct type for most Python expressions, there are some cases where type inference can be wrong, including: - Empty containers like `[]` and `{}`, which TorchScript assumes to be container of `Tensor` - Optional types like `Optional[T]` but assigned a valid value of type `T`, TorchScript would assume it is type `T` rather than `Optional[T]` Note that `annotate()` does not help in `__init__` method of `torch.nn.Module` subclasses because it is executed in eager mode. To annotate types of `torch.nn.Module` attributes, use :meth:`~torch.jit.Attribute` instead. Example: .. testcode:: import torch from typing import Dict @torch.jit.script def fn(): # Telling TorchScript that this empty dictionary is a (str -> int) dictionary # instead of default dictionary type of (str -> Tensor). d = torch.jit.annotate(Dict[str, int], {}) # Without `torch.jit.annotate` above, following statement would fail because of # type mismatch. d["name"] = 20 .. testcleanup:: del fn Args: the_type: Python type that should be passed to TorchScript compiler as type hint for `the_value` the_value: Value or expression to hint type for. Returns: `the_value` is passed back as return value. )the_type the_values rKr>r>s Z rLc[U5$)a Compiles ``fn`` when it is first called during tracing. ``torch.jit.script`` has a non-negligible start up time when it is first called due to lazy-initializations of many compiler builtins. Therefore you should not use it in library code. However, you may want to have parts of your library work in tracing even if they use control flow. In these cases, you should use ``@torch.jit.script_if_tracing`` to substitute for ``torch.jit.script``. Args: fn: A function to compile. Returns: If called during tracing, a :class:`ScriptFunction` created by `torch.jit.script` is returned. Otherwise, the original function `fn` is returned. )r2)fns rKrCrCs$ b !!rLc[X5$)a Provide container type refinement in TorchScript. It can refine parameterized containers of the List, Dict, Tuple, and Optional types. E.g. ``List[str]``, ``Dict[str, List[torch.Tensor]]``, ``Optional[Tuple[int,str,int]]``. It can also refine basic types such as bools and ints that are available in TorchScript. Args: obj: object to refine the type of target_type: type to try to refine obj to Returns: ``bool``: True if obj was successfully refined to the type of target_type, False otherwise with no new type refinement Example (using ``torch.jit.isinstance`` for type refinement): .. testcode:: import torch from typing import Any, Dict, List class MyModule(torch.nn.Module): def __init__(self) -> None: super().__init__() def forward(self, input: Any): # note the Any type if torch.jit.isinstance(input, List[torch.Tensor]): for t in input: y = t.clamp(0, 0.5) elif torch.jit.isinstance(input, Dict[str, str]): for val in input.values(): print(val) m = torch.jit.script(MyModule()) x = [torch.rand(3,3), torch.rand(4,3)] m(x) y = {"key1":"val1","key2":"val2"} m(y) )r )obj target_types rKrArAsP s ((rLcB\rSrSrSrS SjrSrS\S\S \SS4S jrS r g) rDa Give errors if not all nodes have been fused in inference, or symbolically differentiated in training. Example: Forcing fusion of additions. .. code-block:: python @torch.jit.script def foo(x): with torch.jit.strict_fusion(): return x + x + x returnNcx[RR5(d[R"S5 gg)NzOnly works in script mode)rF _jit_internalrwarningswarnselfs rK__init__strict_fusion.__init__s)""//11 MM5 62rLcgNrNr]s rK __enter__strict_fusion.__enter__ rLtypevaluetbcgrbrN)r^rfrgrhs rK__exit__strict_fusion.__exit__ rerLrN)rXN) __name__ __module__ __qualname____firstlineno____doc__r_rcrrj__static_attributes__rNrLrKrDrDs2 7  S  # $ rLrDrXc#^# [RRRn[RRR S5 Sv [RRR U5 g![RRR U5 f=f7f)NF)rFrGGraphglobal_print_source_rangesset_global_print_source_ranges)old_enable_source_rangess rK_hide_source_rangesrwsf$xx~~HHP 55e<  556NO556NOs%B--A?*B-?+B**B-enabledcB[RRU5 g)zFEnable or disables onednn JIT fusion based on the parameter `enabled`.N)rFrG_jit_set_llga_enabled)rxs rKr?r?s HH""7+rLc>[RR5$)z,Return whether onednn JIT fusion is enabled.)rFrG_jit_llga_enabledrNrLrKrBrBs 88 % % ''rLzJIT initialization failed)_r[collections.abcr contextlibrtypingrtorch._CrFtorch._jit_internalrrrr r r r r rrrrtorch.jit._asyncrrtorch.jit._awaitrrrtorch.jit._decomposition_utilsrtorch.jit._freezerrrtorch.jit._fuserrrrrtorch.jit._ir_utilsrtorch.jit._scriptr r!r"r#r$r%r&r'r(r)r*r+torch.jit._serializationr,r-r.r/torch.jit._tracer0r1r2r3r4r5r6r7r8r9r:r; torch.utilsr<__all___fork_wait_set_fusion_strategyr@rG JITExceptionr=rlrnr>rCrArDrwboolr?rB _jit_init RuntimeErrorrNrLrKrsA$%    (KKBVV -        # >  * *  5+-`",()V  <PXd^PP,$, (  xx 2 33rL