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