def run(self, x, cpu_core):
"""
In this method, the NUFFT_hsa are created and executed on a fixed CPU core.
"""
pid= os.getpid()
print('pid=', pid)
os.system("taskset -p -c %d %d" % (cpu_core, pid))
"""
Control the CPU affinity. Otherwise the process on one core can be switched to another core.
"""
# create NUFFT
NUFFT = NUFFT_hsa(self.API, self.device_number,0)
# plan the NUFFT
NUFFT.plan(self.om, self.Nd, self.Kd, self.Jd)
# send the image to device
gx = NUFFT.to_device(x)
# carry out 10000 forward transform
for pp in range(0, 100):
gy = NUFFT.forward(gx)
# return the object
return gy.get()
def test_cuda():
import numpy
import matplotlib.pyplot
# load example image
import pkg_resources
## Define the source of data
DATA_PATH = pkg_resources.resource_filename('pynufft', 'src/data/')
# PHANTOM_FILE = pkg_resources.resource_filename('pynufft', 'data/phantom_256_256.txt')
import scipy
image = scipy.misc.ascent()
image = scipy.misc.imresize(image, (256, 256))
image = image.astype(numpy.float) / numpy.max(image[...])
Nd = (256, 256) # image space size
Kd = (512, 512) # k-space size
Jd = (6, 6) # interpolation size
# load k-space points as M * 2 array
om = numpy.load(DATA_PATH + 'om2D.npz')['arr_0']
# Show the shape of om
print('the shape of om = ', om.shape)
# initiating NUFFT_cpu object
nfft = NUFFT_cpu() # CPU NUFFT class
# Plan the nfft object
nfft.plan(om, Nd, Kd, Jd)
# initiating NUFFT_hsa object
NufftObj = NUFFT_hsa('cuda', 0, 0)
# Plan the NufftObj (similar to NUFFT_cpu)
NufftObj.plan(om, Nd, Kd, Jd)
import time
t0 = time.time()
for pp in range(0, 10):
y = nfft.forward(image)
t_cpu = (time.time() - t0) / 10.0
## Moving image to gpu
## gx is an gpu array, dtype = complex64
gx = NufftObj.to_device(image)
t0 = time.time()
for pp in range(0, 100):
gy = NufftObj.forward(gx)
t_cu = (time.time() - t0) / 100
print('t_cpu = ', t_cpu)
print('t_cuda =, ', t_cu)
print('gy close? = ',
numpy.allclose(y, gy.get(), atol=numpy.linalg.norm(y) * 1e-3))
print("acceleration=", t_cpu / t_cu)
maxiter = 100
import time
t0 = time.time()
x_cpu_cg = nfft.solve(y, 'cg', maxiter=maxiter)
# x2 = nfft.solve(y2, 'L1TVLAD',maxiter=maxiter, rho = 2)
t1 = time.time() - t0
# gy=NufftObj.thr.copy_array(NufftObj.thr.to_device(y2))
t0 = time.time()
x_cuda_cg = NufftObj.solve(gy, 'cg', maxiter=maxiter)
# x = NufftObj.solve(gy,'L1TVLAD', maxiter=maxiter, rho=2)
t2 = time.time() - t0
print(t1, t2)
print('acceleration of cg=', t1 / t2)
t0 = time.time()
x_cpu_TV = nfft.solve(y, 'L1TVOLS', maxiter=maxiter, rho=2)
t1 = time.time() - t0
t0 = time.time()
x_cuda_TV = NufftObj.solve(gy, 'L1TVOLS', maxiter=maxiter, rho=2)
t2 = time.time() - t0
print(t1, t2)
print('acceleration of TV=', t1 / t2)
matplotlib.pyplot.subplot(2, 2, 1)
matplotlib.pyplot.imshow(x_cpu_cg.real, cmap=matplotlib.cm.gray)
matplotlib.pyplot.title('CG_cpu')
matplotlib.pyplot.subplot(2, 2, 2)
matplotlib.pyplot.imshow(x_cuda_cg.get().real, cmap=matplotlib.cm.gray)
matplotlib.pyplot.title('CG_cuda')
matplotlib.pyplot.subplot(2, 2, 3)
matplotlib.pyplot.imshow(x_cpu_TV.real, cmap=matplotlib.cm.gray)
matplotlib.pyplot.title('TV_cpu')
matplotlib.pyplot.subplot(2, 2, 4)
matplotlib.pyplot.imshow(x_cuda_TV.get().real, cmap=matplotlib.cm.gray)
matplotlib.pyplot.title('TV_cuda')
matplotlib.pyplot.show()
NufftObj.release()
del NufftObj
radix=1)
# Casting the dtype to be complex64
dtype = np.complex64
# Computing the forward pass of the NUFFT
# JML: not needed in the new version
# nufftObj.x_Nd = nufftObj.thr.to_device(Il[:3].astype(dtype))
# gx = nufftObj.thr.copy_array(nufftObj.x_Nd)
#x = numpy.einsum('cxyz -> xyzc', Il[0:3]).copy() # coil must be the last dimension; Assume it is a C-order array
gy = nufftObj.forward(x)
#y = np.copy(gy.get())
# Checking the shape of the kspace
#print("K-space shapes: ", y.shape)
# Computing the backward pass
gx2 = nufftObj.adjoint(gy)
rec_Il = gx2.get() #np.copy(gx.get())
print(rec_Il.shape)
# Plotting the results
import matplotlib.pyplot
matplotlib.pyplot.subplot(2,3,1)
matplotlib.pyplot.imshow(x[:,:,64,0].real)
matplotlib.pyplot.title('input_image (64-th slice, first coil)')
print("copy image to gx")
time_6 = time.clock()
gx = NufftObj.thr.copy_array(NufftObj.x_Nd)
time_7 = time.clock()
print('total:', time_7 - time_1, '/Decl obj: ', time_2 - time_1, '/plan: ', \
time_3 - time_2, '/offload: ', time_4 - time_3, '/to_device: ', time_6 - time_5, '\copy_array: ', time_7 - time_6)
else:
NufftObj = NUFFT_cpu()
# mem_usage = memory_usage((NufftObj.plan,(om, Nd, Kd, Jd)))
# print(mem_usage)
NufftObj.plan(om, Nd, Kd, Jd)
# Compute F_hat
if gpu == True:
time_comp = time.clock()
gy = NufftObj.forward(gx)
# print(type(gy))
# gy = np.array(gy)
# print(type(gy))
# print(gy)
# exit(0)
y_pynufft = gy.get()
time_end = time.clock()
else:
time_comp = time.clock()
y_pynufft = NufftObj.forward(image)
time_end = time.clock()
time_preproc = time_comp - time_pre
time_proc = time_end - time_comp
time_total = time_preproc + time_proc
import numpy
from pynufft import NUFFT_hsa
import scipy.misc
import matplotlib
Nd = (256,256)
Kd = (512,512)
Jd = (6,6)
om = numpy.random.randn(65536, 2)
x = scipy.misc.imresize(scipy.misc.ascent(), Nd)
om1 = om[om[:,0]>0, :]
om2 = om[om[:,0]<=0, :]
NufftObj1 = NUFFT_hsa('ocl')
NufftObj1.plan(om1, Nd, Kd, Jd)
NufftObj2 = NUFFT_hsa('cuda')
NufftObj2.plan(om2, Nd, Kd, Jd)
y1 = NufftObj1.forward(x)
y2 = NufftObj2.forward(x)
class NUFFT(Singleton):
""" GPU implementation of N-D non uniform Fast Fourrier Transform class.
Attributes
----------
samples: np.ndarray
the mask samples in the Fourier domain.
shape: tuple of int
shape of the image (necessarly a square/cubic matrix).
nufftObj: The pynufft object
depending on the required computational platform
platform: string, 'opencl' or 'cuda'
string indicating which hardware platform will be used to compute the
NUFFT
Kd: int or tuple
int or tuple indicating the size of the frequency grid, for regridding.
if int, will be evaluated to (Kd,)*nb_dim of the image
Jd: int or tuple
Size of the interpolator kernel. If int, will be evaluated
to (Jd,)*dims image
n_coils: int default 1
Number of coils used to acquire the signal in case of multiarray
receiver coils acquisition. If n_coils > 1, please organize data as
n_coils X data_per_coil
"""
numOfInstances = 0
def __init__(self,
samples,
shape,
platform='cuda',
Kd=None,
Jd=None,
n_coils=1,
verbosity=0):
""" Initilize the 'NUFFT' class.
Parameters
----------
samples: np.ndarray
the mask samples in the Fourier domain.
shape: tuple of int
shape of the image (necessarly a square/cubic matrix).
platform: string, 'cpu', 'opencl' or 'cuda'
string indicating which hardware platform will be used to
compute the NUFFT
Kd: int or tuple
int or tuple indicating the size of the frequency grid,
for regridding. If int, will be evaluated
to (Kd,)*nb_dim of the image
Jd: int or tuple
Size of the interpolator kernel. If int, will be evaluated
to (Jd,)*dims image
n_coils: int
Number of coils used to acquire the signal in case of multiarray
receiver coils acquisition
"""
if (n_coils < 1) or (type(n_coils) is not int):
raise ValueError('The number of coils should be an integer >= 1')
if not pynufft_available:
raise ValueError('PyNUFFT Package is not installed, please '
'consider using `gpuNUFFT` or install the '
'PyNUFFT package')
self.nb_coils = n_coils
self.shape = shape
self.platform = platform
self.samples = samples * (2 * np.pi) # Pynufft use samples in
# [-pi, pi[ instead of [-0.5, 0.5[
self.dim = samples.shape[1] # number of dimensions of the image
if type(Kd) == int:
self.Kd = (Kd, ) * self.dim
elif type(Kd) == tuple:
self.Kd = Kd
elif Kd is None:
# Preferential option
self.Kd = tuple([2 * ix for ix in shape])
if type(Jd) == int:
self.Jd = (Jd, ) * self.dim
elif type(Jd) == tuple:
self.Jd = Jd
elif Jd is None:
# Preferential option
self.Jd = (5, ) * self.dim
for (i, s) in enumerate(shape):
assert (self.shape[i] <= self.Kd[i]), 'size of frequency grid' + \
'must be greater or equal ' \
'than the image size'
if verbosity > 0:
print('Creating the NUFFT object...')
if self.platform == 'opencl':
warn('Attemping to use OpenCL plateform. Make sure to '
'have all the dependecies installed')
Singleton.__init__(self)
if self.getNumInstances() > 1:
warn('You have created more than one NUFFT object. '
'This could cause memory leaks')
self.nufftObj = NUFFT_hsa(API='ocl',
platform_number=None,
device_number=None,
verbosity=verbosity)
self.nufftObj.plan(
om=self.samples,
Nd=self.shape,
Kd=self.Kd,
Jd=self.Jd,
batch=1, # TODO self.nb_coils,
ft_axes=tuple(range(samples.shape[1])),
radix=None)
elif self.platform == 'cuda':
warn('Attemping to use Cuda plateform. Make sure to '
'have all the dependecies installed and '
'to create only one instance of NUFFT GPU')
Singleton.__init__(self)
if self.getNumInstances() > 1:
warn('You have created more than one NUFFT object. '
'This could cause memory leaks')
self.nufftObj = NUFFT_hsa(API='cuda',
platform_number=None,
device_number=None,
verbosity=verbosity)
self.nufftObj.plan(
om=self.samples,
Nd=self.shape,
Kd=self.Kd,
Jd=self.Jd,
batch=1, # TODO self.nb_coils,
ft_axes=tuple(range(samples.shape[1])),
radix=None)
else:
raise ValueError('Wrong type of platform. Platform must be'
'\'opencl\' or \'cuda\'')
def __del__(self):
# This is an important desctructor to ensure that the device memory
# is freed
# TODO this is still not freeing the memory right on device.
# Mostly issue with reikna library.
# Refer : https://github.com/fjarri/reikna/issues/53
if self.platform == 'opencl' or self.platform == 'cuda':
self.nufftObj.release()
def op(self, img):
""" This method calculates the masked non-cartesian Fourier transform
of a 3-D image.
Parameters
----------
img: np.ndarray
input 3D array with the same shape as shape.
Returns
-------
x: np.ndarray
masked Fourier transform of the input image.
"""
if self.nb_coils == 1:
dtype = np.complex64
# Send data to the mCPU/GPU platform
self.nufftObj.x_Nd = self.nufftObj.thr.to_device(img.astype(dtype))
gx = self.nufftObj.thr.copy_array(self.nufftObj.x_Nd)
# Forward operator of the NUFFT
gy = self.nufftObj.forward(gx)
y = np.squeeze(gy.get())
else:
dtype = np.complex64
# Send data to the mCPU/GPU platform
y = []
for ch in range(self.nb_coils):
self.nufftObj.x_Nd = self.nufftObj.thr.to_device(
np.copy(img[ch]).astype(dtype))
gx = self.nufftObj.thr.copy_array(self.nufftObj.x_Nd)
# Forward operator of the NUFFT
gy = self.nufftObj.forward(gx)
y.append(np.squeeze(gy.get()))
y = np.asarray(y)
return y * 1.0 / np.sqrt(np.prod(self.Kd))
def adj_op(self, x):
""" This method calculates inverse masked non-uniform Fourier
transform of a 1-D coefficients array.
Parameters
----------
x: np.ndarray
masked non-uniform Fourier transform 1D data.
Returns
-------
img: np.ndarray
inverse 3D discrete Fourier transform of the input coefficients.
"""
if self.nb_coils == 1:
dtype = np.complex64
cuda_array = self.nufftObj.thr.to_device(x.astype(dtype))
gx = self.nufftObj.adjoint(cuda_array)
img = np.squeeze(gx.get())
else:
dtype = np.complex64
img = []
for ch in range(self.nb_coils):
cuda_array = self.nufftObj.thr.to_device(
np.copy(x[ch]).astype(dtype))
gx = self.nufftObj.adjoint(cuda_array)
img.append(gx.get())
img = np.asarray(np.squeeze(img))
return img * np.sqrt(np.prod(self.Kd))
Nd = (128, 128, 128) # time grid, tuple
Kd = (256, 256, 256) # frequency grid, tuple
Jd = (6, 6, 6) # interpolator
mid_slice = int(Nd[2] / 2)
# om= numpy.load(DATA_PATH+'om3D.npz')['arr_0']
numpy.random.seed(0)
om = numpy.random.randn(int(5e+5), 3)
print(om.shape)
from pynufft import NUFFT_cpu, NUFFT_hsa, NUFFT_hsa_legacy
NufftObj = NUFFT_hsa(API='ocl', platform_number=1, device_number=0)
NufftObj.plan(om, Nd, Kd, Jd)
# NufftObj.offload(API = 'cuda', platform_number = 0, device_number = 0)
gx = NufftObj.thr.to_device(image.astype(numpy.complex64))
gy = NufftObj.forward(gx)
import time
t0 = time.time()
restore_x2 = GBPDNA_old(NufftObj, gy, maxiter=5)
t1 = time.time()
restore_x = NufftObj.solve(gy, 'cg', maxiter=50)
t2 = time.time()
print("GBPDNA time = ", t1 - t0)
print("CG time = ", t2 - t1)
#restore_image1 = NufftObj.solve(kspace,'L1TVLAD', maxiter=300,rho=0.1)
#
# restore_x2 = NufftObj.solve(gy,'L1TVOLS', maxiter=100,rho=0.2)
# tau_1 = 1
# tau_2 = 0.1
def test_init():
# cm = matplotlib.cm.gray
# load example image
import pkg_resources
DATA_PATH = pkg_resources.resource_filename('pynufft', 'src/data/')
# PHANTOM_FILE = pkg_resources.resource_filename('pynufft', 'data/phantom_256_256.txt')
import numpy
# import matplotlib.pyplot
import scipy
image = scipy.misc.ascent()[::2,::2]
image=image.astype(numpy.float)/numpy.max(image[...])
Nd = (256, 256) # image space size
Kd = (512, 512) # k-space size
Jd = (6,6) # interpolation size
# load k-space points
om = numpy.load(DATA_PATH+'om2D.npz')['arr_0']
nfft = NUFFT_cpu() # CPU
nfft.plan(om, Nd, Kd, Jd)
try:
NufftObj = NUFFT_hsa('cuda',0,0)
except:
NufftObj = NUFFT_hsa('ocl',0,0)
# NufftObj2 = NUFFT_hsa('cuda',0,0)
NufftObj.debug = 1
NufftObj.plan(om, Nd, Kd, Jd, radix=2)
# NufftObj2.plan(om, Nd, Kd, Jd)
# NufftObj.offload(API = 'cuda', platform_number = 0, device_number = 0)
# NufftObj2.offload(API = 'cuda', platform_number = 0, device_number = 0)
# NufftObj2.offload('cuda')
# NufftObj.offload(API = 'cuda', platform_number = 0, device_number = 0)
# print('api=', NufftObj.thr.api_name())
# NufftObj.offload(API = 'ocl', platform_number = 0, device_number = 0)
y = nfft.k2y(nfft.xx2k(nfft.x2xx(image)))
NufftObj.x_Nd = NufftObj.thr.to_device( image.astype(dtype))
gx = NufftObj.thr.copy_array(NufftObj.x_Nd)
print('x close? = ', numpy.allclose(image, gx.get() , atol=1e-4))
gxx = NufftObj.x2xx(gx)
print('xx close? = ', numpy.allclose(nfft.x2xx(image), gxx.get() , atol=1e-4))
gk = NufftObj.xx2k(gxx)
k = nfft.xx2k(nfft.x2xx(image))
print('k close? = ', numpy.allclose(nfft.xx2k(nfft.x2xx(image)), gk.get(), atol=1e-3*numpy.linalg.norm(k)))
gy = NufftObj.k2y(gk)
k2 = NufftObj.y2k(gy)
print('y close? = ', numpy.allclose(y, gy.get() , atol=1e-3*numpy.linalg.norm(y)), numpy.linalg.norm((y - gy.get())/numpy.linalg.norm(y)))
y2 = y
print('k2 close? = ', numpy.allclose(nfft.y2k(y2), k2.get(), atol=1e-3*numpy.linalg.norm(nfft.y2k(y2)) ), numpy.linalg.norm(( nfft.y2k(y2)- k2.get())/numpy.linalg.norm(nfft.y2k(y2))))
gxx2 = NufftObj.k2xx(k2)
# print('xx close? = ', numpy.allclose(nfft.k2xx(nfft.y2k(y2)), NufftObj.xx_Nd.get(queue=NufftObj.queue, async=False) , atol=0.1))
gx2 = NufftObj.xx2x(gxx2)
print('x close? = ', numpy.allclose(nfft.adjoint(y2), gx2.get() , atol=1e-3*numpy.linalg.norm(nfft.adjoint(y2))))
image3 = gx2.get()
import time
t0 = time.time()
# k = nfft.xx2k(nfft.x2xx(image))
for pp in range(0,50):
# y = nfft.k2y(nfft.xx2k(nfft.x2xx(image)))
y = nfft.forward(image)
# y = nfft.k2y(k)
# k = nfft.y2k(y)
# x = nfft.adjoint(y)
# y = nfft.forward(image)
# y2 = NufftObj.y.get( NufftObj.queue, async=False)
t_cpu = (time.time() - t0)/50.0
print(t_cpu)
# del nfft
gy2=NufftObj.forward(gx)
# gk = NufftObj.xx2k(NufftObj.x2xx(gx))
t0= time.time()
for pp in range(0,20):
# pass
gy2 = NufftObj.forward(gx)
# gy2 = NufftObj.k2y(gk)
# gx2 = NufftObj.adjoint(gy2)
# gk2 = NufftObj.y2k(gy2)
# del gy2
# c = gx2.get()
# gy=NufftObj.forward(gx)
NufftObj.thr.synchronize()
t_cl = (time.time() - t0)/20
print(t_cl)
print('gy close? = ', numpy.allclose(y, gy.get(), atol=numpy.linalg.norm(y)*1e-3))
print("acceleration=", t_cpu/t_cl)
maxiter =100
import time
t0= time.time()
# x2 = nfft.solve(y2, 'cg',maxiter=maxiter)
x2 = nfft.solve(y2, 'L1TVOLS',maxiter=maxiter, rho = 2)
t1 = time.time()-t0
# gy=NufftObj.thr.copy_array(NufftObj.thr.to_device(y2))
t0= time.time()
# x = NufftObj.solve(gy,'cg', maxiter=maxiter)
x = NufftObj.solve(gy,'L1TVOLS', maxiter=maxiter, rho=2)
t2 = time.time() - t0
print(t1, t2)
print('acceleration=', t1/t2 )
# k = x.get()
# x = nfft.k2xx(k)/nfft.st['sn']
# return
try:
import matplotlib.pyplot
matplotlib.pyplot.subplot(1, 2, 1)
matplotlib.pyplot.imshow( x.get().real, cmap= matplotlib.cm.gray, vmin = 0, vmax = 1)
matplotlib.pyplot.title("HSA reconstruction")
matplotlib.pyplot.subplot(1, 2,2)
matplotlib.pyplot.imshow(x2.real, cmap= matplotlib.cm.gray)
matplotlib.pyplot.title("CPU reconstruction")
matplotlib.pyplot.show(block = False)
matplotlib.pyplot.pause(3)
matplotlib.pyplot.close()
# del NufftObj.thr
# del NufftObj
except:
print("no graphics")