cuda函数库介绍

概览

cuda是利用Nvidia GPU进行计算，计算的方式，就是利用 cuda 函数库，应该熟悉这些函数库的分类方式和它们之间的关系。
常用的有：随机数生成（curand）、傅里叶变换（cufft）、基本线性代数（cublas）、稀疏矩阵运算（cusparse）、深度神经网络加速（cudnn）、解线性方程（cusolver）

NVIDIA cuRAND 库详细介绍

NVIDIA cuRAND（CUDA Random Number Generation library）是 NVIDIA 提供的一个高性能伪随机数生成库，用于在 NVIDIA GPU 上生成随机数。cuRAND 支持多种随机数生成算法，提供了生成均匀分布、正态分布、泊松分布等多种分布的随机数。cuRAND 能够利用 GPU 的并行计算能力，快速生成大量高质量的随机数。

cuRAND 的主要特点包括：

  • 高性能：利用 GPU 的并行计算能力，快速生成大量随机数。
  • 多种分布：支持均匀分布、正态分布、泊松分布等多种常用分布。
  • 灵活接口：提供简单易用的 API，支持多种随机数生成器和种子初始化。
  • 与 CUDA 集成：可以与其他 CUDA 库（如 cuBLAS、cuFFT 等）无缝集成，适用于科学计算、模拟和机器学习等领域。

使用 cuRAND 的 Python 示例

虽然 cuRAND 是一个 C/C++ 库，但我们可以通过 CuPy 库在 Python 中利用其功能。CuPy 是一个与 NumPy 兼容的 GPU 数组库，提供了与 NumPy 相同的接口，并且可以利用 cuRAND 生成随机数。

安装 CuPy

首先，确保你已经安装了 CuPy。你可以使用以下命令安装：

pip install cupy-cuda12x  # 这里的 cuda12x 表示适用于 CUDA 12.x 版本

使用 CuPy 生成随机数

以下是一个使用 CuPy 和 cuRAND 生成随机数的示例：

import cupy as cp

# 生成均匀分布的随机数
uniform_random_numbers = cp.random.rand(1024)

# 生成正态分布的随机数
normal_random_numbers = cp.random.randn(1024)

# 将结果从 GPU 复制到 CPU 并转换为 NumPy 数组
uniform_random_numbers_cpu = cp.asnumpy(uniform_random_numbers)
normal_random_numbers_cpu = cp.asnumpy(normal_random_numbers)

# 打印结果
print("Uniform random numbers:")
print(uniform_random_numbers_cpu)
print("\nNormal random numbers:")
print(normal_random_numbers_cpu)

PyTorch 和 cuRAND 的集成示例

在 PyTorch 中，虽然没有直接使用 cuRAND 的接口，但可以通过集成 CuPy 来利用 cuRAND 生成随机数。以下是一个示例，展示如何在 PyTorch 中使用 CuPy 生成随机数：

import torch
import cupy as cp

# 生成均匀分布的随机数，并转换为 PyTorch 张量
uniform_random_numbers_cupy = cp.random.rand(1024)
uniform_random_numbers_torch = torch.as_tensor(uniform_random_numbers_cupy, device='cuda')

# 生成正态分布的随机数，并转换为 PyTorch 张量
normal_random_numbers_cupy = cp.random.randn(1024)
normal_random_numbers_torch = torch.as_tensor(normal_random_numbers_cupy, device='cuda')

# 打印结果
print("Uniform random numbers (PyTorch):")
print(uniform_random_numbers_torch)
print("\nNormal random numbers (PyTorch):")
print(normal_random_numbers_torch)

解释和总结

  1. 生成随机数：使用 CuPy 生成均匀分布和正态分布的随机数。CuPy 内部利用了 cuRAND 库来实现高效的随机数生成。
  2. 数据转换：使用 torch.as_tensor 将 CuPy 数组转换为 PyTorch 张量，以便在 PyTorch 中继续处理或分析这些随机数。
  3. 打印结果：显示生成的随机数。

总结

NVIDIA cuRAND 提供了高性能的随机数生成功能，能够利用 GPU 的并行计算能力，快速生成各种分布的随机数。通过 CuPy 库，Python 用户可以方便地利用 cuRAND 的功能，从而在科学计算、模拟和机器学习等领域显著加速随机数生成过程。通过示例代码，我们展示了如何在 Python 和 PyTorch 环境中使用 cuRAND 生成高效的随机数。

