def setUp(self):
parser = tmpArgs()
parser.streamed = False
parser.devices = -1
parser.use_GPU = False
par = {}
pyqmri.pyqmri._setupOCL(parser, par)
setupPar(par)
if DTYPE == np.complex128:
file = resource_filename('pyqmri',
'kernels/OpenCL_Kernels_double.c')
else:
file = resource_filename('pyqmri', 'kernels/OpenCL_Kernels.c')
prg = []
for j in range(len(par["ctx"])):
with open(file) as myfile:
prg.append(Program(par["ctx"][j], myfile.read()))
prg = prg[0]
self.weights = par["weights"]
self.symgrad = pyqmri.operator.OperatorFiniteSymGradient(
par, prg, DTYPE=DTYPE, DTYPE_real=DTYPE_real)
self.symgradin = np.random.randn(par["unknowns"], par["NSlice"],
par["dimY"], par["dimX"], 4) +\
1j * np.random.randn(par["unknowns"], par["NSlice"],
par["dimY"], par["dimX"], 4)
self.symdivin = np.random.randn(par["unknowns"], par["NSlice"],
par["dimY"], par["dimX"], 8) +\
1j * np.random.randn(par["unknowns"], par["NSlice"],
par["dimY"], par["dimX"], 8)
self.symgradin = self.symgradin.astype(DTYPE)
self.symdivin = self.symdivin.astype(DTYPE)
self.dz = par["dz"]
self.queue = par["queue"][0]
parser = tmpArgs()
parser.streamed = False
parser.devices = -1
parser.use_GPU = True
par = {}
pyqmri.pyqmri._setupOCL(parser, par)
setupPar(par)
prg = []
for j in range(len(par["ctx"])):
with open(file) as myfile:
prg.append(Program(par["ctx"][j], myfile.read()))
prg = prg[0]
self.symgrad_GPU = pyqmri.operator.OperatorFiniteSymGradient(
par, prg, DTYPE=DTYPE, DTYPE_real=DTYPE_real)
self.queue_GPU = par["queue"][0]
def setUp(self):
parser = tmpArgs()
parser.streamed = True
parser.devices = -1
parser.use_GPU = True
par = {}
par["packs"] = 6
par["MB"] = 2
par["shift"] = np.array([0, 64])
par["numofpacks"] = 1
pyqmri.pyqmri._setupOCL(parser, par)
setupPar(par)
if DTYPE == np.complex128:
file = resource_filename(
'pyqmri', 'kernels/OpenCL_Kernels_double_streamed.c')
else:
file = resource_filename(
'pyqmri', 'kernels/OpenCL_Kernels_streamed.c')
prg = []
for j in range(len(par["ctx"])):
with open(file) as myfile:
prg.append(Program(
par["ctx"][j],
myfile.read()))
par["par_slices"] = 1
par["mask"] = np.ones((par["dimY"], par["dimX"]),
dtype=DTYPE_real)
self.op = pyqmri.operator.OperatorKspaceSMSStreamed(
par, prg,
DTYPE=DTYPE,
DTYPE_real=DTYPE_real)
self.opinfwd = np.random.randn(par["NSlice"], par["unknowns"],
par["dimY"], par["dimX"]) +\
1j * np.random.randn(par["NSlice"], par["unknowns"],
par["dimY"], par["dimX"])
self.opinadj = np.random.randn(par["packs"], par["NScan"], par["NC"],
par["dimY"], par["dimX"]) +\
1j * np.random.randn(par["packs"], par["NScan"], par["NC"],
par["dimY"], par["dimX"])
self.model_gradient = np.random.randn(par["NSlice"], par["unknowns"],
par["NScan"],
par["dimY"], par["dimX"]) + \
1j * np.random.randn(par["NSlice"], par["unknowns"],
par["NScan"],
par["dimY"], par["dimX"])
self.C = np.random.randn(par["NSlice"], par["NC"],
par["dimY"], par["dimX"]) + \
1j * np.random.randn(par["NSlice"], par["NC"],
par["dimY"], par["dimX"])
self.model_gradient = self.model_gradient.astype(DTYPE)
self.C = self.C.astype(DTYPE)
self.opinfwd = self.opinfwd.astype(DTYPE)
self.opinadj = self.opinadj.astype(DTYPE)
self.queue = par["queue"][0]
def setUp(self):
parser = tmpArgs()
parser.streamed = False
parser.devices = -1
parser.use_GPU = True
par = {}
pyqmri.pyqmri._setupOCL(parser, par)
setupPar(par)
if DTYPE == np.complex128:
file = resource_filename(
'pyqmri', 'kernels/OpenCL_Kernels_double.c')
else:
file = resource_filename(
'pyqmri', 'kernels/OpenCL_Kernels.c')
prg = []
for j in range(len(par["ctx"])):
with open(file) as myfile:
prg.append(Program(
par["ctx"][j],
myfile.read()))
prg = prg[0]
par["mask"] = np.ones((par["dimY"], par["dimX"]),
dtype=DTYPE_real)
self.op = pyqmri.operator.OperatorKspace(
par, prg,
DTYPE=DTYPE,
DTYPE_real=DTYPE_real, trafo=False)
self.opinfwd = np.random.randn(par["unknowns"], par["NSlice"],
par["dimY"], par["dimX"]) +\
1j * np.random.randn(par["unknowns"], par["NSlice"],
par["dimY"], par["dimX"])
self.opinadj = np.random.randn(par["NScan"], par["NC"], par["NSlice"],
par["dimY"], par["dimX"]) +\
1j * np.random.randn(par["NScan"], par["NC"], par["NSlice"],
par["dimY"], par["dimX"])
self.model_gradient = np.random.randn(par["unknowns"], par["NScan"],
par["NSlice"],
par["dimY"], par["dimX"]) + \
1j * np.random.randn(par["unknowns"], par["NScan"],
par["NSlice"],
par["dimY"], par["dimX"])
self.C = np.random.randn(par["NC"], par["NSlice"],
par["dimY"], par["dimX"]) + \
1j * np.random.randn(par["NC"], par["NSlice"],
par["dimY"], par["dimX"])
self.model_gradient = self.model_gradient.astype(DTYPE)
self.C = self.C.astype(DTYPE)
self.opinfwd = self.opinfwd.astype(DTYPE)
self.opinadj = self.opinadj.astype(DTYPE)
self.queue = par["queue"][0]
self.grad_buf = clarray.to_device(self.queue, self.model_gradient)
self.coil_buf = clarray.to_device(self.queue, self.C)
def setUp(self):
parser = tmpArgs()
parser.streamed = True
parser.devices = -1
parser.use_GPU = True
par = {}
pyqmri.pyqmri._setupOCL(parser, par)
setupPar(par)
if DTYPE == np.complex128:
file = resource_filename(
'pyqmri', 'kernels/OpenCL_Kernels_double_streamed.c')
else:
file = resource_filename(
'pyqmri', 'kernels/OpenCL_Kernels_streamed.c')
prg = []
for j in range(len(par["ctx"])):
with open(file) as myfile:
prg.append(Program(
par["ctx"][j],
myfile.read()))
par["par_slices"] = 1
self.op = pyqmri.operator.OperatorImagespaceStreamed(
par, prg,
DTYPE=DTYPE,
DTYPE_real=DTYPE_real)
self.opinfwd = np.random.randn(par["NSlice"], par["unknowns"],
par["dimY"], par["dimX"]) +\
1j * np.random.randn(par["NSlice"], par["unknowns"],
par["dimY"], par["dimX"])
self.opinadj = np.random.randn(par["NSlice"], par["NScan"], 1,
par["dimY"], par["dimX"]) +\
1j * np.random.randn(par["NSlice"], par["NScan"], 1,
par["dimY"], par["dimX"])
self.model_gradient = np.random.randn(par["NSlice"], par["unknowns"],
par["NScan"],
par["dimY"], par["dimX"]) + \
1j * np.random.randn(par["NSlice"], par["unknowns"],
par["NScan"],
par["dimY"], par["dimX"])
self.model_gradient = self.model_gradient.astype(DTYPE)
self.opinfwd = self.opinfwd.astype(DTYPE)
self.opinadj = self.opinadj.astype(DTYPE)
def __init__(
self,
par,
model,
trafo=1,
imagespace=False,
SMS=0,
reg_type="TGV",
config="",
streamed=False,
DTYPE=np.complex64,
DTYPE_real=np.float32,
):
self.par = par
self.gn_res = []
self.irgn_par = utils.read_config(config, reg_type)
utils.save_config(self.irgn_par, par["outdir"], reg_type)
num_dev = len(par["num_dev"])
self._fval_old = 0
self._fval = 0
self._fval_init = 0
self._ctx = par["ctx"]
self._queue = par["queue"]
self._model = model
self._reg_type = reg_type
self._prg = []
self._DTYPE = DTYPE
self._DTYPE_real = DTYPE_real
self._streamed = streamed
self._imagespace = imagespace
self._SMS = SMS
if streamed and par["NSlice"] / (num_dev * par["par_slices"]) < 2:
raise ValueError(
"Number of Slices devided by parallel "
"computed slices and devices needs to be larger two.\n"
"Current values are %i total Slices, %i parallel slices and "
"%i compute devices." %
(par["NSlice"], par["par_slices"], num_dev))
if streamed and par["NSlice"] % par["par_slices"]:
raise ValueError(
"Number of Slices devided by parallel "
"computed slices needs to be an integer.\n"
"Current values are %i total Slices with %i parallel slices." %
(par["NSlice"], par["par_slices"]))
if DTYPE == np.complex128:
if streamed:
kernname = "kernels/OpenCL_Kernels_double_streamed.c"
else:
kernname = "kernels/OpenCL_Kernels_double.c"
for j in range(num_dev):
self._prg.append(
Program(self._ctx[j],
open(resource_filename("pyqmri",
kernname)).read()))
else:
if streamed:
kernname = "kernels/OpenCL_Kernels_streamed.c"
else:
kernname = "kernels/OpenCL_Kernels.c"
for j in range(num_dev):
self._prg.append(
Program(self._ctx[j],
open(resource_filename("pyqmri",
kernname)).read()))
if imagespace:
self._coils = []
self.sliceaxis = 1
if self._streamed:
self._data_trans_axes = (1, 0, 2, 3)
self._grad_trans_axes = (2, 0, 1, 3, 4)
else:
if SMS:
self._data_shape = (
par["NScan"],
par["NC"],
par["packs"] * par["numofpacks"],
par["Nproj"],
par["N"],
)
else:
if par["is3D"] and trafo:
self._data_shape = (
par["NScan"],
par["NC"],
1,
par["Nproj"],
par["N"],
)
else:
self._data_shape = (
par["NScan"],
par["NC"],
par["NSlice"],
par["Nproj"],
par["N"],
)
if self._streamed:
self._data_trans_axes = (2, 0, 1, 3, 4)
self._grad_trans_axes = (2, 0, 1, 3, 4)
self._coils = np.require(np.swapaxes(par["C"], 0, 1),
requirements="C",
dtype=DTYPE)
if SMS:
self._data_shape = (
par["packs"] * par["numofpacks"],
par["NScan"],
par["NC"],
par["dimY"],
par["dimX"],
)
self._data_shape_T = (
par["NScan"],
par["NC"],
par["packs"] * par["numofpacks"],
par["dimY"],
par["dimX"],
)
self._expdim_dat = 1
self._expdim_C = 0
else:
self._data_shape = (
par["NSlice"],
par["NScan"],
par["NC"],
par["Nproj"],
par["N"],
)
self._data_shape_T = self._data_shape
self._expdim_dat = 2
self._expdim_C = 1
else:
self._coils = clarray.to_device(self._queue[0], self.par["C"])
self._MRI_operator, self._FT = operator.Operator.MRIOperatorFactory(
par, self._prg, DTYPE, DTYPE_real, trafo, imagespace, SMS,
streamed)
self._grad_op, self._symgrad_op, self._v = self._setupLinearOps(
DTYPE, DTYPE_real)
if not reg_type == "H1":
self._pdop = optimizer.PDBaseSolver.factory(
self._prg,
self._queue,
self.par,
self.irgn_par,
self._fval_init,
self._coils,
linops=(self._MRI_operator, self._grad_op, self._symgrad_op),
model=model,
reg_type=self._reg_type,
SMS=self._SMS,
streamed=self._streamed,
imagespace=self._imagespace,
DTYPE=DTYPE,
DTYPE_real=DTYPE_real,
)
else:
self._pdop = optimizer.CGSolver_H1(
self._prg,
self._queue,
self.par,
self.irgn_par,
self._coils,
linops=(self._MRI_operator, self._grad_op),
)
self._gamma = None
self._delta = None
self._omega = None
self._step_val = None
self._modelgrad = None
