Почему python медленнее, чем Matlab?

Question

Наконец, мне удалось изменить код MATLAB на Python code.

Однако, вопреки тому, что я слышал, скорость выполнения Python была удивительно низкой.

Является ли MATLAB лучше в области обработки изображений в наши дни?

Конечно, у меня нет выбора, кроме как использовать Python, потому что компания не покупает MATLAB ...

ps. запустите Python в visual studio среде и IDLE.

Если есть способ ускорить Python, пожалуйста, помогите мне.

## Exercise Python image processing ##

import numpy as np
import cv2
import matplotlib.pyplot as plt

B = cv2.imread(r'D:\remedi\Exercise\Xray\Offset.png', -1) # offset image

for i in range(2,3):

    org_I = cv2.imread(r'D:\remedi\Exercise\Xray\objects\object (' + str(i) + ').png', -1) # original image

    w = cv2.imread(r'D:\remedi\Exercise\Xray\white\white (' + str(i) + ').png', -1) # white image

    # dead & bad pixel correction
    corrected_w = w.copy()
    corrected_org_I = org_I.copy()

    c = np.mean(corrected_w)
    p = np.abs(corrected_w - c)

    sens = 0.7
    [num_y, num_x] = np.where((p < c*sens) | (p > c*sens))

    ar = np.zeros((3,3))
    ar2 = np.zeros((3,3))
    for n in range(0, num_y.shape[0]):
        for j in range(-1,2):
            for k in range(-1,2):
                if num_y[n]+j+1 == 0 or num_x[n]+k+1 == 0 or num_y[n]+j+1 == 577 or num_x[n]+k+1 == 577:
                    ar[j+1][k+1] = 0
                    ar2[j+1][k+1] = 0
                else:
                    ar[j+1][k+1] = corrected_w[num_y[n]+j-1][num_x[n]+k-1]
                    ar2[j+1][k+1] = corrected_org_I[num_y[n]+j-1][num_x[n]+k-1]
        ar[1][1] = 0
        ar2[1][1] = 0
        corrected_w[num_y[n]][num_x[n]] = np.sum(ar)/np.count_nonzero(ar)
        corrected_org_I[num_y[n]][num_x[n]] = np.sum(ar2)/np.count_nonzero(ar2)

c = np.mean(corrected_w) # constant

FFC = np.uint16(np.divide(c*(corrected_org_I-B), (corrected_w-B))) # flat field correction

plt.subplot(2,3,1), plt.imshow(org_I, cmap='gray'), plt.title('Original Image')
plt.subplot(2,3,2), plt.imshow(corrected_org_I, cmap='gray'), plt.title('corrected original Image')
plt.subplot(2,3,3), plt.imshow(FFC, cmap='gray'), plt.title('FFC')
plt.subplot(2,3,4), plt.imshow(w, cmap='gray'), plt.title('w')
plt.subplot(2,3,5), plt.imshow(corrected_w, cmap='gray'), plt.title('corrected w')
plt.subplot(2,3,6), plt.imshow(B, cmap='gray'), plt.title('B')
plt.show()

Answer 1

cv2 вызывает в коде библиотеки c ++, каждый из этих вызовов имеет некоторые издержки. Они могут складываться в зависимости от того, что вы делаете. Кроме того, opencv использует преимущества некоторых оптимизаций процессора, таких как SIMD и NEON.

Вот конкретный пример, я реализовал свою собственную функцию порога, перебирая пиксели. Затем я использую встроенную пороговую функцию opencv. Я печатаю время для каждой функции и сравниваю конечный результат, чтобы убедиться, что они совпадают.

img = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)
thresh = 128
thresh_loops = img.copy()

# implement threshold with loops
t1 = cv2.getTickCount()
for c in range(img.shape[0]):
    for r in range(img.shape[1]):
        if thresh_loops[c,r] > thresh:
            thresh_loops[c,r] = 255
        else:
            thresh_loops[c,r] = 0
t2 = cv2.getTickCount()
print((t2-t1)/cv2.getTickFrequency())

# use the threshold function
t1 = cv2.getTickCount()
thr, thresh_fun = cv2.threshold(img, thresh, 255, cv2.THRESH_BINARY)
t2 = cv2.getTickCount()
print((t2-t1)/cv2.getTickFrequency())

print(np.all(thresh_loops == thresh_fun)) # verify the same result

Я запускал изображение 720p (720x1280 - или примерно 1 миллион пикселей), на моей машине первая функция тоже 2.319724256 секунд, секунда заняла 0.013217389 секунд. Поэтому вторая функция примерно в 200 раз быстрее! Вы столкнетесь с этой проблемой, если будете использовать Java или другие языки, которые вызывают в библиотеку OpenCV (или любую другую C библиотеку).

Используйте это как хорошую мотивацию для изучения API.

Я также добавлю, что если вы выполняете обработку изображений в Python с OpenCV, вы должны также изучить API Numpy, так как матрица (Mat) класс представлен в виде numpy массива. Вы можете добиться значительных ускорений, зная также numpy API.

Answer 2

Я перешел на python в год go от моего любимого Матлаба. Да, вы правы, Matlab быстрее, чем python, обычно, по крайней мере, в 3 раза или более.

2 способа найти python здесь

1. Попробуйте прочитать Numpy Подпрограммы функционального программирования и замените некоторые циклы for другими методами. Они намного быстрее, чем нарезка ndarray в сторону for-l oop.

2. Попробуйте многопроцессорную обработку. Я знаю, что Matlab parfor также лучше, чем любой пакет параллельных вычислений в python. Попробуйте 'joblib' или 'multiprocessing'. Они могут немного помочь.