NVIDIA cuFFT 库详细介绍

NVIDIA cuFFT（CUDA Fast Fourier Transform library）是一个高性能的 FFT（快速傅里叶变换）库，用于在 NVIDIA GPU 上执行快速傅里叶变换。FFT 是一种广泛应用于信号处理、图像处理、音频分析和其他科学计算领域的重要算法。cuFFT 提供了高效的实现，使得用户能够利用 GPU 的并行计算能力来显著加速 FFT 计算。

cuFFT 的主要特点包括：

  • 高性能：利用 GPU 的并行计算能力，加速 FFT 计算。
  • 多种变换类型：支持一维、二维和三维 FFT 变换。
  • 多种精度：支持单精度和双精度浮点数计算。
  • 灵活接口：提供简单易用的 API，与 CPU 上的 FFTW 库类似。

使用 cuFFT 的 Python 示例

尽管 cuFFT 是一个 C/C++ 库，但我们可以通过 CuPy 库在 Python 中利用 cuFFT 的功能。CuPy 是一个与 NumPy 兼容的 GPU 数组库，提供了与 NumPy 相同的接口，并且可以利用 cuFFT 进行快速傅里叶变换。

安装 CuPy

首先，确保你已经安装了 CuPy。你可以使用以下命令安装：

pip install cupy-cuda12x  # 这里的 cuda12x 表示适用于 CUDA 12.x 版本

使用 CuPy 进行 FFT 计算

以下是一个使用 CuPy 和 cuFFT 进行 FFT 计算的示例：

import cupy as cp
import numpy as np

# 创建一个随机的复数数组（大小为1024）
data = cp.random.random(1024) + 1j * cp.random.random(1024)

# 执行 FFT 计算
fft_result = cp.fft.fft(data)

# 执行逆 FFT 计算
ifft_result = cp.fft.ifft(fft_result)

# 将结果从 GPU 复制到 CPU 并转换为 NumPy 数组
fft_result_cpu = cp.asnumpy(fft_result)
ifft_result_cpu = cp.asnumpy(ifft_result)

# 打印结果
print("Original data:")
print(data)
print("\nFFT result:")
print(fft_result_cpu)
print("\nInverse FFT result:")
print(ifft_result_cpu)

PyTorch 和 cuFFT 的集成示例

在 PyTorch 中，虽然直接使用 cuFFT 的情况不多，但可以通过集成 CuPy 来利用 cuFFT 的功能。以下是一个示例，展示如何在 PyTorch 中使用 CuPy 进行 FFT 计算：

import torch
import cupy as cp
import numpy as np

# 创建一个随机的 PyTorch 张量（大小为1024）
data_torch = torch.randn(1024, dtype=torch.complex64, device='cuda')

# 将 PyTorch 张量转换为 CuPy 数组
data_cupy = cp.asarray(data_torch)

# 执行 FFT 计算
fft_result_cupy = cp.fft.fft(data_cupy)

# 将结果转换回 PyTorch 张量
fft_result_torch = torch.as_tensor(fft_result_cupy, device='cuda')

# 打印结果
print("Original data (PyTorch):")
print(data_torch)
print("\nFFT result (CuPy):")
print(fft_result_torch)

解释和总结

  1. 创建数据：我们使用 PyTorch 在 GPU 上创建一个大小为 1024 的随机复数张量 data_torch。
  2. 数据转换：使用 cp.asarray 将 PyTorch 张量转换为 CuPy 数组 data_cupy。这是因为 CuPy 能够直接调用 cuFFT 库来进行 FFT 计算。
  3. 执行 FFT 计算：使用 cp.fft.fft 进行 FFT 计算，得到的结果是一个 CuPy 数组 fft_result_cupy。
  4. 结果转换：将 CuPy 数组转换回 PyTorch 张量 fft_result_torch，以便在 PyTorch 中继续处理或分析结果。

总结

NVIDIA cuFFT 提供了在 GPU 上进行快速傅里叶变换的高性能实现。通过 CuPy 库，Python 用户可以方便地利用 cuFFT 的功能，从而显著加速信号处理、图像处理和科学计算中的 FFT 计算。通过示例代码，我们展示了如何在 Python 和 PyTorch 环境中使用 cuFFT 来进行高效的 FFT 计算。

NVIDIA cuBLAS 库详细介绍

