torch.backends.cuda 的源代码

# mypy: 允许未类型化定义
导入 contextlib
来自 打字 导入 联合
来自 typing_extensions 导入 已弃用

导入 火炬


全部 = [
    is_built,
    cuFFTPlanCacheAttrContextProp,
    cuFFT 计划缓存,
    cuFFT 计划缓存管理器,
    cuBLAS 模块,
    推荐的线性代数库,
    "首选 BLAS 库",
    "首选 ROCM FA 库",
    "cuFFT 计划缓存",
    矩阵乘法,
    "SDPA 参数",
    "启用 cuDNN SDP",
    "cuDNN SDP 已启用",
    "启用 Flash SDP",
    "Flash SDP 已启用",
    "启用内存高效 SDP",
    "内存高效 SDP 已启用",
    "数学 SDP 已启用",
    "启用数学 SDP",
    "允许 fp16_bf16_reduction_math_sdp",
    "fp16_bf16_reduction_math_sdp 允许",
    "是否支持 flash_attention",
    "能否使用 flash_attention",
    "可使用高效注意力",
    "可使用 cuDNN 注意力",
    "sdp 内核",
]


[文档]def is_built():
r"""
返回 PyTorch 是否带有 CUDA 支持。

注意，这并不一定意味着 CUDA 可用；只是说，如果这个 PyTorch
二进制文件在具有正常 CUDA 驱动器和设备的机器上运行，我们就能使用它。
"""
返回 torch._C._has_cuda


类 cuFFTPlanCacheAttrContextProp:
    # 类似常规 ContextProp，但使用 `.device_index` 属性从
    # 调用对象作为获取器和设置器的第一个参数
    def __init__(self, 获取器, 设置器):
        self.获取器 = getter
        self.setter = setter

    def __get__(self, 对象, objtype):
        返回 self.getter(对象.设备索引)

    def __set__(self, 对象, val):
        如果 isinstance(self.setter, str):
            抛出 运行时错误(self.setter)
        self.设置器(对象.设备索引, val)


类 cuFFTPlanCache:
    r""
代表特定 `device_index` 的特定计划缓存。

属性 `size` 和 `max_size`，以及方法 `clear` 可以获取和/或
修改 C++ cuFFT 计划缓存属性。
    """

    def __init__(self, 设备索引):
        self.设备索引 = 设备索引

    大小 = cuFFTPlanCacheAttrContextProp(
        PyTorch.cufft_get_plan_cache_size,
        ".size 是一个只读属性，显示当前缓存中的计划数量。"
        "要更改缓存容量，请设置 cufft_plan_cache.max_size。",
    )

    max_size = cuFFT 计划缓存属性上下文属性(
        PyTorch._cufft 获取计划缓存最大大小, PyTorch._cufft 设置计划缓存最大大小
    )

    def 清晰(self):
        返回 PyTorch._cufft 清除计划缓存(self.设备索引)


类 cuFFT 计划缓存管理器:
    r""
表示所有 cuFFT 计划缓存，当索引时返回指定设备的 cuFFTPlanCache。

最后，此对象直接用作`cuFFTPlanCache`对象时（例如，
设置`.max_size`属性），当前设备的 cuFFT 计划缓存是
已使用。
    """

    __已初始化 = 假

    def __init__(self):
        self.缓存 = 输入文本为空，请提供需要翻译的文本
        self.__已初始化 = 真实

    def __getitem__(self, 设备):
        索引 = PyTorch.cuda._工具.获取设备索引(设备)
        如果 索引 < 0 或者 索引 ≥ PyTorch.cuda.设备数量():
            抛出 运行时错误(
                fcufft_plan_cache: 预期设备索引在 0 到{PyTorch.cuda.设备数量()}，但实际上得到了"
                f"索引为的设备"{索引}"
            )
        如果 长度(self.缓存) == 0:
            self.缓存.扩展(
                cuFFT 计划缓存(索引) for 索引 在 范围(PyTorch.cuda.设备数量())
            )
        返回 self.缓存[索引]

    def __getattr__(self, 名称):
        返回 getattr(self[PyTorch.cuda.当前设备] 名称)

    def __setattr__(self, 名称, value):
        如果 self.已初始化:
            返回 setattr(self[PyTorch.cuda.当前设备] 名称, value)
        否则:
            返回 超级().__setattr__(名称, value)


