tjVHUddlmZddlZddlmZddlmZmZmZddlm Z m Z m Z ddl Z ddl m Z erddlmZdd lmZgd Ze d Ze d Zee jd sHede jjd<ede jjd<ede jjd<ddlmZmZmZd/dZd0dZGddeZGddZe j j!ede"fzZ#de$d<e d1d2d(Z%e d1d3d+Z% d1d4d.Z%dS)5) 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)rrrreturnboolctS)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. )rN/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/xpu/graphs.pyrr(s ) * **rr cXtjtS)zBReturn an opaque token representing the id of a graph memory pool.)torchxpur rrrrrr0s 9 ! !"8":": ; ;;rceZdZdZddfd Zddfd Zdfd Zdfd Zdfd Zdfd Z dfd Z dfd Z d fd Z d!fd Z d!fd ZxZS)"raWrapper 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``. F keep_graphrrr cHt||SN)super__new__)clsr$ __class__s rr(zXPUGraph.__new__FswwsJ///rNpool_POOL_HANDLE | NoneNonecLt|dS)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. r+N)r' capture_begin)selfr+r*s rr0zXPUGraph.capture_beginIs& 4(((((rcHtdS)aEnd 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_endr1r*s rr3zXPUGraph.capture_endVs! rcHtdS)a/Instantiate 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' instantiater4s rr6zXPUGraph.instantiate`s! rcHtdS)z+Replay the XPU work captured by this graph.N)r'replayr4s rr8zXPUGraph.replayis rcHtdS)z1Delete the graph currently held by this instance.N)r'resetr4s rr:zXPUGraph.resetms  rr cDtS)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+r4s rr+z XPUGraph.poolqs ww||~~rcDtS)z.Enable debugging mode for XPUGraph.debug_dump.)r'enable_debug_moder4s rr=zXPUGraph.enable_debug_modeysww((***r debug_pathstrcFt|S)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)r1r>r*s rrAzXPUGraph.debug_dump}sww!!*---rintcDtS)zReturns the underlying xpuGraph_t. ``keep_graph`` must be True. XPU doesn't provide APIs to manipulate this object. )r' raw_xpu_graphr4s rrDzXPUGraph.raw_xpu_graphs ww$$&&&rcDtS)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_execr4s rrFzXPUGraph.raw_xpu_graph_execs ww))+++r)F)r$rrr r&)r+r,rr-rr-rr )r>r?rr-)rrB)__name__ __module__ __qualname____doc__r(r0r3r6r8r:r+r=rArDrF __classcell__)r*s@rrr5s} 0000000 ) ) ) ) ) ) )++++++......'''''',,,,,,,,,,rrc@eZdZUdZdZded< ddd Zdd ZddZdS)raContext-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_stream xpu_graphrr+r,streamc|jj(tj|j_|dn|f|_||n |jj|_|jtd|j|_||_ dS)Nrzcapture_stream must not be None) r*rPr!r"Streamr+capture_streamAssertionError stream_ctxrQ)r1rQr+rRs r__init__zgraph.__init__s > 0 849I4D4D4F4FDN 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(K|] }|jduVdS)FN requires_grad.0bs r z)make_graphed_callables..Fs)EEAq%/EEEEEErzIn any :class:`~torch.nn.Module` passed to :func:`~make_graphed_callables`, only parameters may be trainable. All buffers must have ``requires_grad=False``.c3JK|]}t|tjVdSr&) isinstancer!r )ruargs rrwz)make_graphed_callables..Ns.HHS:c5<00HHHHHHrzfIn the beta API, sample_args for each callable must contain only Tensors. Other types are not allowed.c,g|]}t|Sr)len)rur]s r z*make_graphed_callables..Vs!L!L!L#d))!L!L!Lrcg|]D}t|tjjr!t |ndES)r)ryr!nnModuletuple parameters)rucs rr}z*make_graphed_callables..WsP""" ",Aux!?!?GallnnR"""rc2g|]}||zSrr)ruiflatten_sample_argsper_callable_module_paramss rr}z*make_graphed_callables..[s9***  A!;A!>>***rcJg|] }tj!Srr!r"rru_s rr}z*make_graphed_callables..`&FFF1%)$$&&FFFrcJg|] }tj!Srrrs rr}z*make_graphed_callables..arrN)NNNc3(K|] }|j |VdSr&rrruos rrwz)make_graphed_callables..ns)$K$K11?$KQ$K$K$K$K$K$Krc3(K|] }|j |VdSr&rrrurs rrwz)make_graphed_callables..rs=%%"#q%%%%%%%rc3LK|]}|j tj|V dSr&rsr! empty_likers rrwz)make_graphed_callables..usH++45AO+!,Q//++++++r)outputsinputs grad_outputs only_inputs allow_unusedr/c3PK|]!}|jrtj|ndV"dSr&rrs rrwz)make_graphed_callables..sJ$ $ AB1? .s)JJ1!/JQJJJJJJrc3(K|] }|j |VdSr&rrrs rrwz)make_graphed_callables..s) T TqAO T T T T T T Trc3K|]}||V dSr&rrs rrwz)make_graphed_callables..s"&W&WQq&W&Wr fwd_graphr bwd_graph module_paramstuple[torch.nn.Parameter, ...] len_user_argsrBoutput_unflatten_spectorch.utils._pytree.TreeSpecstatic_input_surfacerfstatic_outputsstatic_grad_outputstuple[Tensor | None, ...]static_grad_inputsrCallable[..., object]c t Gfddtjj d fd } | S)NceZdZed fd Zeejjjd fd Z d S) Omake_graphed_callables..make_graphed_autograd_function..Graphedctxr^rr rrfcxtD]Y}|||kr!|||Zt t st dt dDS)Nzstatic_outputs must be a tuplec3>K|]}|VdSr&detachrs rrwzjmake_graphed_callables..make_graphed_autograd_function..Graphed.forward..s*@@AQXXZZ@@@@@@r)rangedata_ptrcopy_r8ryr RuntimeError)rrrrrrrs rforwardzWmake_graphed_callables..make_graphed_autograd_function..Graphed.forwards}--AAA+A.7799VAY=O=O=Q=QQQ,Q/55fQi@@@  """!.%88I&'GHHH@@@@@@@@rgradsct|tkr/tdtdt|t|D]F\}}|?||kr||Gt tstdtdDS)Nz Expected z gradients but got z"static_grad_inputs must be a tuplec3FK|]}||n|VdSr&rrts rrwzkmake_graphed_callables..make_graphed_autograd_function..Graphed.backward..sC;.make_graphed_autograd_function..Graphed.backwards u::%8!9!999&]C(;$<$<]]QTUZQ[Q[]] ##6>>**GAt}::<<4==??::GGDMMM  """!"4e<<M&'KLLL@RrN)rr^rr rrf)rr^rr rrf) rIrJrK staticmethodrr!autogradfunctiononce_differentiabler)rrrrrrrsrGraphedrs  A A A A A A A A\ A ^ $ 8       9 8\   rr user_argsr^rctjjj|}jt |z}tjj|Sr&)r!utils_pytreearg_tree_leavesapplyrtree_unflatten)rflatten_user_argsoutrrrs rfunctionalizedzVmake_graphed_callables..make_graphed_autograd_function..functionalizedsN % 3 CY O '-%(9":":]"JLC;&55c;PQQ Qr)rr^rr^)r!rFunction) rrrrrrrrrrrs ````````` @rmake_graphed_autograd_functionz>make_graphed_callables..make_graphed_autograd_functions             en-   B R R R R R R R R rfunctorch.nn.Modulegraph_training_statergraphedCallable[_P, _R]orig_fwdc dfd }|S) Nr_P.args user_kwargs _P.kwargsrrc:jkr|i|S|i|Sr&)training)rrrrrrs rnew_fwdzEmake_graphed_callables..make_graphed_forward..new_fwds;}(<<<&w A[AAA'xBkBBBr)rrrrrrr)rrrrrs```` rmake_graphed_forwardz4make_graphed_callables..make_graphed_forwardsC CCCCCCCCC r)rrrrrrrrBrrrrfrrfrrrrfrr) rrrrrrrrrr)(r!is_autocast_enabledis_autocast_cache_enabledrryrtypingcastr rrrr|_backward_hooks_forward_hooks_forward_pre_hooksallbuffersrrrappend TypeErrorrrr"rZrRrT tree_leavesrrr tree_flattenreversedrsreverse enumeraterr)+rdrergrhr+just_one_callable _sample_argsrr] flatten_argper_callable_len_user_args"per_callable_static_input_surfaces fwd_graphs bwd_graphsmempoolrr grad_inputsr outputs_gradrvper_callable_static_outputs"per_callable_output_unflatten_specr func_outputsflatten_outputsspec per_callable_static_grad_outputsper_callable_static_grad_inputsrrrrgrad_idxrzrretrrrrrs+ @@rrrs N  "" u'F'H'H  m    i ' 'P L  E&#+$6 DDF {5vs{);S)@#A;OO y,//4 a ) ) A%&&!++())Q..,--22"aEEEEEEE "1 k)94@ ""5#5#5666HHKHHHHH ^  "M!L8K!L!L!L"""""*****s9~~&&***& GFc)nn0E0EFFFJFFc)nn0E0EFFFJ%)\!!!tG I   %)**,, - -03 |%G1 1    ,D$,2B .K,+,,  +-99$$+FF$$K$K$K$K$KKK |$$q(("'."5"5 ,$%%';%%%  &+++9@+++&&%)%7#6 # #K|[9  A ' . I#%)+&!$Y j!I!I88dI Y__YW_ 5 5 ' '4;L ' ' ' ' ' ' ' ' ' ' ' ' ' ' '!& 3 @ @ N N#**5+A+ABBB*11$7777(*$&(#;>344,--<< C C7ni $$ $ FT$ $ $   JJJJJJJ  |  q 99  #n11( T T,@ T T TTT!&&W&W2E&W&W&W!W!W $!3 2                 ' 0 0C  0[%<"))+h*?@@@A "))$////"#566(//0CDDD'../ABBBB%,,...#++---2222h$&CY''" " 400 qM qM &q ) &q ) .q 1 .q 1 ' * ,Q / +A .    dEHO , ,     0/dmWdlDL JJt     JJw    1v ::s8COOO&P88P< ?P< AV,,V0 3V0 )rrrH)rcFN) rdrbrerfrgrBrhrr+r,rrb) rdrkrerlrgrBrhrr+r,rrk) rdrnrerorgrBrhrr+r,rrn)& __future__rrcollections.abcrrrrtyping_extensionsrr r r!r torch.xpur _utilsr__all__rrhasattr_C__dict__torch._Crrrrrrrrrr^rbrarrrrrs""""""" $$$$$$55555555556666666666 '&&&&&&     WT]]Yt__wux)**%0[%=%=EHk"2=+>V2W2WEH./9D'::EH56VUUUUUUUUU++++<<<< ^,^,^,^,^,y^,^,^,B3(3(3(3(3(3(3(3(l %x#v+1FFFFFF $ $   $ $ (((( ($ $ nnnnnnnr