NVIDIA cuBLAS（CUDA Basic Linear Algebra Subprograms library）是 NVIDIA 提供的一套用于 GPU 上的高性能基本线性代数运算的库。它实现了 BLAS 标准中的大部分函数，包括向量和矩阵的操作，如矩阵乘法、求逆、求解线性方程组等。

cuBLAS 的主要特点包括：

  • 高性能：利用 GPU 的并行计算能力，加速线性代数运算。
  • 与 BLAS 标准兼容：提供与传统 BLAS 接口兼容的函数，使得现有的 BLAS 代码可以轻松移植到 GPU 上。
  • 与 CUDA 集成：可以与其他 CUDA 库（如 cuFFT、cuRAND）无缝集成，构建复杂的数值计算应用。

安装 cuBLAS

cuBLAS 是 CUDA 工具包的一部分。安装 PyTorch 时，如果指定了 GPU 支持，cuBLAS 会作为依赖项自动安装。如果单独使用 cuBLAS，可以通过安装 CUDA 工具包来获取。

使用 cuBLAS 的 Python 示例

虽然 cuBLAS 本身是一个 C/C++ 库，但可以通过 PyTorch 或 CuPy 这样的库来间接使用它们的功能。以下是一个通过 PyTorch 使用 cuBLAS 进行矩阵乘法的示例：

import torch

# 确定是否有 GPU 可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 定义两个矩阵 A 和 B
A = torch.randn(3, 3, device=device)
B = torch.randn(3, 3, device=device)

# 使用 cuBLAS 进行矩阵乘法
C = torch.matmul(A, B)

print("Matrix A:")
print(A)
print("\nMatrix B:")
print(B)
print("\nMatrix C (A * B):")
print(C)

在这个示例中：

  1. 检查 GPU 是否可用：如果有 GPU 可用，则选择 CUDA 设备。
  2. 定义矩阵 A 和 B：在 GPU 上创建两个随机矩阵。
  3. 矩阵乘法：使用 torch.matmul 函数进行矩阵乘法。这个操作在 GPU 上执行，并使用 cuBLAS 库来加速计算。
  4. 打印结果：显示输入矩阵和计算结果。

使用 CuPy 直接调用 cuBLAS

CuPy 是一个与 NumPy 兼容的库，可以直接调用 cuBLAS 函数来加速计算。以下是使用 CuPy 进行矩阵乘法的示例：

import cupy as cp

# 定义两个矩阵 A 和 B
A = cp.random.randn(3, 3)
B = cp.random.randn(3, 3)

# 使用 cuBLAS 进行矩阵乘法
C = cp.dot(A, B)

print("Matrix A:")
print(cp.asnumpy(A))  # 将结果从 GPU 复制到 CPU 并转换为 NumPy 数组
print("\nMatrix B:")
print(cp.asnumpy(B))
print("\nMatrix C (A * B):")
print(cp.asnumpy(C))

在这个示例中：

  1. 定义矩阵 A 和 B：使用 CuPy 在 GPU 上创建两个随机矩阵。
  2. 矩阵乘法：使用 cp.dot 函数进行矩阵乘法，调用 cuBLAS 库。
  3. 打印结果：将 GPU 上的矩阵复制到 CPU 并转换为 NumPy 数组，然后打印结果。

这些示例展示了如何通过 PyTorch 和 CuPy 利用 cuBLAS 库在 GPU 上加速线性代数计算。通过这种方式，可以显著提升深度学习和科学计算任务的性能。

NVIDIA cuSPARSE 库详细介绍

NVIDIA cuSPARSE（CUDA Sparse Matrix Library）是一个高性能库，用于在 NVIDIA GPU 上执行稀疏矩阵操作。稀疏矩阵在许多科学计算、工程模拟和机器学习应用中都非常常见。cuSPARSE 提供了一组优化的函数，用于处理稀疏矩阵的各种操作，如矩阵向量乘法、矩阵矩阵乘法、求解稀疏线性系统等。

cuSPARSE 的主要特点包括：

  • 高性能：利用 GPU 的并行计算能力，加速稀疏矩阵运算。
  • 多种稀疏格式：支持多种稀疏矩阵存储格式，如 CSR（Compressed Sparse Row）、CSC（Compressed Sparse Column）、COO（Coordinate List）等。
  • 广泛的功能：提供矩阵向量乘法、矩阵矩阵乘法、稀疏三角求解、稀疏 QR 和 LU 分解等功能。
  • 灵活接口：提供简单易用的 API，适用于科学计算、工程模拟和机器学习等领域。

