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的整合和呼叫。