Python实现GPU加速图像处理的代码详解

import torch
import torch.nn as nn
import cv2
import numpy as np

# 检查 gpu 是否可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"using device: {device}")

# 读取图像并转换为 pytorch 张量
image = cv2.imread("input.jpg")  # 读取 bgr 格式图像
image = cv2.cvtcolor(image, cv2.color_bgr2rgb)  # 转为 rgb
image_tensor = torch.from_numpy(image).float().permute(2, 0, 1)  # hwc -> chw
image_tensor = image_tensor.unsqueeze(0).to(device)  # 添加 batch 维度并移至 gpu

# 定义边缘检测卷积核（sobel算子）
conv_layer = nn.conv2d(
    in_channels=3,
    out_channels=3,
    kernel_size=3,
    bias=false,
    padding=1
).to(device)

# 手动设置 sobel 核权重（示例，仅作用于水平边缘）
sobel_kernel = torch.tensor([
    [[[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]],  # red 通道
    [[[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]],  # green 通道
    [[[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]],  # blue 通道
], dtype=torch.float32).repeat(3, 1, 1, 1).to(device)

conv_layer.weight.data = sobel_kernel

# 执行卷积操作（gpu加速）
with torch.no_grad():
    output_tensor = conv_layer(image_tensor)

# 将结果转换回 numpy 并保存
output = output_tensor.squeeze(0).permute(1, 2, 0).cpu().numpy()
output = np.clip(output, 0, 255).astype(np.uint8)
cv2.imwrite("edge_detection_gpu.jpg", cv2.cvtcolor(output, cv2.color_rgb2bgr))

import cv2
import time

# 检查 opencv 是否支持 cuda
print("cuda devices:", cv2.cuda.getcudaenableddevicecount())

# 读取图像并上传到 gpu
image = cv2.imread("input.jpg")
gpu_image = cv2.cuda_gpumat()
gpu_image.upload(image)

# 创建 gpu 加速的高斯滤波器
gaussian_filter = cv2.cuda.creategaussianfilter(
    cv2.cv_8uc3,  # 输入类型 (8-bit unsigned, 3 channels)
    cv2.cv_8uc3,  # 输出类型
    (15, 15),      # 核大小
    0              # sigma（自动计算）
)

# 执行滤波（重复多次测试速度）
start_time = time.time()
for _ in range(100):  # 重复 100 次模拟大数据量
    gpu_blur = gaussian_filter.apply(gpu_image)
end_time = time.time()

# 下载结果到 cpu 并保存
result = gpu_blur.download()
print(f"gpu time: {end_time - start_time:.4f} seconds")
cv2.imwrite("blur_gpu.jpg", result)

import cupy as cp
import cv2
import numpy as np
import time

# 读取图像并转为灰度
image = cv2.imread("input.jpg", cv2.imread_grayscale)

# 将 numpy 数组转为 cupy 数组（上传到 gpu）
image_gpu = cp.asarray(image)

# 快速傅里叶变换（fft）和逆变换（ifft）
start_time = time.time()
fft_gpu = cp.fft.fft2(image_gpu)
fft_shift = cp.fft.fftshift(fft_gpu)
magnitude_spectrum = cp.log(cp.abs(fft_shift))
end_time = time.time()

# 将结果转回 cpu
magnitude_cpu = cp.asnumpy(magnitude_spectrum)
print(f"gpu fft time: {end_time - start_time:.4f} seconds")

# 归一化并保存频谱图
magnitude_cpu = cv2.normalize(magnitude_cpu, none, 0, 255, cv2.norm_minmax)
cv2.imwrite("fft_spectrum_gpu.jpg", magnitude_cpu.astype(np.uint8))

from numba import cuda
import numpy as np
import cv2
import time

# 读取图像
image = cv2.imread("input.jpg")
height, width, channels = image.shape

# 定义 gpu 核函数
@cuda.jit
def invert_colors_kernel(image):
    x, y = cuda.grid(2)
    if x < image.shape[0] and y < image.shape[1]:
        for c in range(3):  # 遍历 rgb 通道
            image[x, y, c] = 255 - image[x, y, c]

# 将图像上传到 gpu
image_gpu = cuda.to_device(image)

# 配置线程和块
threads_per_block = (16, 16)
blocks_per_grid_x = (height + threads_per_block[0] - 1) // threads_per_block[0]
blocks_per_grid_y = (width + threads_per_block[1] - 1) // threads_per_block[1]
blocks_per_grid = (blocks_per_grid_x, blocks_per_grid_y)

# 执行核函数
start_time = time.time()
invert_colors_kernel[blocks_per_grid, threads_per_block](image_gpu)
cuda.synchronize()  # 等待 gpu 完成
end_time = time.time()

# 下载结果并保存
image_cpu = image_gpu.copy_to_host()
print(f"gpu invert time: {end_time - start_time:.6f} seconds")
cv2.imwrite("inverted_gpu.jpg", image_cpu)

import torch
import torchvision.models as models
from torchvision import transforms
from pil import image

# 加载预训练模型到 gpu
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = models.vgg19(pretrained=true).features.to(device).eval()

# 图像预处理
preprocess = transforms.compose([
    transforms.resize(512),
    transforms.totensor(),
    transforms.normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# 加载内容图像和风格图像
content_image = image.open("content.jpg")
style_image = image.open("style.jpg")

# 将图像转为张量并移至 gpu
content_tensor = preprocess(content_image).unsqueeze(0).to(device)
style_tensor = preprocess(style_image).unsqueeze(0).to(device)

# 定义风格迁移函数（示例，需完整实现损失计算和优化）
def style_transfer(model, content_input, style_input, iterations=500):
    # 创建可优化图像
    input_image = content_input.clone().requires_grad_(true)
    
    # 定义优化器
    optimizer = torch.optim.lbfgs([input_image])
    
    # 风格迁移循环
    for i in range(iterations):
        def closure():
            optimizer.zero_grad()
            # 提取特征并计算损失（需实现具体细节）
            # ...
            return total_loss
        
        optimizer.step(closure)
    
    return input_image

# 执行风格迁移（需补充完整代码）
output_image = style_transfer(model, content_tensor, style_tensor)

# 后处理并保存结果
output_image = output_image.squeeze().cpu().detach()
output_image = transforms.topilimage()(output_image)
output_image.save("style_transfer_gpu.jpg")

pip install torch torchvision opencv-python-headless cupy numba