opencv如何使用GPU的三种方法_opencv gpu

我在工作实验涉及到图像和视频处理时，通常使用opencv提供的库来做处理，虽然OpenCV是一个广泛使用的库，它提供了丰富的功能和工具。然而，有时候在处理大量图片或视频时，我们可能会面临速度受限的问题。

opencv执行图像处理，就跟我们电脑一样，打游戏CPU是来加载处理数据的，显卡（GPU）是来渲染图像。下面由我助理来介绍如何本文的内容吧

numpy运算加速

一开始我其实考虑使用python其他库来加速图像处理的计算，因为在计算机视角下的图像是可以等价为numpy类型的数值，在Python中，有几个库可以加速NumPy运算。其中最常用的库是NumPy本身，它已经高度优化，可以提供快速的数值计算。但是，如果你需要进一步加速NumPy运算，可以考虑下面这个库：

Numba：Numba是一个即时（just-in-time）编译器，可以将Python函数编译成高效的机器码。它支持在NumPy数组上进行加速运算。你可以使用装饰器@numba.jit将函数编译为机器码，以提高其性能。

以下是一个使用Numba加速NumPy运算的示例代码：

import numba
import numpy as np



def cpu_function(a):
    # 在这里编写需要加速的NumPy运算代码
    trace = 0
    # 假设输入变量是numpy数组
    for i in range(a.shape[0]):   # Numba 擅长处理循环
        trace += np.tanh(a[i, i])  # numba喜欢numpy函数
    return a + trace

@numba.jit(nopython=True)
def gpu_function(a):
    # 在这里编写需要加速的NumPy运算代码
    trace = 0
    # 假设输入变量是numpy数组
    for i in range(a.shape[0]):   # Numba 擅长处理循环
        trace += np.tanh(a[i, i])  # numba喜欢numpy函数
    return a + trace
    


# 调用加速后的函数
x = np.arange(10000).reshape(100, 100)


print('cpu执行时间：')
% timeit cpu_function(x)
print('gpu执行时间：')
% timeit gpu_function(x)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

cpu执行时间：
199 µs ± 1.27 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
gpu执行时间：
4.18 µs ± 32.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
1
2
3
4

1 微秒(us)=0.000001 秒

但这种方法对于读取视频速度还是没有影响的，为了解决这个问题，我们可以利用GPU加速来提高图像和视频的读取速度。使用OpenCV的cuda模块，我们可以将解码和处理操作从CPU转移到GPU上，以利用GPU的并行计算能力。这种方式可以显著提高处理速度，特别是在大规模图像和视频处理的情况下。下面我将介绍三种opencv使用GPU的方法

opencv内置函数运算

在OpenCV的Python绑定中，可以使用一些内置函数来利用GPU进行加速。以下是使用GPU加速的方法和原理：

1. 安装正确的依赖项：与使用DNN模块相同，首先需要确保在系统上安装了与GPU加速相关的依赖项，包括CUDA和cuDNN。
2. 创建GPU加速的函数：在OpenCV中，某些函数可以利用GPU进行加速，例如图像处理函数（如滤波、图像变换等）和矩阵操作函数（如矩阵乘法、转置等）。这些函数在使用时需要将数据传递到GPU上进行处理。
3. 分配GPU内存：在使用GPU加速函数之前，需要为输入和输出数据在GPU上分配内存。可以使用cv2.cuda.alloc()函数来为输入和输出数据创建GPU内存。
4. 将数据传输到GPU：将输入数据从主机内存（CPU）传输到GPU内存。可以使用cv2.cuda_GpuMat.upload()函数将数据从CPU内存上传到GPU内存。
5. 执行GPU加速函数：调用相应的GPU加速函数，传递GPU上的输入数据作为参数，并在GPU上进行计算。这些函数将直接在GPU上执行，以获得加速的效果。
6. 从GPU中下载数据：如果需要将结果数据从GPU内存下载到主机内存，可以使用cv2.cuda_GpuMat.download()函数。这样，就可以在主机上进行后续的处理或输出。

下面是一个结合前面的计时器类的示例代码，展示了如何使用OpenCV的cv2.calcOpticalFlowFarneback函数进行图像的光流计算预处理，并通过CPU和GPU实现对比执行速度：

import cv2
import time

