def main(nqubits,
nlayers,
backend,
varlayer=False,
method="Powell",
maxiter=None,
filename=None):
"""Performs a VQE circuit minimization test."""
qibo.set_backend(backend)
logs = BenchmarkLogger(filename)
logs.append({
"nqubits": nqubits,
"nlayers": nlayers,
"varlayer": varlayer,
"backend": qibo.get_backend(),
"precision": qibo.get_precision(),
"device": qibo.get_device(),
"threads": qibo.get_threads(),
"method": method,
"maxiter": maxiter
})
print("Number of qubits:", nqubits)
print("Number of layers:", nlayers)
print("Backend:", logs[-1]["backend"])
start_time = time.time()
if varlayer:
circuit = varlayer_circuit(nqubits, nlayers)
else:
circuit = standard_circuit(nqubits, nlayers)
hamiltonian = hamiltonians.XXZ(nqubits=nqubits)
vqe = models.VQE(circuit, hamiltonian)
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)
nparams = 2 * nqubits * nlayers + nqubits
initial_parameters = np.random.uniform(0, 2 * np.pi, nparams)
start_time = time.time()
options = {'disp': False, 'maxiter': maxiter}
best, params, _ = vqe.minimize(initial_parameters,
method=method,
options=options,
compile=False)
logs[-1]["minimization_time"] = time.time() - start_time
epsilon = np.log10(1 / np.abs(best - target))
print("Found state =", best)
print("Final eps =", epsilon)
logs[-1]["best_energy"] = float(best)
logs[-1]["epsilon_energy"] = float(epsilon)
print("\nCreation time =", logs[-1]["creation_time"])
print("Minimization time =", logs[-1]["minimization_time"])
print("Total time =",
logs[-1]["minimization_time"] + logs[-1]["creation_time"])
logs.dump()
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_precision_dictionary(precision):
"""Check if ``set_precision`` changes the ``DTYPES`` dictionary."""
import qibo
import tensorflow as tf
from qibo.config import DTYPES
original_precision = qibo.get_precision()
qibo.set_precision(precision)
if precision == "single":
assert DTYPES.get("DTYPECPX") == tf.complex64
else:
assert DTYPES.get("DTYPECPX") == tf.complex128
qibo.set_precision(original_precision)
def main(nqubits,
dt,
solver,
backend,
dense=False,
accelerators=None,
filename=None):
"""Performs adiabatic evolution with critical TFIM as the "hard" Hamiltonian."""
qibo.set_backend(backend)
if accelerators is not None:
dense = False
solver = "exp"
logs = BenchmarkLogger(filename)
logs.append({
"nqubits": nqubits,
"dt": dt,
"solver": solver,
"dense": dense,
"backend": qibo.get_backend(),
"precision": qibo.get_precision(),
"device": qibo.get_device(),
"threads": qibo.get_threads(),
"accelerators": accelerators
})
print(f"Using {solver} solver and dt = {dt}.")
print(f"Accelerators: {accelerators}")
print("Backend:", logs[-1]["backend"])
start_time = time.time()
h0 = hamiltonians.X(nqubits, dense=dense)
h1 = hamiltonians.TFIM(nqubits, h=1.0, dense=dense)
logs[-1]["hamiltonian_creation_time"] = time.time() - start_time
print(f"\nnqubits = {nqubits}, solver = {solver}")
print(f"dense = {dense}, accelerators = {accelerators}")
print("Hamiltonians created in:", logs[-1]["hamiltonian_creation_time"])
start_time = time.time()
evolution = models.AdiabaticEvolution(h0,
h1,
lambda t: t,
dt=dt,
solver=solver,
accelerators=accelerators)
logs[-1]["creation_time"] = time.time() - start_time
print("Evolution model created in:", logs[-1]["creation_time"])
start_time = time.time()
final_psi = evolution(final_time=1.0)
logs[-1]["simulation_time"] = time.time() - start_time
print("Simulation time:", logs[-1]["simulation_time"])
logs.dump()
def test_state_precision(precision):
"""Check ``set_precision`` in state dtype."""
import qibo
import tensorflow as tf
original_precision = qibo.get_precision()
qibo.set_precision(precision)
c1 = Circuit(2)
c1.add([H(0), H(1)])
final_state = c1()
if precision == "single":
expected_dtype = tf.complex64
else:
expected_dtype = tf.complex128
assert final_state.dtype == expected_dtype
qibo.set_precision(original_precision)
def test_matrices_dtype():
"""Check if ``set_precision`` changes matrices types."""
import qibo
original_precision = qibo.get_precision()
# Check that matrices can be imported
from qibo import matrices
assert matrices.I.dtype == np.complex128
np.testing.assert_allclose(matrices.I, np.eye(2))
# Check that matrices precision is succesfully switched
qibo.set_precision("single")
assert matrices.H.dtype == np.complex64
H = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
np.testing.assert_allclose(matrices.H, H)
qibo.set_precision("double")
# Check that ``qibo.matrices`` also works.
np.testing.assert_allclose(qibo.matrices.H, H)
CNOT = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
np.testing.assert_allclose(qibo.matrices.CNOT, CNOT)
qibo.set_precision(original_precision)
def test_unitary_channel_probability_tolerance(backend, precision):
"""Create ``UnitaryChannel`` with probability sum within tolerance (see #562)."""
import qibo
original_precision = qibo.get_precision()
qibo.set_precision(precision)
nqubits = 2
param = 0.006
num_terms = 2**(2 * nqubits)
max_param = num_terms / (num_terms - 1)
prob_identity = 1 - param / max_param
prob_pauli = param / num_terms
probs = [prob_identity] + [prob_pauli] * (num_terms - 1)
if precision == "double":
probs = np.array(probs, dtype="float64")
else:
probs = np.array(probs, dtype="float32")
matrices = len(probs) * [((0, 1), np.random.random((4, 4)))]
gate = gates.UnitaryChannel(probs, matrices)
qibo.set_precision(original_precision)
def main(nqubits,
circuit_name,
backend="custom",
precision="double",
nreps=1,
nshots=None,
transfer=False,
fuse=False,
device=None,
accelerators=None,
threadsafe=False,
compile=False,
get_branch=True,
nlayers=None,
gate_type=None,
params={},
filename=None):
"""Runs circuit simulation benchmarks for different circuits.
See benchmark documentation for a description of arguments.
"""
qibo.set_backend(backend)
qibo.set_precision(precision)
if device is not None:
qibo.set_device(device)
logs = BenchmarkLogger(filename)
# Create log dict
logs.append({
"nqubits": nqubits,
"circuit_name": circuit_name,
"threading": "",
"backend": qibo.get_backend(),
"precision": qibo.get_precision(),
"device": qibo.get_device(),
"accelerators": accelerators,
"nshots": nshots,
"transfer": transfer,
"fuse": fuse,
"compile": compile,
})
if get_branch:
logs[-1]["branch"] = get_active_branch_name()
params = {k: v for k, v in params.items() if v is not None}
kwargs = {"nqubits": nqubits, "circuit_name": circuit_name}
if params: kwargs["params"] = params
if nlayers is not None: kwargs["nlayers"] = nlayers
if gate_type is not None: kwargs["gate_type"] = gate_type
if accelerators is not None:
kwargs["accelerators"] = accelerators
logs[-1].update(kwargs)
start_time = time.time()
circuit = circuits.CircuitFactory(**kwargs)
if nshots is not None:
# add measurement gates
circuit.add(qibo.gates.M(*range(nqubits)))
if fuse:
circuit = circuit.fuse()
logs[-1]["creation_time"] = time.time() - start_time
start_time = time.time()
if compile:
circuit.compile()
# Try executing here so that compile time is not included
# in the simulation time
result = circuit(nshots=nshots)
del (result)
logs[-1]["compile_time"] = time.time() - start_time
start_time = time.time()
result = circuit(nshots=nshots)
logs[-1]["dry_run_time"] = time.time() - start_time
start_time = time.time()
if transfer:
result = result.numpy()
logs[-1]["dry_run_transfer_time"] = time.time() - start_time
del (result)
simulation_times, transfer_times = [], []
for _ in range(nreps):
start_time = time.time()
result = circuit(nshots=nshots)
simulation_times.append(time.time() - start_time)
start_time = time.time()
if transfer:
result = result.numpy()
transfer_times.append(time.time() - start_time)
logs[-1]["dtype"] = str(result.dtype)
if nshots is None:
del (result)
logs[-1]["simulation_times"] = simulation_times
logs[-1]["transfer_times"] = transfer_times
logs[-1]["simulation_times_mean"] = np.mean(simulation_times)
logs[-1]["simulation_times_std"] = np.std(simulation_times)
logs[-1]["transfer_times_mean"] = np.mean(transfer_times)
logs[-1]["transfer_times_std"] = np.std(transfer_times)
start_time = time.time()
if nshots is not None:
freqs = result.frequencies()
logs[-1]["measurement_time"] = time.time() - start_time
if logs[-1]["backend"] == "qibojit" and qibo.K.get_platform() == "numba":
from numba import threading_layer
logs[-1]["threading"] = threading_layer()
print()
print(logs)
print()
logs.dump()
def main(nqubits, type,
backend="custom", precision="double",
device=None, accelerators=None,
nshots=None, fuse=False, compile=False,
nlayers=None, gate_type=None, params={},
filename=None):
"""Runs benchmarks for different circuit types.
Args:
nqubits (int): Number of qubits in the circuit.
type (str): Type of Circuit to use.
See ``benchmark_models.py`` for available types.
device (str): Tensorflow logical device to use for the benchmark.
If ``None`` the first available device is used.
accelerators (dict): Dictionary that specifies the accelarator devices
for multi-GPU setups.
nshots (int): Number of measurement shots.
Logs the time required to sample frequencies (no samples).
If ``None`` no measurements are performed.
fuse (bool): If ``True`` gate fusion is used for faster circuit execution.
compile: If ``True`` then the Tensorflow graph is compiled using
``circuit.compile()``. Compilation time is logged in this case.
nlayers (int): Number of layers for supremacy-like or gate circuits.
If a different circuit is used ``nlayers`` is ignored.
gate_type (str): Type of gate for gate circuits.
If a different circuit is used ``gate_type`` is ignored.
params (dict): Gate parameter for gate circuits.
If a non-parametrized circuit is used then ``params`` is ignored.
filename (str): Name of file to write logs.
If ``None`` logs will not be saved.
"""
qibo.set_backend(backend)
qibo.set_precision(precision)
if device is not None:
qibo.set_device(device)
if filename is not None:
if os.path.isfile(filename):
with open(filename, "r") as file:
logs = json.load(file)
print("Extending existing logs from {}.".format(filename))
else:
print("Creating new logs in {}.".format(filename))
logs = []
else:
logs = []
# Create log dict
logs.append({
"nqubits": nqubits, "circuit_type": type,
"backend": qibo.get_backend(), "precision": qibo.get_precision(),
"device": qibo.get_device(), "accelerators": accelerators,
"nshots": nshots, "fuse": fuse, "compile": compile
})
params = {k: v for k, v in params.items() if v is not None}
kwargs = {"nqubits": nqubits, "circuit_type": type}
if params: kwargs["params"] = params
if nlayers is not None: kwargs["nlayers"] = nlayers
if gate_type is not None: kwargs["gate_type"] = gate_type
if accelerators is not None:
kwargs["accelerators"] = accelerators
kwargs["device"] = device
logs[-1].update(kwargs)
start_time = time.time()
circuit = circuits.CircuitFactory(**kwargs)
if nshots is not None:
# add measurement gates
circuit.add(qibo.gates.M(*range(nqubits)))
if fuse:
circuit = circuit.fuse()
logs[-1]["creation_time"] = time.time() - start_time
if compile:
start_time = time.time()
circuit.compile()
# Try executing here so that compile time is not included
# in the simulation time
result = circuit(nshots=nshots)
logs[-1]["compile_time"] = time.time() - start_time
start_time = time.time()
result = circuit(nshots=nshots)
logs[-1]["simulation_time"] = time.time() - start_time
logs[-1]["dtype"] = str(result.dtype)
if nshots is not None:
start_time = time.time()
freqs = result.frequencies()
logs[-1]["measurement_time"] = time.time() - start_time
print()
for k, v in logs[-1].items():
print("{}: {}".format(k, v))
if filename is not None:
with open(filename, "w") as file:
json.dump(logs, file)