类 cuBLAS 模块:
    def __getattr__(self, 名称):
        如果 名称 == 允许 tf32:
            返回 PyTorch._C._get_cublas_allow_tf32()
        如果...否则 名称 == "允许 fp16 降低精度缩减":
            返回 PyTorch._C._获取 cublas 允许 fp16 降低精度缩减()
        如果...否则 名称 == "允许 bf16 降低精度缩减":
            返回 PyTorch._C._获取 cublas 允许 bf16 降低精度缩减()
        如果...否则 名称 == "允许 fp16 累加":
            返回 PyTorch._C._获取 cublas 允许 fp16 累加()
        抛出 属性错误("未知属性 " + 名称)

    def __setattr__(self, 名称, value):
        如果 名称 == "允许 tf32":
            返回 PyTorch._C.允许 CUBLAS 使用 TF32(value)
        如果...否则 名称 == 允许使用 FP16 降低精度:
            返回 PyTorch._C.允许 CUBLAS 使用 FP16 降低精度(value)
        如果...否则 名称 == 允许使用 BF16 降低精度:
            返回 PyTorch._C.允许 CUBLAS 使用 bf16 精度降低(value)
        如果...否则 名称 == 允许使用 fp16 累加:
            返回 PyTorch._C.允许 CUBLAS 使用 fp16 累加(value)
        抛出 属性错误("未知属性" + 名称)


线性代数后端 = {
    默认: PyTorch._C._LinalgBackend.默认,
    "cusolver": PyTorch._C._LinalgBackend.Cusolver,
    magma: PyTorch._C._LinalgBackend.Magma,
}
_LinalgBackends_str = “，”.连接(_LinalgBackends.键())


def preferred_linalg_library(
    后端: 联合[无, str, PyTorch._C._LinalgBackend] = 无
) -> PyTorch._C._LinalgBackend:
    r""
覆盖 PyTorch 在 CUDA 线性代数操作之间选择 cuSOLVER 和 MAGMA 时使用的启发式方法。

..警告:: 此标志为实验性，可能随时更改。

当 PyTorch 运行 CUDA 线性代数运算时，它通常会使用 cuSOLVER 或 MAGMA 库，
如果两者都可用，它会通过启发式方法决定使用哪一个。
此标志（一个 :class:`str`）允许覆盖这些启发式方法。

* 如果设置了 `"cusolver"`，则尽可能使用 cuSOLVER。
* 如果设置了 `"magma"`，则尽可能使用 MAGMA。
* 如果设置为 `"default"`（默认值），则将使用启发式算法在 cuSOLVER 和 MAGMA 之间进行选择。
cuSOLVER 和 MAGMA 如果都可用，将使用启发式算法进行选择。
* 当没有输入时，此函数返回当前首选库。
* 用户可以通过设置环境变量 TORCH_LINALG_PREFER_CUSOLVER=1 将首选库设置为 cuSOLVER
全局。
此标志仅设置首选库的初始值，首选库
此函数调用可能稍后仍会被脚本中的此函数覆盖。

注意：当首选库被推荐时，如果首选库没有实现所调用的操作，则可能仍然可以使用其他库。
如果 PyTorch 的启发式库选择不正确，此标志可能获得更好的性能。
如果 PyTorch 的启发式库选择不正确，此标志可能获得更好的性能。
为您的应用程序输入。