# 图像预处理函数（CPU实现）
def preprocess_image_cpu(img):
    # 在这里进行图像预处理
    # 转换为灰度图像  
	gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  
	  
	# 直方图均衡化  
	equalized = cv2.equalizeHist(gray)  
	  
	# Sobel锐化  
	sobelx = cv2.Sobel(equalized, cv2.CV_64F, 1, 1, ksize=3)  
	sobely = cv2.Sobel(equalized, cv2.CV_64F, 0, 1, ksize=3)  
	sober = np.sqrt(sobelx ** 2 + sobely ** 2) 

	# 显示原图、直方图均衡化后的图像、Sobel锐化后的图像  
	cv2.imshow('Original', img)  
	cv2.imshow('Equalized', equalized)  
	cv2.imshow('Sober', sober)  
	  
	cv2.waitKey(0)  
	cv2.destroyAllWindows() 


# 图像预处理函数（GPU实现）
def preprocess_image_gpu(img):
    if not cv2.cuda.getCudaEnabledDeviceCount():
        print("CUDA is not available. Please make sure CUDA drivers are installed.")
        return

    gpu_image = cv2.cuda_GpuMat()
    gpu_image.upload(img)

    # 在这里进行图像预处理（GPU实现）
    # 转换为灰度图像  
	gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  
	  
	# 直方图均衡化  
	equalized = cv2.equalizeHist(gray)  
	  
	# Sobel锐化  
	sobelx = cv2.Sobel(equalized, cv2.CV_64F, 1, 1, ksize=3)  
	sobely = cv2.Sobel(equalized, cv2.CV_64F, 0, 1, ksize=3)  
	sober = np.sqrt(sobelx ** 2 + sobely ** 2) 

	# 显示原图、直方图均衡化后的图像、Sobel锐化后的图像  
	cv2.imshow('Original', img)  
	cv2.imshow('Equalized', equalized)  
	cv2.imshow('Sober', sober)  
	  
	cv2.waitKey(0)  
	cv2.destroyAllWindows() 

# 读取图像
image_path = "path/to/image.jpg"
image = cv2.imread(image_path)

print('cpu执行时间：')
% timeit preprocess_image_cpu(image)
print('gpu执行时间：')
% timeit preprocess_image_gpu(image)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

openCV DNN 模块

在OpenCV的Python绑定中，DNN模块可以利用GPU加速来进行深度神经网络的推理。以下是使用GPU加速的方法和原理：

1. 安装正确的依赖项：首先，确保你的系统上安装了与GPU加速相关的依赖项。这通常包括安装CUDA（Compute Unified Device Architecture）和cuDNN（CUDA Deep Neural Network）。
2. 配置OpenCV编译选项：在编译OpenCV时，需要确保启用了GPU加速选项。可以使用CMake进行编译配置，通过启用相关的CUDA选项来启用GPU加速支持。
3. 加载模型和权重：使用OpenCV的DNN模块加载深度神经网络模型和相应的权重文件。例如，可以使用cv2.dnn.readNet()函数加载模型。
4. 设置推理设备：使用cv2.dnn_DNN_BACKEND_CUDA和cv2.dnn.DNN_TARGET_CUDA参数设置推理设备为CUDA。
5. 配置网络：为了使用GPU加速，需要将网络配置为使用CUDA。可以使用net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)和net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)方法设置网络的后端和目标。
6. 进行推理：现在，可以使用GPU加速进行深度神经网络的推理。使用net.forward()方法来运行前向传播，并获取网络的输出。

下面是一个结合计时器的示例代码，展示了如何使用OpenCV的dnn模块进行图像处理，并通过CPU和GPU实现对比执行速度：

import cv2
import time

# 图像处理函数（CPU实现）
def process_image_cpu(image):
    # 在这里进行图像处理（CPU实现）
    # ...

    return processed_image

# 图像处理函数（GPU实现）
def process_image_gpu(image):
    if not cv2.cuda.getCudaEnabledDeviceCount():
        print("CUDA is not available. Please make sure CUDA drivers are installed.")
        return

    net = cv2.dnn.readNetFromCaffe("path/to/caffe/prototxt", "path/to/caffe/model")
    blob = cv2.dnn.blobFromImage(image, scalefactor=1.0, size=(300, 300), mean=(104.0, 177.0, 123.0), swapRB=True)

    gpu_blob = cv2.cuda_GpuMat()
    gpu_blob.upload(blob)

    net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA)
    net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA)

    gpu_net = cv2.dnn_DetectionModel(net)
    gpu_net.setInput(gpu_blob)

    start_time = time.time()
    gpu_detection = gpu_net.forward()
    end_time = time.time()
    gpu_execution_time = end_time - start_time

    # 在这里进行图像处理（GPU实现）
    # ...

    gpu_processed_image = gpu_blob.download()
    return gpu_processed_image, gpu_execution_time

