YTh %SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKJ r SSK J r J r J r Jr SSKJr SSKrSSKJrJrJrJr SSKJr SSKJrJrJr SS KJrJr SS K J!r! SS K"J#r# \RHRJr&\RHRNr(\"S S S9r)\"S5r*S8Sjr+S9Sjr,"SS\RZRB5r.Sr/\R`RcSS5r2\R`RcSS5r3\R`RcSS5r4\RjS:Sj5r6\RnS4Sjr8Sr9Sr:"SS\;5r<\Rz"5S9Sj5r>"S S!\?5r@\@R5 \RHR5 S"rCS#rDS$rES%rFSSS SS&S SS\SS 4 S'jrG"S(S)\H\ 5rI"S*S+\H\ 5rJSSS SS&S SS\SS 4 S,jrKSrL\ \M\ \ 4\NS-'SS SS&S SS\SS 4 S.jrOS/rP"S0S1\5rQ"S2S3\Q5rRS4\ \*\)4S5\ \*\)44S6jrSS;S7jrTg)[R"5nU(d [S5eSnUTS-:a.URnU(d [S5eUS- nUTS-:aM.URnUR 5H8upE[ U[R5(dM&XLdM,US:waUs $Ss $ g)Nzfailed to inspect framerzfailed to get frameself) inspect currentframe RuntimeErrorf_backf_localsitems isinstancetorchTensor)varframeir!kv frames_ups H/var/www/auris/envauris/lib/python3.13/site-packages/torch/jit/_trace.py_get_interpreter_name_for_varI_create_interpreter_name_lookup_fn.._get_interpreter_name_for_var-s$$&89 9 )a-LLE"#899 FA )a- >>NN$DA!U\\**sxKq/R/%)r+r-s` r,"_create_interpreter_name_lookup_fnr1,s& )(r/FcURSS9n[U5"5n[5nUR5HOupV[ U5U;aMUR [ U55 U(aXcU'M=UR 5X5'MQ U$)NT keep_vars) state_dicttypesetr"idadddetach)moduler4r5 filtered_dictseen_idsr)r*s r,_unique_state_dictr>Cs""T"2J$&MH  " a5H   RU  !  xxzM # r/cV^\rSrSrSU4SjjrS\R 4SjrSrU=r $)ONNXTracedModuleUc^>[TU]5 XlX lX0lX@lXPlgN)super__init__innerstrict_force_outplace_return_inputs_return_inputs_states)rrFrGforce_outplace return_inputsreturn_inputs_states __class__s r,rEONNXTracedModule.__init__Vs.   -+%9"r/argsc^^^^^ ^ [U5umm[[TSS9R55n/m /m/m UUUU U U4Sjn[R R UTU-[5TRTR5upETR(a UT ST S4$TR(a UT STS4$UT S4$)NTr3cZ>/n[[T55HBn[X[R5(d [ S5eUR X5 MD [UT5nT R(a!T R [SU555 T R(aTR [UT55 T R T R"U65 T R(a TSU4TS'[T 5upE[U5S:XaUS$[U5$)NzExpected Tensor argumentc3Z# UH!oR[RS9v M# g7f) memory_formatN)cloner$preserve_format).0xs r, .wrapper..}s!UPT1''0E0E'FPTs)+rr) rangelenr#r$r%rappend _unflattenrItuplerJrF_flatten) rPin_argsr( trace_inputsout_vars_in_descin_vars inputs_statesouts ret_inputsrs r,wrapper)ONNXTracedModule.forward..wrapperrs*,G3w<(!$'5<<88&'ABBtw') &gw7L""!!UPTUU))$$Z%AB KK L1 2))$1!$4l#C a "4.KH8}!{"X&r/r) ralistr>valuesr$_C_create_graph_by_tracingr1rGrHrIrJ) rrP module_staterkgraph_outrfrgrhrirjs ` @@@@@r,forwardONNXTracedModule.forwardhs#D>.ttDKKMN    ' '0hh77  l " . 0 KK      $q':a=0 0  % %$q'=#33 3$q'> !r/)rHrIrJrFrG)TFFF) __name__ __module__ __qualname____firstlineno__rEr$r%rt__static_attributes__ __classcell__rNs@r,r@r@Us+" :$/"U\\/"/"r/r@cJ^U4Sjm[R"STSS9"U5$)Nc~>Ucg[U[R5(a}UR5R UR (aSO[R S9RUR5nURbT"UR5Ul U$UR [R S9$)NrT) r#r$r%r:rV is_mkldnnrWrequires_grad_ requires_gradgrad)ar* clone_inputs r,r"_clone_inputs..clone_inputs 9 5<< ( ( Q[[Te>S>ST0  vv!$QVV,H77)>)>7? ?r/c6[U[R5$rC)r#r$r%rYs r,_clone_inputs..s*Q -r/tensors) condition_msg)r _nested_map)rPrs @r, _clone_inputsrs-@   -{)    r/PYTORCH_JIT_TIMEPYTORCH_JIT_DISABLEPYTORCH_JIT_STATSc #v# [(dU(a#[RR5(dSv g[RR 5n[RR SS9n[RR SS9nUR U5 Sv UR U5 UR5 [USUSURU5S35 g!UR U5 UR5 [USUSURU5S35 f=f7f)NT) enable_timing z time: z ms) _JIT_TIMEr$cuda is_availablecurrent_streamEvent record_event synchronizeprint elapsed_time) trace_namenametimestreamstartends r,_timers Id5::+B+B+D+D  ZZ & & (F JJ  4  0E **    .C I C    AdV75+=+=c+B*C3GH C    AdV75+=+=c+B*C3GHs B$D9'C0+AD90AD66D9cN^^^ [T[RR5(d [ S5e[T[ 5m [U[ 5(dU4nT (a$[R"TR55nS U UU4Sjjn[RRUSS9 U"USS9upgTR"U6(deSSS5 T (aTRW5 U"USS9up[WU5 [WU 5 g!,(df  NH=f) a Verify that a JIT compiled model has the same behavior as its uncompiled version along with its backwards pass. If your model returns multiple outputs, you must also specify a `loss_fn` to produce a loss for which the backwards will be computed. This function has side-effects (e.g., it executes your model / saves and loads parameters), so don't expect the model to come out exactly the same as what you passed in. Args: model (compiled torch.nn.Module or function): the module/function to be verified. The module/function definition MUST have been decorated with `@torch.jit.compile`. args (tuple or Tensor): the positional arguments to pass to the compiled function/module to be verified. A non-tuple is assumed to be a single positional argument to be passed to the model. loss_fn (function, optional): the loss function to be applied to the output of the model, before backwards is invoked. By default, we assume that a model returns a single result, and we :func:`torch.sum` before calling backwards; if this is inappropriate, you can pass your own loss function. Note that if a model returns a tuple of results, these are passed as separate positional arguments to `loss_fn`. devices (iterable of device IDs, optional): the GPU devices which the compiled module will be run on. This determines the RNG state we must save when running both compiled and uncompiled versions of the model. zICannot verify an uncompiled module. Add @torch.jit.compile to compile itc>T(a[TR55O/n[X45upETnU(aUR5 U(a URnT"U6nU(aURW:Xa [ S5e[ U[5(dU4nT[R:Xa'[U5S:wa[S[U5S35e[U5upU V s/sH-oR5R[RS9PM/ n n T"U6n [RR!U /U5n U V s/sH-oR5R[RS9PM/ nn X4$s sn fs sn f)Nz#failed to use the compiled functionrzModel returns zO outputs, but default loss function (torch.sum) can only handle a single outputrT)rm parametersra clear_cachehitsrr#r`r$sumr] ValueErrorr:rVrWautogradr)rP force_traceassert_compiledparamsrgre compiled_fnroutrdr* saved_outslossgrads saved_grads is_moduleloss_fnmodels r, run_fwd_bwdverify..run_fwd_bwdsl-6e&&()Btn-    # # % ##DTl {//47DE E#u%%&C eii CHM S +>> sm KS KSaHHJ  5+@+@  A8  }##TFG4LQ KPaHHJ  5+@+@  A5  ((  s )4F 4Fztorch.jit.verify)_callerT)rN)r)FF)r#r$roCompiledFunction TypeErrorrr`copydeepcopyr5randomfork_rng has_trace_forload_state_dict _verify_equal) rrPrdevices saved_stateruncompiled_outsuncompiled_grads compiled_outscompiled_gradsrs ` ` @r,verifyrsF eUXX66 7 7 W  5&)I dE " "wmmE$4$4$67 ))>   w0B  C,7$,O)""D))) D k*$/d$K!M/=1"N3 D Cs 3 D D$c[X5HAup#URU5R5R5S:dM8[ S5e g)Ngư>z!JIT and real computation mismatch)zipsubabsmaxr)xsysrYys r,rr!s=B  558<<>   $ &BC Cr/crSRUR5Vs/sHnSU-PM sn5$s snf)N  )join splitlines)slines r,indentr's- 99alln=nddTkn= >>=s4c,^\rSrSrSU4SjjrSrU=r$)TracingCheckErrori+c`>SUlUbU=RUS-- slUb6U=RS- slU=R[U5S-- slUb6U=RS- slU=R[U5S-- sl[TU] UR5 g)NzTracing failed sanity checks! rz+ERROR: Graphs differed across invocations! zERROR: Tensor-valued Constant nodes differed in value across invocations. This often indicates that the tracer has encountered untraceable code. )messagerrDrE)rgraph_diff_errortensor_compare_error extra_msgrNs r,rETracingCheckError.__init__,s8  LLI, ,L  ' LLJ JL LLF#34t; ;L  + LL3 L LLF#784? ?L &r/)rrC)rvrwrxryrErzr{r|s@r,rr+s ''r/rc  ^^^^^^^^UGHn [U [R5(aU 4n U(a0n U R5Hup[ U 5X'M [R R [USU5U SUUU[RR5TSS9 n U RRTR5mU TRn [U [R5(d[U [5(a T(dU 4n ObT(a-[R RUSUUU[ U 5SS9n O,[R RU[ U 5SUUUSS9n U mUU4SjmSmUUU4SjnS/mUU4S jmUU4S jnU"TU S 5nU"XS 5nU"UUS 5(aU"TU S 5nU"UUS 5 T"5n[SU55(dGM[!U6e g)N__self__F) check_tracerGrH _module_class_compilation_unitexample_inputs_is_kwarg _store_inputs)rrGrHrexample_kwarg_inputsr)rrGrHrrc T>[RRTR5n[RR U5 [RR U5 [ U5n[R"SSU5n[RRTR5n[RR U5 [RR U5 [ U5n[R"SSU5nSnX:wGa`SSK nURURS5URS55nS[SRU55-S-n[UR5UR55Hupx[ U5[ U5:wdMUS- nUR[ U5RS5[ U5RS55n S[SRU 55-S-n UR!5n U (aU S [U 5-S-- n UR!5n U (aU S [U 5-S-- n XJ- n O Sn [UR5UR55HupxUR#5UR#5:wa XM4$UR#5S :XdMAUR%5(aMXUR%5(aMoUR'S 5(dMUR)S 5S :wdUR)S 5S :waMUR+S 5nUR+S 5n[R,R/XSS9 M XM4$![0[24atnU cSn U S[[ U55-S-- n UR!5nU(aU S[U5-S-- n U S[[ U55-- n SnA XM4$SnAff=f)Nz___torch_mangle_[0-9]+\.rrTz Graph diff: rzFirst diverging operator: z Node diff: zTrace source location: zCheck source location: zprim::Constantvaluet) equal_nanzNode: zSource Location: zComparison exception: )r$ro_jit_pass_canonicalizerr_jit_pass_inline!_jit_pass_erase_shape_informationstrrerdifflibndiffrrrrnodes sourceRangekind mustBeNone hasAttributekindOfrtesting assert_closerAssertionError)mod_canonicalizedmod_strcheck_canonicalized check_strgraph_diff_errorsr graph_diffn_modn_check node_diffsource_printout mod_stack check_stacktensor_compare_errorsmod_tensor_valcheck_tensor_vale compare_stackcheck_mod_func traced_funcs r,graph_diagnostic_info+_check_trace..graph_diagnostic_info}s % ? ? @Q@Q R  HH % %&7 8 HH 6 67H I+,Gff8"gFG"'(("A"A.BVBV"W  HH % %&9 : HH 6 67J K/0I:B JI $ #$]]&&t,i.B.B4.H %4fRWWZ=P6Q$QTX$X!&)%++-/B/H/H/J'NE5zS\1)-JJ)$+MMJ11$7W9P9PQU9V% +VBGGI4F-GG$N(%*$5$5$7 $+ :VI=N NQU UO'.&9&9&; &+ :VK=P PSW WO*<)/'2%) !"%!'')+>+D+D+F#::<7<<>1@%; ;=::<#33$$&&'*<*<*>*> --g66 ||G,3w~~g7NRU7U %*WWW%5N'.yy'9$ 22*3%#H%; ;).9 08461-VCJ=O1ORV1VV-(-(9(9(; (1 4vm7L Lt S1.1IFFM2-$; ; s>N##P'3A'P""P'c6[U[5(aU$U4$rC)r#r`rs r, wrap_retval!_check_trace..wrap_retvals"1e,,1 61$ 6r/c z>[U[5(aT (aT "U"S0UD65nOT "U"[U565nUVs/sH&n[U[R5(dM$UPM( nnU$s snf![ a4nT "5upgSUS[ [U553n[UUUS9UeSnAff=f)Nz+encountered an exception while running the z with test inputs. Exception: )rr0) r#dictrr$r% Exceptionrrr) modinputs running_whatrirrrr msgrrrs r,!run_mod_and_filter_tensor_outputs7_check_trace..run_mod_and_filter_tensor_outputss fd++0G&s}V}5D&sM&,A'BCD'+Mtz#u||/LtM N ;P;R8!CL>Qqrxy|}~ysArBC'%)!  s0AA<#A7-A73A<7A<< B:/B55B:c >TS(agSTS'TRR5Vs/sHoR5(dMUPM nn[U5S:aaSnUS- nUSR UVs/sHn[ [ U55PM snSS5- nUS- n[R"U[SS 9 ggs snfs snf) NrTz"Trace had nondeterministic nodes. z2Did you forget call .eval() on your model? Nodes: rzp This may cause errors in trace checking. To disable trace checking, pass check_trace=False to torch.jit.trace()category stacklevel) rrrisNondeterministicr]rrrwarningswarn TracerWarning)op nondeterm_opsnondeterministic_ops_warning has_warnedrs r,maybe_warn_nondeterministic1_check_trace..maybe_warn_nondeterministics!} JqM(..4466r:O:O:Q6 =!A%/S,,I,- /<=}VCG_}=crB1,-C, 0=UV&>sC C8C c .>Sn[[X55GHunupVUR(aUR5nUR(aUR5nUR(aUR 5nUR(aUR 5nUR 5(dUR 5(aj[RRUR[R5UR[R5T [XV5SSS9 GM"UR(dUR(aL[RRUR5UR5T [XV5SSS9 GM[USS5(d[USS5(a[USS5[USS5:Xde[UR!5UR!55HNupx[RRUR#5UR#5T [Xx5SSS9 MP GMO[RRUR#5UR#5T [XV5SSS9 GM U$![$aSn T "5 [&R("S[+US-5-S-U-S-[+U 5-[,SS 9 S nSn A GMSn A ff=f) NTr)rtolatolr is_nestedz Output nr zH. of the traced function does not match the corresponding output of the z. Detailed error: r#F) enumerater is_quantized dequantizerto_dense is_complexr$rrtocdoubleris_mpsfloatgetattrunbinddoublerr'r(rr)) original reference match_whatall_okr(origreft_origt_refrcheck_tolerancer.s r,compare_outputs%_check_trace..compare_outputssF"+C,D"E;D=#((#0''!nn.~~#}}}}!lln~~''4??+<+< 22 GGEMM2FF5==1!0!3D!>q!A&* 3 ;;#**!MM66 $ # %4%7%B1%E*. 7%T;==dBB$+4d#Cw #[$H$$25T[[]CJJL1Q  % : :$*MMO$)LLN)8);F)J1)M.2 !;!"2R"MM66 $ # %4%7%B1%E*. 7U#F@M& #/1MM$a!e*%;;% % 0 0 a& !"/#$ #F #s.DJ7:A+J7(B.Ms6ID4Is)r#r$r%r"rjit trace_moduler>roCompilationUnit_c _get_methodrrrLanyr) check_inputsfuncrrIrGrKis_trace_modulerrr copied_dictrdata check_modrrJ traced_outsfn_outs check_outs diag_inforrr-r.rs `` ` @@@@@r, _check_tracer`>s fell + +YF K$lln $1$$7 !- ..j$/! .+"'((":":"<(?#/ I'\\55k6F6FGNK,,-F6ELL22fd++/ &!IIOO %!$2"/)6v)>"', "IIOO!&) %!$2"/"', 'NT UcgUVs/sHnSU0PM sn$s snf)Nrtr0)rVcs r,wrap_check_inputsrzxs'$0 1LqYNL 11 1scFSSKJs Jn URU5nURU5n[ X45HupVUR UR :wa gUR [ R:Xa g[U5[U5:wa g[U[ RR5(a g[U[ R5(a;URUR:wa g[ R"XV5(d gMXV:wdM g g)NrFT)torch.utils._pytreeutils_pytree tree_leavesrlayoutr$_mkldnnr6r# _subclasses FakeTensorr%dtypeallclose)exportrLpytree flat_export flat_tracerEloadeds r,$analyze_ts_result_with_export_resultrs(($$V,K##E*JK4  ;;&-- ' ;;%-- ' :f % dE--88 9 9 ell + +zzV\\)>>$//0~'5( r/gh㈵>c [U[RR5(a[R "S5 U$[U[R R5(aRUc#[U [5(aU nO [S5e[USU0SU[U5UUUU[U [5U S9 $[US5(a[UR[R R5(alURS:Xa\Uc#[U [5(aU nO [S5e[URSU0SU[U5UUUU[U [5U S9 $[U[R[45(aU cU4nO#U c [U[ 5(d [!U5n[#S5n [US5(a>[UR[R R5(a [%S5e['U5n [U [5(a1U n[R(R+U UU U UU[-U55nO.[R(R/U UUU UU[-U55nU(aCUb [1UUUUUUSU[U [5S 9 O [1U/UUUUUSU[U [5S 9 XlU$) Nz`The input to trace is already a ScriptModule, tracing it is a no-op. Returning the object as is.z%example_kwarg_inputs should be a dictrt)rrrrzVtrace doesn't support compiling individual module's functions. Please use trace_moduleFr)r#r$rPrr'r(nnrrrrQrzhasattrrrvr%r`r1AttributeErrorr ro%_create_function_from_trace_with_dictr _create_function_from_tracer`_torchdynamo_inline)rWrioptimizerrVrIrGrHrrrr var_lookup_fnrtraceds r, _trace_implrs$ ..//  n  $((  !.55!5"#JKK   '   l +    $./CT$J'   j!! t}}ehhoo 6 6 MMY &  !.55!5"#JKK MM  '   l +    $./CT$J'  >ELL$#788 ((*  %j.O.O~.6q9MtZ  Z uxx%O%O &  4 D&---??      ' - 55       ' -   # (23G(N   (23G(N "& Mr/c.\rSrSrSrSrSrS\4SjrSr g) _ExportTypei& DIRECT_EXPORTTRACE_AND_EXPORTSOURCE_TO_SOURCEreturncUR$rCrrs r,__str___ExportType.__str__+ zzr/r0N) rvrwrxryrrrrrrzr0r/r,rr&s#M))r/rc2\rSrSrSrSrSrSrS\4Sjr Sr g ) _ExportOutcomei/SUCCESSFAILED_TO_EXPORT FAILED_TO_RUNACCURACY_ERRORrcUR$rCrrs r,r_ExportOutcome.__str__5rr/r0N) rvrwrxryrrrrrrrzr0r/r,rr/s#G)#M%Nr/rc 6^^[(dU$Ub[R"S[SS9 SSKJn JmJn [UUUUUUUUUU U U 5 nU "S[U5S9 U "5(aSSK J m SS K J nJn [UUUS UUUUUU U U S 9 nU"X5unnU4S jnS nU4Sjn[U[ R"R$5(dU"UUU[&R(5 U"UUU[&R*5 U"UUU[&R,5 U$)a Trace a function and return an executable or :class:`ScriptFunction` that will be optimized using just-in-time compilation. Tracing is ideal for code that operates only on ``Tensor``\\s and lists, dictionaries, and tuples of ``Tensor``\\s. Using `torch.jit.trace` and `torch.jit.trace_module`, you can turn an existing module or Python function into a TorchScript :class:`ScriptFunction` or :class:`ScriptModule`. You must provide example inputs, and we run the function, recording the operations performed on all the tensors. * The resulting recording of a standalone function produces `ScriptFunction`. * The resulting recording of `nn.Module.forward` or `nn.Module` produces `ScriptModule`. This module also contains any parameters that the original module had as well. Warning: Tracing only correctly records functions and modules which are not data dependent (e.g., do not have conditionals on data in tensors) and do not have any untracked external dependencies (e.g., perform input/output or access global variables). Tracing only records operations done when the given function is run on the given tensors. Therefore, the returned `ScriptModule` will always run the same traced graph on any input. This has some important implications when your module is expected to run different sets of operations, depending on the input and/or the module state. For example, * Tracing will not record any control-flow like if-statements or loops. When this control-flow is constant across your module, this is fine and it often inlines the control-flow decisions. But sometimes the control-flow is actually part of the model itself. For instance, a recurrent network is a loop over the (possibly dynamic) length of an input sequence. * In the returned :class:`ScriptModule`, operations that have different behaviors in ``training`` and ``eval`` modes will always behave as if it is in the mode it was in during tracing, no matter which mode the `ScriptModule` is in. In cases like these, tracing would not be appropriate and :func:`scripting ` is a better choice. If you trace such models, you may silently get incorrect results on subsequent invocations of the model. The tracer will try to emit warnings when doing something that may cause an incorrect trace to be produced. Args: func (callable or torch.nn.Module): A Python function or `torch.nn.Module` that will be run with `example_inputs`. `func` arguments and return values must be tensors or (possibly nested) tuples that contain tensors. When a module is passed `torch.jit.trace`, only the ``forward`` method is run and traced (see :func:`torch.jit.trace ` for details). Keyword arguments: example_inputs (tuple or torch.Tensor or None, optional): A tuple of example inputs that will be passed to the function while tracing. Default: ``None``. Either this argument or ``example_kwarg_inputs`` should be specified. The resulting trace can be run with inputs of different types and shapes assuming the traced operations support those types and shapes. `example_inputs` may also be a single Tensor in which case it is automatically wrapped in a tuple. When the value is None, ``example_kwarg_inputs`` should be specified. check_trace (``bool``, optional): Check if the same inputs run through traced code produce the same outputs. Default: ``True``. You might want to disable this if, for example, your network contains non- deterministic ops or if you are sure that the network is correct despite a checker failure. check_inputs (list of tuples, optional): A list of tuples of input arguments that should be used to check the trace against what is expected. Each tuple is equivalent to a set of input arguments that would be specified in ``example_inputs``. For best results, pass in a set of checking inputs representative of the space of shapes and types of inputs you expect the network to see. If not specified, the original ``example_inputs`` are used for checking check_tolerance (float, optional): Floating-point comparison tolerance to use in the checker procedure. This can be used to relax the checker strictness in the event that results diverge numerically for a known reason, such as operator fusion. strict (``bool``, optional): run the tracer in a strict mode or not (default: ``True``). Only turn this off when you want the tracer to record your mutable container types (currently ``list``/``dict``) and you are sure that the container you are using in your problem is a ``constant`` structure and does not get used as control flow (if, for) conditions. example_kwarg_inputs (dict, optional): This parameter is a pack of keyword arguments of example inputs that will be passed to the function while tracing. Default: ``None``. Either this argument or ``example_inputs`` should be specified. The dict will be unpacking by the arguments name of the traced function. If the keys of the dict don't not match with the traced function's arguments name, a runtime exception will be raised. Returns: If `func` is `nn.Module` or ``forward`` of `nn.Module`, `trace` returns a :class:`ScriptModule` object with a single ``forward`` method containing the traced code. The returned `ScriptModule` will have the same set of sub-modules and parameters as the original ``nn.Module``. If ``func`` is a standalone function, ``trace`` returns `ScriptFunction`. Example (tracing a function): .. testcode:: import torch def foo(x, y): return 2 * x + y # Run `foo` with the provided inputs and record the tensor operations traced_foo = torch.jit.trace(foo, (torch.rand(3), torch.rand(3))) # `traced_foo` can now be run with the TorchScript interpreter or saved # and loaded in a Python-free environment Example (tracing an existing module):: import torch import torch.nn as nn class Net(nn.Module): def __init__(self) -> None: super().__init__() self.conv = nn.Conv2d(1, 1, 3) def forward(self, x): return self.conv(x) n = Net() example_weight = torch.rand(1, 1, 3, 3) example_forward_input = torch.rand(1, 1, 3, 3) # Trace a specific method and construct `ScriptModule` with # a single `forward` method module = torch.jit.trace(n.forward, example_forward_input) # Trace a module (implicitly traces `forward`) and construct a # `ScriptModule` with a single `forward` method module = torch.jit.trace(n, example_forward_input) ^`optimize` is deprecated and has no effect. Use `with torch.jit.optimized_execution()` insteadr%r)check_if_torch_exportable!log_torch_jit_trace_exportabilitylog_torchscript_usagerL)model_id)TS2EPConverter)"_convert_ts_to_export_experimental$_process_jit_trace_inputs_for_exportF) rirrrVrIrGrHrrrrc >U"U6nU"X5nU"U6n[ X5(d,T "S[U5[[R5S5 gT "S[U5[[R5S5 g![a7nUnT "S[U5[[R5S5 SnAgSnAff=f![a>nT "S[U5[[R5[U55 SnAgSnAff=f![a>nT "S[U5[[R 5[U55 SnAgSnAff=f)NrL succeededzaccuracy error)rrrrrrrr) func_to_export export_func export_args export_type traced_resultrre ep_modulerrs r,_log_exportability!trace.._log_exportabilitysA  . <  'D  "K08NN1 $556$   -[)3~/E/E+F  G 1S-s>3I3I/JK   1 $778F    1S-s>3O3O/PRUVWRX  sEA?CD? C -B;;C D  4DD  E4EEcZ[RRXSS9R5$)NF)rG)r$rr;)rWrs r,_direct_export_and_lower'trace.._direct_export_and_lower>s%<<&&t&GNNP Pr/cL>T"X5R5R5$rC)convertr;)rWrrs r,&_convert_ts_to_export_source_to_source5trace.._convert_ts_to_export_source_to_sourceAs !$4<<>EEG Gr/)rr'r( FutureWarningtorch._utils_internalrrrrr torch._export.converterrtorch.export._tracerrr#r$rPrrrrr)rWrirrrVrIrGrHrrrrrrrrrtraced_func_for_exportrrerrrrrs @@r,rLrL9sTB 8   A      K'M+,FG "": "- )%++'/!5' " >   Q( T Q H0%))2H2HII &())    " .   ( (   " 2   ( (   r/_trace_module_mapc ^^[(dU$Ub[R"S[SS9 [ S5n [ U[ RR5(d [S5e[ U[5(d [S5e[ RRRn 0mUU4SjmUTS'T[ RRl T"US5 [XU 5nUR5GH-unnUS :XaUn[!X5n[#U5nO[!X5n[#U5n[ U[5(aaU (aZUH1nUU;dM S S R%U5-S -n['S USU35e UR(R+UUUU UUUU 5 O-[-U5nUR(R/UUUU UUUU 5 UR(R1U5nU(dGMUb[3UUUUUUSUU S9 GM/UUUUUSUU S9 GM0 U [ RRl U$!U [ RRl f=f)a Trace a module and return an executable :class:`ScriptModule` that will be optimized using just-in-time compilation. When a module is passed to :func:`torch.jit.trace `, only the ``forward`` method is run and traced. With ``trace_module``, you can specify a dictionary of method names to example inputs to trace (see the ``inputs``) argument below. See :func:`torch.jit.trace ` for more information on tracing. Args: mod (torch.nn.Module): A ``torch.nn.Module`` containing methods whose names are specified in ``inputs``. The given methods will be compiled as a part of a single `ScriptModule`. inputs (dict): A dict containing sample inputs indexed by method names in ``mod``. The inputs will be passed to methods whose names correspond to inputs' keys while tracing. ``{ 'forward' : example_forward_input, 'method2': example_method2_input}`` Keyword arguments: check_trace (``bool``, optional): Check if the same inputs run through traced code produce the same outputs. Default: ``True``. You might want to disable this if, for example, your network contains non- deterministic ops or if you are sure that the network is correct despite a checker failure. check_inputs (list of dicts, optional): A list of dicts of input arguments that should be used to check the trace against what is expected. Each tuple is equivalent to a set of input arguments that would be specified in ``inputs``. For best results, pass in a set of checking inputs representative of the space of shapes and types of inputs you expect the network to see. If not specified, the original ``inputs`` are used for checking check_tolerance (float, optional): Floating-point comparison tolerance to use in the checker procedure. This can be used to relax the checker strictness in the event that results diverge numerically for a known reason, such as operator fusion. example_inputs_is_kwarg (``bool``, optional): This parameter indicate whether the example inputs is a pack pack of keyword arguments. Default: ``False``. Returns: A :class:`ScriptModule` object with a single ``forward`` method containing the traced code. When ``func`` is a ``torch.nn.Module``, the returned :class:`ScriptModule` will have the same set of sub-modules and parameters as ``func``. Example (tracing a module with multiple methods):: import torch import torch.nn as nn class Net(nn.Module): def __init__(self) -> None: super().__init__() self.conv = nn.Conv2d(1, 1, 3) def forward(self, x): return self.conv(x) def weighted_kernel_sum(self, weight): return weight * self.conv.weight n = Net() example_weight = torch.rand(1, 1, 3, 3) example_forward_input = torch.rand(1, 1, 3, 3) # Trace a specific method and construct `ScriptModule` with # a single `forward` method module = torch.jit.trace(n.forward, example_forward_input) # Trace a module (implicitly traces `forward`) and construct a # `ScriptModule` with a single `forward` method module = torch.jit.trace(n, example_forward_input) # Trace specific methods on a module (specified in `inputs`), constructs # a `ScriptModule` with `forward` and `weighted_kernel_sum` methods inputs = {"forward": example_forward_input, "weighted_kernel_sum": example_weight} module = torch.jit.trace_module(n, inputs) rrrrz.expected torch.nn.Module as the first argumentz3expected a dictionary of (method_name, input) pairscb>UR5Hup#US-U-nUTU'T"X45 M g)N.)named_children)rprefixrchildsubmod_qualnameregister_submodstrace_module_maps r,r&trace_module..register_submodss9"113 "(3,"5*9 ' 8 4r/__modulert[,]'z\' is not in forward() method's arguments, valid arguments name are Tr)rr'r(rr1r#r$rrrrrP_tracerrwr"r>r r NameErrorrS#_create_method_from_trace_with_dictrj_create_method_from_tracerTr`)rrrrrVrIrGrHrrrrrold_module_mapr; method_namerirWforward_methodargument_nameskeyvalid_argumentscheck_trace_methodrrs @@r,rQrQ`s|x 8   A   7q9M c588?? + +MNN fd # #RSSYY%%77NX<+- 9 (+$-= *j)S1BC+1<<> 'Ki'!(!:!<^!Ls0!^[T U]5 [U[RR 5(de[ 5m"SS[RR 5n[RR[U55Ul U"5nU4SjnURUl URR5H upxUcM XRU'U"U5 M" URR5H upyU cM XRU'U"U 5 M" URR5HYupz[R R#U 5(dM+XqR;dM<XqR;dMM[%XWU 5 M[ UR&(a[)S[+U5-5eUR,R5H&up{U cM [/U [0SS9UR,U'M( [R2R4R7USSSS 9n [U5R8URS 'XRS 'S Hn[;X5 M g) Nc\rSrSrSrg).TracedModule.__init__..QualnameWrapperiGr0N)rvrwrxryrzr0r/r,QualnameWrapperrGs r/rcJ>UT;a [S5eTRU5 g)Nz=TracedModules don't support parameter sharing between modules)rr9)paramid_sets r, check_unique+TracedModule.__init__..check_uniquePs( S JJu r/z=Modules that have backward hooks assigned can't be compiled: rocg)Nr0r0)r;s r,r'TracedModule.__init__..wsrr/FTrl_name_actual_script_module) _parameters_buffers_modulestraining)rDrEr#r$rrr7rpr r6_jit_override_qualnamerrr"r__dict__ro_jit_is_script_objectsetattr_backward_hooksrrrrwrrPrrrtrvdelattr)rrErrr tmp_modulerrrbufval submodule script_modulerNs ` r,rETracedModule.__init__:s $0000  ehhoo 271D1D1T1T J2 .%&  #mm ++113KD /4&&t,U#4,,.ID,/##D)S!/,,.ID..s33 0 00 - #. /   Od)  $}}224OD (3<4)J   % 5 ,,AA )uB "&d!4!4 g1> -.GD D Hr/c[S5e)Nz"Trace submodules cannot be called.)r)rrPkwargss r,rtTracedModule.forwards?@@r/cn>SUR;a[TU] U5$[URU5$Nr)rrD __getattr__r>r)rattrrNs r,rTracedModule.__getattr__s2 "$-- 77&t, ,t11488r/cp>SUR;a[TU] X5$[URX5 gr )rrD __setattr__rr)rrrrNs r,rTracedModule.__setattr__s/ "$-- 77&t3 3**D8r/cUR$rCrrs r, _get_nameTracedModule._get_namerr/c SUR3$)Nzoriginal_name=rrs r, extra_reprTracedModule.extra_reprs |,,r/r0)NN) rvrwrxry_disable_script_metarErtrrrrrzr{r|s@r,rr7s/C JA9 9 --r/rc>\rSrSr%\"5r\S\4\S'Sr Sr g)rui.rtc@URSRU5 g)z Re-construct an instance of TopLevelTracedModule using an instance of a C++ module. Args: cpp_module: The C++ module that this TopLevelTracedModule will be rebuilt around. rN)r _reconstruct)r cpp_modules r,r!TopLevelTracedModule._reconstructs -.;;JGr/r0N) rvrwrxryrrtrr__annotations__rrzr0r/r,rurus"0"2GXc3h 2Hr/rufnrc^^[R"T5S[RS[RS[ 4UU4Sjj5mTTlSTlT$)NrPr rcl>[5(dT"U0UD6$[TR5nU"U0UD6$rC)rnr __original_fn)rPr rr"rks r,rk#_script_if_tracing..wrappers:||t&v& &&,W-B-B&C D+F++r/T) functoolswrapsrrPr rr%__script_if_tracing_wrapper)r"rks`@r,_script_if_tracingr*sR__R,qvv,,a,,G*.G' Nr/cfUc0n[U[5(dU4n[XXEU5"U0UD6nU$)aaReturn a tuple on tracing a function or model. .. warning:: This function is internal-only and should only be used by the ONNX exporter. If you are trying to get a graph through tracing, please go through the public API instead:: trace = torch.jit.trace(nn.LSTMCell(), (input, hidden)) trace_graph = trace.graph Trace a function or model, returning a tuple consisting of the both the *trace* of an execution, as well as the original return value. If return_inputs, also returns the trace inputs as part of the tuple Tracing is guaranteed not to change the semantics of the function/module that is traced. Args: f (torch.nn.Module or function): the function or module to be traced. args (tuple or Tensor): the positional arguments to pass to the function/module to be traced. A non-tuple is assumed to be a single positional argument to be passed to the model. kwargs (dict): the keyword arguments to pass to the function/module to be traced. Example (trace a cell): .. testcode:: trace = torch.jit.trace(nn.LSTMCell(), (input, hidden)) )r#r`r@)frPr rGrHrLrJris r,_get_trace_graphr-sLR~ dE " "w  ?3H    D Kr/)r)F)T)r0NTFFF)U__doc__ contextlibrr'rosrr'enumrtypingrrrrtyping_extensionsrr$torch._jit_internalr r r r torch.autogradr torch.jit._scriptrrrtorch.jit._staterrtorch.nnrtorch.testing._comparisonrro _jit_flattenra_jit_unflattenr_rrr1r>rr@renvirongetr _JIT_DISABLE _JIT_STATScontextmanagerrrrrrrrno_gradr`Warningr)re_tracer_warn_use_pythonrjrwrzrrrrrrLrrr!rQrnrrur*r-r0r/r,rDs  33'  $BB18 88  XX $ $  C4  cN).$B"uxxB"J . JJNN-u 5 zz~~3U; ZZ^^/ 7   I I !& 4W4tD ?' '&"O0O0dEGE!!# " G2>   GT#tS$   aH /38DcN+2   !IX"Y-<Y-x H< H 8AqD> hq!tn $  0r/