EiB*SrSSKJr SSKJr SSKJr SSKrSSKJ r J r SSK J r J r JrJrJrJrJrJrJr /S QrS \4S jrS \4S jrSS \S \R4S-4SjjrS \4Sjr\"S\S9"\5rS\l\SS\ S \\ \44Sjj5r!S\ S S4Sjr"\"S\S9"\"5r#S\#lSS\ S \RH4Sjjr%S\RHS S4Sjr&SS\ S S4Sjjr'"SS5r(g) z] This package introduces support for the current :ref:`accelerator` in python. )cache)Any) deprecatedN) _device_t_get_device_index) empty_cacheget_memory_infomax_memory_allocatedmax_memory_reservedmemory_allocatedmemory_reserved memory_statsreset_accumulated_memory_statsreset_peak_memory_stats)current_acceleratorcurrent_device_idxcurrent_device_indexget_device_capabilitycurrent_stream device_count device_indexr r is_availabler r r rrrrset_device_idxset_device_index set_stream synchronizereturncj[5nUcg[R"U5nUR5$)aReturn the number of current :ref:`accelerator` available. Returns: int: the number of the current :ref:`accelerator` available. If there is no available accelerators, return 0. .. note:: This API delegates to the device-specific version of `device_count`. On CUDA, this API will NOT poison fork if NVML discovery succeeds. Otherwise, it will. For more details, see :ref:`multiprocessing-poison-fork-note`. r)rtorchget_device_moduleraccmods W/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/accelerator/__init__.pyrr2s3  C {  ! !# &C    cj[5nUcg[R"U5nUR5$)aCheck if the current accelerator is available at runtime: it was build, all the required drivers are available and at least one device is visible. See :ref:`accelerator` for details. Returns: bool: A boolean indicating if there is an available :ref:`accelerator`. .. note:: This API delegates to the device-specific version of `is_available`. On CUDA, when the environment variable ``PYTORCH_NVML_BASED_CUDA_CHECK=1`` is set, this function will NOT poison fork. Otherwise, it will. For more details, see :ref:`multiprocessing-poison-fork-note`. Example:: >>> assert torch.accelerator.is_available() "No available accelerators detected." F)rr r!rr"s r%rrEs3*  C {  ! !# &C    r&check_availablec[RR5=nbU(aU(a[5(aU$g)aReturn the device of the accelerator available at compilation time. If no accelerator were available at compilation time, returns None. See :ref:`accelerator` for details. Args: check_available (bool, optional): if True, will also do a runtime check to see if the device :func:`torch.accelerator.is_available` on top of the compile-time check. Default: ``False`` Returns: torch.device: return the current accelerator as :class:`torch.device`. .. note:: The index of the returned :class:`torch.device` will be ``None``, please use :func:`torch.accelerator.current_device_index` to know the current index being used. This API does NOT poison fork. For more details, see :ref:`multiprocessing-poison-fork-note`. Example:: >>> # xdoctest: >>> # If an accelerator is available, sent the model to it >>> model = torch.nn.Linear(2, 2) >>> if (current_device := current_accelerator(check_available=True)) is not None: >>> model.to(current_device) N)r _C_accelerator_getAcceleratorr)r(r#s r%rrbs/4xx3355B_J r&c>[RR5$)zReturn the index of a currently selected device for the current :ref:`accelerator`. Returns: int: the index of a currently selected device. )r r*_accelerator_getDeviceIndexr&r%rrs 88 / / 11r&z#Use `current_device_index` instead.)categorya (Deprecated) Return the index of a currently selected device for the current :ref:`accelerator`. Returns: int: the index of a currently selected device. .. warning:: :func:`torch.accelerator.current_device_idx` is deprecated in favor of :func:`torch.accelerator.current_device_index` and will be removed in a future PyTorch release. devicecT[USS9n[RRU5$)aReturn the capability of the currently selected device. Args: device (:class:`torch.device`, str, int, optional): The device to query capabilities for :ref:`accelerator` device type. If not given, use :func:`torch.accelerator.current_device_index` by default. Returns: dict[str, Any]: A dictionary containing device capability information. The dictionary includes: - ``supported_dtypes`` (set(torch.dtype)): Set of PyTorch data types supported by the device Examples: >>> # xdoctest: +SKIP("requires cuda") >>> # Query capabilities for current device >>> capabilities = torch.accelerator.get_device_capability("cuda:0") >>> print("Supported dtypes:", capabilities["supported_dtypes"]) Toptional)rr r* _accelerator_getDeviceCapabilityr0rs r%rrs%&%Vd;L 88 4 4\ BBr&cV[USS9n[RRU5 g)a Set the current device index to a given device. Args: device (:class:`torch.device`, str, int): a given device that must match the current :ref:`accelerator` device type. .. note:: This function is a no-op if this device index is negative. Fr2N)rr r*_accelerator_setDeviceIndexr5s r%rrs"%Ve` device type. .. warning:: :func:`torch.accelerator.set_device_idx` is deprecated in favor of :func:`torch.accelerator.set_device_index` and will be removed in a future PyTorch release. cT[USS9n[RRU5$)a|Return the currently selected stream for a given device. Args: device (:class:`torch.device`, str, int, optional): a given device that must match the current :ref:`accelerator` device type. If not given, use :func:`torch.accelerator.current_device_index` by default. Returns: torch.Stream: the currently selected stream for a given device. Tr2)rr r*_accelerator_getStreamr5s r%rrs%%Vd;L 88 * *< 88r&streamcB[RRU5 g)a Set the current stream to a given stream. Args: stream (torch.Stream): a given stream that must match the current :ref:`accelerator` device type. .. note:: This function will set the current device index to the device index of the given stream. N)r r*_accelerator_setStream)r:s r%rrs HH##F+r&cV[USS9n[RRU5 g)aWait for all kernels in all streams on the given device to complete. Args: device (:class:`torch.device`, str, int, optional): device for which to synchronize. It must match the current :ref:`accelerator` device type. If not given, use :func:`torch.accelerator.current_device_index` by default. .. note:: This function is a no-op if the current :ref:`accelerator` is not initialized. Example:: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA) >>> assert torch.accelerator.is_available() "No available accelerators detected." >>> start_event = torch.Event(enable_timing=True) >>> end_event = torch.Event(enable_timing=True) >>> start_event.record() >>> tensor = torch.randn(100, device=torch.accelerator.current_accelerator()) >>> sum = torch.sum(tensor) >>> end_event.record() >>> torch.accelerator.synchronize() >>> elapsed_time_ms = start_event.elapsed_time(end_event) Tr2N)rr r*_accelerator_synchronizeDevicer5s r%rrs".%Vd;L HH++L9r&cL\rSrSrSrS\S-SS4SjrS SjrS\SS4S jr S r g) ri aMContext manager to set the current device index for the current :ref:`accelerator`. Temporarily changes the current device index to the specified value for the duration of the context, and automatically restores the previous device index when exiting the context. Args: device (Optional[int]): a given device index to temporarily set. If None, no device index switching occurs. Examples: >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA) >>> # Set device 0 as the current device temporarily >>> with torch.accelerator.device_index(0): ... # Code here runs with device 0 as the current device ... pass >>> # Original device is now restored >>> # No-op when None is passed >>> with torch.accelerator.device_index(None): ... # No device switching occurs ... pass r0NrcXlSUlg)Nidxprev_idx)selfr0s r%__init__device_index.__init__"s r&c|URb/[RRUR5UlggN)rCr r*_accelerator_exchangeDevicerD)rEs r% __enter__device_index.__enter__&s+ 88 !HH@@JDM r&exc_infocrURb*[RRUR5 ggrI)rCr r* _accelerator_maybeExchangeDevicerD)rErMs r%__exit__device_index.__exit__*s' 88  HH 5 5dmm D r&rB)rN) __name__ __module__ __qualname____firstlineno____doc__intrFrKobjectrP__static_attributes__r.r&r%rr s:.sTzKE&ETEr&r)FrI))rV functoolsrtypingrtyping_extensionsrr _utilsrrmemoryr r r r r rrrr__all__rWrboolrr0rr FutureWarningrdictstrrrrStreamrrrrr.r&r%resN( 0    2c&d:%,,:M@2c2 )  C)C$sCx.CC. 7Y 7d 7%   99 95<< 9,u||,,: ::6"E"Er&