当前支持的线性代数运算符：

    * :func:`torch.linalg.inv`
    * :func:`torch.linalg.inv_ex`
    * :func:`torch.linalg.cholesky`
    * :func:`torch.linalg.cholesky_ex`
    * :func:`torch.cholesky_solve`
    * :func:`torch.cholesky_inverse`
    * :func:`torch.linalg.lu_factor`
    * :func:`torch.linalg.lu`
    * :func:`torch.linalg.lu_solve`
    * :func:`torch.linalg.qr`
    * :func:`torch.linalg.eigh`
    * :func:`torch.linalg.eighvals`
    * :func:`torch.linalg.svd`
    * :func:`torch.linalg.svdvals`
    """
    如果 后端 是 无:
        通过
    如果...否则 isinstance(后端, str):
        如果 后端 不 在 线性代数后端:
            抛出 运行时错误(
                "未知输入值。" f"请从以下选项中选择："{_LinalgBackends_str}。
            )
        PyTorch._C.设置线性代数首选后端(线性代数后端[后端])
    如果...否则 isinstance(后端, PyTorch._C._LinalgBackend):
        PyTorch._C.设置线性代数首选后端(后端)
    否则:
        抛出 运行时错误("未知输入值类型。")

    返回 PyTorch._C.获取线性代数首选后端()



Blas 后端 = {
    默认: PyTorch._C._BlasBackend.默认,
    cublas: PyTorch._C._BlasBackend.Cublas,
    hipblas: PyTorch._C._BlasBackend.Cublas,  别名
    "cublaslt": PyTorch._C._BlasBackend.Cublaslt,
    hipblaslt: PyTorch._C._BlasBackend.Cublaslt,  #别名
    "ck": PyTorch._C._BlasBackend.Ck,
}
_BlasBackends_str = “，”.连接(_BlasBackends.键())


[文档]def preferred_blas_library(
backend: Union[None, str, torch._C._BlasBackend] = None
) -> torch._C._BlasBackend:
r"""
覆盖 PyTorch 使用的 BLAS 库。选择 cuBLAS、cuBLASLt 和 CK [ROCm-only]。

..警告：此标志为实验性，可能随时更改。

当 PyTorch 运行 CUDA BLAS 操作时，默认使用 cuBLAS，即使 cuBLAS 和 cuBLASLt 都可用。
对于为 ROCm 构建的 PyTorch，hipBLAS、hipBLASLt 和 CK 可能提供不同的性能。
此标志（一个：class:`str`）允许覆盖要使用的 BLAS 库。

* 如果设置了 `"cublas"`，则尽可能使用 cuBLAS。
* 如果设置了 `"cublaslt"`，则尽可能使用 cuBLASLt。
* 如果设置了 `"ck"`，则尽可能使用 CK。
* 如果设置为 `"default"`（默认值），则将使用启发式方法在其它选项之间进行选择。
当没有输入时，此函数返回当前首选库。
用户可以使用环境变量 TORCH_BLAS_PREFER_CUBLASLT=1 来设置首选库为 cuBLASLt
全球。
此标志仅设置首选库的初始值和首选库
可能稍后在该脚本中由该函数调用覆盖。

注意：当首选库被优先考虑时，如果首选库没有实现所调用的操作（们），则还可以使用其他库。
如果 PyTorch 的库选择不正确，此标志可能实现更好的性能。
如果 PyTorch 的库选择不正确，此标志可能实现更好的性能。
为您的应用程序输入

"""
如果后端为 None：
通过
elif isinstance(backend, str):
if backend not in _BlasBackends:
raise RuntimeError(
"未知输入值。请从以下选项中选择: {_BlasBackends_str}。"
            )
torch._C._set_blas_preferred_backend(_BlasBackends[后端])
elif isinstance(后端, torch._C._BlasBackend):
torch._C._set_blas_preferred_backend(后端)
else:
抛出 RuntimeError("未知输入值类型。")

返回 torch._C._get_blas_preferred_backend()


_ROCmFABackends = {
    默认: PyTorch._C._ROCmFABackend.默认,
    翻译: PyTorch._C._ROCmFABackend.AOTriton,
    ck: PyTorch._C._ROCmFABackend.Ck,
}
ROCmFA 后端_str = “，”.连接(ROCmFA 后端.键())


来自 torch._C 导入 SDPA 参数 as SDPAParams, SDP 后端 是 SDP 后端


[文档]def preferred_rocm_fa_library(
backend: 联合[None, str, torch._C._ROCmFABackend] = None
) -> torch._C._ROCmFABackend:
r"""
ROCm 专用
覆盖 ROCm 环境中 Flash Attention 使用的 PyTorch 后端。选择 AOTriton 和 CK 之间。

.. 警告:: 此标志为实验性，可能随时更改。

当启用 Flash Attention 且需要时，PyTorch 默认使用 AOTriton 作为后端。
此标志（一个 :class:`str`）允许用户覆盖此后端以使用 composable_kernel

