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)