def test_qaoa_errors():
# Invalid Hamiltonian type
with pytest.raises(TypeError):
qaoa = models.QAOA("test")
# Hamiltonians of different type
h = hamiltonians.TFIM(4, h=1.0, dense=False)
m = hamiltonians.X(4, dense=True)
with pytest.raises(TypeError):
qaoa = models.QAOA(h, mixer=m)
# distributed execution with RK solver
with pytest.raises(NotImplementedError):
qaoa = models.QAOA(h, solver="rk4", accelerators={"/GPU:0": 2})
# minimize with odd number of parameters
qaoa = models.QAOA(h)
with pytest.raises(ValueError):
qaoa.minimize(np.random.random(5))
def test_qaoa_execution(backend, solver, dense, accel=None):
h = hamiltonians.TFIM(6, h=1.0, dense=dense)
m = hamiltonians.X(6, dense=dense)
# Trotter and RK require small p's!
params = 0.01 * (1 - 2 * np.random.random(4))
state = random_state(6)
# set absolute test tolerance according to solver
if "rk" in solver:
atol = 1e-2
elif not dense:
atol = 1e-5
else:
atol = 0
target_state = np.copy(state)
h_matrix = K.to_numpy(h.matrix)
m_matrix = K.to_numpy(m.matrix)
for i, p in enumerate(params):
if i % 2:
u = expm(-1j * p * m_matrix)
else:
u = expm(-1j * p * h_matrix)
target_state = u @ target_state
qaoa = models.QAOA(h, mixer=m, solver=solver, accelerators=accel)
qaoa.set_parameters(params)
final_state = qaoa(np.copy(state))
K.assert_allclose(final_state, target_state, atol=atol)
def test_qaoa_callbacks(backend, accelerators):
from qibo import callbacks
# use ``Y`` Hamiltonian so that there are no errors
# in the Trotter decomposition
if accelerators:
with K.on_cpu():
h = hamiltonians.Y(5)
else:
h = hamiltonians.Y(5)
energy = callbacks.Energy(h)
params = 0.1 * np.random.random(4)
state = random_state(5)
ham = hamiltonians.Y(5, dense=False)
qaoa = models.QAOA(ham, callbacks=[energy], accelerators=accelerators)
qaoa.set_parameters(params)
final_state = qaoa(np.copy(state))
h_matrix = K.to_numpy(h.matrix)
m_matrix = K.to_numpy(qaoa.mixer.matrix)
calc_energy = lambda s: (s.conj() * h_matrix.dot(s)).sum()
target_state = np.copy(state)
target_energy = [calc_energy(target_state)]
for i, p in enumerate(params):
if i % 2:
u = expm(-1j * p * m_matrix)
else:
u = expm(-1j * p * h_matrix)
target_state = u @ target_state
target_energy.append(calc_energy(target_state))
K.assert_allclose(energy[:], target_energy)
def test_initial_state(accelerators):
h = hamiltonians.TFIM(3, h=1.0, trotter=True)
qaoa = models.QAOA(h, accelerators=accelerators)
qaoa.set_parameters(np.random.random(4))
target_state = np.ones(2 ** 3) / np.sqrt(2 ** 3)
final_state = qaoa.get_initial_state()
np.testing.assert_allclose(final_state, target_state)
def test_initial_state(backend, accelerators):
h = hamiltonians.TFIM(5, h=1.0, dense=False)
qaoa = models.QAOA(h, accelerators=accelerators)
qaoa.set_parameters(np.random.random(4))
target_state = np.ones(2**5) / np.sqrt(2**5)
final_state = qaoa.get_initial_state()
K.assert_allclose(final_state, target_state)
def test_qaoa_callbacks(accelerators):
from qibo import callbacks
# use ``Y`` Hamiltonian so that there are no errors
# in the Trotter decomposition
h = hamiltonians.Y(3)
energy = callbacks.Energy(h)
params = 0.1 * np.random.random(4)
state = utils.random_numpy_state(3)
ham = hamiltonians.Y(3, trotter=True)
qaoa = models.QAOA(ham, callbacks=[energy], accelerators=accelerators)
qaoa.set_parameters(params)
final_state = qaoa(np.copy(state))
h_matrix = h.matrix.numpy()
m_matrix = qaoa.mixer.matrix.numpy()
calc_energy = lambda s: (s.conj() * h_matrix.dot(s)).sum()
target_state = np.copy(state)
target_energy = [calc_energy(target_state)]
for i, p in enumerate(params):
if i % 2:
u = expm(-1j * p * m_matrix)
else:
u = expm(-1j * p * h_matrix)
target_state = u @ target_state
target_energy.append(calc_energy(target_state))
np.testing.assert_allclose(energy[:], target_energy)
def test_qaoa_execution(solver, trotter, accelerators):
h = hamiltonians.TFIM(4, h=1.0, trotter=trotter)
m = hamiltonians.X(4, trotter=trotter)
# Trotter and RK require small p's!
params = 0.01 * (1 - 2 * np.random.random(4))
state = utils.random_numpy_state(4)
# set absolute test tolerance according to solver
if "rk" in solver:
atol = 1e-2
elif trotter:
atol = 1e-5
else:
atol = 0
target_state = np.copy(state)
h_matrix = h.matrix.numpy()
m_matrix = m.matrix.numpy()
for i, p in enumerate(params):
if i % 2:
u = expm(-1j * p * m_matrix)
else:
u = expm(-1j * p * h_matrix)
target_state = u @ target_state
qaoa = models.QAOA(h, mixer=m, solver=solver, accelerators=accelerators)
qaoa.set_parameters(params)
final_state = qaoa(np.copy(state))
np.testing.assert_allclose(final_state, target_state, atol=atol)
def test_qaoa_optimization(method, options, trotter, filename):
h = hamiltonians.XXZ(3, trotter=trotter)
qaoa = models.QAOA(h)
initial_p = [0.05, 0.06, 0.07, 0.08]
best, params = qaoa.minimize(initial_p, method=method, options=options)
if filename is not None:
utils.assert_regression_fixture(params, filename)
def test_qaoa_optimization(backend, method, options, dense, filename):
if method == "sgd" and qibo.get_backend() != "tensorflow":
pytest.skip("Skipping SGD test for unsupported backend.")
h = hamiltonians.XXZ(3, dense=dense)
qaoa = models.QAOA(h)
initial_p = [0.05, 0.06, 0.07, 0.08]
best, params, _ = qaoa.minimize(initial_p, method=method, options=options)
if filename is not None:
assert_regression_fixture(params, filename)
def test_initial_state(backend, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
h = hamiltonians.TFIM(5, h=1.0, trotter=True)
qaoa = models.QAOA(h, accelerators=accelerators)
qaoa.set_parameters(np.random.random(4))
target_state = np.ones(2**5) / np.sqrt(2**5)
final_state = qaoa.get_initial_state()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def main(nqubits,
nangles,
dense=True,
solver="exp",
method="Powell",
maxiter=None,
filename=None):
"""Performs a QAOA minimization test."""
print("Number of qubits:", nqubits)
print("Number of angles:", nangles)
logs = BenchmarkLogger(filename)
logs.append({
"nqubits": nqubits,
"nangles": nangles,
"dense": dense,
"solver": solver,
"backend": qibo.get_backend(),
"precision": qibo.get_precision(),
"device": qibo.get_device(),
"threads": qibo.get_threads(),
"method": method,
"maxiter": maxiter
})
hamiltonian = hamiltonians.XXZ(nqubits=nqubits, dense=dense)
start_time = time.time()
qaoa = models.QAOA(hamiltonian, solver=solver)
logs[-1]["creation_time"] = time.time() - start_time
target = np.real(np.min(K.to_numpy(hamiltonian.eigenvalues())))
print("\nTarget state =", target)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 0.1, nangles)
start_time = time.time()
options = {'disp': True, 'maxiter': maxiter}
best, params, _ = qaoa.minimize(initial_parameters,
method=method,
options=options)
logs[-1]["minimization_time"] = time.time() - start_time
logs[-1]["best_energy"] = float(best)
logs[-1]["target_energy"] = float(target)
logs[-1]["epsilon"] = np.log10(1 / np.abs(best - target))
print("Found state =", best)
print("Final eps =", logs[-1]["epsilon"])
print("\nCreation time =", logs[-1]["creation_time"])
print("Minimization time =", logs[-1]["minimization_time"])
print("Total time =",
logs[-1]["creation_time"] + logs[-1]["minimization_time"])
logs.dump()
def test_qaoa_optimization(backend, method, options, trotter, filename):
original_backend = qibo.get_backend()
if method == "sgd" and backend != "matmuleinsum":
pytest.skip("Skipping SGD test for unsupported backend.")
qibo.set_backend(backend)
h = hamiltonians.XXZ(3, trotter=trotter)
qaoa = models.QAOA(h)
initial_p = [0.05, 0.06, 0.07, 0.08]
best, params, _ = qaoa.minimize(initial_p, method=method, options=options)
if filename is not None:
assert_regression_fixture(params, filename)
qibo.set_backend(original_backend)
def main(nqubits,
nangles,
trotter=False,
solver="exp",
method="Powell",
maxiter=None):
"""Performs a QAOA minimization test."""
print("Number of qubits:", nqubits)
print("Number of angles:", nangles)
hamiltonian = hamiltonians.XXZ(nqubits=nqubits, trotter=trotter)
start_time = time.time()
qaoa = models.QAOA(hamiltonian, solver=solver)
creation_time = time.time() - start_time
target = np.real(np.min(hamiltonian.eigenvalues().numpy()))
print("\nTarget state =", target)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 0.1, nangles)
start_time = time.time()
options = {'disp': True, 'maxiter': maxiter}
best, params, _ = qaoa.minimize(initial_parameters,
method=method,
options=options)
minimization_time = time.time() - start_time
epsilon = np.log10(1 / np.abs(best - target))
print("Found state =", best)
print("Final eps =", epsilon)
print("\nCreation time =", creation_time)
print("Minimization time =", minimization_time)
print("Total time =", minimization_time + creation_time)
