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")