使用 cuSPARSE 的 Python 示例

尽管 cuSPARSE 本身是一个 C/C++ 库，但我们可以通过 CuPy 库在 Python 中利用其功能。CuPy 是一个与 NumPy 兼容的 GPU 数组库，提供了与 NumPy 相同的接口，并且可以利用 cuSPARSE 进行稀疏矩阵操作。

安装 CuPy

首先，确保你已经安装了 CuPy。你可以使用以下命令安装：

pip install cupy-cuda12x  # 这里的 cuda12x 表示适用于 CUDA 12.x 版本

使用 CuPy 进行稀疏矩阵操作

以下是一个使用 CuPy 和 cuSPARSE 进行稀疏矩阵向量乘法的示例：

import cupy as cp
import numpy as np
from scipy.sparse import random as sparse_random

# 生成一个随机的稀疏矩阵和一个密集向量
size = 10
density = 0.2
A_cpu = sparse_random(size, size, density=density, format='csr', dtype=np.float32)
x_cpu = np.random.rand(size).astype(np.float32)

# 将稀疏矩阵和向量从 CPU 传输到 GPU
A_gpu = cp.sparse.csr_matrix(A_cpu)
x_gpu = cp.asarray(x_cpu)

# 执行稀疏矩阵向量乘法
y_gpu = A_gpu.dot(x_gpu)

# 将结果从 GPU 复制到 CPU 并转换为 NumPy 数组
y_cpu = cp.asnumpy(y_gpu)

# 打印结果
print("Sparse matrix A (CSR format):")
print(A_cpu)
print("\nVector x:")
print(x_cpu)
print("\nResult y (A * x):")
print(y_cpu)

PyTorch 和 cuSPARSE 的集成示例

在 PyTorch 中，虽然没有直接使用 cuSPARSE 的接口，但可以通过集成 CuPy 来利用 cuSPARSE 的功能。以下是一个示例，展示如何在 PyTorch 中使用 CuPy 进行稀疏矩阵向量乘法：

import torch
import cupy as cp
import numpy as np
from scipy.sparse import random as sparse_random

# 生成一个随机的稀疏矩阵和一个密集向量
size = 10
density = 0.2
A_cpu = sparse_random(size, size, density=density, format='csr', dtype=np.float32)
x_torch = torch.rand(size, dtype=torch.float32, device='cuda')

# 将稀疏矩阵从 CPU 传输到 GPU
A_gpu = cp.sparse.csr_matrix(A_cpu)

# 将 PyTorch 向量转换为 CuPy 数组
x_gpu = cp.asarray(x_torch)

# 执行稀疏矩阵向量乘法
y_gpu = A_gpu.dot(x_gpu)

# 将结果转换回 PyTorch 张量
y_torch = torch.as_tensor(y_gpu, device='cuda')

# 打印结果
print("Sparse matrix A (CSR format):")
print(A_cpu)
print("\nVector x (PyTorch):")
print(x_torch)
print("\nResult y (A * x, PyTorch):")
print(y_torch)

解释和总结

  1. 生成稀疏矩阵和向量：我们使用 scipy.sparse.random 生成一个随机稀疏矩阵 A_cpu，并使用 NumPy 生成一个随机密集向量 x_cpu。
  2. 数据传输：将稀疏矩阵和向量从 CPU 传输到 GPU。稀疏矩阵使用 cp.sparse.csr_matrix 转换为 CuPy 的 CSR 格式矩阵，密集向量使用 cp.asarray 转换为 CuPy 数组。
  3. 稀疏矩阵向量乘法：使用 A_gpu.dot(x_gpu) 进行稀疏矩阵向量乘法运算。
  4. 结果传输和打印：将结果从 GPU 传输回 CPU，并打印结果。

总结

NVIDIA cuSPARSE 提供了在 GPU 上进行高性能稀疏矩阵运算的能力，能够加速矩阵向量乘法、矩阵矩阵乘法和稀疏线性系统求解等操作。通过 CuPy 库，Python 用户可以方便地利用 cuSPARSE 的功能，从而在科学计算、工程模拟和机器学习等领域显著提升计算效率。通过示例代码，我们展示了如何在 Python 和 PyTorch 环境中使用 cuSPARSE 进行高效的稀疏矩阵运算。

NVIDIA cuSOLVER 库详细介绍

