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)