def create_farhi_qaoa_circuits(number_of_layers: Union[int, List[int], str],
hamiltonians):
if isinstance(number_of_layers, str):
number_of_layers = load_list(number_of_layers)
hamiltonians_objects = load_qubit_operator_set(hamiltonians)
circuits = farhi_ansatz.create_farhi_qaoa_circuits(hamiltonians_objects,
number_of_layers)
save_circuitset(circuits, "circuits.json")
def test_list_io(self):
# Given
initial_list = [0.1, 0.3, -0.3]
# When
save_list(initial_list, "list.json")
loaded_list = load_list("list.json")
# Then
assert initial_list == loaded_list
remove_file_if_exists("list.json")
def test_named_list_io(self):
# Given
initial_list = [0.1, 0.3, -0.3]
# When
save_list(initial_list, "list.json", "number")
loaded_list = load_list("list.json")
# Then
assert initial_list == loaded_list
# And
# After manually loading json
if isinstance("list.json", str):
with open("list.json", "r") as f:
data = json.load(f)
else:
data = json.load("list.json")
# Check that
assert data["schema"] == SCHEMA_VERSION + "-number-list"
remove_file_if_exists("list.json")
def build_qaoa_ansatz_circuit(
ansatz_specs: Specs,
cost_hamiltonian: Union[str, List],
mixer_hamiltonian: Union[str, List] = None,
params: Optional[Union[str, List]] = None,
thetas: Optional[Union[str, List]] = None,
):
if isinstance(ansatz_specs, str):
DeprecationWarning(
"Loading ansatz_specs as a string will be depreciated in future, please change it to a dictionary."
)
ansatz_specs = json.loads(ansatz_specs)
cost_hamiltonian = load_qubit_operator(cost_hamiltonian)
ansatz_specs["cost_hamiltonian"] = cost_hamiltonian
if mixer_hamiltonian:
mixer_hamiltonian = load_qubit_operator(mixer_hamiltonian)
ansatz_specs["mixer_hamiltonian"] = mixer_hamiltonian
if thetas:
thetas = np.array(load_list(thetas))
ansatz_specs["thetas"] = thetas
ansatz = load_from_specs(ansatz_specs)
if params is not None:
if isinstance(params, str):
params = load_array(params)
else:
params = np.array(params)
circuit = ansatz.get_executable_circuit(params)
elif ansatz.supports_parametrized_circuits:
circuit = ansatz.parametrized_circuit
else:
raise (Exception(
"Ansatz is not parametrizable and no parameters has been provided."
))
save_circuit(circuit, "circuit.json")
def optimize_ansatz_based_cost_function(
optimizer_specs: Specs,
target_operator: Union[SymbolicOperator, str],
ansatz_specs: Specs,
backend_specs: Specs,
estimation_method_specs: Optional[Specs] = None,
estimation_preprocessors_specs: Optional[List[Specs]] = None,
initial_parameters: Union[str, np.ndarray, List[float]] = None,
fixed_parameters: Optional[Union[np.ndarray, str]] = None,
parameter_precision: Optional[float] = None,
parameter_precision_seed: Optional[int] = None,
keep_history: bool = False,
**kwargs,
):
"""Optimize the parameters of an ansatz circuit to prepare the ground state of a
target operator.
Args:
optimizer_specs: The specs of the optimizer to use to refine the parameter
values
target_operator: The operator of which to prepare the ground state
ansatz_specs: The specs describing an Ansatz which will prepare the quantum
circuit
backend_specs: The specs of the quantum backend (or simulator) to use to run the
circuits
estimation_method_specs: A reference to a callable to use to estimate the
expectation value of the operator. The default is the
estimate_expectation_values_by_averaging function.
estimation_preprocessors_specs: A list of Specs that describe callable functions
that adhere to the EstimationPreprocessor protocol.
initial_parameters: The initial parameter values to begin optimization
fixed_parameters: values for the circuit parameters that should be fixed.
parameter_precision: the standard deviation of the Gaussian noise to add to each
parameter, if any.
parameter_precision_seed: seed for randomly generating parameter deviation if
using parameter_precision
keep_history: flag indicating whether to store optimization history.
kwargs:
The following key word arguments are handled explicitly when appropriate:
- thetas: A list of thetas used to initialize the WarmStartQAOAAnsatz
"""
if isinstance(optimizer_specs, str):
optimizer_specs = json.loads(optimizer_specs)
optimizer = create_object(optimizer_specs)
if isinstance(target_operator, str):
target_operator = load_qubit_operator(target_operator)
if isinstance(ansatz_specs, str):
ansatz_specs = json.loads(ansatz_specs)
if "WarmStartQAOAAnsatz" in ansatz_specs["function_name"]:
ansatz_specs["thetas"] = np.array(load_list(kwargs.pop("thetas")))
ansatz_specs["cost_hamiltonian"] = target_operator
elif "QAOA" in ansatz_specs["function_name"]:
ansatz_specs["cost_hamiltonian"] = target_operator
ansatz = create_object(ansatz_specs)
if isinstance(backend_specs, str):
backend_specs = json.loads(backend_specs)
backend = create_object(backend_specs)
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
estimation_preprocessors = []
if estimation_preprocessors_specs is not None:
for estimation_preprocessor_specs in estimation_preprocessors_specs:
if isinstance(estimation_preprocessor_specs, str):
estimation_preprocessor_specs = json.loads(
estimation_preprocessor_specs)
estimation_preprocessors.append(
create_object(estimation_preprocessor_specs))
if initial_parameters is not None:
if isinstance(initial_parameters, str):
initial_parameters = load_array(initial_parameters)
if fixed_parameters is not None:
if isinstance(fixed_parameters, str):
fixed_parameters = load_array(fixed_parameters)
cost_function = AnsatzBasedCostFunction(
target_operator,
ansatz,
backend,
estimation_method=estimation_method,
estimation_preprocessors=estimation_preprocessors,
fixed_parameters=fixed_parameters,
parameter_precision=parameter_precision,
parameter_precision_seed=parameter_precision_seed,
)
optimization_results = optimizer.minimize(cost_function,
initial_parameters, keep_history)
save_optimization_results(optimization_results,
"optimization-results.json")
save_array(optimization_results.opt_params, "optimized-parameters.json")
def convert_relaxed_solution_to_angles(solution, epsilon=0.5):
solution = np.array(load_list(solution))
thetas = warm_start_ansatz.convert_relaxed_solution_to_angles(
solution, epsilon)
save_list(thetas.tolist(), "thetas.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")