NVIDIA cuSOLVER（CUDA Solver Library）是 NVIDIA 提供的一套用于在 GPU 上执行线性代数操作的高性能库。cuSOLVER 支持多种线性代数计算，如矩阵分解、线性方程组求解和特征值分解。它能够利用 GPU 的并行计算能力，大大加速这些复杂的线性代数运算。

cuSOLVER 的主要特点包括：

  • 高性能：利用 GPU 的并行计算能力，加速线性代数运算。
  • 广泛的功能：支持 QR 分解、Cholesky 分解、LU 分解、SVD 分解、特征值计算等。
  • 灵活接口：提供简单易用的 API，方便集成到应用程序中。
  • 与 CUDA 集成：可以与其他 CUDA 库（如 cuBLAS、cuFFT 等）无缝集成，适用于科学计算、机器学习和工程应用。

使用 cuSOLVER 的 Python 示例

虽然 cuSOLVER 本身是一个 C/C++ 库，但可以通过 CuPy 或 PyCUDA 库在 Python 中利用其功能。CuPy 是一个与 NumPy 兼容的 GPU 数组库，提供了与 NumPy 相同的接口，并且可以利用 cuSOLVER 进行线性代数计算。

安装 CuPy

首先，确保你已经安装了 CuPy。你可以使用以下命令安装：

pip install cupy-cuda12x  # 这里的 cuda12x 表示适用于 CUDA 12.x 版本

使用 CuPy 进行矩阵分解和求解

以下是一个使用 CuPy 和 cuSOLVER 进行矩阵分解和求解线性方程组的示例：

import cupy as cp

# 创建一个随机矩阵 A 和一个随机向量 b
A = cp.random.rand(4, 4).astype(cp.float32)
b = cp.random.rand(4).astype(cp.float32)

# 使用 cuSOLVER 进行 LU 分解和线性方程组求解
lu_piv = cp.linalg.lu_factor(A)
x = cp.linalg.lu_solve(lu_piv, b)

# 将结果从 GPU 复制到 CPU 并转换为 NumPy 数组
A_cpu = cp.asnumpy(A)
b_cpu = cp.asnumpy(b)
x_cpu = cp.asnumpy(x)

# 打印结果
print("Matrix A:")
print(A_cpu)
print("\nVector b:")
print(b_cpu)
print("\nSolution x (Ax = b):")
print(x_cpu)

PyTorch 和 cuSOLVER 的集成示例

在 PyTorch 中，虽然没有直接使用 cuSOLVER 的接口，但可以通过集成 CuPy 来利用 cuSOLVER 的功能。以下是一个示例，展示如何在 PyTorch 中使用 CuPy 进行矩阵分解和求解线性方程组：

import torch
import cupy as cp

# 创建一个随机的 PyTorch 张量 A 和 b
A_torch = torch.randn(4, 4, dtype=torch.float32, device='cuda')
b_torch = torch.randn(4, dtype=torch.float32, device='cuda')

# 将 PyTorch 张量转换为 CuPy 数组
A_cupy = cp.asarray(A_torch)
b_cupy = cp.asarray(b_torch)

# 使用 cuSOLVER 进行 LU 分解和线性方程组求解
lu_piv = cp.linalg.lu_factor(A_cupy)
x_cupy = cp.linalg.lu_solve(lu_piv, b_cupy)

# 将结果转换回 PyTorch 张量
x_torch = torch.as_tensor(x_cupy, device='cuda')

# 打印结果
print("Matrix A (PyTorch):")
print(A_torch)
print("\nVector b (PyTorch):")
print(b_torch)
print("\nSolution x (Ax = b, PyTorch):")
print(x_torch)

解释和总结

  1. 创建数据：我们使用 PyTorch 在 GPU 上创建一个随机矩阵 A_torch 和一个随机向量 b_torch。
  2. 数据转换：使用 cp.asarray 将 PyTorch 张量转换为 CuPy 数组 A_cupy 和 b_cupy。这是因为 CuPy 能够直接调用 cuSOLVER 库来进行矩阵分解和求解。
  3. 进行矩阵分解和求解：使用 cp.linalg.lu_factor 进行 LU 分解，并使用 cp.linalg.lu_solve 求解线性方程组 Ax = b。
  4. 结果转换：将 CuPy 数组 x_cupy 转换回 PyTorch 张量 x_torch，以便在 PyTorch 中继续处理或分析这些结果。
  5. 打印结果：显示矩阵 A、向量 b 和解 x。

