def test_build_circuit_layers_and_connectivity(self, x_dimension, y_dimension, layer_type): # Given expected_circuit_layers_filename = "circuit-layers.json" expected_circuit_connectivity_filename = "circuit-connectivity.json" ( expected_circuit_connectivity, expected_circuit_layers, ) = _build_circuit_layers_and_connectivity(x_dimension=x_dimension, y_dimension=y_dimension, layer_type=layer_type) # When build_circuit_layers_and_connectivity(x_dimension=x_dimension, y_dimension=y_dimension, layer_type=layer_type) # Then try: circuit_layers = load_circuit_layers( expected_circuit_layers_filename) circuit_connectivity = load_circuit_connectivity( expected_circuit_connectivity_filename) assert circuit_layers.layers == expected_circuit_layers.layers assert (circuit_connectivity.connectivity == expected_circuit_connectivity.connectivity) finally: remove_file_if_exists(expected_circuit_connectivity_filename) remove_file_if_exists(expected_circuit_layers_filename)
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"] = load_circuit_connectivity( device_connectivity) circuit_set = load_circuit_set(circuitset) backend = create_object(backend_specs) measurements_set = backend.run_circuitset_and_measure(circuit_set, n_samples=n_samples) 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 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 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"] = 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 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"] = load_circuit_connectivity( device_connectivity) backend = create_object(backend_specs) if isinstance(circuit, str): circuit = load_circuit(circuit) else: circuit = 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, 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")