[ThwVSSKrSSKrSSKrSSKJr \"\R S5(d]\"S5\R RS'\"S5\R RS'\"S5\R RS'SSKJ r J r J r S r S r "S S \R R5r"S S5rSSjrg)N) _dummy_type_CudaStreamBase _CUDAGraph_graph_pool_handle_cuda_isCurrentStreamCapturing)rrrc[5$)zReturn True if CUDA graph capture is underway on the current CUDA stream, False otherwise. If a CUDA context does not exist on the current device, returns False without initializing the context. )rI/var/www/auris/envauris/lib/python3.13/site-packages/torch/cuda/graphs.pyis_current_stream_capturingr s * ++r c[5$)zReturn an opaque token representing the id of a graph memory pool. See :ref:`Graph memory management`. .. warning:: This API is in beta and may change in future releases. )rr r r graph_pool_handler"s   r c^\rSrSrSrU4SjrS U4SjjrU4SjrU4SjrU4Sjr U4Sjr U4S jr U4S jr S r U=r$) CUDAGraph.zfWrapper around a CUDA graph. .. warning:: This API is in beta and may change in future releases. c">[TU]U5$N)super__new__)cls __class__s r rCUDAGraph.__new__5sws##r c >[TU]XS9 g)aBegin capturing CUDA work on the current stream. Typically, you shouldn't call ``capture_begin`` yourself. Use :class:`~torch.cuda.graph` or :func:`~torch.cuda.make_graphed_callables`, which call ``capture_begin`` internally. Arguments: pool (optional): Token (returned by :func:`~torch.cuda.graph_pool_handle` or :meth:`other_Graph_instance.pool()`) that hints this graph may share memory with the indicated pool. See :ref:`Graph memory management`. capture_error_mode (str, optional): specifies the cudaStreamCaptureMode for the graph capture stream. Can be "global", "thread_local" or "relaxed". During cuda graph capture, some actions, such as cudaMalloc, may be unsafe. "global" will error on actions in other threads, "thread_local" will only error for actions in the current thread, and "relaxed" will not error on these actions. Do NOT change this setting unless you're familiar with `cudaStreamCaptureMode `_ )poolcapture_error_modeN)r capture_begin)selfrrrs r rCUDAGraph.capture_begin8s" 4Or c">[TU]5 g)aEnd CUDA 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.cuda.graph` or :func:`~torch.cuda.make_graphed_callables`, which call ``capture_end`` internally. N)r capture_endrrs r r!CUDAGraph.capture_endKs r c">[TU]5 g)z,Replay the CUDA work captured by this graph.N)rreplayr"s r r%CUDAGraph.replayVs  r c">[TU]5 g)z1Delete the graph currently held by this instance.N)rresetr"s r r(CUDAGraph.resetZs   r c >[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. )rrr"s r rCUDAGraph.pool^s w|~r c >[TU]5$)z/Enable debugging mode for CUDAGraph.debug_dump.)renable_debug_moder"s r r-CUDAGraph.enable_debug_modefsw(**r c">[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 CUDAGraph.enable_debug_mode() )r debug_dump)r debug_pathrs r r0CUDAGraph.debug_dumpjsw!*--r r )Nglobal)__name__ __module__ __qualname____firstlineno____doc__rrr!r%r(rr-r0__static_attributes__ __classcell__)rs@r rr.s6 $P& +..r rcf\rSrSr%SrSr\RS\S'S S\ 4Sjjr Sr S r S r g) graphuamContext-manager that captures CUDA work into a :class:`torch.cuda.CUDAGraph` object for later replay. See :ref:`CUDA Graphs ` for a general introduction, detailed use, and constraints. Arguments: cuda_graph (torch.cuda.CUDAGraph): Graph object used for capture. pool (optional): Opaque token (returned by a call to :func:`~torch.cuda.graph_pool_handle()` or :meth:`other_Graph_instance.pool()`) hinting this graph's capture may share memory from the specified pool. See :ref:`Graph memory management`. stream (torch.cuda.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. capture_error_mode (str, optional): specifies the cudaStreamCaptureMode for the graph capture stream. Can be "global", "thread_local" or "relaxed". During cuda graph capture, some actions, such as cudaMalloc, may be unsafe. "global" will error on actions in other threads, "thread_local" will only error for actions in the current thread, and "relaxed" will not error on actions. Do NOT change this setting unless you're familiar with `cudaStreamCaptureMode `_ .. 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. .. warning:: This API is in beta and may change in future releases. .. _cudaStreamCaptureMode: https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__STREAM.html#group__CUDART__STREAM_1g9d0535d93a214cbf126835257b16ba85 Nztorch.cuda.Streamdefault_capture_streamrcxURRc-[RR 5URlUcSOU4UlUbUOURRUlUR ce[RRUR 5UlXl X@l g)Nr ) rr>torchcudaStreamrcapture_streamstream stream_ctx cuda_graphr)rrFrrDrs r __init__graph.__init__s >> 0 0 849JJ4E4E4GDNN 1,BTG (Fdnn.S.S ""...**++D,?,?@$"4r c:[RR5 [R"5 [RR 5 UR R5 URR"URSUR06 g)Nr) r@rA synchronizegccollect empty_cacherE __enter__rFrrr)rs r rNgraph.__enter__sd      !!# %% YY +/+B+B r cpURR5 URRXU5 gr)rFr!rE__exit__)rexc_type exc_value tracebacks r rQgraph.__exit__s& ##%   i@r )rrCrFrrE)NNr3)r4r5r6r7r8r>typingOptional__annotations__strrGrNrQr9r r r r<r<usE:DHFOO,?@G "* 5  5,  Ar r<c 6[R"5(a%[R"5(a [S5eSn[ U[ 5(dSnU4nU4n/n[ X5GH upx[ U[RR5(a~[UR5S:Xa2[UR5S:Xa[UR5S:XdS5e[SUR555(dS5e[RR R""U6n UR%[ U 55 [SU 55(aGMS 5e UVs/sHn[U5PM n nUVs/sHGn[ U[RR5(a[ UR'55OS PMI n n[)[U55V s/sH n XlX-PM n n [)[U55Vs/sH!n[R*R-5PM# nn[)[U55Vs/sH!n[R*R-5PM# nnUc [/5OUn[R*R15 [R*R3[R*R555 [ XU 5HunnnS unnn[)U5Hn[RR R7U"U65n[ S U55n[U5S:dMR[R8R;U[ SU55[ SU55SUS9nM UUU4HnAM M S S S 5 [R*R15 /n/n[ XU5Hunnn[R*R=UUS9 U"U6nS S S 5 [RR R?W5unnUR%[ U55 UR%U5 M /n/n[ [AU 5[AU5[AU55GHunnn [ SU55n![ SU55nS n[U5S:ah[R*R=U US9 [R8R;U[ SU55[ SU!55SUS9nS S S 5 /n"Sn#UHCn$U$RB(aUbU"R%UU#5 U#S- n#M2U"R%S 5 ME [ U"5n"UR%U!5 UR%U"5 GM" URE5 URE5 Sn%/n&[GU5Hun nU%"XUU XXUU XUU UU UU 5 n'[ U[RR5(a:Sn(U("UURHU'URJ5Ul%U&R%U5 MU&R%U'5 M U(aU&S$[ U&5$s snfs snfs sn fs snfs snf!,(df  GN =f!,(df  GN=f!,(df  GN=f)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 CUDA work as a CUDA 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 CUDA 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. See :ref:`Graph memory management` for when this is appropriate. Arguments: callables (torch.nn.Module or Python function, or tuple of these): Callable or callables to graph. See :ref:`Graph memory management` for when passing a tuple of callables is appropriate. 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.cuda.graph_pool_handle` or :meth:`other_Graph_instance.pool()`) that hints this graph may share memory with the indicated pool. See :ref:`Graph memory management`. .. 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.cuda.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.cuda.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.cuda.make_graphed_callables` only with disabled caching. The context manager `torch.cuda.amp.autocast()` must have `cache_enabled=False`. z_make_graphed_callables does not support the autocast caching. Please set `cache_enabled=False`.FTrzModules 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..sEA%/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) isinstancer@Tensor)r_args r rarb#sHKS:c5<<00Ks')zfIn the beta API, sample_args for each callable must contain only Tensors. Other types are not allowed.r N)NNNc3J# UHoR(dMUv M g7frr\r_os r rarbDs$K1??QQ# #c3J# UHoR(dMUv M g7frr\r_is r rarbHs%';!AA';rjc3r# UH-oR(dM[R"U5v M/ g7frr]r@ empty_likerhs r rarbKs(+9@AOO/E,,Q//s77)outputsinputs grad_outputs only_inputs allow_unused)rc3r# UH-oR(a[R"U5OSv M/ g7frrorhs r rarbos'$ FT??E  Q  \rSrSr\UUUU4Sj5r\\RRRUUU4Sj55r Sr g)Omake_graphed_callables..make_graphed_autograd_function..Graphedic>[T5HBnTUR5XR5:wdM,TURX5 MD TR5 [ T[ 5(de[ ST55$)Nc3@# UHoR5v M g7frdetachrhs r rajmake_graphed_callables..make_graphed_autograd_function..Graphed.forward..s@AXXZZs)rangedata_ptrcopy_r%rdtuple)ctxrrrm fwd_graph len_user_argsstatic_input_surfacestatic_outputss r forwardWmake_graphed_callables..make_graphed_autograd_function..Graphed.forwards|}-A+A.779VY=O=O=QQ,Q/55fi@.  "!.%8888@@@@r cH>[U5[T5:Xde[TU5H?up#UcM UR5UR5:wdM.URU5 MA TR 5 [ T[ 5(de[ ST55$)Nc3J# UHobUR5OUv M g7frrr^s r rakmake_graphed_callables..make_graphed_autograd_function..Graphed.backward..s!@R1-AHHJQ6@Rs!#)lenziprrr%rdr)rgradsggrad bwd_graphstatic_grad_inputsstatic_grad_outputss r backwardXmake_graphed_callables..make_graphed_autograd_function..Graphed.backwards5zS)<%===="#6>GA}::<4==?:GGDM ?   """4e<<<<@Rr r N) r4r5r6r7 staticmethodrr@autogradfunctiononce_differentiablerr9)rrrrrrrsr Graphedr}sC  A A ^^ $ $ 8 8 9 r rc>[RRR"U6nTR"[ U5T-6n[RRR UT5$r)r@utils_pytreearg_tree_leavesapplyrtree_unflatten) user_argsflatten_user_argsoutr module_paramsoutput_unflatten_specs r functionalizedVmake_graphed_callables..make_graphed_autograd_function..functionalizedsW!& 3 3 C CY O --%(9":]"JLC;;&&55c;PQ Qr )r@rFunction) rrrrrrrrrrrs ````````` @r make_graphed_autograd_function>make_graphed_callables..make_graphed_autograd_functions-  enn-- : Rr c ^^^^UUUU4SjnU$)Nc8>TRT:XaT"U6$T"U6$r)training)rfuncgraph_training_stategraphedorig_fwds r new_fwdEmake_graphed_callables..make_graphed_forward..new_fwds(}}(<<& 22'33r r )rrrrrs```` r make_graphed_forward4make_graphed_callables..make_graphed_forwards44r )&r@is_autocast_enabledis_autocast_cache_enabled RuntimeErrorrdrrnnModuler_backward_hooks_forward_hooks_forward_pre_hooksallbuffersrrrappend parametersrrArrrJrDrB tree_leavesrrr< tree_flattenreversedr]reverse enumeraterr)) callables sample_argsnum_warmup_itersallow_unused_inputrjust_one_callableflatten_sample_argscargs flatten_argper_callable_len_user_argsper_callable_module_paramsrm"per_callable_static_input_surfaces_ fwd_graphs bwd_graphsmempoolrr grad_inputsrq outputs_gradvper_callable_static_outputs"per_callable_output_unflatten_specrflatten_outputsspec per_callable_static_grad_outputsper_callable_static_grad_inputsrrrrgrad_idxrfrretrrs) r make_graphed_callablesrsJ   ""u'F'F'H'H m   i ' ' L "n y. a ) )A%%&!+(()Q.,,-2  ]  3EEEE - E kk))994@ ""5#56HKHHH  Z H#/09L!L8K#d)8K!L"A",Auxx!?!?allnRG" s9~&*&A !;!>>&'* 38I2GH2GQ%**&&(2GJH27I2GH2GQ%**&&(2GJH%)\!tG  JJ   5::,,. /03 $F1 ,D$,2B .K,+,++--99$+F$$K$KK |$q("'.."5"5 ,$%';% &++9@+&%)%7#6 #K -|[9:'1  0. JJ#%)+&!$YZ!HdI ZZ  ig  6DkG7!& 3 3 @ @ I#**5+AB*11$7 "I(*$&(#;>34,-<7ni$$ FT$  JJJ  | q !!)'!:#nn11( T,@ TT!&&W2E&W!W $!3 2 ; 'C  [%<"))+h*?@A "))$/ ( ##56(//0CD'../ABK<P%,,.#++-0f CY'40 M qM & ) & ) .q 1 . 1 ' * ,Q / +A .   dEHHOO , , 0dmmWdllL JJt  JJw ;(>1v :A"M"* IH 0 /B7 60;:sL[ A[[-([-([ ?A3[%6A[%'[7A\ % [47 \ \ )FN)rKrVr@_utilsrhasattr_C__dict__torch._Crrrr rrr<rr r r rs uxx*++&1,&?EHHl#.9:N.OEHH*+:E(;EHH67, D.##D.NFAFAVPTkr