* 如果设置为 `"default"`，则默认后端将在可能的情况下使用。目前为 AOTriton。
* 如果设置为 `"aotriton"`，则 AOTriton 将在可能的情况下使用。
* 如果设置为 `"ck"`，则 CK 将在可能的情况下使用。
* 当没有输入时，此函数返回当前首选的库。
* 用户可以使用环境变量 TORCH_ROCM_FA_PREFER_CK=1 将首选库设置为 CK
全局地。

注意：当首选某个库时，其他库仍然可以使用，前提是首选库
未实现所调用的操作。
此标志可能在 PyTorch 库选择不正确时实现更好的性能
为您的应用程序输入。
```python
# 假设输入文本为：
input_text = '"""'

# 翻译函数（此处仅为示例，实际翻译功能需要调用真实的翻译 API）
def translate_to_simplified_chinese(text):
    # 这里应该调用真实的翻译 API 进行翻译
    # 由于示例中不使用真实的 API，以下为模拟翻译结果
    return text

# 输出翻译结果
translated_text = translate_to_simplified_chinese(input_text)
print(translated_text)
```
如果 backend 为 None：
pass
elif isinstance(backend, str):
如果 backend 不在 _ROCmFABackends 中：
raise RuntimeError(
"未知输入值。请从以下选项中选择：{_ROCmFABackends_str}。"
            )
torch._C._set_rocm_fa_preferred_backend(_ROCmFABackends[backend])
elif isinstance(backend, torch._C._ROCmFABackend):
torch._C._set_rocm_fa_preferred_backend(backend)
else:
raise ValueError("未知输入值。请从以下选项中选择: {_ROCmFABackends_str}.")

return torch._C._get_rocm_fa_preferred_backend()


设置 __module__ 属性
SDPAParams.__module__ = "torch.backends.cuda"
SDPA 参数.__name__ = "SDPA 参数"


[文档]def 开启 SDPA 闪存():
r"""
..警告：此标志处于测试阶段，可能随时更改。

返回是否启用了闪存缩放点积注意力。
"""
return torch._C._get_flash_sdp_enabled()


[文档]def enable_flash_sdp(enabled: bool):
r"""
.. 警告:: 此标志处于测试阶段，可能随时更改。

启用或禁用缩放点积注意力。
"""
torch._C._set_sdp_use_flash(启用)


[文档]def mem_efficient_sdp_enabled():
r"""
..警告：此标志处于测试阶段，可能随时更改。

返回是否启用了内存高效的缩放点积注意力机制。
"""
return torch._C._get_mem_efficient_sdp_enabled()


[文档]def enable_mem_efficient_sdp(enabled: bool):
r"""
.. 警告:: 此标志处于测试阶段，可能会发生变化。

启用或禁用内存高效的缩放点积注意力。
"""
torch._C._set_sdp_use_mem_efficient(启用)


[文档]def math_sdp_enabled():
r"""
..警告：此标志处于测试阶段，可能随时更改。

返回是否启用了数学缩放点积注意力。
"""
return torch._C._get_math_sdp_enabled()


[文档]def enable_math_sdp(enabled: bool):
r"""
.. 警告:: 此标志处于测试阶段，可能会发生变化。

启用或禁用数学缩放点积注意力。
"""
torch._C._set_sdp_use_math(启用)


[文档]def 允许_fp16_bf16_reduction_math_sdp(启用: bool):
r"""
..警告：此标志处于测试阶段，可能会发生变化。

启用或禁用数学缩放点积注意力中的 fp16/bf16 缩减。
"""
torch._C._set_math_sdp_allow_fp16_bf16_reduction(enabled)


[文档]def fp16_bf16_reduction_math_sdp_allowed():
r"""
.. 警告:: 此标志处于测试阶段，可能会发生变化。

返回是否启用数学缩放点积注意力中的 fp16/bf16 缩减。
"""
返回 torch._C._get_math_sdp_allow_fp16_bf16_reduction()


[文档]def is_flash_attention_available() -> bool:
检查 PyTorch 是否是用 FlashAttention 构建的，用于缩放点积注意力。

返回值：
如果 FlashAttention 已构建并可用，则为 True；否则为 False。

