def test_switcher_errors():
"""Check set precision and backend errors."""
import qibo
with pytest.raises(RuntimeError):
qibo.set_precision('test')
with pytest.raises(RuntimeError):
qibo.set_backend('test')
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 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_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 test_switcher_warnings():
"""Check set precision and backend warnings."""
import qibo
from qibo import gates
g = gates.H(0)
qibo.set_precision("double")
with pytest.warns(RuntimeWarning):
qibo.set_precision("single")
qibo.set_precision("double")
with pytest.warns(RuntimeWarning):
qibo.set_backend("matmuleinsum")
qibo.set_backend("custom")
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)
import tensorflow as tf
tf.config.threading.set_inter_op_parallelism_threads(16)
tf.config.threading.set_intra_op_parallelism_threads(16)
import qibo
qibo.set_precision("double")
import numpy as np
from qibo.models import Circuit
from qibo import gates
import pytest
nqubits_list = range(4, 26)
def first_rotation(circuit, nqubits):
for k in range(nqubits):
circuit.add(gates.RX(k, np.random.rand()))
circuit.add(gates.RZ(k, np.random.rand()))
def mid_rotation(circuit, nqubits):
for k in range(nqubits):
circuit.add(gates.RZ(k, np.random.rand()))
circuit.add(gates.RX(k, np.random.rand()))
circuit.add(gates.RZ(k, np.random.rand()))
def last_rotation(circuit, nqubits):
for k in range(nqubits):
circuit.add(gates.RZ(k, np.random.rand()))
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)
print("\nAttempting to limit GPU memory to {}.\n".format(memory_limit))
gpus = tf.config.list_physical_devices("GPU")
for gpu in tf.config.list_physical_devices("GPU"):
config = tf.config.experimental.VirtualDeviceConfiguration(
memory_limit=memory_limit)
tf.config.experimental.set_virtual_device_configuration(gpu, [config])
print("Limiting memory of {} to {}.".format(gpu.name, memory_limit))
print()
limit_gpu_memory(args.pop("memory"))
import qibo
qibo.set_backend(args.pop("backend"))
qibo.set_precision(args.pop("precision"))
import circuits
import utils
def main(nqubits_list: List[int],
type: str,
device: Optional[str] = "/CPU:0",
accelerators: Optional[Dict[str, int]] = None,
fuse: bool = False,
nlayers: Optional[int] = None,
gate_type: Optional[str] = None,
params: Dict[str, float] = {},
nshots: Optional[int] = None,
directory: Optional[str] = None,
name: Optional[str] = None,
