def test_trotter_ansatzes_default_initial_params_iterations_1(
ansatz_factory, trotter_algorithm, order, hamiltonian, atol):
"""Check that a Trotter ansatz with one iteration and default parameters
is consistent with time evolution with one Trotter step."""
ansatz = ansatz_factory(hamiltonian, iterations=1)
objective = HamiltonianObjective(hamiltonian)
qubits = ansatz.qubits
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
one_body = hamiltonian.one_body
elif isinstance(hamiltonian, openfermion.InteractionOperator):
one_body = hamiltonian.one_body_tensor
preparation_circuit = cirq.Circuit.from_ops(
prepare_gaussian_state(qubits,
openfermion.QuadraticHamiltonian(one_body),
occupied_orbitals=range(len(qubits) // 2)))
# Compute value using ansatz circuit and objective
circuit = (preparation_circuit +
ansatz.circuit).with_parameters_resolved_by(
ansatz.param_resolver(ansatz.default_initial_params()))
result = circuit.apply_unitary_effect_to_state(
qubit_order=ansatz.qubit_permutation(qubits))
obj_val = objective.value(result)
# Compute value using study
study = VariationalStudy('study',
ansatz,
objective,
preparation_circuit=preparation_circuit)
study_val = study.value_of(ansatz.default_initial_params())
# Compute value by simulating time evolution
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
half_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body, two_body=0.5 * hamiltonian.two_body)
elif isinstance(hamiltonian, openfermion.InteractionOperator):
half_way_hamiltonian = openfermion.InteractionOperator(
constant=hamiltonian.constant,
one_body_tensor=hamiltonian.one_body_tensor,
two_body_tensor=0.5 * hamiltonian.two_body_tensor)
simulation_circuit = cirq.Circuit.from_ops(
simulate_trotter(qubits,
half_way_hamiltonian,
time=ansatz.adiabatic_evolution_time,
n_steps=1,
order=order,
algorithm=trotter_algorithm))
final_state = (preparation_circuit +
simulation_circuit).apply_unitary_effect_to_state()
correct_val = openfermion.expectation(objective._hamiltonian_linear_op,
final_state).real
numpy.testing.assert_allclose(obj_val, study_val, atol=atol)
numpy.testing.assert_allclose(obj_val, correct_val, atol=atol)
def test_variational_study_save_load():
datadir = 'tmp_yulXPXnMBrxeUVt7kYVw'
study_name = 'test_study'
study = ExampleStudy(
study_name,
test_ansatz,
datadir=datadir)
study.optimize(
OptimizationParams(
ScipyOptimizationAlgorithm(
kwargs={'method': 'COBYLA'},
options={'maxiter': 2}),
initial_guess=numpy.array([7.9, 3.9]),
initial_guess_array=numpy.array([[7.5, 7.6],
[8.8, 1.1]]),
cost_of_evaluate=1.0),
'example')
study.save()
loaded_study = VariationalStudy.load(study_name, datadir=datadir)
assert loaded_study.name == study.name
assert str(loaded_study.circuit) == str(study.circuit)
assert loaded_study.datadir == datadir
assert len(loaded_study.results) == 1
result = loaded_study.results['example']
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 1
assert isinstance(result.params.algorithm, ScipyOptimizationAlgorithm)
assert result.params.algorithm.kwargs == {'method': 'COBYLA'}
assert result.params.algorithm.options == {'maxiter': 2}
assert result.params.cost_of_evaluate == 1.0
loaded_study = VariationalStudy.load('{}.study'.format(study_name),
datadir=datadir)
assert loaded_study.name == study.name
# Clean up
os.remove(os.path.join(datadir, '{}.study'.format(study_name)))
os.rmdir(datadir)
def test_variational_study_initial_state():
preparation_circuit = cirq.Circuit.from_ops(cirq.X(test_ansatz.qubits[0]))
initial_state = numpy.array([0.0, 0.0, 1.0, 0.0])
class TestObjective(VariationalObjective):
def value(self, circuit_output):
return circuit_output[0].real
study1 = VariationalStudy(
'study1',
test_ansatz,
TestObjective(),
preparation_circuit=preparation_circuit,
black_box_type=variational_black_box.UNITARY_SIMULATE_STATEFUL)
study2 = VariationalStudy(
'study2',
test_ansatz,
TestObjective(),
initial_state=initial_state,
black_box_type=variational_black_box.UNITARY_SIMULATE_STATEFUL)
initial_guess = numpy.random.randn(2)
result1 = study1.optimize(
OptimizationParams(LazyAlgorithm(), initial_guess=initial_guess))
result2 = study2.optimize(
OptimizationParams(LazyAlgorithm(), initial_guess=initial_guess))
numpy.testing.assert_allclose(result1.optimal_value, result2.optimal_value)
def test_variational_study_save_load():
datadir = 'tmp_yulXPXnMBrxeUVt7kYVw'
study_name = 'test_study'
study = VariationalStudy(
study_name,
test_ansatz,
test_objective,
initial_state=numpy.array([0.0, 1.0, 0.0,
0.0]).astype(numpy.complex64),
datadir=datadir,
black_box_type=variational_black_box.XMON_SIMULATE_STATEFUL)
study.optimize(
OptimizationParams(ScipyOptimizationAlgorithm(
kwargs={'method': 'COBYLA'}, options={'maxiter': 2}),
initial_guess=numpy.array([7.9, 3.9]),
initial_guess_array=numpy.array([[7.5, 7.6],
[8.8, 1.1]]),
cost_of_evaluate=1.0), 'example')
study.save()
loaded_study = VariationalStudy.load(study_name, datadir=datadir)
assert loaded_study.name == study.name
assert str(loaded_study.circuit) == str(study.circuit)
assert loaded_study.datadir == datadir
assert len(loaded_study.trial_results) == 1
numpy.testing.assert_allclose(loaded_study.initial_state,
numpy.array([0.0, 1.0, 0.0, 0.0]))
result = loaded_study.trial_results['example']
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 1
assert isinstance(result.params.algorithm, ScipyOptimizationAlgorithm)
assert result.params.algorithm.kwargs == {'method': 'COBYLA'}
assert result.params.algorithm.options == {'maxiter': 2}
assert result.params.cost_of_evaluate == 1.0
loaded_study = VariationalStudy.load('{}.study'.format(study_name),
datadir=datadir)
assert loaded_study.name == study.name
# Clean up
os.remove(os.path.join(datadir, '{}.study'.format(study_name)))
os.rmdir(datadir)
def test_variational_study_optimize_and_extend_and_summary():
numpy.random.seed(63351)
study = VariationalStudy('study', test_ansatz, test_objective)
assert len(study.results) == 0
# Optimization run 1
result = study.optimize(OptimizationParams(test_algorithm), 'run1')
assert len(study.results) == 1
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 1
# Extend optimization run 1
study.extend_result('run1', repetitions=2)
assert study.results['run1'].repetitions == 3
# Optimization run 2
study.optimize(OptimizationParams(test_algorithm),
repetitions=2,
use_multiprocessing=True)
result = study.results[0]
assert len(study.results) == 2
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 2
# Optimization run 3
study.optimize(OptimizationParams(test_algorithm,
initial_guess=numpy.array([4.5, 8.8]),
initial_guess_array=numpy.array(
[[7.2, 6.3], [3.6, 9.8]]),
cost_of_evaluate=1.0),
reevaluate_final_params=True,
stateful=True,
save_x_vals=True)
result = study.results[1]
assert len(study.results) == 3
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 1
assert all(result.data_frame['optimal_parameters'].apply(
lambda x: VariationalBlackBox(test_ansatz, test_objective).evaluate(x))
== result.data_frame['optimal_value'])
assert isinstance(result.results[0].cost_spent, float)
# Try extending non-existent run
with pytest.raises(KeyError):
study.extend_result('run100')
# Check that getting a summary works
assert isinstance(study.summary, str)
ScipyOptimizationAlgorithm)
from openfermioncirq.variational.study import (VariationalBlackBox,
VariationalStudy)
from openfermioncirq.testing import (ExampleAlgorithm, ExampleAnsatz,
ExampleVariationalObjective,
ExampleVariationalObjectiveNoisy)
test_algorithm = ExampleAlgorithm()
test_ansatz = ExampleAnsatz()
test_objective = ExampleVariationalObjective()
test_objective_noisy = ExampleVariationalObjectiveNoisy()
a, b = test_ansatz.qubits
preparation_circuit = cirq.Circuit.from_ops(cirq.X(a))
test_study = VariationalStudy('test_study',
test_ansatz,
test_objective,
preparation_circuit=preparation_circuit)
test_study_noisy = VariationalStudy('test_study_noisy',
test_ansatz,
test_objective_noisy,
preparation_circuit=preparation_circuit)
def test_variational_study_circuit():
assert (test_study.circuit.to_text_diagram().strip() == """
0: ───X───X^theta0───@───X^theta0───M('all')───
│ │
1: ───────X^theta1───@───X^theta1───M──────────
""".strip())
def test_variational_study_optimize_and_extend_and_summary():
numpy.random.seed(63351)
study = VariationalStudy(
'study',
test_ansatz,
test_objective,
black_box_type=variational_black_box.XMON_SIMULATE_STATEFUL,
target=-10.5)
assert len(study.trial_results) == 0
assert study.target == -10.5
# Optimization run 1
result = study.optimize(OptimizationParams(test_algorithm), 'run1')
assert len(study.trial_results) == 1
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 1
# Extend optimization run 1
study.extend_result('run1', repetitions=2)
assert study.trial_results['run1'].repetitions == 3
# Optimization run 2
study.optimize(OptimizationParams(test_algorithm),
repetitions=2,
use_multiprocessing=True)
result = study.trial_results[0]
assert len(study.trial_results) == 2
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 2
# Optimization run 3
study.optimize(OptimizationParams(test_algorithm,
initial_guess=numpy.array([4.5, 8.8]),
initial_guess_array=numpy.array(
[[7.2, 6.3], [3.6, 9.8]]),
cost_of_evaluate=1.0),
reevaluate_final_params=True,
save_x_vals=True)
result = study.trial_results[1]
assert len(study.trial_results) == 3
assert isinstance(result, OptimizationTrialResult)
assert result.repetitions == 1
assert all(result.data_frame['optimal_parameters'].apply(
lambda x: XmonSimulateVariationalBlackBox(test_ansatz, test_objective).
evaluate(x)) == result.data_frame['optimal_value'])
assert isinstance(result.results[0].cost_spent, float)
# Optimization run 4
trial_results = study.optimize_sweep([
OptimizationParams(test_algorithm),
OptimizationParams(LazyAlgorithm())
],
identifiers=['test', 'lazy'],
use_multiprocessing=True,
num_processes=2)
assert isinstance(trial_results[0].params.algorithm, ExampleAlgorithm)
assert isinstance(trial_results[1].params.algorithm, LazyAlgorithm)
assert isinstance(study.trial_results['test'].params.algorithm,
ExampleAlgorithm)
assert isinstance(study.trial_results['lazy'].params.algorithm,
LazyAlgorithm)
# Try extending non-existent run
with pytest.raises(KeyError):
study.extend_result('run100')
# Check that getting a summary works
assert str(study).startswith('This study contains')
XmonSimulateVariationalBlackBox)
from openfermioncirq.testing import (ExampleAlgorithm, ExampleAnsatz,
ExampleVariationalObjective,
ExampleVariationalObjectiveNoisy,
LazyAlgorithm)
test_algorithm = ExampleAlgorithm()
test_ansatz = ExampleAnsatz()
test_objective = ExampleVariationalObjective()
test_objective_noisy = ExampleVariationalObjectiveNoisy()
a, b = test_ansatz.qubits
preparation_circuit = cirq.Circuit.from_ops(cirq.X(a))
test_study = VariationalStudy(
'test_study',
test_ansatz,
test_objective,
preparation_circuit=preparation_circuit,
black_box_type=variational_black_box.XMON_SIMULATE)
test_study_noisy = VariationalStudy(
'test_study_noisy',
test_ansatz,
test_objective_noisy,
preparation_circuit=preparation_circuit,
black_box_type=variational_black_box.XMON_SIMULATE)
def test_variational_study_circuit():
assert (test_study.circuit.to_text_diagram().strip() == """
0: ───X───X^theta0───@───X^theta0───M('all')───
│ │
1: ───────X^theta1───@───X^theta1───M──────────
def test_trotter_ansatzes_default_initial_params_iterations_2(
ansatz_factory, trotter_algorithm, hamiltonian, atol):
"""Check that a Trotter ansatz with two iterations and default parameters
is consistent with time evolution with two Trotter steps."""
ansatz = ansatz_factory(hamiltonian, iterations=2)
objective = HamiltonianObjective(hamiltonian)
qubits = ansatz.qubits
preparation_circuit = cirq.Circuit.from_ops(
prepare_gaussian_state(
qubits,
openfermion.QuadraticHamiltonian(hamiltonian.one_body),
occupied_orbitals=range(len(qubits) // 2))
)
simulator = cirq.google.XmonSimulator()
# Compute value using ansatz circuit and objective
result = simulator.simulate(
preparation_circuit + ansatz.circuit,
param_resolver=
ansatz.param_resolver(ansatz.default_initial_params()),
qubit_order=ansatz.qubit_permutation(qubits)
)
obj_val = objective.value(result)
# Compute value using study
study = VariationalStudy(
'study',
ansatz,
objective,
preparation_circuit=preparation_circuit)
study_val = study.value_of(ansatz.default_initial_params())
# Compute value by simulating time evolution
quarter_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.25 * hamiltonian.two_body)
three_quarters_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.75 * hamiltonian.two_body)
simulation_circuit = cirq.Circuit.from_ops(
simulate_trotter(
qubits,
quarter_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=1,
algorithm=trotter_algorithm),
simulate_trotter(
qubits,
three_quarters_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=1,
algorithm=trotter_algorithm)
)
result = simulator.simulate(preparation_circuit + simulation_circuit)
final_state = result.final_state
correct_val = openfermion.expectation(
objective._hamiltonian_linear_op, final_state).real
numpy.testing.assert_allclose(obj_val, study_val, atol=atol)
numpy.testing.assert_allclose(obj_val, correct_val, atol=atol)
def test_trotter_ansatzes_default_initial_params_iterations_2(
ansatz, trotter_algorithm, order, hamiltonian, atol):
"""Check that a Trotter ansatz with two iterations and default parameters
is consistent with time evolution with two Trotter steps."""
objective = HamiltonianObjective(hamiltonian)
qubits = ansatz.qubits
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
one_body = hamiltonian.one_body
elif isinstance(hamiltonian, openfermion.InteractionOperator):
one_body = hamiltonian.one_body_tensor
if isinstance(ansatz, SwapNetworkTrotterHubbardAnsatz):
occupied_orbitals = (range(len(qubits) // 4), range(len(qubits) // 4))
else:
occupied_orbitals = range(len(qubits) // 2)
preparation_circuit = cirq.Circuit(
prepare_gaussian_state(qubits,
openfermion.QuadraticHamiltonian(one_body),
occupied_orbitals=occupied_orbitals))
# Compute value using ansatz circuit and objective
circuit = cirq.resolve_parameters(
preparation_circuit + ansatz.circuit,
ansatz.param_resolver(ansatz.default_initial_params()))
result = circuit.final_wavefunction(
qubit_order=ansatz.qubit_permutation(qubits))
obj_val = objective.value(result)
# Compute value using study
study = VariationalStudy('study',
ansatz,
objective,
preparation_circuit=preparation_circuit)
study_val = study.value_of(ansatz.default_initial_params())
# Compute value by simulating time evolution
if isinstance(hamiltonian, openfermion.DiagonalCoulombHamiltonian):
quarter_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.25 * hamiltonian.two_body)
three_quarters_way_hamiltonian = openfermion.DiagonalCoulombHamiltonian(
one_body=hamiltonian.one_body,
two_body=0.75 * hamiltonian.two_body)
elif isinstance(hamiltonian, openfermion.InteractionOperator):
quarter_way_hamiltonian = openfermion.InteractionOperator(
constant=hamiltonian.constant,
one_body_tensor=hamiltonian.one_body_tensor,
two_body_tensor=0.25 * hamiltonian.two_body_tensor)
three_quarters_way_hamiltonian = openfermion.InteractionOperator(
constant=hamiltonian.constant,
one_body_tensor=hamiltonian.one_body_tensor,
two_body_tensor=0.75 * hamiltonian.two_body_tensor)
simulation_circuit = cirq.Circuit(
simulate_trotter(qubits,
quarter_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=order,
algorithm=trotter_algorithm),
simulate_trotter(qubits,
three_quarters_way_hamiltonian,
time=0.5 * ansatz.adiabatic_evolution_time,
n_steps=1,
order=order,
algorithm=trotter_algorithm))
final_state = (preparation_circuit +
simulation_circuit).final_wavefunction()
correct_val = openfermion.expectation(objective._hamiltonian_linear_op,
final_state).real
numpy.testing.assert_allclose(obj_val, study_val, atol=atol)
numpy.testing.assert_allclose(obj_val, correct_val, atol=atol)
