JTh n%SSKrSSKrSSKrSSKrSSKrSSKJr SSK7 SSKrSSKJ r SSK r SSK J s J r SSKJr SSKJr SSKJrJr SSKJr /S QrS rSq\\\S '\R<S \\4S j5rS\ \!S4S\ \ RDS44Sjr#S\$\!SS4Sjr%SPSjr&"SS5r'Sr(S\ \)\*\)\ RD44Sjr+SS.SQSjjr,SPSjr-"SS\ R\R^5r0Sr1\ RdS\1\SS.S \\S!\3/\ \4\444S"\5S#\4S$jj5r6SRS%jr7S&r8S'q9\R<S(\4S)j5r:"S*S+5r;"S,S-5r<"S.S/\ R\R^5r="S0S15r>S2r?"S3S4\@5rAS\ \3/\!4\3\A/S444S5jrBS6\ RDS\C\5\!44S7jrD\\DS8S90rE\C\5\3\ RD/\!44\S:'"S;S<\F5rG"S=S>\ R\RR5rJ"S?S@\ R\RR5rKSArL"SBSC5rMSDrN"SESF5rO"SGSH\R5rQSIrR\ RRRR\ RRRR1\Y"\ RRRR5-r^"SJSK\5r_"SLSM\5r`SSSNjraS'\1\S4S!\3/\ \4\444S"\5S#\4SOjjrbg)TN) defaultdict)*) ReferenceType)is_fun)tree_map) capture_logsLoggingTensorMode)TorchDispatchMode) checkpointcheckpoint_sequentialCheckpointErrorCheckpointFunctioncheck_backward_validitydetach_variableget_device_statesset_device_statesnoop_context_fnset_checkpoint_early_stopDefaultDeviceTypeset_checkpoint_debug_enabledCheckpointPolicySelectiveCheckpointContext$create_selective_checkpoint_contextsSAC_IGNORED_OPSdefault_checkpoint_debug_enabledenabledc#8# [nUqSv Uqg!Wqf=f7f)a Context manager that sets whether checkpoint should print additional debug information when running. See the ``debug`` flag for :func:`~torch.utils.checkpoint.checkpoint` for more information. Note that when set, this context manager overrides the value of ``debug`` passed to checkpoint. To defer to the local setting, pass ``None`` to this context. Args: enabled (bool): Whether checkpoint should print debug information. Default is 'None'. N)r)rprevs N/var/www/auris/envauris/lib/python3.13/site-packages/torch/utils/checkpoint.pyrr+s$)($+! $(!D! inputs.returnc^[U[5(az/nUHgn[U[R5(dUR U5 M5UR 5nUR UlUR U5 Mi [U5$[S[U5R5e)Nz@Only tuple of tensors is supported. Got Unsupported input type: ) isinstancetupletorchTensorappenddetach requires_grad RuntimeErrortype__name__)r"outinpxs r rrAs&%  Cc5<<00 3 A!//AO JJqMSz N L ! !  c`[SU55(d[R"S5 gg)Nc3|# UH2n[U[R5(dM$URv M4 g7fN)r%r'r(r+.0r0s r *check_backward_validity..Us&TFSjell6S s  Fs#<<zBNone of the inputs have requires_grad=True. Gradients will be None)anywarningswarn)r"s r rrTs( TFT T T P  Ur2c^US:Xa[R"S5$[[U5nU$)Nmeta)r'devicegetattr)r? device_modules r _get_device_modulerB[s+ ||F##E6*M r2cP\rSrSrSrSr\S S\4Sjj5r\S\4Sj5r Sr g ) rba) A class that manages the default device type for checkpointing. If no non-CPU tensors are present, the default device type will be used. The default value is 'cuda'. The device type is used in the checkpointing process when determining which device states to save and restore for recomputation. cudar?cU[lg)z Set the default device type for checkpointing. Args: device (str): The device type to be set as default. Default is 'cuda'. Nr_default_device_type)r?s r set_device_type!DefaultDeviceType.set_device_typens 28.r2r#c"[R$)zl Get the current default device type for checkpointing. Returns: str: The current default device type. rGr2r get_device_type!DefaultDeviceType.get_device_typexs!555r2rLNrE) r. __module__ __qualname____firstlineno____doc__rH staticmethodstrrIrM__static_attributes__rLr2r rrbsC"8886S66r2rc ^/mU4Sjn[X5 [T5n[U5S:a([R"S[ U5STS35 [T5S:Xa[ R5$SU;agTS$)Nc>[U[R5(aAURRS:Xd&TR URR5 ggg)Ncpu)r%r'r(r?r-r))arg device_typess r add_device_types,_infer_device_type..add_device_typessB c5<< ( (E1I     02J (r2aTensor arguments, excluding CPU tensors, are detected on at least two types of devices. Device state will only be saved for devices of a single device type, and the remaining devices will be ignored. Consequently, if any checkpointed functions involve randomness, this may result in incorrect gradients. (Note that if CUDA devices are among the devices detected, it will be prioritized; otherwise, the first device encountered will be selected.) Device types: z first device type: rrE)rsetlenr;r<sortedrrM)argsr\device_types_setr[s @r _infer_device_typerdsL1 $<( q    &&6788L\Z[_L]  _  <A 0022 # #Ar2c^/mU4Sjn[X5 /n[[U65nTH<nURU5 UR UR 55 SSS5 M> TU4$!,(df  MS=f)Nc>[U[R5(a;URRS;a TR UR 55 ggg)N>rYr>)r%r'r(r?r-r) get_device)rZfwd_device_idss r add_device_ids)get_device_states..add_device_idssA c5<< ( (SZZ__O-S  ! !#.."2 3.T (r2)rrBrdr?r) get_rng_state)rbrifwd_device_statesrA device_idrhs @r rrs}N4 ^"&'94'@AM#  ! !) ,  $ $]%@%@%B C- ,$ , ,,- ,s A.. A=  device_typecUc[R5nUS:Xag[U5n[X5H0upEUR U5 UR U5 SSS5 M2 g!,(df  MD=f)aSets random number generator states for the specified devices. Args: devices: Device ids to set states for. states: States to set. device_type: ``device_type`` of the devices to set states for. Default is the device returned by a call to ``DefaultDeviceType.get_device_type()``, which is ``cuda`` if not changed by calling ``DefaultDeviceType::set_device_type()``. Nr>)rrMrBzipr? set_rng_state)devicesstatesrorAr?states r rrsi'779 f&{3MW-   ! !& )  ' ' .* ). ) )s A** A9 cZ[RRU5(aB[R"U5[R"U5[R "5S.nOSn[R"S5[R"S5[R "5S.nX4$)N)rdtype cache_enabledrY)r'ampis_autocast_availableis_autocast_enabledget_autocast_dtypeis_autocast_cache_enabled)rodevice_autocast_kwargscpu_autocast_kwargss r _get_autocast_kwargsrs yy&&{3300=--k:"<<>"  "&,,U3))%088: " 66r2c4\rSrSr\S5r\S5rSrg)rc6[U5 XlX l[U6Ul[ UR5uUlUlU(ad[R"5Ul SUl [UR5n[USS5(aSUl [U6uUlUl/Ul/Ul/n['U5Hupg[R("U5(aIUR+U5 UR$R+U5 UR"R+S5 MiUR"R+U5 M UR,"U6 [R."5 U"U6nSSS5 U$!,(df  W$=f)NF _initializedT)r run_functionpreserve_rng_staterdrorr~rr'rk fwd_cpu_statehad_device_in_fwdrBr@r fwd_devicesrlr"tensor_indices enumerate is_tensorr)save_for_backwardno_grad) ctxrrrbrA tensor_inputsirZoutputss r forwardCheckpointFunction.forwardsL%'!3,d3>R OO? ;"C$;  % 3 3 5C  %*C !.s?M}ne<<(,%9JD9Q6!6  oFAs##$$S)""))!, !!$' !!#& & }- ]]_"D)G_s 9F  Fc [RR5(d [S5e[ UR 5nUR nURn[U5H upVXEX&'M /nUR(aUR(a URn[RRXpRURS9 UR(aZ[R"UR 5 UR(a)[#URUR$URS9 ['[)U55n[R*R-UR5(a6[R*R."S SUR0UR0D6O[2R4"5n [R6"5 U  [R*R."S 0UR8D6 UR:"U6n SSS5 SSS5 SSS5 SSS5 [=W [R>5(aU 4n /n /n [A[CU 55H]n[RD"X5(dM"XRF(dM7U RIX5 U RIX5 M_ [CU 5S:Xa [S5e[RRKX5 [)SW55n SU -$!,(df  GN=f!,(df  GN=f!,(df  GN&=f!,(df  GN0=f) NzWhen use_reentrant=True, torch.utils.checkpoint is incompatible with .grad() or passing an `inputs` parameter to .backward(). To resolve this error, you can either set use_reentrant=False, or call .backward() without passing the `inputs` argument.rsrrornrorzInone of output has requires_grad=True, this checkpoint() is not necessaryc3|# UH2n[U[R5(a UROSv M4 g7fr5)r%r'r(gradr6s r r8.CheckpointFunction.backward..As0 &#3 55CHH4 ?&s:<)NNrLrY)&r'autograd_is_checkpoint_validr,listr"r saved_tensorsrrrrrandomfork_rngrorrrrrlrr&ryrzautocastr~ contextlib nullcontext enable_gradrrr%r(ranger`rr+r)backward)rrbr"rtensorsridx rng_devicesdetached_inputsdevice_autocast_ctxroutputs_with_gradargs_with_gradgradss r rCheckpointFunction.backward s~~2244N cjj!++## /FA!*FK0   ! !c&;&;//K \\ " ")?)?S__# %%##C$5$56((%coos7L7LZ]ZiZij-eFm 9M M M M" M%% M4rLN)r.rPrQrRrTrrrVrLr2r rrs)&&P;$;$r2rcV[R"5[R"54$r5)rrrLr2r rrIs  ! ! #Z%;%;%= ==r2F) use_reentrant context_fndeterminism_checkdebugrrrrcUc[R"SSS9 SnURSS5nU(a+U(a$[SSR S U55-5eU(a0U[ LdUS La [S 5e[ R"X/UQ76$[XX#U/UQ70UD6n[U5 U"U0UD6n [U5 g![a U s$f=f) aCheckpoint a model or part of the model. Activation checkpointing is a technique that trades compute for memory. Instead of keeping tensors needed for backward alive until they are used in gradient computation during backward, forward computation in checkpointed regions omits saving tensors for backward and recomputes them during the backward pass. Activation checkpointing can be applied to any part of a model. There are currently two checkpointing implementations available, determined by the :attr:`use_reentrant` parameter. It is recommended that you use ``use_reentrant=False``. Please refer the note below for a discussion of their differences. .. warning:: If the :attr:`function` invocation during the backward pass differs from the forward pass, e.g., due to a global variable, the checkpointed version may not be equivalent, potentially causing an error being raised or leading to silently incorrect gradients. .. warning:: The ``use_reentrant`` parameter should be passed explicitly. In version 2.4 we will raise an exception if ``use_reentrant`` is not passed. If you are using the ``use_reentrant=True`` variant, please refer to the note below for important considerations and potential limitations. .. note:: The reentrant variant of checkpoint (``use_reentrant=True``) and the non-reentrant variant of checkpoint (``use_reentrant=False``) differ in the following ways: * Non-reentrant checkpoint stops recomputation as soon as all needed intermediate activations have been recomputed. This feature is enabled by default, but can be disabled with :func:`set_checkpoint_early_stop`. Reentrant checkpoint always recomputes :attr:`function` in its entirety during the backward pass. * The reentrant variant does not record the autograd graph during the forward pass, as it runs with the forward pass under :func:`torch.no_grad`. The non-reentrant version does record the autograd graph, allowing one to perform backward on the graph within checkpointed regions. * The reentrant checkpoint only supports the :func:`torch.autograd.backward` API for the backward pass without its `inputs` argument, while the non-reentrant version supports all ways of performing the backward pass. * At least one input and output must have ``requires_grad=True`` for the reentrant variant. If this condition is unmet, the checkpointed part of the model will not have gradients. The non-reentrant version does not have this requirement. * The reentrant version does not consider tensors in nested structures (e.g., custom objects, lists, dicts, etc) as participating in autograd, while the non-reentrant version does. * The reentrant checkpoint does not support checkpointed regions with detached tensors from the computational graph, whereas the non-reentrant version does. For the reentrant variant, if the checkpointed segment contains tensors detached using ``detach()`` or with :func:`torch.no_grad`, the backward pass will raise an error. This is because ``checkpoint`` makes all the outputs require gradients and this causes issues when a tensor is defined to have no gradient in the model. To avoid this, detach the tensors outside of the ``checkpoint`` function. Args: function: describes what to run in the forward pass of the model or part of the model. It should also know how to handle the inputs passed as the tuple. For example, in LSTM, if user passes ``(activation, hidden)``, :attr:`function` should correctly use the first input as ``activation`` and the second input as ``hidden`` preserve_rng_state(bool, optional): Omit stashing and restoring the RNG state during each checkpoint. Note that under torch.compile, this flag doesn't take effect and we always preserve RNG state. Default: ``True`` use_reentrant(bool): specify whether to use the activation checkpoint variant that requires reentrant autograd. This parameter should be passed explicitly. In version 2.5 we will raise an exception if ``use_reentrant`` is not passed. If ``use_reentrant=False``, ``checkpoint`` will use an implementation that does not require reentrant autograd. This allows ``checkpoint`` to support additional functionality, such as working as expected with ``torch.autograd.grad`` and support for keyword arguments input into the checkpointed function. context_fn(Callable, optional): A callable returning a tuple of two context managers. The function and its recomputation will be run under the first and second context managers respectively. This argument is only supported if ``use_reentrant=False``. determinism_check(str, optional): A string specifying the determinism check to perform. By default it is set to ``"default"`` which compares the shapes, dtypes, and devices of the recomputed tensors against those the saved tensors. To turn off this check, specify ``"none"``. Currently these are the only two supported values. Please open an issue if you would like to see more determinism checks. This argument is only supported if ``use_reentrant=False``, if ``use_reentrant=True``, the determinism check is always disabled. debug(bool, optional): If ``True``, error messages will also include a trace of the operators ran during the original forward computation as well as the recomputation. This argument is only supported if ``use_reentrant=False``. args: tuple containing inputs to the :attr:`function` Returns: Output of running :attr:`function` on :attr:`*args` Naetorch.utils.checkpoint: the use_reentrant parameter should be passed explicitly. In version 2.5 we will raise an exception if use_reentrant is not passed. use_reentrant=False is recommended, but if you need to preserve the current default behavior, you can pass use_reentrant=True. Refer to docs for more details on the differences between the two variants.) stacklevelTrUnexpected keyword arguments: ,c3$# UHov M g7fr5rLr7rZs r r8checkpoint..7NvvFzKPassing `context_fn` or `debug` is only supported when use_reentrant=False.) r;r<pop ValueErrorjoinrrapply'_checkpoint_without_reentrant_generatornext StopIteration) functionrrrrrbkwargspreservegenrets r r r Vsr  C   zz.5H - ,sxx7Nv7N/N N   _ ,U0B' "''BTBB5  u GK OU  S ''  I J s; C CCc Uc[R"S5 SnURSS5nU(a$[SSR SU55-5eSn[ U[ RR5(a[UR55n[U5U-nSn[S XqS - -U5Hn X-S - n[U"XU5UUUS 9nM U"US -[U5S - U5"U5$) aCheckpoint a sequential model to save memory. Sequential models execute a list of modules/functions in order (sequentially). Therefore, we can divide such a model in various segments and checkpoint each segment. All segments except the last will not store the intermediate activations. The inputs of each checkpointed segment will be saved for re-running the segment in the backward pass. .. warning:: The ``use_reentrant`` parameter should be passed explicitly. In version 2.4 we will raise an exception if ``use_reentrant`` is not passed. If you are using the ``use_reentrant=True` variant, please see :func:`~torch.utils.checkpoint.checkpoint` for the important considerations and limitations of this variant. It is recommended that you use ``use_reentrant=False``. .. warning: Since PyTorch 1.4, it allows only one Tensor as the input and intermediate outputs, just like :class:`torch.nn.Sequential`. Args: functions: A :class:`torch.nn.Sequential` or the list of modules or functions (comprising the model) to run sequentially. segments: Number of chunks to create in the model input: A Tensor that is input to :attr:`functions` preserve_rng_state(bool, optional): Omit stashing and restoring the RNG state during each checkpoint. Default: ``True`` use_reentrant(bool): specify whether to use the activation checkpoint variant that requires reentrant autograd. This parameter should be passed explicitly. In version 2.5 we will raise an exception if ``use_reentrant`` is not passed. If ``use_reentrant=False``, ``checkpoint`` will use an implementation that does not require reentrant autograd. This allows ``checkpoint`` to support additional functionality, such as working as expected with ``torch.autograd.grad`` and support for keyword arguments input into the checkpointed function. Returns: Output of running :attr:`functions` sequentially on :attr:`*inputs` Example: >>> # xdoctest: +SKIP("stub") >>> model = nn.Sequential(...) >>> input_var = checkpoint_sequential(model, chunks, input_var) a{torch.utils.checkpoint.checkpoint_sequential: the use_reentrant parameter should be passed explicitly. In version 2.5 we will raise an exception if use_reentrant is not passed. use_reentrant=False is recommended, but if you need to preserve the current default behavior, you can pass use_reentrant=True. Refer to docs for more details on the differences between the two variants.Trrrc3$# UHov M g7fr5rLrs r r8(checkpoint_sequential..7rrc^^^UUU4SjnU$)NcJ>[TTS-5HnTU"U5nM U$Nr^)r)inputjend functionsstarts r r.run_function..forward;s+5#'*!! U++Lr2rL)rrrrs``` r r+checkpoint_sequential..run_function:s  r2rr^)rr)r;r<rrrr%r'nn Sequentialrchildrenr`rr ) rsegmentsrrrrr segment_sizerrs r r r s `  C  zz.5H  ,sxx7Nv7N/N N  )UXX0011++-. y>X-L Cq,Q,7F"Q& Y / ''  G aY!!3Y ? FFr2c(U(d [S5eg)NzqSomething went unexpectedly wrong in activation checkpoint. Please report this bug by filing an issue to PyTorch.AssertionError)conds r _internal_assertrSs  D   r2Tenablec#8# [nUqSv Uqg!Wqf=f7f)aContext manager that sets whether checkpoint should stop recomputation early. By default, non-reentrant checkpoint stops recomputation as soon as it has computed all needed Tensors. This context manager can be used to disable that feature if it is problematic for your specific application. This context manager only needs to be active when forward is run. It does not need to be active during backward. Example:: >>> # xdoctest: +SKIP(failing) >>> message = "saved tensors default hooks are disabled" >>> with set_checkpoint_early_stop(False): ... # Any checkpoint under this context manager will respect this ... # context manager, even if its backward is performed outside. ... out = checkpoint(fn, inputs) ... >>> out.backward() N)_enable_checkpoint_early_stop)rrs r rrs$.-,(.% (,%%r!c\rSrSrSrg)_HandleirLNr.rPrQrRrVrLr2r rrr2rc\rSrSrSrSrg)_Holderic0Ulgr5handlesselfs r __init___Holder.__init__s 57 r2rN)r.rPrQrRrrVrLr2r rrs8r2rc b\rSrSr\S5r\S\S\\S4S\SS4S j5r\S 5r S r g) _NoopSaveInputsi c.[R"S5$)Nr)r'empty)rbs r r_NoopSaveInputs.forward s{{4  r2rr".outputr#Nc ^ ^ ^ [[U5VVs/sH)up4[U[R5(dM&X44PM+ snn6um n[T 5VVs0sHupgXv_M snnm UVs/sH&n[U[R5(aSOUPM( snm U U U 4SjnXlUR "U6 gs snnfs snnfs snf)Nct>[T5VVs/sHupUT;aUTUOUPM nnnUSS$s snnfr)r)rrorrb idx2saved_idxrs r get_args/_NoopSaveInputs.setup_context..get_argssS&dO+DA453F mA./AM+  qr7N s4)rqrr%r'r(rr) rr"rrrrabrrbrrs @@@r setup_context_NoopSaveInputs.setup_contexts#&!*6!2 R!2jELL6Qfqf!2 R# +4N*CD*C$!*CD DJKFq 1ell33:FK   w')SDKs%C C C3-C c[S5e)Nz(Did not expect to backward on this graphr)r grad_outputss r r_NoopSaveInputs.backward)sGHHr2rL) r.rPrQrRrTrAnyTuplerrrVrLr2r rr sb!!(3(c3h((((4IIr2rc \rSrSrSrSrSrg)_CheckpointFramei.cXlSUl/Ul[[R 5Ul[[5Ul[[5Ul X l X@l X0l /UlSUlSUlgNF) recompute_fn input_saver weak_holdersrweakrefWeakKeyDictionary recomputedintrecomp_counterbool is_recomputed early_stop metadata_fnunpack_error_cb x_metadatasforward_completedignore_saved_mismatch)rr rrrs r r_CheckpointFrame.__init__/sy(13 11 2  6A5E5@5F%'.!&%*"r2c  UR(ag[UR5URU:Xd1[ S[UR5SURU35e/n[ UR5Hup4U"5nUcM[ XR;5 [ URUSL5 [ URUURU;5 URUnURUURUnX`RU5:wdMURX6URU545 M [U5S:a+SnUHup6n USUSUSU S3- nM [ S U35eg) Nztorch.utils.checkpoint: A different number of tensors was saved during the original forward and recomputation. Number of tensors saved during forward: z/ Number of tensors saved during recomputation: rztensor at position z: saved metadata: z recomputed metadata:  zztorch.utils.checkpoint: Recomputed values for the following tensors have different metadata than during the forward pass. ) rr`rrr rrrrrrr)) rgidnb_meta_differentr weak_holderholderx_meta recomputed_xmismatched_tensorsrecomputed_metas r check_recomputed_tensors_match/_CheckpointFrame.check_recomputed_tensors_matchHs  % % 4$$%)<)t?P?P;Q:RSAAEATATUXAY@Z\  )$*;*; < C ]F~ SNN2 3 V^^C0< = V^^C0DOOC4HH I%%c*F??3/s0CDL)),77!((#t7G7G 7U)VW%!=(  !A %!# 0A,_")#/''-h/,,;+\rSrSrSrU4SjrSrg)._get_debug_context_and_cb..CaptureLogsic SUlSUlgr5logstbsrs r r7_get_debug_context_and_cb..CaptureLogs.__init__sDIDHr2cH>^[RUU4Sj5nU"5$)Nc3># [5 [SSSTS9nUuTlTlUv SSS5 SSS5 g!,(df  N=f!,(df  g=f7f)NT) python_tb script_tbcpp_tb)r rr3r4) logs_and_tbr:rs r logging_modeX_get_debug_context_and_cb..CaptureLogs.get_context_manager..logging_modesN&(!$$$vVZe*5'DItx%%W)(VV)(s1 A" AAA A" A A AA")rcontextmanager)rr<r:s` r get_context_managerB_get_debug_context_and_cb..CaptureLogs.get_context_managers%  & & &' &  > !r2r2N)r.rPrQrRrr?rV)r:sr CaptureLogsr0s  " "r2rAec >SnTRceTRce[[RU"ST5U"ST5SR TR5SR TR5S95Ue)Nc VSn[UR5n[[URUR55HdunupVX%SUS-SUSUS3- nSnUH<nUSS :Hn U(d U (dMU (aS nM&X(S S US S USS3- nM> US- nMf U$)Nrz (r^z of z in z) Fname__torch_dispatch__Tfilename:liner z )r`r3rrqr4) labelrr/ total_lenrlogtbfound_torch_dispatchrIis_torch_dispatchs r get_str_tbF_get_debug_context_and_cb..unpack_error_cb..get_str_tbsCL--.I )#l.?.?AQAQ*R S 9Cd1q5'i[UG5II',$D(,V 8L(L%/8I */3, :./qfaV ~RPPCv !TJr2original recomputer )forward_tracesrecompute_traces forward_ops recompute_ops)r3r _checkpoint_error_templateformatr)rBrPcapture_logs_fwdcapture_logs_recomputes r r2_get_debug_context_and_cb..unpack_error_cbs " $$000%**666 & - -)*6FG!+K9O!P II&6&;&;<"ii(>(C(CD .   r2cD>TR5TR54$r5)r?)rZr[sr r-_get_debug_context_and_cb..context_fns!3357M7a7a7cccr2)platformmachinesystemr )rArrrZr[r:s @@@r _get_debug_context_and_cbrbsg    8 + L0AW0LF " "#}(]?:d  &&r2r1cJURURURS.$)Nshaperwr?rdr1s r _default_meta_extractorrgs#(( r2nonecgr5rL)_s r rksdr2"_allowed_determinism_checks_to_fnsc\rSrSrSrg)_StopRecomputationErrorirLNrrLr2r rnrnrr2rnc4^\rSrSrS\S\4U4SjjrSrU=r$)_recomputation_hookitarget_frame_refr!c<>^^UU4SjnSn[TU]X45 g)Nc>UR(aUR5OUnT"5nUceURTnURT==S- ss'U[UR5:a8UR (aeUR (d SUlU$[S5eURU"5nUb\[URRTS5SL5 [5URT'XRTURT'UR (a,URT[UR5:Xa[eU$)Nr^Tzotorch.utils.checkpoint: trying to save more tensors during recomputation than during the original forward pass.)r+r*rr`rrrrr rrgetrrrn)r1 target_frame recomp_idxr$r!rqs r pack_hook/_recomputation_hook.__init__..pack_hooks=oo 1A+-L+ ++%44S9J  ' ' , 1 ,S!:!:;;'2222#55 :>L6H%K "..z:$!FG&-is#DE'',V^^C-@A&&<+F+Fs+Ks))P,.-Hr2cU$r5rLrfs r unpack_hook1_recomputation_hook.__init__..unpack_hookBs Hr2)superr)rrqr!rwrz __class__s `` r r_recomputation_hook.__init__s$ L  0r2rL) r.rPrQrRrrrrV __classcell__r}s@r rprps,1,1S,1,1r2rpc(^\rSrSrU4SjrSrU=r$)_checkpoint_hookiJc>^^U4SjnU4SjmTRbUU4Sjn[TU] X#5 g[TU] UT5 g)NcL>[5nTRR[R"U55 TR bJ[ R"5 TRRTR U55 SSS5 U$U$!,(df  U$=fr5) rrr)rrefrr'rr)r1r$frames r rw,_checkpoint_hook.__init__..pack_hookLsvYF    % %gkk&&9 :  ,]]_%%,,U->->q-AB%M6M%_Ms +B B#c>[RR5nUS:Xa[[R "55nTR U(dTRRnURUR5n[[R"T5U5 [RR5 TR "U6 SSS5 SSS5 STR U'TR%U5 ['XR(;5 UR(Uc [+S5e['UR(UTR,U;5 TR,UUR(UnSUR(U'U$!,(df  N=f!,(df  N=f!["a Nf=f)NrTztorch.utils.checkpoint: Unpack is being triggered for a tensor that was already unpacked once. If you are calling ctx.saved_tensors in backward, make sure to do so only once. Otherwise please open an issue with details on your use case.)r'_C_current_graph_task_idruuiduuid4rrgrad_fnrrrprrrrr rnr)rrr r)r$r!rrbrrs r rz._checkpoint_hook.__init__..unpack_hookVsn((113Cby$**,'&&s+''//||C$5$56, E*C~~113**D14 ,0##C(44S9 SNN2 3~~c"*%b V^^C0E4D4DS4II J""3's(;T"U5$![anTRU5 SnAgSnAff=fr5)r r)r$rBrrzs r unpack_hook_with_error_cb<_checkpoint_hook.__init__..unpack_hook_with_error_cbxs4-&v..&-))!,,-s 0+0)rr|r)rrrwrrzr}s ` @r r_checkpoint_hook.__init__Ks?  B  , - G Y B G Y 4r2rL)r.rPrQrRrrVrrs@r rrJs 4545r2rc|UH6n[U[R5(dM$[U5(dM6 g g)NTF)r%r'r(r)funcrbrrZs r _is_compilingrs/ c5<< ( (VC[[ r2c \rSrSrSrSrSrg)_VersionWrappericXl[U[R5(aURUlgSUlgr5)valr%r'r(_versionversion)rrs r r_VersionWrapper.__init__s)-06@ell6S6Scll Y] r2cURb6U(d/URRUR:wa [S5eUR$)NzETensor cached during selective activation checkpoint has been mutated)rrrr,)rallow_cache_entry_mutations r get_val_VersionWrapper.get_vals@ << #,Fxx  DLL0"[xxr2)rrN)r.rPrQrRrrrVrLr2r rrs ^r2rc[U[R5(aUR5(dUR 5(dU(a][R R [R RRS5 UR5nSSS5 U$U$!,(df  U$=fr ) r%r'r(is_floating_point is_complexr_SetExcludeDispatchKeyGuard DispatchKeyADInplaceOrViewr*r1any_ret_has_alias_infos r _maybe_detachrs!U\\""(;(;(=(=Si XX 1 1%((2F2F2V2VX] ^  A _ H1H_ ^ Hs B00 B?c\rSrSrSrSrSrg)ria Context passed to policy function during selective checkpointing. This class is used to pass relevant metadata to the policy function during selective checkpointing. The metadata includes whether the current invocation of the policy function is during recomputation or not. Example: >>> # xdoctest: +SKIP(stub) >>> >>> def policy_fn(ctx, op, *args, **kwargs): >>> print(ctx.is_recompute) >>> >>> context_fn = functools.partial(create_selective_checkpoint_contexts, policy_fn) >>> >>> out = torch.utils.checkpoint.checkpoint( >>> fn, x, y, >>> use_reentrant=False, >>> context_fn=context_fn, >>> ) cXlgr5 is_recompute)rrs r r#SelectiveCheckpointContext.__init__s(r2rN)r.rPrQrRrSrrVrLr2r rrs *)r2rc(\rSrSrSrSrSrSrSrSr g) riax Enum for specifying the policy for checkpointing during backpropagation. The following policies are supported: - ``{MUST,PREFER}_SAVE``: The operation's output will be saved during the forward pass and will not be recomputed during the backward pass - ``{MUST,PREFER}_RECOMPUTE``: The operation's output will not be saved during the forward pass and will be recomputed during the backward pass Use ``MUST_*`` over ``PREFER_*`` to indicate that the policy should not be overridden by other subsystems like `torch.compile`. .. note:: A policy function that always returns ``PREFER_RECOMPUTE`` is equivalent to vanilla checkpointing. A policy function that returns ``PREFER_SAVE`` every op is NOT equivalent to not using checkpointing. Using such a policy would save additional tensors not limited to ones that are actually needed for gradient computation. rr^rrLN) r.rPrQrRrS MUST_SAVE PREFER_SAVEMUST_RECOMPUTEPREFER_RECOMPUTErVrLr2r rrs,IKNr2rcPU(a[R$[R$r5rrr)rs r _policy_from_boolrs)*  % %Q0@0Q0QQr2c$\rSrSrSrSSjrSrg)_CachingTorchDispatchModeicXlX lgr5 policy_fnstorage)rrrs r r"_CachingTorchDispatchMode.__init__s " r2Nc ^U[;aU"U0UD6$Uc0OUnUR"[SS9U/UQ70UD6n[U[5(a [ U5n[ XU5nU(aU[RS'U"U0UD6n[SURR55mU[R[R4;dU(a,URUR![#U4SjU55 U$)NFrrSc3<# UHoRSLv M g7fr5) alias_info)r7rs r r8?_CachingTorchDispatchMode.__torch_dispatch__.. s$`K_C^^4%?K_sc.>[[UT55$r5)rrrs r rk>_CachingTorchDispatchMode.__torch_dispatch__..sWXZpIq9rr2)rrrr%rrr fx_traceback current_metar:_schemareturnsrrrrr)r) rrtypesrbrpolicy is_compilingr/rs @r rF,_CachingTorchDispatchMode.__torch_dispatch__s ? "(( (~6 : N $7'+7/57 fd # #&v.F$T8 5;L % %k 2D#F#!$$`4<URTR5$r5)rr)r1rs r rk=_CachedTorchDispatchMode.__torch_dispatch__../sQYYt/N/N%Or2)rrrr%rrrrrrrrtr,r`rr) rrrrbrrrrr/s ` r rF+_CachedTorchDispatchMode.__torch_dispatch__s ? "(( (~6 : M $7'+7/57 fd # #&v.F$T8 &002B2N2NO OS_ll&&t,G"dV+a#bcc7|q "TOQXQ\Q\]^Q_`C ''C r2)rrrrrrLr2r rrs E r2rc ^[T[5(aTHvn[U[RR5(aM.[U[RR 5(aSOSn[ SUS[U5SU35e U4SjnO[T5(aTnO [S5e[[5n[XE5[XEU54$)a Helper to avoid recomputing certain ops during activation checkpointing. Use this with `torch.utils.checkpoint.checkpoint` to control which operations are recomputed during the backward pass. Args: policy_fn_or_list (Callable or List): - If a policy function is provided, it should accept a :class:`SelectiveCheckpointContext`, the :class:`OpOverload`, args and kwargs to the op, and return a :class:`CheckpointPolicy` enum value indicating whether the execution of the op should be recomputed or not. - If a list of operations is provided, it is equivalent to a policy returning `CheckpointPolicy.MUST_SAVE` for the specified operations and `CheckpointPolicy.PREFER_RECOMPUTE` for all other operations. allow_cache_entry_mutation (bool, optional): By default, an error is raised if any tensors cached by selective activation checkpoint are mutated in order to ensure correctness. If set to `True`, this check is disabled. Returns: A tuple of two context managers. Example: >>> # xdoctest: +REQUIRES(LINUX) >>> import functools >>> >>> x = torch.rand(10, 10, requires_grad=True) >>> y = torch.rand(10, 10, requires_grad=True) >>> >>> ops_to_save = [ >>> torch.ops.aten.mm.default, >>> ] >>> >>> def policy_fn(ctx, op, *args, **kwargs): >>> if op in ops_to_save: >>> return CheckpointPolicy.MUST_SAVE >>> else: >>> return CheckpointPolicy.PREFER_RECOMPUTE >>> >>> context_fn = functools.partial(create_selective_checkpoint_contexts, policy_fn) >>> >>> # or equivalently >>> context_fn = functools.partial(create_selective_checkpoint_contexts, ops_to_save) >>> >>> def fn(x, y): >>> return torch.sigmoid(torch.matmul(torch.matmul(x, y), y)) * y >>> >>> out = torch.utils.checkpoint.checkpoint( >>> fn, x, y, >>> use_reentrant=False, >>> context_fn=context_fn, >>> ) zPlease update the OpOverloadPacket to a specific OpOverload.For example, if you have `torch.ops.aten.mm`, change it to `torch.ops.aten.mm.default`.rz6Expected op in `op_list` to be an OpOverload but got: z of type z. cP>UT;a[R$[R$r5r)roprbrpolicy_fn_or_lists r r7create_selective_checkpoint_contexts..policy_fnzs$&&'111'888r2z=policy_fn_or_list must be either a function or a list of ops.) r%rr'_ops OpOverloadOpOverloadPacketrr-callable TypeErrorrrr)rrr _extra_msgrrs` r rr5sr#T**#Bb%**"7"788 EJJ$?$?@@nFH!LRDQ#Bxj:,8 $ 9 # $ $% WXX$/$5G!)5 5OP r2c /H^^^^^^^^^^# Sn[b [(a)OU(a!U[:wa [S5e[5up'U[;a [UnO,[S[ [R 55SU35e[U6m[T5n U"5un m[TXV5(a;U[:wa1[U [5(a[T[5(dS5e[TS9ummT(a6[R"5mSm[U SS5(a S m[!U6ummUUUUUUUUUU4 S jn [#U [$UU5n [R&"S S S 9n [(R*"X/UQ76U lU R,R.cSv g[1U 5 U  Sv SSS5 SSS5 S U l[U SS5(aT(aT(d [5S 5eg!,(df  NI=f!,(df  NR=f7f)aCheckpointing without reentrant autograd. Args: fn: describes what to run in the forward pass of the model or part of the model. It should also know how to handle the inputs passed as the tuple. For example, in LSTM, if user passes ``(activation, hidden)``, :attr:`function` should correctly use the first input as ``activation`` and the second input as ``hidden`` preserve_rng_state(bool, optional): Omit stashing and restoring the RNG state during each checkpoint. Default: ``True`` context_fn(Callable, optional): A callable returning a tuple of two context managers. The function and its recomputation will be run under the first and second context managers respectively. determinism_check(str, optional): A string specifying the determinism check to perform. By default it is set to ``"default"`` which compares the shapes, dtypes, and devices of the recomputed tensors against those the saved tensors. To turn off this check, specify ``"none"``. Currently these are the only two supported values. Please open an issue if you would like to see more determinism checks. debug(bool, optional): If ``True``, error messages will also include a trace of the operators ran during the original forward computation as well as the recomputation. *args: Arguments to pass in to the given ``function``. **kwargs: Keyword arguments to pass into the given ``function``. Nz6debug=True is incompatible with non-default context_fnz#determinism_check should be one of z , but got z}In torch.compile mode, `context_fn` arg passed to `torch.utils.checkpoint` must generate a tuple of two `TorchDispatchMode`s.rnFrTc > Utp/nT (a T (aT n[RRUT TS9 T (a([R"T 5 T (a [ T T TS9 [R R T5(a"[R R"SST0TD6O[R"5nU [R R"S0TD6 T T"U0UD6 SSS5 SSS5 SSS5 SSS5 g!,(df  N'=f!,(df  N0=f!,(df  N9=f!,(df  g=f)NrrnrorLr) r'rrrrrryrzrrr)r"rrbrrrr~rofnrrlrrrrecompute_contexts r r =_checkpoint_without_reentrant_generator..recompute_fns  "3%K \\ " ");# "##M2$%k3DR]^00==#())"4"4#'#+A#CMCYCYC[ %eii&8&8&VBU&VXiD#F#Yj&V$  YjXi&V&V$$  sTB E!D3$D"' D 0D"8D3E D D"" D0 ,D33 E =E Er)r+zPyTorch's device state was initialized in the forward pass of a Checkpoint, which is not allowed. Please open an issue if you need this feature.)rrrrbrlrkeysrdrBrr%r rr'rkr@rr rrrrrrrrr,)rrrrrrbrrrrAforward_contextr  new_framedummyrr~rorrlrrrs`` @@@@@@@@r rrs HO$=$I  u  (H '@&A# >>89JK 1$7Y7^7^7`2a1bc() +  %d+K&{3M)3&O&R&&:+H (9 : : (*; < < A A  A = 3GS^2_//++- " =.% 8 8 $ ->-E *K*$$*!% I KKD 1E+11%G$GI$$,  ) $o '6 $"&I}ne44"3 (   '6o $ $s6F)H"5H8H=H;H" H H HH"rO)r#Nr5)F)crr_rr;r collectionsrtypingenumrr'torch.fx.tracebackfx tracebackr/torch._functorch._aot_autograd.functional_utilsrtorch.utils._pytreer&torch.testing._internal.logging_tensorrr torch.utils._python_dispatchr __all___DEFAULT_DETERMINISM_MODErOptionalr__annotations__r>rrrr(rIterablerrBrrdListrrrrrFunctionrr_disable_dynamoCallableContextManagerrUr r rrrrrrr rXr,r rbDictrgrl Exceptionrngraphsaved_tensors_hooksrprrrrrEnumrropsatenr*rprimr?r_ _subclassesfunctional_tensorFunctionalTensor metadata_fnsrrrrrrLr2r r s # ! ))B(R: &&,08D>0 )(4.))* E#s(O ellC6G0H & HSM d 66BD-d3iell1C&C D-(7;/(7&f$00f$R>%)FU6 ]D>]U>>#ABBC ]  ]  ]]@YGx V!% -d--<  88 "Ienn--"IJ\\~:x l 9'5"c'):HoEVX\E\<])]#^9'vu||S#X6 NP"Dh ~s7J.K)K$L  i -1%....BB-1`55u~~++??55p    &))4tyy:R IINN!! IINN!! ++<<IIJK 1<0DStFU6  U>>#ABBC     r2