总结

NVIDIA cuSOLVER 提供了在 GPU 上进行高性能线性代数运算的能力，能够加速矩阵分解、线性方程组求解和特征值分解等操作。通过 CuPy 库，Python 用户可以方便地利用 cuSOLVER 的功能，从而在科学计算和机器学习等领域显著提升计算效率。通过示例代码，我们展示了如何在 Python 和 PyTorch 环境中使用 cuSOLVER 进行高效的线性代数计算。

nvidia-cudnn-cu12 库是 NVIDIA CUDA Deep Neural Network library 的简称，是专门为深度学习应用设计的一个GPU加速库。CUDNN提供了高度优化的卷积神经网络（Convolutional Neural Networks, CNNs）以及其他深度学习算法的实现，如激活函数、池化操作等。它作为GPU加速计算的底层加速模块，被集成在许多深度学习框架中，包括PyTorch、TensorFlow等，以提升训练和推理的速度。

CUDNN的关键特性：

  1. 高度优化：CUDNN对深度学习中常见的操作进行了高度优化，如卷积、激活函数、归一化、池化等，大大提高了运算速度。
  2. 易于集成：CUDNN设计为一个库的形式，可以无缝集成到深度学习框架中，开发者无需关心底层实现细节。
  3. 兼容性：CUDNN支持多种CUDA版本，如这里的cu12表示与CUDA 12版本兼容，确保了与最新硬件和驱动的兼容性。
  4. 灵活性：提供多种算法选择和优化配置，比如可以选择不同的卷积算法来平衡速度和内存使用。

在PyTorch中使用CUDNN

PyTorch在安装时如果检测到系统中有支持的CUDA和CUDNN版本，会自动编译并使用CUDNN加速。你不需要直接调用CUDNN的API，但可以通过配置PyTorch的一些参数来控制CUDNN的行为。

示例：配置PyTorch中的CUDNN行为

在使用PyTorch进行深度学习任务时，可以通过调整torch.backends.cudnn的几个参数来优化性能或调试：

import torch

# 启用CUDNN benchmarking，让PyTorch在第一次运行时自动选择最佳的卷积算法
torch.backends.cudnn.benchmark = True

# 设置确定性行为，牺牲一点性能以获得可重复的实验结果
torch.backends.cudnn.deterministic = True

# 关闭CUDNN的非确定性，这在需要精确复现结果时非常重要
torch.backends.cudnn.enabled = True  # 默认就是True，显式设置表示启用CUDNN

简单的例子来展示PyTorch使用CUDNN进行加速

即便代码本身不直接调用CUDNN。这个例子将仅展示如何创建一个简单的卷积层，并通过GPU执行正向传播，其中CUDNN的加速是自动应用的。

import torch
import torch.nn as nn

# 检查是否有GPU可用，并设置设备
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# 定义一个简单的卷积层
class SimpleConvLayer(nn.Module):
    def __init__(self):
        super(SimpleConvLayer, self).__init__()
        self.conv = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1)

    def forward(self, x):
        return self.conv(x)

# 实例化卷积层并移动到GPU
conv_layer = SimpleConvLayer().to(device)

# 创建一个随机输入张量，并同样移动到GPU
input_tensor = torch.randn(10, 3, 32, 32).to(device)  # 假设一批10个样本，每个样本为3通道，32x32大小

# 执行正向传播
output = conv_layer(input_tensor)

# 打印输出张量的形状，验证操作成功
print("Output shape:", output.shape)

在这个例子中，当我们调用conv_layer(input_tensor)进行正向传播时，如果PyTorch和CUDNN已经正确安装并且当前设备是GPU，那么卷积操作将自动利用CUDNN库进行加速。这个过程是透明的，用户无需直接与CUDNN交互，PyTorch框架内部处理了与CUDNN的集成和调用。

posted @   立体风  阅读(776)  评论(0)  编辑  收藏  举报
相关博文：
· Cuda计算能力
· ubuntu24.04 安装 cupy
· Python-GPU-编程实用指南（二）
· Cupy：利用 NVIDIA GPU 来加速计算
· cuda在ubuntu的安装使用分享
阅读排行：
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
历史上的今天：
2021-05-25 debian使用useradd创建新用户
2020-05-25 C++中list的erase()函数问题
点击右上角即可分享
微信分享提示