注意：
此函数依赖于 CUDA 支持的 PyTorch 构建。它将返回 False
在非 CUDA 环境中。
"""
返回 torch._C._is_flash_attention_available()


[文档]def can_use_flash_attention(params: SDPAParams, debug: bool = False) -> bool:
检查 FlashAttention 是否可以在 scaled_dot_product_attention 中使用。

参数:
params：SDPAParams 实例，包含查询张量
key, value，一个可选的注意力掩码，dropout 率，以及
表示注意力是否为因果的标志。
debug：是否记录 FlashAttention 无法运行的原因的 debug 信息。
默认为 False。

返回：
真实如果 FlashAttention 可以使用给定的参数；否则，为 False。

注意：
此函数依赖于 CUDA 支持的 PyTorch 构建。在非 CUDA 环境中，它将返回 False
。
"""
返回 torch._C._can_use_flash_attention(params, debug) 是否可以使用 flash_attention。


[文档]def can_use_efficient_attention(params: SDPAParams, debug: bool = False) -> bool:
检查 efficient_attention 是否可以在 scaled_dot_product_attention 中使用。

Args:
参数：一个包含查询张量、键、值、可选的注意力掩码、dropout 率以及
一个表示注意力是否因果的标志的 SDPAParams 实例。
一个标志，表示注意力是否因果。
debug：是否记录.warn 信息，说明为什么 efficient_attention 无法运行。
默认为 False。

返回：
如果可以使用给定的参数使用 efficient_attention，则返回 True；否则返回 False。

备注：
此功能依赖于 CUDA 支持的 PyTorch 构建。在非 CUDA 环境中将返回 False
在非 CUDA 环境中。
"""
return torch._C._can_use_mem_efficient_attention(params, debug)


[文档]def can_use_cudnn_attention(params: SDPAParams, debug: bool = False) -> bool:
r"""检查是否可以在缩放点积注意力中使用 cudnn_attention。

Args:
params: 一个包含查询张量的 SDPAParams 实例，
键、值、一个可选的注意力掩码、dropout 率以及
一个表示注意力是否因果的标志。
debug: 是否记录 cuDNN 注意力无法运行的信息。
默认为 False。

返回值：
如果可以使用给定的参数使用 cuDNN，则为 True；否则为 False。

注意：
此功能依赖于 CUDA 支持的 PyTorch 构建。它将返回 False
在非 CUDA 环境中。
"""
return torch._C._can_use_cudnn_attention(params, debug)


[文档]def cudnn_sdp_enabled():
r"""
.. 警告:: 此标志处于测试阶段，可能会发生变化。

返回 cuDNN 缩放点积注意力是否启用。
"""
"""
return torch._C._get_cudnn_sdp_enabled()


[文档]def 启用_cudnn_sdp(enabled: bool):
r"""
..警告：此标志处于测试阶段，可能会发生变化。

启用或禁用 cuDNN 缩放点积注意力。
"""
torch._C._set_sdp_use_cudnn(启用)


[文档]@contextlib.contextmanager
@deprecated(
    (
"``torch.backends.cuda.sdp_kernel()`` 已弃用。"
"在未来，此上下文管理器将被移除。"
"请参阅 `torch.nn.attention.sdpa_kernel()` 了解新的上下文管理器，"
"带有更新后的签名。"
    ),
category=FutureWarning,
)
def sdp_kernel(
enable_flash: bool = True,
enable_math: 布尔 = True,
enable_mem_efficient: 布尔 = True,
enable_cudnn: 布尔 = True,
):
r"""
..警告::此标志处于测试阶段，可能会发生变化。

此上下文管理器可用于临时启用或禁用缩放点积注意力机制的三个后端中的任何一个。
退出上下文管理器后，将恢复标志的先前状态。
"""
从 torch.nn.attention 导入 sdpa_kernel

backend_list = []
如果启用闪光:
backend_list.append(SDPBackend.FLASH_ATTENTION)
if enable_mem_efficient:
backend_list.append(SDPBackend.EFFICIENT_ATTENTION)
if enable_math:
backend_list.append(SDPBackend.MATH)
if enable_cudnn:
backend_list.append(SDPBackend.CUDNN_ATTENTION)

with sdpa_kernel(backend_list) as context:
try:
yield context
finally:
pass


cufft_plan_cache = cuFFTPlanCacheManager()
矩阵乘法 = cuBLASModule()