# 读取图像
image_path = "path/to/image.jpg"
image = cv2.imread(image_path)


print('cpu执行时间：')
% timeit preprocess_image_cpu(image)
print('gpu执行时间：')
% timeit preprocess_image_gpu(image)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

在上述代码中，我们定义了两个图像处理函数：process_image_cpu和process_image_gpu，分别表示CPU和GPU的实现方式。

读取视频

在Python中使用OpenCV读取视频时，可以使用GPU加速来提高读取速度。为此，你可以使用OpenCV的cuda模块以及支持CUDA的显卡驱动和CUDA工具包。

下面是一个示例代码，展示如何使用GPU加速在OpenCV中读取视频的每一帧：

import cv2

# 检查是否支持CUDA
if not cv2.cuda.getCudaEnabledDeviceCount():
    print("CUDA is not available. Please make sure CUDA drivers are installed.")
    exit()

# 创建GPU设备对象
gpu_id = 0  # 选择GPU设备的ID
device = cv2.cuda.Device(gpu_id)
ctx = device.createContext()

# 打开视频文件
video_path = "path/to/video/file.mp4"
cap = cv2.VideoCapture(video_path)

# 检查视频文件是否成功打开
if not cap.isOpened():
    print("Failed to open the video file.")
    exit()

# 设置GPU加速
cap.set(cv2.CAP_PROP_CUDA_MPS, 1)

# 循环读取视频的每一帧
while True:
    # 使用GPU加速读取一帧
    ret, frame = cap.read(cv2.CAP_CUDA)

    # 检查是否成功读取帧
    if not ret:
        break

    # 在这里进行你希望执行的操作
    # ...

# 释放资源
cap.release()
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

在上述代码中，首先检查是否支持CUDA，然后创建一个指定GPU设备的上下文（context）。接着打开视频文件，设置GPU加速，并循环读取视频的每一帧。读取过程中，使用cv2.CAP_CUDA作为参数来启用GPU加速。你可以在读取帧后的代码块中执行你希望的操作，例如对帧进行处理或展示。

请确保你的系统中已经正确安装了支持CUDA的显卡驱动和CUDA工具包，以及适用于GPU加速的OpenCV版本。同时，根据实际情况修改代码中的视频文件路径和GPU设备的ID。

下面是一个示例案例，演示了如何使用CPU和GPU分别读取视频，并使用time库计算二者读取视频的时间，并进行对比：

import cv2
import time

# 用CPU读取视频
def read_video_cpu(video_path):
    cap = cv2.VideoCapture(video_path)

    while True:
        ret, frame = cap.read()

        if not ret:
            break

        # 在这里进行你希望执行的操作
        # ...
    cap.release()


# 用GPU读取视频
def read_video_gpu(video_path):
    if not cv2.cuda.getCudaEnabledDeviceCount():
        print("CUDA is not available. Please make sure CUDA drivers are installed.")
        return

    gpu_id = 0
    device = cv2.cuda.Device(gpu_id)
    ctx = device.createContext()

    cap = cv2.VideoCapture(video_path)

    cap.set(cv2.CAP_PROP_CUDA_MPS, 1)

    while True:
        ret, frame = cap.read(cv2.CAP_CUDA)

        if not ret:
            break

        # 在这里进行你希望执行的操作
        # ...

    cap.release()


# 视频文件路径
video_path = "path/to/video/file.mp4"

print('cpu执行时间：')
% timeit read_video_cpu(video_path)
print('gpu执行时间：')
% timeit read_video_gpu(video_path)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

使用GPU读取视频的原理是将视频解码和帧处理操作从CPU转移到GPU上进行加速。在这种情况下，GPU负责解码视频帧并执行任何与帧相关的处理操作，而CPU主要负责控制和协调工作流程。

具体实现方式是，通过OpenCV的cv2.VideoCapture函数设置参数cv2.CAP_CUDA来启用GPU加速。这将使用GPU进行视频解码，并将解码后的帧传输到GPU内存中。然后，在每一帧上进行处理时，GPU负责执行相应的操作，例如图像处理、计算等。CPU则不直接参与这些操作，而是仅在必要时与GPU进行通信和同步，以确保正确的工作流程和数据传输。

需要注意的是，虽然视频的解码和帧处理操作是由GPU完成的，但仍然需要CPU的参与来完成初始化、设置参数、控制流程以及与GPU的通信和同步。因此，在整个过程中，CPU和GPU是协同工作的。在Linux系统中使用top命令查看CPU利用率时，如果视频读取和处理操作主要由GPU执行，那么CPU利用率可能会较低