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,