Cupy Ndimage Confolroting в вложенной для петли кажется быстрым, но следующее выполнение остановилось ⇐ Python

[Anonymous]

Я пытаюсь написать код, который свернул 3D -изображение с 3D -вейвлет -ядром, которое можно описать с использованием трех независимых параметров. Я хочу проанализировать результаты свертки для всех комбинаций трех параметров, используемых для генерации вейвлета. Создайте ядро ​​для данного набора параметров (цикл I ,

Код: Выделить всё

j

,

Код: Выделить всё

k

) и развернуть с изображением.
К сожалению, первая итерация работает за 0,1, но следующая итерация занимает 600 -е!
Я думаю Проблема по сути сводится к тому, что я использую Cupy в вложенной для петли, но я действительно не знаю, как избежать замедления, которое я получаю. Может быть, это связано с очередью памяти? Тем не менее, мои изображения довольно большие (800x800x200), поэтому именно поэтому я пытаюсь сделать это партиями, а не параллельно. < /P>
Вот фрагмент соответствующего кода, если он полезен для диагностики. Функция Skern3 использует исключительно Cupy Arrays и возвращает массив Cupy.

Код: Выделить всё

# External Packages
import numpy as np
import cupy as cp
from cupyx.scipy.ndimage import convolve as convolve_gpu

# Custom kernel
def skern3(x, y, z, a, theta, phi, xi):
# stretched mexican hat wavelet
x = x - cp.max(x)/2
y = y - cp.max(y)/2
z = z - cp.max(z)/2
rT = x*cp.cos(phi)*cp.cos(theta) - y*cp.sin(theta) + z*cp.sin(phi)*cp.cos(theta)
rp = x*cp.cos(phi)*cp.sin(theta) + y*cp.cos(theta) + z*cp.sin(phi)*cp.sin(theta)
rp2 = -1*x*cp.sin(phi) + z*cp.cos(phi)
A = (3-(rp/a)**2 - (1/xi**2)*(rT/a)**2 - (rp2/a)**2)
B = cp.exp((-1/2)*((rp/a)**2 + (1/xi**2)*(rT/a)**2 + (rp2/a)**2))
model = A*B
return  model

mempool = cp.get_default_memory_pool()
pinned_mempool = cp.get_default_pinned_memory_pool()
mempool.set_limit(10*1024**3)

theta_list = np.arange(0, np.pi, np.pi/100)
phi_list = theta_list
xi_list = np.arange(0,20,1)
a=1
energy_const = (1/np.sqrt(xi_list**2+2*a**2))
fib_sum_log = np.random.rand(200, 200, 200)

shape_im = np.array(fib_sum_log.shape)
w = shape_im[0]
h = shape_im[1]
l = shape_im[2]
x = np.uint16(np.linspace(0, w, w))
y = np.uint16(np.linspace(0, h, h))
z = np.uint16(np.linspace(0, l, l))
x, y, z = np.meshgrid(x, y, z)

x = cp.asarray(x.ravel())
y = cp.asarray(y.ravel())
z = cp.asarray(z.ravel())
xi_list = cp.asarray(xi_list)
theta_list = cp.asarray(theta_list)
phi_list = cp.asarray(phi_list)
a = cp.asarray(a)
fib_sum_log = cp.asarray(fib_sum_log.ravel())
energy_const = cp.asarray(energy_const)

# Pre-calculate wavelet energies (if needed)
wavelet_ener = cp.zeros(xi_list.size)
for k in range(xi_list.size):
xi = xi_list[k]
wavelet = skern3(x,y,z, a, theta_list[0], phi_list[0], xi)  # Use arbitrary theta/phi for initial calc
wavelet_ener[k] = cp.sum(cp.abs(wavelet)**2)

# Pre-allocate output arrays on the GPU
trans_ener = cp.zeros((theta_list.size, phi_list.size, xi_list.size))
var_image = cp.zeros((theta_list.size, phi_list.size, xi_list.size))
max_image = cp.zeros((theta_list.size, phi_list.size, xi_list.size))
pinned_mempool.free_all_blocks()
for i in range(theta_list.size):
theta = theta_list[i]
for j in range(phi_list.size):
phi = phi_list[j]
# Calculate wavelet *ONCE* for this theta and phi
for k in range(xi_list.size):
xi = xi_list[k]
wavelet = skern3(x,y,z, a, theta, phi, xi)
# No more freeing memory inside the loop!
G_Ixy = convolve_gpu(fib_sum_log, wavelet)  # Make sure fib_sum_log is a CuPy array
pinned_mempool.free_all_blocks()
print('Post Convolution')
print('mempool used bytes:  ' + str(mempool.used_bytes()))
print('mempool total bytes: ' + str(mempool.get_limit()))
print('pinned mempool free blocks: ' + str(pinned_mempool.n_free_blocks()))
print('=======================================================================\n')
images_wt = cp.multiply(energy_const[k], G_Ixy)  # Make sure energy_const is a CuPy array
trans_ener[i, j, k] = cp.sum(cp.abs(G_Ixy)**2)
var_image[i, j, k] = cp.sqrt(cp.var(G_Ixy))
max_image[i, j, k] = cp.max(G_Ixy)
< /code>
Я попытался сделать все внутри петли для массива Cupy, чтобы избежать передачи накладных расходов. И это работает ... но мне нужно повторить, поэтому я не уверен, что я должен сделать. n_free_blocks () 

всегда возвращает 3-5 бесплатных блоков в закрепленной памяти. Я думаю, что это указывает на накладные расходы, но я не знаю, почему.

Подробнее здесь: https://stackoverflow.com/questions/794 ... -execution