def test_operator_matrix_multiply(self):
matrix_size = (10,10)
m = yp.rand(matrix_size, global_dtype, global_backend)
xm = yp.rand(matrix_size[1], global_dtype, global_backend)
M = ops.MatrixMultiply(m)
# Check Forward operator
assert yp.sumb(yp.abs(yp.vec(yp.changeBackend(M * xm, 'numpy')) - yp.vec(yp.changeBackend(m, 'numpy').dot(yp.changeBackend(xm, 'numpy'))))) < eps, "%f" % yp.sumb(yp.abs(yp.changeBackend(M * xm, 'numpy') - yp.changeBackend(m, 'numpy').dot(yp.changeBackend(xm, 'numpy'))[:, np.newaxis]))
# Check Adjoint
assert yp.sumb(yp.abs(yp.vec(yp.changeBackend(M.H * xm, 'numpy')) - yp.vec(np.conj(yp.changeBackend(m, 'numpy').T).dot(yp.changeBackend(xm, 'numpy'))))) < eps, "%f" % yp.sumb(yp.abs(yp.changeBackend(M.H * xm, 'numpy') - np.conj(yp.changeBackend(m, 'numpy').T).dot(yp.changeBackend(xm, 'numpy'))[:, np.newaxis]))
# Check gradient
M.gradient_check()
def _check_communitivity(self):
"""This function simply checks whether a list of objective functions is communative"""
# Generate test arrays
test_arrays = []
for objective in self.objective_list:
test_arrays.append(yp.rand(objective.N))
# Loop over each objective, setting arguments and operating on missing one
objective_value_list = []
for index, objective in enumerate(self.objective_list):
# Get sublist with all arguments EXCEPT the index. These will be used to set arguments.
arguments = [None] * len(objective.arguments)
for (_index, replacement) in zip(
self.argument_mask,
test_arrays[:index] + test_arrays[index + 1:]):
arguments[_index] = replacement
objective.arguments = arguments
# Determine value of objective function and append to list
objective_value_list.append(
yp.scalar(objective * test_arrays[index]))
# Ensure all the objective values are the same
assert all([
value == objective_value_list[0] for value in objective_value_list
]), "Objective functions are not commutative"
def test_matmul(self):
matrix_size = (10, 20)
m = bops.rand(matrix_size, dtype, 'arrayfire')
xm = bops.rand(matrix_size[1], dtype, 'arrayfire')
assert np.sum(
np.abs(
bops.changeBackend(bops.matmul(m, xm), 'numpy') -
bops.changeBackend(m, 'numpy').dot(
bops.changeBackend(xm, 'numpy')))) < eps
# Check matrix multiply (numpy to arrayfire)
m_np = bops.rand(matrix_size, dtype, 'numpy')
xm_np = bops.rand(matrix_size[1], dtype, 'numpy')
m_ocl = bops.changeBackend(m_np, 'arrayfire')
xm_ocl = bops.changeBackend(xm_np, 'arrayfire')
assert np.sum(
np.abs(
bops.changeBackend(bops.matmul(m_ocl, xm_ocl), 'numpy') -
m_np.dot(xm_np))) < eps
def setup_method(self, test_method):
# Load object and crop to size
x_0 = yp.rand(image_size)
# Convert object to desired backend
self.x = yp.changeBackend(x_0, global_backend)
# Generate convolution kernel h
h_size = np.array([4, 4])
self.h = yp.zeros(image_size, global_dtype, global_backend)
self.h[image_size[0] // 2 - h_size[0] // 2:image_size[0] // 2 + h_size[0] // 2,
image_size[1] // 2 - h_size[1] // 2:image_size[1] // 2 + h_size[1] // 2] = yp.randn((h_size[0], h_size[1]), global_dtype, global_backend)
# A = ops.Convolution(image_size, h, dtype=global_dtype, fft_backend='numpy', backend=global_backend)
self.A = ops.FourierTransform(image_size, dtype=global_dtype, backend=global_backend, center=True)
self.y = self.A(yp.vectorize(self.x))
def test_indexing(self):
q = bops.randn((10, 10), backend='numpy', dtype='complex32')
q_ocl = bops.changeBackend(q, 'arrayfire')
q_ocl_np = bops.changeBackend(q_ocl, 'numpy')
assert np.sum(np.abs(q - q_ocl_np)) < eps
m = bops.rand((10, 20), dtype, "numpy")
m_ocl = bops.changeBackend(m, 'arrayfire')
assert abs(m[0, 1] - bops.scalar(m_ocl[0, 1])) < eps
assert abs(m[1, 1] - bops.scalar(m_ocl[1, 1])) < eps
assert abs(bops.scalar(m_ocl[4, 1]) - m[4, 1]) < eps
assert bops.scalar(self.x_np_rect[5, 15]) == bops.scalar(
bops.changeBackend(self.x_np_rect, 'arrayfire')[5, 15])
assert bops.scalar(self.x_ocl_rect[5, 15]) == bops.scalar(
bops.changeBackend(self.x_ocl_rect, 'numpy')[5, 15])
def test_crop(self):
crop_size = [self.x_np_randn.shape[i] - 2 for i in range(len(shape))]
assert np.sum(
np.abs(
bops.crop(self.x_np_randn, crop_size, crop_start=(0, 0)) -
np.asarray(
bops.crop(self.x_ocl_randn, crop_size, crop_start=(
0, 0))))) < 1e-4
x_full_np = bops.rand((20, 20), dtype=dtype, backend='numpy')
x_full_ocl = bops.changeBackend(x_full_np, 'arrayfire')
crop_size = tuple(np.asarray(bops.shape(x_full_np)) // 2)
crop_start = (2, 2)
x_crop_np = bops.crop(x_full_np, crop_size, crop_start=crop_start)
x_crop_ocl = bops.crop(x_full_ocl, crop_size, crop_start=crop_start)
assert np.sum(
np.abs(bops.changeBackend(x_crop_ocl, 'numpy') - x_crop_np)) < 1e-4