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")