3jV%SSKJr SSKrSSKJr SSKJrJrJr SSKJ r J r J r SSK r SSK J r \(aSSKJr SS KJr /S Qr\ "S 5r\ "S 5r\"\ R,S 5(d]\"S5\ R,R.S'\"S5\ R,R.S'\"S5\ R,R.S'SSKJrJrJr SSjrSSjr"SS\5r"SS5r\ R@RB\S\"4-r#S\$S'\S S!Sjj5r%\S S"Sjj5r%S S#Sjjr%g)$) annotationsN)Callable)overload TYPE_CHECKING TypeAlias) ParamSpecSelfTypeVar)Tensor) _POOL_HANDLE) _dummy_type)is_current_stream_capturinggraph_pool_handleXPUGraphgraphmake_graphed_callables_R_P_XpuStreamBase _XPUGraph_xpu_graph_pool_handle_xpu_isCurrentStreamCapturing)rrrc[5$)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. )rJ/home/wildlama/miniconda3/lib/python3.13/site-packages/torch/xpu/graphs.pyrr(s ) **rcP[RR[55$)zBReturn an opaque token representing the id of a graph memory pool.)torchxpur rrrrrr0s 99 ! !"8": ;;rc^\rSrSrSrSSU4SjjjrSSU4SjjjrSU4SjjrSU4SjjrSU4Sjjr SU4Sjjr SU4S jjr SU4S jjr SU4S jjr SU4S jjrSU4S jjrSrU=r$)r5aWrapper around a XPU graph. Arguments: keep_graph (bool, optional): If ``keep_graph=False``, the executable command graph will be instantiated on GPU at the end of ``capture_end`` and the underlying modifiable command graph will be destroyed. Note that the executable command graph will not be instantiated at the end of ``capture_end`` in this case. Instead, it will be instantiated via an explicit called to ``instantiate`` or automatically on the first call to ``replay`` if ``instantiate`` was not already called. Calling ``instantiate`` manually before ``replay`` is recommended to prevent increased latency on the first call to ``replay``. c">[TU]X5$N)super__new__)cls keep_graph __class__s rr&XPUGraph.__new__Fsws//rc >[TU]US9 g)aBegin capturing XPU work on the current xpu stream. Typically, you shouldn't call ``capture_begin`` yourself. Use :class:`~torch.xpu.graph`, which call ``capture_begin`` internally. Arguments: 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. poolN)r% capture_begin)selfr-r)s rr.XPUGraph.capture_beginIs 4(rc">[TU]5 g)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_endr/r)s rr2XPUGraph.capture_endVs rc">[TU]5 g)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% instantiater3s rr6XPUGraph.instantiate`s rc">[TU]5 g)z+Replay the XPU work captured by this graph.N)r%replayr3s rr9XPUGraph.replayis  rc">[TU]5 g)z1Delete the graph currently held by this instance.N)r%resetr3s rr<XPUGraph.resetms   rc >[TU]5$)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%r-r3s rr- XPUGraph.poolqs w|~rc >[TU]5$)z.Enable debugging mode for XPUGraph.debug_dump.)r%enable_debug_moder3s rrAXPUGraph.enable_debug_modeysw(**rc">[TU]U5$)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)r/ debug_pathr)s rrDXPUGraph.debug_dump}sw!*--rc >[TU]5$)zuReturns the underlying xpuGraph_t. ``keep_graph`` must be True. XPU doesn't provide APIs to manipulate this object. )r% raw_xpu_graphr3s rrHXPUGraph.raw_xpu_graphs w$&&rc >[TU]5$)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_execr3s rrKXPUGraph.raw_xpu_graph_execs w)++rr)F)r(boolreturnr r$)r-_POOL_HANDLE | NonerNNonerNrPrNr )rEstrrNrP)rNint)__name__ __module__ __qualname____firstlineno____doc__r&r.r2r6r9r<r-rArDrHrK__static_attributes__ __classcell__)r)s@rrr5sN 00 ) )+.',,rrcX\rSrSr%SrSrS\S'S S SjjrS SjrS Sjr S r g)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_streamcDURRc-[RR 5URlUcSOU4UlUbUOURRUlUR c [S5eUR UlXl g)Nrzcapture_stream must not be None) r)r_rr Streamr-capture_streamAssertionError stream_ctx xpu_graph)r/rer-streams r__init__graph.__init__s >> 0 0 849II4D4D4FDNN 1;?`\ 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`. z_make_graphed_callables does not support the autocast caching. Please set `cache_enabled=False`.FT.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.c3<# UHoRSLv M g7f)FN requires_grad.0bs r )make_graphed_callables..FsEA%/szIn any :class:`~torch.nn.Module` passed to :func:`~make_graphed_callables`, only parameters may be trainable. All buffers must have ``requires_grad=False``.c3V# UHn[U[R5v M! g7fr$) isinstancerr )rargs rrrNsHKS:c5<<00Ks')zfIn the beta API, sample_args for each callable must contain only Tensors. Other types are not allowed.rN)NNNc3J# UHoR(dMUv M g7fr$r~ros rrrns$K1??QQ# #c3J# UHoR(dMUv M g7fr$r~ris rrrrs%';!AA';rc3r# UH-oR(dM[R"U5v M/ g7fr$rr empty_likers rrrus(+9@AOO/E,,Q//s77)outputsinputs grad_outputs only_inputs allow_unusedr,c3r# UH-oR(a[R"U5OSv M/ g7fr$rrs rrrs'$ FT??E  Q  \rSrSr\SUUUU4Sjj5r\\RRRSUUU4Sjj55r Sr g)Omake_graphed_callables..make_graphed_autograd_function..Graphedic*>[T5HBnTUR5XR5:wdM,TURX5 MD TR5 [ T[ 5(d [ S5e[ ST55$)Nzstatic_outputs must be a tuplec3@# UHoR5v M g7fr$detachrs rrjmake_graphed_callables..make_graphed_autograd_function..Graphed.forward..s@AXXZZs)rangedata_ptrcopy_r9rtuple RuntimeError)ctxrr fwd_graph len_user_argsstatic_input_surfacestatic_outputss rforwardWmake_graphed_callables..make_graphed_autograd_function..Graphed.forwards}-A+A.779VY=O=O=QQ,Q/55fi@.  "!.%88&'GHH@@@@rc>[U5[T5:wa#[S[T5S[U535e[TU5H?up#UcM UR5UR5:wdM.UR U5 MA TR 5 [ T[5(d [S5e[ST55$)Nz Expected z gradients but got z"static_grad_inputs must be a tuplec3J# UHobUR5OUv M g7fr$rrs rrkmake_graphed_callables..make_graphed_autograd_function..Graphed.backward..s!@R1-AHHJQ6@Rs!#)lenrziprrr9rr)rgradsggrad bwd_graphstatic_grad_inputsstatic_grad_outputss rbackwardXmake_graphed_callables..make_graphed_autograd_function..Graphed.backwardsu:%8!99&#C(;$<#==PQTUZQ[P\] ##6>GA}::<4==?:GGDM ?  "!"4e<<&'KLL@RrrN)rrrrr rNtuple[Tensor, ...])rrrrr rNr) rUrVrWrX staticmethodrrautogradfunctiononce_differentiablerrZ)rrrrrrrsrGraphedrsN  A A A ^^ $ $ 8 8  9 rrc>[RRR"U6nTR"[ U5T-6n[RRR UT5$r$)rutils_pytreearg_tree_leavesapplyrtree_unflatten) user_argsflatten_user_argsoutr module_paramsoutput_unflatten_specs rfunctionalizedVmake_graphed_callables..make_graphed_autograd_function..functionalizedsU % 3 3 C CY O --%(9":]"JLC;;&&55c;PQ Qr)rrrrNrr)rrFunction) rrrrrrrrrrrs ````````` @rmake_graphed_autograd_function>make_graphed_callables..make_graphed_autograd_functions4  enn-- B R R rc$^^^^SUUUU4SjjnU$)NcD>TRT:XaT"U0UD6$T"U0UD6$r$)training)r user_kwargsfuncgraph_training_stategraphedorig_fwds rnew_fwdEmake_graphed_callables..make_graphed_forward..new_fwds0}}(<<& A[AA'BkBBr)rz_P.argsrz _P.kwargsrNrr)rrrrrs```` rmake_graphed_forward4make_graphed_callables..make_graphed_forwards CC r)rrrrrztuple[torch.nn.Parameter, ...]rrTrztorch.utils._pytree.TreeSpecrrrrrztuple[Tensor | None, ...]rrrNzCallable[..., object]) rztorch.nn.ModulerrMrCallable[_P, _R]rrrNr)*ris_autocast_enabledis_autocast_cache_enabledrrrtypingcastr rnnModuler_backward_hooks_forward_hooks_forward_pre_hooksallbuffersrrrappend TypeError parametersrr rrrjrfra tree_leavesrrr tree_flattenreversedrreverse enumeraterr)+rwrxryrzr-just_one_callable _sample_argsflatten_sample_argscrp 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+ rrrsHN   ""u'F'F'H'H m   i ' ' L  E&#+$6 DF {{5vs{);S)@#A;O y/ a ) )A%%&!+(()Q.,,-2"aEEEE"1 kk))994@ ""5#56HKHHH^ )069L!L8K#d)8K!L"A",Auxx!?!?allnRG" s9~&*&A !;!>>&'* 16c)n0EF0E1%))$$&0EJF05c)n0EF0E1%))$$&0EJF%)\!tG II   %))**, -03 %G1 ,D$,2B .K,+,++--99$+F$$K$KK |$q("'.."5"5 ,$%';% &++9@+&%)%7#6 #K -|[9:'1  .. II#%)+&!$Yj!IdI YY__YW_ 5;L6!& 3 3 @ @ N#**5+AB*11$7"J(*$&(#;>34,-<7ni $$ FT$  JJJ  | q 9#nn11( T,@ TT!&&W2E&W!W $!3 2 : 'C  [%<"))+h*?@A "))$/ ( ##56(//0CD'../ABA<F%,,.#++-22262 2 < 2 1 2+272/2 2h$&CY'40 qM qM & ) & ) .q 1 . 1 ' * ,Q / +A .   dEHHOO , , % &* * +  " 0dmmWdllDL JJt  JJw E(H1v :w"M"* GF . -<6 5,:9sL] 8A]] (] (]A3]$A]$]63A^$ ]36 ^  ^ )rNrMrR)FN) rwrtrxrryrTrzrMr-rOrNrt) rwtuple[_ModuleOrCallable, ...]rxztuple[tuple[Tensor, ...], ...]ryrTrzrMr-rOrNr ) rw1_ModuleOrCallable | tuple[_ModuleOrCallable, ...]rxz3tuple[Tensor, ...] | tuple[tuple[Tensor, ...], ...]ryrTrzrMr-rOrNr )& __future__rrcollections.abcrrrrtyping_extensionsrr r rr torch.xpur _utilsr__all__rrhasattr_C__dict__torch._Crrrrrrrrrrrrtrsrrrrrs" $5566 &   T]t_uxx)**%0%=EHHk"2=>V2WEHH./9D':EHH56VU+< ^,y^,B3(3(l %xx#v+1FF9F $ $  #       $ $ (,(/(( (  ( # ( ($ $ n@nDnn n  n 7 nr