def test_probabilistic_measurement(backend, accelerators, use_samples):
original_backend = qibo.get_backend()
original_threads = qibo.get_threads()
qibo.set_backend(backend)
# set single-thread to fix the random values generated from the frequency custom op
qibo.set_threads(1)
c = models.Circuit(4, accelerators)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.M(0, 1))
result = c(nshots=1000)
K.set_seed(1234)
if use_samples:
# calculates sample tensor directly using `tf.random.categorical`
# otherwise it uses the frequency-only calculation
_ = result.samples()
# update reference values based on backend and device
if K.name == "tensorflow":
if K.gpu_devices: # pragma: no cover
# CI does not use GPU
decimal_frequencies = {0: 273, 1: 233, 2: 242, 3: 252}
else:
decimal_frequencies = {0: 271, 1: 239, 2: 242, 3: 248}
elif K.name == "numpy":
decimal_frequencies = {0: 249, 1: 231, 2: 253, 3: 267}
assert sum(result.frequencies().values()) == 1000
assert_result(result, decimal_frequencies=decimal_frequencies)
qibo.set_backend(original_backend)
qibo.set_threads(original_threads)
def test_unbalanced_probabilistic_measurement(backend, use_samples):
original_backend = qibo.get_backend()
original_threads = qibo.get_threads()
qibo.set_backend(backend)
# set single-thread to fix the random values generated from the frequency custom op
qibo.set_threads(1)
state = np.array([1, 1, 1, np.sqrt(3)]) / np.sqrt(6)
c = models.Circuit(2)
c.add(gates.Flatten(state))
c.add(gates.M(0, 1))
result = c(nshots=1000)
K.set_seed(1234)
if use_samples:
# calculates sample tensor directly using `tf.random.categorical`
# otherwise it uses the frequency-only calculation
_ = result.samples()
# update reference values based on backend and device
if K.name == "tensorflow":
if K.gpu_devices: # pragma: no cover
# CI does not use GPU
decimal_frequencies = {0: 196, 1: 153, 2: 156, 3: 495}
else:
decimal_frequencies = {0: 168, 1: 188, 2: 154, 3: 490}
elif K.name == "numpy":
decimal_frequencies = {0: 171, 1: 148, 2: 161, 3: 520}
assert sum(result.frequencies().values()) == 1000
assert_result(result, decimal_frequencies=decimal_frequencies)
qibo.set_backend(original_backend)
qibo.set_threads(original_threads)
def test_parallel_parametrized_circuit():
"""Evaluate circuit for multiple parameters."""
if 'GPU' in get_device(): # pragma: no cover
pytest.skip("unsupported configuration")
original_threads = get_threads()
set_threads(1)
nqubits = 5
nlayers = 10
c = Circuit(nqubits)
for l in range(nlayers):
c.add((gates.RY(q, theta=0) for q in range(nqubits)))
c.add((gates.CZ(q, q + 1) for q in range(0, nqubits - 1, 2)))
c.add((gates.RY(q, theta=0) for q in range(nqubits)))
c.add((gates.CZ(q, q + 1) for q in range(1, nqubits - 2, 2)))
c.add(gates.CZ(0, nqubits - 1))
c.add((gates.RY(q, theta=0) for q in range(nqubits)))
size = len(c.get_parameters())
np.random.seed(0)
parameters = [np.random.uniform(0, 2 * np.pi, size) for i in range(10)]
state = None
r1 = []
for params in parameters:
c.set_parameters(params)
r1.append(c(state))
r2 = parallel_parametrized_execution(c,
parameters=parameters,
initial_state=state,
processes=2)
np.testing.assert_allclose(r1, r2)
set_threads(original_threads)
def test_parallel_circuit_evaluation(backend,
skip_parallel): # pragma: no cover
"""Evaluate circuit for multiple input states."""
device = qibo.get_device()
backend_name = qibo.get_backend()
if skip_parallel:
pytest.skip("Skipping parallel test.")
if not is_parallel_supported(backend_name):
pytest.skip("Skipping parallel test due to unsupported configuration.")
original_threads = qibo.get_threads()
qibo.set_threads(1)
nqubits = 10
np.random.seed(0)
c = QFT(nqubits)
states = [np.random.random(2**nqubits) for i in range(5)]
r1 = []
for state in states:
r1.append(c(state))
r2 = parallel_execution(c, states=states, processes=2)
np.testing.assert_allclose(r1, r2)
qibo.set_threads(original_threads)
def test_aavqe(backend, method, options, compile, filename, skip_parallel):
"""Performs a AAVQE circuit minimization test."""
original_threads = qibo.get_threads()
if method == 'parallel_L-BFGS-B': # pragma: no cover
if skip_parallel:
pytest.skip("Skipping parallel test.")
from qibo.tests.test_parallel import is_parallel_supported
backend_name = qibo.get_backend()
if not is_parallel_supported(backend_name):
pytest.skip(
"Skipping parallel test due to unsupported configuration.")
qibo.set_threads(1)
nqubits = 6
layers = 4
circuit = models.Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
easy_hamiltonian = hamiltonians.X(nqubits)
problem_hamiltonian = hamiltonians.XXZ(nqubits)
s = lambda t: t
aavqe = models.AAVQE(circuit,
easy_hamiltonian,
problem_hamiltonian,
s,
nsteps=10,
t_max=1)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
best, params = aavqe.minimize(params=initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
assert_regression_fixture(params, filename, rtol=1e-2)
qibo.set_threads(original_threads)
def test_vqe(backend, method, options, compile, filename):
"""Performs a VQE circuit minimization test."""
original_backend = qibo.get_backend()
original_threads = qibo.get_threads()
if (method == "sgd" or compile) and backend != "matmuleinsum":
pytest.skip("Skipping SGD test for unsupported backend.")
qibo.set_backend(backend)
if method == 'parallel_L-BFGS-B':
device = qibo.get_device()
if device is not None and "GPU" in device: # pragma: no cover
pytest.skip("unsupported configuration")
import os
if os.name == 'nt': # pragma: no cover
pytest.skip("Parallel L-BFGS-B not supported on Windows.")
qibo.set_threads(1)
nqubits = 6
layers = 4
circuit = models.Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
v = models.VQE(circuit, hamiltonian)
best, params, _ = v.minimize(initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
assert_regression_fixture(params, filename)
qibo.set_backend(original_backend)
qibo.set_threads(original_threads)
def test_vqe(method, options, compile, filename):
"""Performs a VQE circuit minimization test."""
import qibo
original_backend = qibo.get_backend()
if method == "sgd" or compile:
qibo.set_backend("matmuleinsum")
else:
qibo.set_backend("custom")
original_threads = get_threads()
if method == 'parallel_L-BFGS-B':
if 'GPU' in qibo.get_device(): # pragma: no cover
pytest.skip("unsupported configuration")
qibo.set_threads(1)
nqubits = 6
layers = 4
circuit = Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
hamiltonian = XXZ(nqubits=nqubits)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
v = VQE(circuit, hamiltonian)
best, params = v.minimize(initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
utils.assert_regression_fixture(params, filename)
qibo.set_backend(original_backend)
qibo.set_threads(original_threads)
def test_vqe(backend, method, options, compile, filename, skip_parallel):
"""Performs a VQE circuit minimization test."""
original_threads = qibo.get_threads()
if (method == "sgd" or compile) and qibo.get_backend() != "tensorflow":
pytest.skip("Skipping SGD test for unsupported backend.")
if method == 'parallel_L-BFGS-B': # pragma: no cover
if skip_parallel:
pytest.skip("Skipping parallel test.")
from qibo.tests.test_parallel import is_parallel_supported
backend_name = qibo.get_backend()
if not is_parallel_supported(backend_name):
pytest.skip(
"Skipping parallel test due to unsupported configuration.")
qibo.set_threads(1)
nqubits = 6
layers = 4
circuit = models.Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
v = models.VQE(circuit, hamiltonian)
best, params, _ = v.minimize(initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
assert_regression_fixture(params, filename)
qibo.set_threads(original_threads)
def test_parallel_circuit_evaluation():
"""Evaluate circuit for multiple input states."""
if 'GPU' in get_device(): # pragma: no cover
pytest.skip("unsupported configuration")
original_threads = get_threads()
set_threads(1)
nqubits = 10
np.random.seed(0)
c = QFT(nqubits)
states = [np.random.random(2**nqubits) for i in range(5)]
r1 = []
for state in states:
r1.append(c(state))
r2 = parallel_execution(c, states=states, processes=2)
np.testing.assert_allclose(r1, r2)
set_threads(original_threads)
def test_unbalanced_probabilistic_measurement(backend, use_samples):
original_threads = qibo.get_threads()
# set single-thread to fix the random values generated from the frequency custom op
qibo.set_threads(1)
state = np.array([1, 1, 1, np.sqrt(3)]) / np.sqrt(6)
c = models.Circuit(2)
c.add(gates.Flatten(state))
c.add(gates.M(0, 1))
result = c(nshots=1000)
K.set_seed(1234)
if use_samples:
# calculates sample tensor directly using `tf.random.categorical`
# otherwise it uses the frequency-only calculation
_ = result.samples()
# update reference values based on backend and device
decimal_frequencies = K.test_regressions(
"test_unbalanced_probabilistic_measurement")
assert sum(result.frequencies().values()) == 1000
assert_result(result, decimal_frequencies=decimal_frequencies)
qibo.set_threads(original_threads)
def test_parallel_circuit_evaluation(backend):
"""Evaluate circuit for multiple input states."""
device = qibo.get_device()
backend = qibo.get_backend()
if 'GPU' in qibo.get_device(
) or sys.platform == "win32" or sys.platform == "darwin" or backend == "tensorflow" or backend == "qibojit": # pragma: no cover
pytest.skip("unsupported configuration")
original_threads = qibo.get_threads()
qibo.set_threads(1)
nqubits = 10
np.random.seed(0)
c = QFT(nqubits)
states = [np.random.random(2**nqubits) for i in range(5)]
r1 = []
for state in states:
r1.append(c(state))
r2 = parallel_execution(c, states=states, processes=2)
np.testing.assert_allclose(r1, r2)
qibo.set_threads(original_threads)
