+ jVa0t$^RIHt^RIt^RIHt^RIHtHtHt^RI H t H t H t ^RI t ^RI Ht]'d^RIHt^RIHt.R!Ot] !R 4t] !R 4t]!] P.R 4'g^]!R4] P.P0R&]!R4] P.P0R&]!R4] P.P0R&^RIHtHtHtRRltRRlt!RR ]4t!RR 4t ] PBPD]R]#3,,t$R]%R&]R"RRll4t&]R"RRll4t&R"RR llt&R#)#) annotationsN)Callable)overload TYPE_CHECKING TypeAlias) ParamSpecSelfTypeVar)Tensor) _POOL_HANDLE) _dummy_typeXPUGraphgraph_R_P_XpuStreamBase _XPUGraph_xpu_graph_pool_handle_xpu_isCurrentStreamCapturing)rrrcV^8dQhRR/#)returnbool)formats"Q/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/xpu/graphs.py __annotate__r(s++T+c\4#)zReturn True if XPU graph capture is underway on the current XPU stream, False otherwise. If a XPU context does not exist on the current device, returns False without initializing the context. )rrrris_current_stream_capturingr (s ) **rcV^8dQhRR/#rrr r)rs"rrr0s<<<`) that hints this graph may share memory with the indicated pool. r3N)r- capture_begin)selfr3r0s&&rr8XPUGraph.capture_beginIs 4(rcV^8dQhRR/#rrr5r)rs"rrr*VsTrc $<\SV`4R#)zEnd XPU graph capture on the current stream. After ``capture_end``, ``replay`` may be called on this instance. Typically, you shouldn't call ``capture_end`` yourself. Use :class:`~torch.xpu.graph`, which call ``capture_end`` internally. N)r- capture_endr9r0s&rr>XPUGraph.capture_endVs rcV^8dQhRR/#r<r)rs"rrr*`sTrc $<\SV`4R#)aInstantiate the XPU graph. Will be called by ``capture_end`` if ``keep_graph=False``, or by ``replay`` if ``keep_graph=True`` and ``instantiate`` has not already been explicitly called. Does not destroy the xpu modify command graph returned by ``raw_xpu_graph``. N)r- instantiater?s&rrCXPUGraph.instantiate`s rcV^8dQhRR/#r<r)rs"rrr*isrc $<\SV`4R#)z+Replay the XPU work captured by this graph.N)r-replayr?s&rrGXPUGraph.replayis  rcV^8dQhRR/#r<r)rs"rrr*mstrc $<\SV`4R#)z1Delete the graph currently held by this instance.N)r-resetr?s&rrKXPUGraph.resetms   rcV^8dQhRR/#r"r)rs"rrr*qslrc <\SV`4#)zReturn an opaque token representing the id of this graph's memory pool. This id can optionally be passed to another graph's ``capture_begin``, which hints the other graph may share the same memory pool. )r-r3r?s&rr3 XPUGraph.poolqs w|~rcV^8dQhRR/#r<r)rs"rrr*ys++4+rc <\SV`4#)z.Enable debugging mode for XPUGraph.debug_dump.)r-enable_debug_moder?s&rrRXPUGraph.enable_debug_modeysw(**rc V^8dQhRRRR/#)r debug_pathstrrr5r)rs"rrr*}s..S.T.rc "<\SV`V4#)z Arguments: debug_path (required): Path to dump the graph to. Calls a debugging function to dump the graph if the debugging is enabled via XPUGraph.enable_debug_mode() )r- debug_dump)r9rUr0s&&rrXXPUGraph.debug_dump}sw!*--rcV^8dQhRR/#rrintr)rs"rrr*s''s'rc <\SV`4#)zuReturns the underlying xpuGraph_t. ``keep_graph`` must be True. XPU doesn't provide APIs to manipulate this object. )r- raw_xpu_graphr?s&rr^XPUGraph.raw_xpu_graphs w$&&rcV^8dQhRR/#r[r)rs"rrr*s,,C,rc <\SV`4#)aReturns the underlying xpuGraphExec_t. ``instantiate`` must have been called if ``keep_graph`` is True, or ``capture_end`` must have been called if ``keep_graph`` is False. If you call ``instantiate()`` after ``raw_xpu_graph_exec()``, the previously returned xpuGraphExec_t will be destroyed. It is your responsibility not to use this object after destruction. XPU doesn't provide APIs to manipulate this object. )r-raw_xpu_graph_execr?s&rrbXPUGraph.raw_xpu_graph_execs w)++rr)Fr,)__name__ __module__ __qualname____firstlineno____doc__r.r8r>rCrGrKr3rRrXr^rb__static_attributes__ __classcell__)r0s@rrr5sv 00 ) )++..'',,rcR]tRt^t$RtRtR]R&R RRlltRRltR R lt R t R#) ra^Context-manager that captures XPU work into a :class:`torch.xpu.XPUGraph` object for later replay. Arguments: xpu_graph (torch.xpu.XPUGraph): Graph object used for capture. pool (optional): Opaque token (returned by a call to :func:`~torch.xpu.graph_pool_handle()` or :meth:`other_Graph_instance.pool()`) hinting this graph's capture may share memory from the specified pool. stream (torch.xpu.Stream, optional): If supplied, will be set as the current stream in the context. If not supplied, ``graph`` sets its own internal side stream as the current stream in the context. .. note:: For effective memory sharing, if you pass a ``pool`` used by a previous capture and the previous capture used an explicit ``stream`` argument, you should pass the same ``stream`` argument to this capture. Ntorch.xpu.Stream | Nonedefault_capture_streamc$V^8dQhRRRRRR/#)r xpu_graphrr3r4streamrlr)rs"rrgraph.__annotate__s(###"#( #rc NVPPf.\PP 4VPnVfRMV3VnVeTMVPPVnVP f \R4hVP VnWn R#)Nzcapture_stream must not be Noner) r0rmr$r%Streamr3capture_streamAssertionError stream_ctxro)r9ror3rps&&&&r__init__graph.__init__s >> 0 0 849II4D4D4FDNN 1;?rv__exit__)r9rs&*rrgraph.__exit__s$ ""$   $'r)rtr3rvro)NN) rdrerfrgrhrm__annotations__rwr}rrirrrrrs) 7;3:#*1((r.r_ModuleOrCallablec 0V^8dQhRRRRRRRRR R R R/#) r callablesr sample_argstuple[Tensor, ...]num_warmup_itersr\allow_unused_inputrr3r4rr)rs"rrrsD #     rcR#r,rrrrrr3s&&&&&rmake_graphed_callablesrsrc 0V^8dQhRRRRRRRRR R R R/#) rrztuple[_ModuleOrCallable, ...]rztuple[tuple[Tensor, ...], ...]rr\rrr3r4rr)rs"rrrsD((,(/(( (  ( # (rcR#r,rrs&&&&&rrrs%(rc 0V^8dQhRRRRRRRRR R R R/#) rrz1_ModuleOrCallable | tuple[_ModuleOrCallable, ...]rz3tuple[Tensor, ...] | tuple[tuple[Tensor, ...], ...]rr\rrr3r4rr)rs"rrrsLnn@nDnn n  n 7 nrc \P!R4'd'\P!4'd \R4hRp\ V\ 4'g0RpV3p\ P!\ \R3,V43pM5\ P!\ \ \R3,R3,V4p.p\W4EFqwr\ V\PP4'd\VP4^8Xd5\VP4^8Xd\VP4^8Xg \R4h\ ;QJd*RVP#44F 'dK RM RM!RVP#444'g \R4h\P$P&P(!V !p VP+\ V 44\ ;QJdRV 4F 'dK RM RM !RV 44'dEKi\-R4h VU u.uFp \V 4NK p p VUu.uFHp\ V\PP4'd\ VP/44MRNKJ p p\1\V44U u.uFp W},W,,NK pp \1\V44Uu.uF!p\P2P54NK# pp\1\V44Uu.uF!p\P2P54NK# ppVf \74MTp\P2P94\P2P;\P2P=44;_uu_4\WV4EFwpp pRRRppp\1V4Fp\P$P&P?V!V !4p\ ;QJd.R V4FNK 5M !R V44p\V4^8gKn\P@PCT\ ;QJd.R V4FNK 5M !R V44\ ;QJd.R V4FNK 5M !R V44RVR 7pK VVV3Fp?K EK RRR4\P2P94.p.p\WV4Fwpp p\P2PEVVR 7;_uu_4V!V !pRRR4\P$P&PGX4wppVP+\ V44VP+V4K .p.p \\IV4\IV4\IV44EFwpp!p"\ ;QJd.RV!4FNK 5M !RV!44p#\ ;QJd.RV!4FNK 5M !RV!44pRp\V4^8d\P2PEV"VR 7;_uu_4\P@PCT\ ;QJd.RV4FNK 5M !RV44\ ;QJd.RV#4FNK 5M !RV#44RVR 7pRRR4.p$^p%VFMp&V&PJ'd(Ve$V$P+VV%,4V%^, p%K<V$P+R4KO \ V$4p$VP+V#4V P+V$4EK VPM4V PM4RRlp'.p(\OV4Fwp pV'!VV ,VV ,W,W,VV ,W,VV ,VV ,V V ,4 p)\ V\PP4'd>RRlp*V*!VVPPV)VPR4Vn)V(P+V4KV(P+V)4K V'd V(^,#\ V(4#uup iuupiuup iuupiuupi +'giEL;i +'giEL;i +'giEL;i)a Accept callables (functions or :class:`nn.Module`\ s) and returns graphed versions. Each graphed callable's forward pass runs its source callable's forward XPU work as a XPU graph inside a single autograd node. The graphed callable's forward pass also appends a backward node to the autograd graph. During backward, this node runs the callable's backward work as a XPU graph. Therefore, each graphed callable should be a drop-in replacement for its source callable in an autograd-enabled training loop. See :ref:`Partial-network capture` for detailed use and constraints. If you pass a tuple of several callables, their captures will use the same memory pool. Arguments: callables (torch.nn.Module or Python function, or tuple of these): Callable or callables to graph. If you pass a tuple of callables, their order in the tuple must be the same order they'll run in the live workload. sample_args (tuple of Tensors, or tuple of tuples of Tensors): Samples args for each callable. If a single callable was passed, ``sample_args`` must be a single tuple of argument Tensors. If a tuple of callables was passed, ``sample_args`` must be tuple of tuples of argument Tensors. num_warmup_iters (int): The number of warmup iterations. Currently, ``DataDistributedParallel`` needs 11 iterations for warm up. Default: ``3``. allow_unused_input (bool): If False, specifying inputs that were not used when computing outputs (and therefore their grad is always zero) is an error. Defaults to False. pool (optional): Token (returned by :func:`~torch.xpu.graph_pool_handle` or :meth:`other_Graph_instance.pool()`) that hints this graph may share memory with the indicated pool. .. note:: The ``requires_grad`` state of each Tensor in ``sample_args`` must match the state that's expected for the corresponding real input in the training loop. .. warning:: This API is in beta and may change in future releases. .. warning:: ``sample_args`` for each callable must contain only Tensors. Other types are not allowed. .. warning:: Returned callables do not support higher order differentiation (e.g., double backward). .. warning:: In any :class:`~torch.nn.Module` passed to :func:`~make_graphed_callables`, only parameters may be trainable. Buffers must have ``requires_grad=False``. .. warning:: After you pass a :class:`torch.nn.Module` through :func:`~make_graphed_callables`, you may not add or remove any of that Module's parameters or buffers. .. warning:: :class:`torch.nn.Module`\s passed to :func:`~torch.xpu.make_graphed_callables` must not have module hooks registered on them at the time they are passed. However, registering hooks on modules *after* passing them through :func:`~torch.xpu.make_graphed_callables` is allowed. .. warning:: When running a graphed callable, you must pass its arguments in the same order and format they appeared in that callable's ``sample_args``. .. warning:: The automatic mixed precision is supported in :func:`~torch.xpu.make_graphed_callables` only with disabled caching. The context manager `torch.amp.autocast()` must have `cache_enabled=False`. r%z_make_graphed_callables does not support the autocast caching. Please set `cache_enabled=False`.FT.c3<"TFqPRJxK R#5i)FN requires_grad.0bs& r )make_graphed_callables..FsEA%/sc3V"TFp\V\P4xK! R#5ir,) isinstancer$r )rargs& rrrNsHKS:c5<<00Ks')Nc3L"TFqP'gKVxK R#5ir,rros& rrrns$K1??QQ$ $c3L"TFqP'gKVxK R#5ir,rris& rrrrs%';!AA';rc3t"TF.qP'gK\P!V4xK0 R#5ir,rr$ empty_likers& rrrus(+9@AOO/E,,Q//s88)outputsinputs grad_outputs only_inputs allow_unusedr7c3t"TF.qP'd\P!V4MRxK0 R#5ir,rrs& rrrs)$ FT???E  Q  .__annotate__sl222262 2 < 2 1 2+272/2 2rc aaaaaaaaaa !VVVVVVV3RlR\PP4o RV VV3Rllp V #)c<]tRtRt]RVVVV3Rll4t]]PPPRVVV3Rll44t Rt R#)Omake_graphed_callables..make_graphed_autograd_function..Graphedic$V^8dQhRRRRRR/#)rctxrrr rrr)rs"rr\make_graphed_callables..make_graphed_autograd_function..Graphed.__annotate__s' A AV Af A9K Arc <\S4FSpSV,P4W,P48wgK5SV,PW,4KU SP4\ S\ 4'g \ R4h\ ;QJd.RS4FNK 5#!RS44#)zstatic_outputs must be a tuplec3@"TFqP4xK R#5ir,detachrs& rrjmake_graphed_callables..make_graphed_autograd_function..Graphed.forward..s@AXXZZs)rangedata_ptrcopy_rGrtuple RuntimeError)rrrrrrrs&* rforwardWmake_graphed_callables..make_graphed_autograd_function..Graphed.forwards}-A+A.779VY=O=O=QQ,Q/55fi@.  "!.%88&'GHHu@@u@u@@@@rc$V^8dQhRRRRRR/#)rrrgradsr rrr)rs"rrrs"  f f 9K rc <\V4\S48wd$\R\S4 R\V4 24h\SV4FAwr#VfK VP4VP48wgK0VP V4KC SP 4\ S\4'g \R4h\;QJd.RS4FNK 5#!RS44#)z Expected z gradients but got z"static_grad_inputs must be a tuplec3L"TFqeVP4MTxK R#5ir,rrs& rrkmake_graphed_callables..make_graphed_autograd_function..Graphed.backward..s!@R1-AHHJQ6@Rs"$)lenrziprrrGrr)rrggradrrrs&* rbackwardXmake_graphed_callables..make_graphed_autograd_function..Graphed.backwardsu:%8!99&#C(;$<#==PQTUZQ[P\] ##6>GA}::<4==?:GGDM ?  "!"4e<<&'KLLu@Ruu@RrrN) rdrerfrg staticmethodrr$autogradfunctiononce_differentiablerri)rrrrrrrsrGraphedrsN  A A A ^^ $ $ 8 8  9 rrc V^8dQhRRRR/#)r user_argsrrr)rs"rrTmake_graphed_callables..make_graphed_autograd_function..__annotate__s R Rv R& Rrc<\PPP!V!pSP!\ V4S,!p\PPP VS4#r,)r$utils_pytreearg_tree_leavesapplyrtree_unflatten)rflatten_user_argsoutrrrs* rfunctionalizedVmake_graphed_callables..make_graphed_autograd_function..functionalizedsU % 3 3 C CY O --%(9":]"JLC;;&&55c;PQ Qr)r$rFunction) rrrrrrrrrrrs fffffffff @rmake_graphed_autograd_function>make_graphed_callables..make_graphed_autograd_functions4  enn-- B R R rc ,V^8dQhRRRRRRRRRR/#) rfuncztorch.nn.Modulegraph_training_statergraphedzCallable[_P, _R]orig_fwdrr)rs"rrrs:  % &* * +  " rc&aaaaRVVVV3RllpV#)c$V^8dQhRRRRRR/#)rrz_P.args user_kwargsz _P.kwargsrrr)rs"rrJmake_graphed_callables..make_graphed_forward..__annotate__s&CCC CbCrcF<SPS8Xd S!V/VB#S!V/VB#r,)training)rrrrrrs*,rnew_fwdEmake_graphed_callables..make_graphed_forward..new_fwds0}}(<<& A[AA'BkBBrr)rrrrrsffff rmake_graphed_forward4make_graphed_callables..make_graphed_forwards CC rzModules must not have hooks registered at the time they are passed. However, registering hooks on modules after passing them through make_graphed_callables is allowed.zIn any :class:`~torch.nn.Module` passed to :func:`~make_graphed_callables`, only parameters may be trainable. All buffers must have ``requires_grad=False``.zfIn the beta API, sample_args for each callable must contain only Tensors. Other types are not allowed.r)*r$is_autocast_enabledis_autocast_cache_enabledrrrtypingcastr rnnModuler_backward_hooks_forward_hooks_forward_pre_hooksallbuffersrrrappend TypeError parametersrr%rr&r{rprs tree_leavesrrr tree_flattenreversedrreverse enumeraterr)+rrrrr3just_one_callable _sample_argsflatten_sample_argscr flatten_argper_callable_len_user_argsper_callable_module_paramsr"per_callable_static_input_surfaces_ fwd_graphs bwd_graphsmempoolrr grad_inputsr outputs_gradvper_callable_static_outputs"per_callable_output_unflatten_specr func_outputsflatten_outputsspec per_callable_static_grad_outputsper_callable_static_grad_inputsrrrrgrad_idxrrretrrs+&&&&& rrrsmN   ''E,K,K,M,M m   i ' ' L  E&#+$6 DF {{5vs{);S)@#A;O y/ a ) )A%%&!+(()Q.,,-2"a3EE333EEEE"1 kk))994@ ""5#56sHKHsssHKHHH^ )069L!L8K#d)8K!L"A",Auxx!?!?allnRG" s9~&*&A !;!>>>&'* 16c)n0EF0E1%))$$&0EJF05c)n0EF0E1%))$$&0EJF%)\!tG II   %))**, - -03 %G1 ,D$,26tT,K+,++--99$+F$u$K$Kuu$K$KK |$q("'.."5"5 ,$u%';%uu%';% &+U+9@+UU+9@+&%)%7#6 #K -|[9:'1  .. II#%)+&!$Yj!IdI YY__YW_ 5 5;L6!& 3 3 @ @ N#**5+AB*11$7"J(*$&(#;>34,-<7ni $e$ FT$ ee$ FT$  uJJuuJJJ  | q 99#nn11( 5 T,@ T55 T,@ TT!&&W2E&W&W2E&W!W $!3 2 : 'C   [%<"))+h*?@A "))$/ ( ##56(//0CD'../ABA<F%,,.#++-2h$&CY'40 qM qM & ) & ) .q 1 . 1 ' * ,Q / +A .   dEHHOO , , 0dmmWdllDL JJt  JJw E(H1v :w"M"* GF . - -<6 5 5,:99s]b5 Ab:b?<'c;'c Bc)$c*c9>cc"Ac6(c6 c " c3 6 d )r r&rrr)FN)'__conditional_annotations__ __future__rrcollections.abcrrrrtyping_extensionsrr r r$r torch.xpur _utilsr __all__rrhasattr_C__dict__torch._Crrrr r&rrrrrrrr)r*s@rr5s1"" $5566 &   T]t_uxx)**%0%=EHHk"2=>V2WEHH./9D':EHH56VU+< ^,y^,B3(3(l %xx#v+1FF9F   ( (nnr