def run_circuitset_and_measure( backend_specs: Specs, circuitset: str, n_samples: Optional[int] = None, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, ): if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = layouts.load_circuit_connectivity( device_connectivity ) circuit_set = circuits.load_circuitset(circuitset) backend = create_object(backend_specs) n_samples_list = [n_samples for _ in circuit_set] measurements_set = backend.run_circuitset_and_measure( circuit_set, n_samples=n_samples_list ) list_of_measurements = [measurement.bitstrings for measurement in measurements_set] save_list(list_of_measurements, "measurements-set.json")
def evaluate_ansatz_based_cost_function( ansatz_specs: Specs, backend_specs: Specs, cost_function_specs: Specs, ansatz_parameters: Specs, qubit_operator: str, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, prior_expectation_values: Optional[str] = None, ): ansatz_parameters = load_circuit_template_params(ansatz_parameters) # Load qubit op operator = load_qubit_operator(qubit_operator) if isinstance(ansatz_specs, str): ansatz_specs = json.loads(ansatz_specs) if ansatz_specs["function_name"] == "QAOAFarhiAnsatz": ansatz = create_object(ansatz_specs, cost_hamiltonian=operator) else: ansatz = create_object(ansatz_specs) if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) if isinstance(cost_function_specs, str): cost_function_specs = json.loads(cost_function_specs) estimator_specs = cost_function_specs.pop("estimator-specs", None) if estimator_specs is not None: cost_function_specs["estimator"] = create_object(estimator_specs) cost_function_specs["target_operator"] = operator cost_function_specs["ansatz"] = ansatz cost_function_specs["backend"] = backend cost_function = create_object(cost_function_specs) if prior_expectation_values is not None: if isinstance(prior_expectation_values, str): cost_function.estimator.prior_expectation_values = load_expectation_values( prior_expectation_values) value_estimate = cost_function(ansatz_parameters) save_value_estimate(value_estimate, "value_estimate.json")
def run_circuit_and_measure( backend_specs: Dict, circuit: str, noise_model: str = "None", device_connectivity: str = "None", ): backend_specs = json.loads(backend_specs) if noise_model != "None": backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity != "None": backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) circuit = load_circuit(circuit) measurements = backend.run_circuit_and_measure(circuit) measurements.save("measurements.json")
def test_noise_model_io(self): # Given module_name = "zquantum.core.testing.mocks" function_name = "mock_create_noise_model" noise_model_data = {"testing": "data"} # When save_noise_model( noise_model_data, module_name, function_name, "noise_model.json", ) noise_model = load_noise_model("noise_model.json") # Then assert noise_model is None remove_file_if_exists("noise_model.json")
def get_bitstring_distribution( backend_specs: Dict, circuit: str, noise_model: str = "None", device_connectivity: str = "None", ): backend_specs = json.loads(backend_specs) if noise_model != "None": backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity != "None": backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) circuit = load_circuit(circuit) bitstring_distribution = backend.get_bitstring_distribution(circuit) save_bitstring_distribution(bitstring_distribution, "bitstring-distribution.json")
def run_circuit_and_measure( backend_specs: Dict, circuit: str, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, ): if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) circuit = load_circuit(circuit) measurements = backend.run_circuit_and_measure(circuit) measurements.save("measurements.json")
def test_noise_model_with_additional_args(self): # Given filename = "noise_model.json" with open(filename, "w") as f: f.write( json.dumps({ "module_name": "zquantum.core.testing.mocks", "function_name": "mock_create_noise_model", "data": { "testing": "data" }, "schema": "THIS IS FOR TESTING ONLY", })) # When _ = load_noise_model(filename) # Then remove_file_if_exists(filename)
def get_bitstring_distribution( backend_specs: Specs, circuit: str, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, ): if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = layouts.load_circuit_connectivity( device_connectivity ) backend = create_object(backend_specs) circuit = circuits.load_circuit(circuit) bitstring_distribution = backend.get_bitstring_distribution(circuit) save_bitstring_distribution(bitstring_distribution, "bitstring-distribution.json")
def test_noise_model_io_using_core_functions(self): # Given noise_model = AerNoise.NoiseModel() quantum_error = AerNoise.depolarizing_error(0.0, 1) coherent_error = np.asarray([ np.asarray( [0.87758256 - 0.47942554j, 0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j]), np.asarray( [0.0 + 0.0j, 0.87758256 + 0.47942554j, 0.0 + 0.0j, 0.0 + 0.0j]), np.asarray( [0.0 + 0.0j, 0.0 + 0.0j, 0.87758256 + 0.47942554j, 0.0 + 0.0j]), np.asarray( [0.0 + 0.0j, 0.0 + 0.0j, 0.0 + 0.0j, 0.87758256 - 0.47942554j]), ]) noise_model.add_quantum_error( AerNoise.coherent_unitary_error(coherent_error), ["cx"], [0, 1]) noise_model_data = noise_model.to_dict(serializable=True) module_name = "qeqiskit.utils" function_name = "load_qiskit_noise_model" filename = "noise_model.json" # When save_noise_model(noise_model_data, module_name, function_name, filename) new_noise_model = load_noise_model(filename) # Then self.assertEqual( noise_model.to_dict(serializable=True), new_noise_model.to_dict(serializable=True), ) # Cleanup subprocess.run(["rm", "noise_model.json"])
def evaluate_ansatz_based_cost_function( ansatz_specs: str, backend_specs: str, cost_function_specs: str, ansatz_parameters: str, qubit_operator: str, noise_model="None", device_connectivity="None", ): ansatz_parameters = load_circuit_template_params(ansatz_parameters) # Load qubit op operator = load_qubit_operator(qubit_operator) ansatz_specs = json.loads(ansatz_specs) if ansatz_specs["function_name"] == "QAOAFarhiAnsatz": ansatz = create_object(ansatz_specs, cost_hamiltonian=operator) else: ansatz = create_object(ansatz_specs) backend_specs = json.loads(backend_specs) if noise_model != "None": backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity != "None": backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) cost_function_specs = json.loads(cost_function_specs) estimator_specs = cost_function_specs.pop("estimator-specs", None) if estimator_specs is not None: cost_function_specs["estimator"] = create_object(estimator_specs) cost_function_specs["target_operator"] = operator cost_function_specs["ansatz"] = ansatz cost_function_specs["backend"] = backend cost_function = create_object(cost_function_specs) value_estimate = cost_function(ansatz_parameters) save_value_estimate(value_estimate, "value_estimate.json")
def run_circuit_and_measure( backend_specs: Specs, circuit: Union[str, Dict], n_samples: Optional[int] = None, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, ): if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = layouts.load_circuit_connectivity( device_connectivity ) backend = create_object(backend_specs) if isinstance(circuit, str): circuit = circuits.load_circuit(circuit) else: circuit = circuits.circuit_from_dict(circuit) measurements = backend.run_circuit_and_measure(circuit, n_samples=n_samples) measurements.save("measurements.json")
def evaluate_ansatz_based_cost_function( ansatz_specs: Specs, backend_specs: Specs, cost_function_specs: Specs, ansatz_parameters: str, target_operator: Union[str, openfermion.SymbolicOperator], estimation_method_specs: Optional[Specs] = None, estimation_preprocessors_specs: Optional[List[Specs]] = None, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, prior_expectation_values: Optional[str] = None, estimation_tasks_transformations_kwargs: Optional[Dict] = None, ): # Empty dict as default is bad if estimation_tasks_transformations_kwargs is None: estimation_tasks_transformations_kwargs = {} ansatz_parameters = load_array(ansatz_parameters) # Load qubit op if isinstance(target_operator, str): operator = load_qubit_operator(target_operator) else: operator = target_operator if isinstance(ansatz_specs, str): ansatz_specs = json.loads(ansatz_specs) if ansatz_specs["function_name"] == "QAOAFarhiAnsatz": ansatz = create_object(ansatz_specs, cost_hamiltonian=operator) else: ansatz = create_object(ansatz_specs) if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = layouts.load_circuit_connectivity( device_connectivity ) backend = create_object(backend_specs) if isinstance(cost_function_specs, str): cost_function_specs = json.loads(cost_function_specs) if ( "estimator-specs" in cost_function_specs.keys() or "estimation-tasks-transformations-specs" in cost_function_specs.keys() ): raise RuntimeError( "Estimation-related specs should be separate arguments and not in " "cost_function_specs" ) if prior_expectation_values is not None: if isinstance(prior_expectation_values, str): prior_expectation_values = load_expectation_values(prior_expectation_values) if estimation_method_specs is not None: if isinstance(estimation_method_specs, str): estimation_method_specs = json.loads(estimation_method_specs) estimation_method = create_object(estimation_method_specs) else: estimation_method = estimate_expectation_values_by_averaging cost_function_specs["estimation_method"] = estimation_method if estimation_preprocessors_specs is not None: cost_function_specs["estimation_preprocessors"] = [] for estimation_tasks_transformation_specs in estimation_preprocessors_specs: if isinstance(estimation_tasks_transformation_specs, str): estimation_tasks_transformation_specs = json.loads( estimation_tasks_transformation_specs ) if prior_expectation_values is not None: # Since we don't know which estimation task transformation uses # prior_expectation_values, we add it to the kwargs of each one. If not # used by a particular transformer, it will be ignored. estimation_tasks_transformation_specs[ "prior_expectation_values" ] = prior_expectation_values cost_function_specs["estimation_preprocessors"].append( create_object( estimation_tasks_transformation_specs, **estimation_tasks_transformations_kwargs ) ) # cost_function.estimator.prior_expectation_values cost_function_specs["target_operator"] = operator cost_function_specs["ansatz"] = ansatz cost_function_specs["backend"] = backend cost_function = create_object(cost_function_specs) value_estimate = cost_function(ansatz_parameters) save_value_estimate(value_estimate, "value_estimate.json")
def evaluate_ansatz_based_cost_function( ansatz_specs: Specs, backend_specs: Specs, cost_function_specs: Specs, ansatz_parameters: str, qubit_operator: str, noise_model: Optional[str] = None, device_connectivity: Optional[str] = None, prior_expectation_values: Optional[str] = None, ): ansatz_parameters = load_circuit_template_params(ansatz_parameters) # Load qubit op operator = load_qubit_operator(qubit_operator) if isinstance(ansatz_specs, str): ansatz_specs = json.loads(ansatz_specs) if ansatz_specs["function_name"] == "QAOAFarhiAnsatz": ansatz = create_object(ansatz_specs, cost_hamiltonian=operator) else: ansatz = create_object(ansatz_specs) if isinstance(backend_specs, str): backend_specs = json.loads(backend_specs) if noise_model is not None: backend_specs["noise_model"] = load_noise_model(noise_model) if device_connectivity is not None: backend_specs["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) if isinstance(cost_function_specs, str): cost_function_specs = json.loads(cost_function_specs) if prior_expectation_values is not None: if isinstance(prior_expectation_values, str): prior_expectation_values = load_expectation_values( prior_expectation_values) estimator_specs = cost_function_specs.pop("estimator-specs", None) if estimator_specs is not None: if isinstance(estimator_specs, str): estimator_specs = json.loads(estimator_specs) cost_function_specs["estimator"] = create_object(estimator_specs) estimation_preprocessors_specs = cost_function_specs.pop( "estimation-tasks-transformations-specs", None) if estimation_preprocessors_specs is not None: cost_function_specs["estimation_preprocessors"] = [] for estimation_tasks_transformation_specs in estimation_preprocessors_specs: if isinstance(estimation_tasks_transformation_specs, str): estimation_tasks_transformation_specs = json.loads( estimation_tasks_transformation_specs) if prior_expectation_values is not None: # Since we don't know which estimation task transformation uses prior_expectation_values, # we add it to the kwargs of each one. If not used by a particular transformer, it will be ignored. estimation_tasks_transformation_specs[ "prior_expectation_values"] = prior_expectation_values cost_function_specs["estimation_preprocessors"].append( create_object(estimation_tasks_transformation_specs)) # cost_function.estimator.prior_expectation_values cost_function_specs["target_operator"] = operator cost_function_specs["ansatz"] = ansatz cost_function_specs["backend"] = backend cost_function = create_object(cost_function_specs) value_estimate = cost_function(ansatz_parameters) save_value_estimate(value_estimate, "value_estimate.json")
def optimize_variational_circuit( ansatz_specs, backend_specs, optimizer_specs, cost_function_specs, qubit_operator, initial_parameters="None", fixed_parameters="None", noise_model="None", device_connectivity="None", parameter_grid="None", constraint_operator="None", ): if initial_parameters != "None": initial_params = load_circuit_template_params(initial_parameters) else: initial_params = None if fixed_parameters != "None": fixed_params = load_circuit_template_params(fixed_parameters) else: fixed_params = None # Load qubit operator operator = load_qubit_operator(qubit_operator) if isinstance(ansatz_specs, str): ansatz_specs_dict = yaml.load(ansatz_specs, Loader=yaml.SafeLoader) else: ansatz_specs_dict = ansatz_specs if ansatz_specs_dict["function_name"] == "QAOAFarhiAnsatz": ansatz = create_object(ansatz_specs_dict, cost_hamiltonian=operator) else: ansatz = create_object(ansatz_specs_dict) # Load parameter grid if parameter_grid != "None": grid = load_parameter_grid(parameter_grid) else: grid = None # Load optimizer specs if isinstance(optimizer_specs, str): optimizer_specs_dict = yaml.load(optimizer_specs, Loader=yaml.SafeLoader) else: optimizer_specs_dict = optimizer_specs if (grid is not None and optimizer_specs_dict["function_name"] == "GridSearchOptimizer"): optimizer = create_object(optimizer_specs_dict, grid=grid) else: optimizer = create_object(optimizer_specs_dict) # Load backend specs if isinstance(backend_specs, str): backend_specs_dict = yaml.load(backend_specs, Loader=yaml.SafeLoader) else: backend_specs_dict = backend_specs if noise_model != "None": backend_specs_dict["noise_model"] = load_noise_model(noise_model) if device_connectivity != "None": backend_specs_dict["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs_dict) # Load cost function specs if isinstance(cost_function_specs, str): cost_function_specs_dict = yaml.load(cost_function_specs, Loader=yaml.SafeLoader) else: cost_function_specs_dict = cost_function_specs estimator_specs = cost_function_specs_dict.pop("estimator-specs", None) if estimator_specs is not None: cost_function_specs_dict["estimator"] = create_object(estimator_specs) cost_function_specs_dict["target_operator"] = operator cost_function_specs_dict["ansatz"] = ansatz cost_function_specs_dict["backend"] = backend cost_function_specs_dict["fixed_parameters"] = fixed_params cost_function = create_object(cost_function_specs_dict) if constraint_operator != "None": constraint_op = load_qubit_operator(constraint_operator) constraints_cost_function_specs = yaml.load(cost_function_specs, Loader=yaml.SafeLoader) constraints_estimator_specs = constraints_cost_function_specs.pop( "estimator-specs", None) if constraints_estimator_specs is not None: constraints_cost_function_specs["estimator"] = create_object( constraints_estimator_specs) constraints_cost_function_specs["ansatz"] = ansatz constraints_cost_function_specs["backend"] = backend constraints_cost_function_specs["target_operator"] = constraint_op constraint_cost_function = create_object( constraints_cost_function_specs) constraint_cost_function_wrapper = ( lambda params: constraint_cost_function.evaluate(params).value) constraint_functions = ({ "type": "eq", "fun": constraint_cost_function_wrapper }, ) optimizer.constraints = constraint_functions opt_results = optimizer.minimize(cost_function, initial_params) save_optimization_results(opt_results, "optimization-results.json") save_circuit_template_params(opt_results.opt_params, "optimized-parameters.json")
def optimize_variational_circuit( ansatz_specs, backend_specs, optimizer_specs, cost_function_specs, qubit_operator, initial_parameters="None", fixed_parameters="None", noise_model="None", device_connectivity="None", parameter_grid="None", parameter_values_list=None, constraint_operator="None", prior_expectation_values: Optional[str] = None, keep_history=False, thetas=None, ): warnings.warn( "optimize_variational_circuit will be depreciated in favor of optimize_ansatz_based_cost_function in steps/optimize.py in z-quantum-core.", DeprecationWarning, ) if initial_parameters != "None": initial_params = load_array(initial_parameters) else: initial_params = None if fixed_parameters != "None": fixed_params = load_array(fixed_parameters) else: fixed_params = None # Load qubit operator operator = load_qubit_operator(qubit_operator) if isinstance(ansatz_specs, str): ansatz_specs_dict = yaml.load(ansatz_specs, Loader=yaml.SafeLoader) else: ansatz_specs_dict = ansatz_specs if "WarmStartQAOAAnsatz" in ansatz_specs_dict["function_name"]: thetas = np.array(load_list(thetas)) ansatz = create_object(ansatz_specs_dict, cost_hamiltonian=operator, thetas=thetas) elif "QAOA" in ansatz_specs_dict["function_name"]: ansatz = create_object(ansatz_specs_dict, cost_hamiltonian=operator) else: ansatz = create_object(ansatz_specs_dict) # Load parameter grid if parameter_grid != "None": grid = load_parameter_grid(parameter_grid) else: grid = None # Load parameter values list if parameter_values_list is not None: parameter_values_list = load_array(parameter_values_list) # Load optimizer specs if isinstance(optimizer_specs, str): optimizer_specs_dict = yaml.load(optimizer_specs, Loader=yaml.SafeLoader) else: optimizer_specs_dict = optimizer_specs if (grid is not None and optimizer_specs_dict["function_name"] == "GridSearchOptimizer"): optimizer = create_object(optimizer_specs_dict, grid=grid) elif (parameter_values_list is not None and optimizer_specs_dict["function_name"] == "SearchPointsOptimizer"): optimizer = create_object(optimizer_specs_dict, parameter_values_list=parameter_values_list) else: optimizer = create_object(optimizer_specs_dict) # Load backend specs if isinstance(backend_specs, str): backend_specs_dict = yaml.load(backend_specs, Loader=yaml.SafeLoader) else: backend_specs_dict = backend_specs if noise_model != "None": backend_specs_dict["noise_model"] = load_noise_model(noise_model) if device_connectivity != "None": backend_specs_dict["device_connectivity"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs_dict) # Load cost function specs if isinstance(cost_function_specs, str): cost_function_specs_dict = yaml.load(cost_function_specs, Loader=yaml.SafeLoader) else: cost_function_specs_dict = cost_function_specs estimation_method_specs = cost_function_specs_dict.pop( "estimation_method_specs", None) if estimation_method_specs is not None: if isinstance(estimation_method_specs, str): estimation_method_specs = yaml.loads(estimation_method_specs) estimation_method = create_object(estimation_method_specs) else: estimation_method = estimate_expectation_values_by_averaging cost_function_specs_dict["estimation_method"] = estimation_method estimation_preprocessors_specs_list = cost_function_specs_dict.pop( "estimation_preprocessors_specs", None) if estimation_preprocessors_specs_list is not None: estimation_preprocessors = [] for estimation_preprocessor_specs in estimation_preprocessors_specs_list: if isinstance(estimation_preprocessor_specs, str): estimation_preprocessor_specs = yaml.loads( estimation_preprocessor_specs) estimation_preprocessors.append( create_object(estimation_preprocessor_specs)) cost_function_specs_dict[ "estimation_preprocessors"] = estimation_preprocessors cost_function_specs_dict["target_operator"] = operator cost_function_specs_dict["ansatz"] = ansatz cost_function_specs_dict["backend"] = backend cost_function_specs_dict["fixed_parameters"] = fixed_params cost_function = create_object(cost_function_specs_dict) if prior_expectation_values is not None: if isinstance(prior_expectation_values, str): cost_function.estimator.prior_expectation_values = load_expectation_values( prior_expectation_values) if constraint_operator != "None": constraint_op = load_qubit_operator(constraint_operator) constraints_cost_function_specs = yaml.load(cost_function_specs, Loader=yaml.SafeLoader) constraints_estimator_specs = constraints_cost_function_specs.pop( "estimator-specs", None) if constraints_estimator_specs is not None: constraints_cost_function_specs["estimator"] = create_object( constraints_estimator_specs) constraints_cost_function_specs["ansatz"] = ansatz constraints_cost_function_specs["backend"] = backend constraints_cost_function_specs["target_operator"] = constraint_op constraint_cost_function = create_object( constraints_cost_function_specs) constraint_cost_function_wrapper = ( lambda params: constraint_cost_function.evaluate(params).value) constraint_functions = ({ "type": "eq", "fun": constraint_cost_function_wrapper }, ) optimizer.constraints = constraint_functions opt_results = optimizer.minimize(cost_function, initial_params, keep_history) save_optimization_results(opt_results, "optimization-results.json") save_array(opt_results.opt_params, "optimized-parameters.json")