def test_backend_compile(tested_backend, target_backend):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
func = lambda x: x + 1
x = rand(5)
cfunc1 = tested_backend.compile(func)
cfunc2 = target_backend.compile(func)
tested_backend.assert_allclose(cfunc1(x), cfunc2(x))
def test_backend_concatenate(tested_backend, target_backend):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
tensors = [rand((2, 3)), rand((2, 4))]
target_result = target_backend.concatenate(tensors, axis=1)
tensors = [tested_backend.cast(x) for x in tensors]
tested_result = tested_backend.concatenate(tensors, axis=1)
tested_backend.assert_allclose(tested_result, target_result)
def test_backend_stack(tested_backend, target_backend):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
tensors = [rand(4), rand(4)]
target_result = target_backend.stack(tensors)
tensors = [tested_backend.cast(x) for x in tensors]
tested_result = tested_backend.stack(tensors)
tested_backend.assert_allclose(tested_result, target_result)
def test_backend_eigh(tested_backend, target_backend):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
m = rand((5, 5))
eigvals1, eigvecs1 = tested_backend.eigh(m)
eigvals2, eigvecs2 = target_backend.eigh(m)
np.testing.assert_allclose(eigvals1, eigvals2)
np.testing.assert_allclose(np.abs(eigvecs1), np.abs(eigvecs2))
def test_construct_backend(backend):
bk = K.construct_backend(backend)
try:
assert bk.name == backend
except AssertionError:
assert bk.name.split("_")[-1] == backend
with pytest.raises(ValueError):
bk = K.construct_backend("test")
def test_backend_methods_dict(tested_backend, target_backend, method, kwargs):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
tested_func = getattr(tested_backend, method)
target_func = getattr(target_backend, method)
target_result = target_func(**kwargs)
kwargs = {
k: tested_backend.cast(v) if isinstance(v, np.ndarray) else v
for k, v in kwargs.items()
}
tested_result = tested_func(**kwargs)
tested_backend.assert_allclose(tested_result, target_result)
def test_backend_methods(tested_backend, target_backend, method, kwargs):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
tested_func = getattr(tested_backend, method)
target_func = getattr(target_backend, method)
if isinstance(kwargs, dict):
np.testing.assert_allclose(tested_func(**kwargs), target_func(**kwargs))
else:
if method in {"kron", "inv"} and "numpy" not in tested_backend.name:
with pytest.raises(NotImplementedError):
tested_func(*kwargs)
else:
np.testing.assert_allclose(tested_func(*kwargs), target_func(*kwargs))
def test_backend_unique(tested_backend, target_backend, return_counts):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
x = np.random.randint(10, size=(10,))
target_result = target_backend.unique(x, return_counts=return_counts)
test_result = tested_backend.unique(x, return_counts=return_counts)
if return_counts:
idx = np.argsort(test_result[0])
np.testing.assert_allclose(np.array(test_result[0])[idx], target_result[0])
np.testing.assert_allclose(np.array(test_result[1])[idx], target_result[1])
else:
idx = np.argsort(test_result)
np.testing.assert_allclose(np.array(test_result)[idx], target_result)
def test_backend_transpose_state(tested_backend, target_backend):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
nqubits = 5
order = [0, 2, 3, 4, 1]
shape = (2**nqubits, )
state = np.random.random(shape) + 1j * np.random.random(shape)
state = state / np.sqrt(np.sum(np.abs(state)**2))
new_state = np.zeros_like(state)
state = np.reshape(state, (4, 8))
pieces = [state[i] for i in range(4)]
target_result = target_backend.transpose_state(pieces, new_state, 5, order)
tested_result = tested_backend.transpose_state(pieces, new_state, 5, order)
tested_backend.assert_allclose(tested_result, target_result)
def test_backend_methods_list(tested_backend, target_backend, method, args):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
tested_func = getattr(tested_backend, method)
target_func = getattr(target_backend, method)
target_result = target_func(*args)
args = [
tested_backend.cast(v, dtype=str(v.dtype)) if isinstance(
v, np.ndarray) else v for v in args
]
try:
tested_result = tested_func(*args)
except NotImplementedError:
with pytest.raises(NotImplementedError):
tested_func(*args)
return
tested_backend.assert_allclose(tested_result, target_result)
def test_backend_eigh(tested_backend, target_backend, sparse_type):
if tested_backend == "tensorflow" and sparse_type is not None:
pytest.skip("Temporary skip.")
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
if sparse_type is None:
m = rand((5, 5))
else:
from scipy import sparse
m = sparse.rand(16, 16, format=sparse_type, density=0.1)
eigvals1, eigvecs1 = tested_backend.eigh(tested_backend.cast(m),
k=m.shape[0])
eigvals2, eigvecs2 = target_backend.eigh(target_backend.cast(m),
k=m.shape[0])
tested_backend.assert_allclose(eigvals1, eigvals2, atol=1e-10)
m1 = eigvecs1 @ np.diag(eigvals1) @ tested_backend.transpose(eigvecs1)
m2 = eigvecs2 @ np.diag(eigvals2) @ target_backend.transpose(eigvecs2)
tested_backend.assert_allclose(m1, m2, atol=1e-10)
def test_backend_transpose_state(tested_backend, target_backend):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
if ((tested_backend.name == "qibotf" or target_backend.name == "qibotf")
and
("GPU" in tested_backend.default_device
or "GPU" in target_backend.default_device)): # pragma: no cover
pytest.skip("qibotf does not implement `transpose_state` for GPU.")
nqubits = 5
order = [0, 2, 3, 4, 1]
shape = (2**nqubits, )
state = np.random.random(shape) + 1j * np.random.random(shape)
state = state / np.sqrt(np.sum(np.abs(state)**2))
new_state = np.zeros_like(state)
state = np.reshape(state, (4, 8))
pieces = [state[i] for i in range(4)]
target_result = target_backend.transpose_state(pieces, new_state, 5, order)
tested_result = tested_backend.transpose_state(pieces, new_state, 5, order)
tested_backend.assert_allclose(tested_result, target_result)
def test_backend_gather(tested_backend, target_backend):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
x = rand(5)
target_result = target_backend.gather(x, indices=[0, 1, 3])
test_result = tested_backend.gather(x, indices=[0, 1, 3])
tested_backend.assert_allclose(test_result, target_result)
x = rand((5, 5))
target_result = target_backend.gather(x, indices=[0, 1, 3], axis=-1)
test_result = tested_backend.gather(x, indices=[0, 1, 3], axis=-1)
tested_backend.assert_allclose(test_result, target_result)
x = rand(3)
target_result = target_backend.gather(x, condition=[True, False, True])
test_result = tested_backend.gather(x, condition=[True, False, True])
tested_backend.assert_allclose(test_result, target_result)
with pytest.raises(ValueError):
result1 = target_backend.gather(x)
with pytest.raises(ValueError):
result2 = tested_backend.gather(x)
def test_backend_sparse_eigh(tested_backend, target_backend, sparse_type):
if tested_backend == "tensorflow":
pytest.skip("Temporary skip.")
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
from scipy import sparse
from qibo import hamiltonians
ham = hamiltonians.TFIM(6, h=1.0)
m = getattr(sparse, f"{sparse_type}_matrix")(K.to_numpy(ham.matrix))
eigvals1, eigvecs1 = tested_backend.eigh(tested_backend.cast(m))
eigvals2, eigvecs2 = target_backend.eigh(target_backend.cast(m))
eigvals1 = sorted(K.to_numpy(eigvals1))
eigvals2 = sorted(K.to_numpy(eigvals2))
tested_backend.assert_allclose(eigvals1, eigvals2)
eigvals1 = tested_backend.eigvalsh(tested_backend.cast(m))
eigvals2 = target_backend.eigvalsh(target_backend.cast(m))
eigvals1 = sorted(K.to_numpy(eigvals1))
eigvals2 = sorted(K.to_numpy(eigvals2))
tested_backend.assert_allclose(eigvals1, eigvals2)
def test_backend_methods_list(tested_backend, target_backend, method, args):
tested_backend = K.construct_backend(tested_backend)
target_backend = K.construct_backend(target_backend)
tested_func = getattr(tested_backend, method)
target_func = getattr(target_backend, method)
target_result = target_func(*args)
if tested_backend.name == "qibojit" and tested_backend.op.get_backend(
) == "cupy": # pragma: no cover
# cupy is not tested by CI!
args = [
tested_backend.cast(v) if isinstance(v, np.ndarray) else v
for v in args
]
try:
tested_result = tested_func(*args)
except NotImplementedError:
with pytest.raises(NotImplementedError):
tested_func(*args)
return
tested_backend.assert_allclose(tested_result, target_result)
def test_construct_backend(backend_name):
bk = K.construct_backend(backend_name)
assert bk.name == backend_name
with pytest.raises(ValueError):
bk = K.construct_backend("test")
