Python中GPU计算的库pycuda的使用

pip install pycuda

import pycuda.autoinit
import pycuda.driver as cuda

import pycuda.autoinit
import pycuda.gpuarray as gpuarray

# 定义两个向量
a = gpuarray.to_gpu([1, 2, 3, 4])
b = gpuarray.to_gpu([5, 6, 7, 8])

# 执行向量加法
c = a + b
print(c)

import numpy as np
import pycuda.autoinit
import pycuda.gpuarray as gpuarray
import pycuda.driver as cuda
from pycuda.elementwise import ElementwiseKernel

# 定义矩阵
A = np.random.randn(3, 3).astype(np.float32)
B = np.random.randn(3, 3).astype(np.float32)

# 将矩阵上传到 GPU
d_A = cuda.mem_alloc(A.nbytes)
d_B = cuda.mem_alloc(B.nbytes)
cuda.memcpy_htod(d_A, A)
cuda.memcpy_htod(d_B, B)

# 定义矩阵乘法的内核函数
matmul_kernel = ElementwiseKernel(
    "float *A, float *B, float *C",
    "C[i] = A[i] * B[i]",
    "matmul_kernel"
)

# 执行矩阵乘法
C = gpuarray.empty_like(A)
matmul_kernel(d_A, d_B, C)

# 从 GPU 获取结果
result = np.empty_like(C.get())
cuda.memcpy_dtoh(result, C)

print(result)

import numpy as np
import pycuda.autoinit
import pycuda.gpuarray as gpuarray
import pycuda.driver as cuda
from pycuda.compiler import SourceModule

# 定义 CUDA 核函数
mod = SourceModule("""
    __global__ void add(int *a, int *b, int *c) {
        int idx = threadIdx.x + blockIdx.x * blockDim.x;
        c[idx] = a[idx] + b[idx];
    }
""")

# 获取核函数
add_func = mod.get_function("add")

# 定义输入数据
a = np.array([1, 2, 3, 4]).astype(np.int32)
b = np.array([5, 6, 7, 8]).astype(np.int32)
c = np.zeros_like(a)

# 将数据上传到 GPU
d_a = gpuarray.to_gpu(a)
d_b = gpuarray.to_gpu(b)
d_c = gpuarray.to_gpu(c)

# 执行核函数
block_size = 4
grid_size = len(a) // block_size
add_func(d_a, d_b, d_c, block=(block_size, 1, 1), grid=(grid_size, 1))

# 从 GPU 获取结果
result = d_c.get()
print(result)

import numpy as np
import pycuda.autoinit
import pycuda.gpuarray as gpuarray
from pycuda.elementwise import ElementwiseKernel

# 定义矩阵运算内核函数
matmul_kernel = ElementwiseKernel(
    "float *A, float *B, float *C",
    "C[i] = A[i] * B[i]",
    "matmul_kernel"
)

# 创建随机矩阵
A = np.random.randn(1000, 1000).astype(np.float32)
B = np.random.randn(1000, 1000).astype(np.float32)

# 将矩阵上传到 GPU
d_A = gpuarray.to_gpu(A)
d_B = gpuarray.to_gpu(B)
d_C = gpuarray.empty_like(d_A)

# 执行矩阵运算内核函数
matmul_kernel(d_A, d_B, d_C)

# 从 GPU 获取结果
result = d_C.get()

print(result)

import numpy as np
import pycuda.autoinit
import pycuda.gpuarray as gpuarray
from sklearn.datasets import make_classification
from sklearn.neural_network import MLPClassifier

# 创建一个虚拟数据集
X, y = make_classification(n_samples=10000, n_features=20, random_state=42)

# 将数据上传到 GPU
d_X = gpuarray.to_gpu(X.astype(np.float32))
d_y = gpuarray.to_gpu(y.astype(np.int32))

# 创建并训练神经网络模型
mlp = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=100)
mlp.fit(d_X.get(), d_y.get())

# 打印模型评分
score = mlp.score(d_X.get(), d_y.get())
print("模型评分:", score)

import numpy as np
import pycuda.autoinit
import pycuda.gpuarray as gpuarray
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

# 加载 MNIST 数据集
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 数据预处理
X_train = X_train.reshape(-1, 784).astype('float32') / 255.0
X_test = X_test.reshape(-1, 784).astype('float32') / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# 将数据上传到 GPU
d_X_train = gpuarray.to_gpu(X_train)
d_y_train = gpuarray.to_gpu(y_train)
d_X_test = gpuarray.to_gpu(X_test)
d_y_test = gpuarray.to_gpu(y_test)

# 创建并训练深度学习模型
model = Sequential([
    Dense(512, activation='relu', input_shape=(784,)),
    Dense(256, activation='relu'),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(d_X_train.get(), d_y_train.get(), epochs=10, batch_size=128)

# 评估模型
loss, accuracy = model.evaluate(d_X_test.get(), d_y_test.get())
print('测试集损失:', loss)
print('测试集准确率:', accuracy)