def test_exact_eval(self):
""" exact eval test """
depth = 1
var_form = RYRZ(self.qubit_op.num_qubits, depth)
circuit = var_form.construct_circuit(
np.array(np.random.randn(var_form.num_parameters)))
run_config = RunConfig(shots=1)
backend = BasicAer.get_backend('statevector_simulator')
matrix_mode = self.qubit_op.eval('matrix',
circuit,
backend,
run_config=run_config)[0]
non_matrix_mode = self.qubit_op.eval('paulis',
circuit,
backend,
run_config=run_config)[0]
diff = abs(matrix_mode - non_matrix_mode)
self.assertLess(
diff, 0.01, "Values: ({} vs {})".format(matrix_mode,
non_matrix_mode))
run_config = RunConfig(shots=1)
compile_config = {'pass_manager': PassManager()}
non_matrix_mode = self.qubit_op.eval('paulis',
circuit,
backend,
run_config=run_config,
compile_config=compile_config)[0]
diff = abs(matrix_mode - non_matrix_mode)
self.assertLess(
diff, 0.01, "Without any pass manager, Values: ({} vs {})".format(
matrix_mode, non_matrix_mode))
def test_submit_multiple_circuits(self):
""" submit multiple circuits test """
num_qubits = 4
pauli_term = []
for pauli_label in itertools.product('IXYZ', repeat=num_qubits):
coeff = np.random.random(1)[0]
pauli_term.append([coeff, Pauli.from_label(pauli_label)])
op = Operator(paulis=pauli_term)
depth = 1
var_form = RYRZ(op.num_qubits, depth)
circuit = var_form.construct_circuit(
np.array(np.random.randn(var_form.num_parameters)))
run_config = RunConfig(shots=1)
backend = BasicAer.get_backend('statevector_simulator')
non_matrix_mode = op.eval('paulis',
circuit,
backend,
run_config=run_config)[0]
matrix_mode = op.eval('matrix',
circuit,
backend,
run_config=run_config)[0]
self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
def setUp(self):
super().setUp()
seed = 0
np.random.seed(seed)
aqua_globals.random_seed = seed
self.num_qubits = 3
paulis = [
Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ',
repeat=self.num_qubits)
]
weights = np.random.random(len(paulis))
self.qubit_op = WeightedPauliOperator.from_list(paulis, weights)
self.var_form = RYRZ(self.qubit_op.num_qubits, 1)
qasm_simulator = BasicAer.get_backend('qasm_simulator')
self.quantum_instance_qasm = QuantumInstance(qasm_simulator,
shots=65536,
seed_simulator=seed,
seed_transpiler=seed)
statevector_simulator = BasicAer.get_backend('statevector_simulator')
self.quantum_instance_statevector = QuantumInstance(
statevector_simulator,
shots=1,
seed_simulator=seed,
seed_transpiler=seed)
def setUp(self):
super().setUp()
seed = 0
aqua_globals.random_seed = seed
self.num_qubits = 3
paulis = [
Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ',
repeat=self.num_qubits)
]
weights = aqua_globals.random.random(len(paulis))
self.qubit_op = WeightedPauliOperator.from_list(paulis, weights)
warnings.filterwarnings('ignore', category=DeprecationWarning)
self.var_form = RYRZ(self.qubit_op.num_qubits, 1)
warnings.filterwarnings('always', category=DeprecationWarning)
qasm_simulator = BasicAer.get_backend('qasm_simulator')
self.quantum_instance_qasm = QuantumInstance(qasm_simulator,
shots=65536,
seed_simulator=seed,
seed_transpiler=seed)
statevector_simulator = BasicAer.get_backend('statevector_simulator')
self.quantum_instance_statevector = \
QuantumInstance(statevector_simulator, shots=1,
seed_simulator=seed, seed_transpiler=seed)
def energy_opt(parameters):
var_form = RYRZ(qubitOp.num_qubits, depth=1, entanglement="linear")
#var_form = UCCSD(qubitOp.num_qubits, depth=1, num_orbitals=num_spin_orbitals, num_particles=num_particles,
# active_occupied=None, active_unoccupied=None, initial_state=HF_state,
# qubit_mapping="jordan_wigner", two_qubit_reduction = False, num_time_slices = 1, shallow_circuit_concat = True, z2_symmetries = None)
circuit = var_form.construct_circuit(parameters)
energy = E(circuit, qubitOp, qr_size)
if plottingTime:
values.append(energy)
print(energy)
return energy
def test_vqc_with_max_evals_grouped(self, use_circuits):
""" vqc with max evals grouped test """
aqua_globals.random_seed = self.seed
optimizer = SPSA(max_trials=10,
save_steps=1,
c0=4.0,
c1=0.1,
c2=0.602,
c3=0.101,
c4=0.0,
skip_calibration=True)
feature_map = SecondOrderExpansion(
feature_dimension=get_feature_dimension(self.training_data),
depth=2)
var_form = RYRZ(num_qubits=feature_map.num_qubits, depth=3)
# convert to circuit if circuits should be used
if use_circuits:
x = ParameterVector('x', feature_map.feature_dimension)
feature_map = feature_map.construct_circuit(x)
theta = ParameterVector('theta', var_form.num_parameters)
var_form = var_form.construct_circuit(theta)
# set up algorithm
vqc = VQC(optimizer,
feature_map,
var_form,
self.training_data,
self.testing_data,
max_evals_grouped=2)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
quantum_instance = QuantumInstance(
BasicAer.get_backend('qasm_simulator'),
shots=1024,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqc.run(quantum_instance)
np.testing.assert_array_almost_equal(result['opt_params'],
self.ref_opt_params,
decimal=8)
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss,
decimal=8)
self.assertEqual(1.0, result['testing_accuracy'])
def test_saving_and_loading_one_circ(self):
""" Saving and Loading one Circ test """
with tempfile.NamedTemporaryFile(suffix='.inp',
delete=True) as cache_tmp_file:
cache_tmp_file_name = cache_tmp_file.name
var_form = RYRZ(num_qubits=4, depth=5)
backend = BasicAer.get_backend('statevector_simulator')
params0 = aqua_globals.random.random_sample(
var_form.num_parameters)
circ0 = var_form.construct_circuit(params0)
qi0 = QuantumInstance(backend,
circuit_caching=True,
cache_file=cache_tmp_file_name,
skip_qobj_deepcopy=True,
skip_qobj_validation=True,
seed_simulator=self.seed,
seed_transpiler=self.seed)
_ = qi0.execute([circ0])
with open(cache_tmp_file_name, "rb") as cache_handler:
saved_cache = pickle.load(cache_handler, encoding="ASCII")
self.assertIn('qobjs', saved_cache)
self.assertIn('mappings', saved_cache)
qobjs = [Qobj.from_dict(qob) for qob in saved_cache['qobjs']]
self.assertTrue(isinstance(qobjs[0], Qobj))
self.assertGreaterEqual(len(saved_cache['mappings'][0][0]), 50)
qi1 = QuantumInstance(backend,
circuit_caching=True,
cache_file=cache_tmp_file_name,
skip_qobj_deepcopy=True,
skip_qobj_validation=True,
seed_simulator=self.seed,
seed_transpiler=self.seed)
params1 = aqua_globals.random.random_sample(
var_form.num_parameters)
circ1 = var_form.construct_circuit(params1)
qobj1 = qi1.circuit_cache.load_qobj_from_cache(
[circ1], 0, run_config=qi1.run_config)
self.assertTrue(isinstance(qobj1, Qobj))
_ = qi1.execute([circ1])
self.assertEqual(qi0.circuit_cache.mappings,
qi1.circuit_cache.mappings)
self.assertLessEqual(qi1.circuit_cache.misses, 0)
def test_vqc_minibatching_no_gradient_support(self):
""" vqc minibatching with no gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=6,
test_size=3,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = COBYLA(maxiter=40)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=3)
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0)
result = vqc.run(quantum_instance)
self.log.debug(result['testing_accuracy'])
self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_vqc_minibatching_with_gradient_support(self):
n_dim = 2 # dimension of each data point
seed = 1024
np.random.seed(seed)
sample_Total, training_input, test_input, class_labels = ad_hoc_data(
training_size=8, test_size=4, n=n_dim, gap=0.3)
aqua_globals.random_seed = seed
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=100)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=2)
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
# TODO: cache only work with optimization_level 0
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed,
optimization_level=0)
result = vqc.run(quantum_instance)
vqc_accuracy_threshold = 0.8
self.log.debug(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], vqc_accuracy_threshold)
def test_vqc_with_max_evals_grouped(self):
""" vqc with max evals grouped test """
aqua_globals.random_seed = self.seed
optimizer = SPSA(max_trials=10,
save_steps=1,
c0=4.0,
c1=0.1,
c2=0.602,
c3=0.101,
c4=0.0,
skip_calibration=True)
feature_map = SecondOrderExpansion(
feature_dimension=get_feature_dimension(self.training_data),
depth=2)
var_form = RYRZ(num_qubits=feature_map.num_qubits, depth=3)
vqc = VQC(optimizer,
feature_map,
var_form,
self.training_data,
self.testing_data,
max_evals_grouped=2)
quantum_instance = QuantumInstance(
BasicAer.get_backend('qasm_simulator'),
shots=1024,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqc.run(quantum_instance)
np.testing.assert_array_almost_equal(result['opt_params'],
self.ref_opt_params,
decimal=8)
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss,
decimal=8)
self.assertEqual(1.0, result['testing_accuracy'])
def test_vqc_with_raw_feature_vector_on_wine(self):
""" vqc with raw features vector on wine test """
feature_dim = 4 # dimension of each data point
training_dataset_size = 8
testing_dataset_size = 4
_, training_input, test_input, _ = _wine_data(
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim
)
aqua_globals.random_seed = self.seed
feature_map = RawFeatureVector(feature_dimension=feature_dim)
vqc = VQC(COBYLA(maxiter=100),
feature_map,
RYRZ(feature_map.num_qubits, depth=3),
training_input,
test_input)
result = vqc.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1024,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.log.debug(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], 0.8)
def test_vqc_minibatching_no_gradient_support(self):
""" vqc minibatching with no gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
np.random.seed(seed)
_, training_input, test_input, _ = _ad_hoc_data(training_size=8,
test_size=4,
n=n_dim,
gap=0.3)
aqua_globals.random_seed = seed
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = COBYLA()
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=3)
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy_threshold = 0.8
self.log.debug(result['testing_accuracy'])
self.assertGreater(result['testing_accuracy'], vqc_accuracy_threshold)
def test_vqc_minibatching_with_gradient_support(self):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=30)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=1)
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def test_create_from_paulis_0(self):
"""Test with single paulis."""
num_qubits = 3
for pauli_label in itertools.product('IXYZ', repeat=num_qubits):
coeff = np.random.random(1)[0]
pauli_term = [coeff, Pauli.from_label(pauli_label)]
op = Operator(paulis=[pauli_term])
depth = 1
var_form = RYRZ(op.num_qubits, depth)
circuit = var_form.construct_circuit(np.array(np.random.randn(var_form.num_parameters)))
run_config = {'shots': 1}
backend = BasicAer.get_backend('statevector_simulator')
non_matrix_mode = op.eval('paulis', circuit, backend, run_config=run_config)[0]
matrix_mode = op.eval('matrix', circuit, backend, run_config=run_config)[0]
self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
def test_vqc_minibatching_with_gradient_support(self, use_circuits):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = n_dim
optimizer = L_BFGS_B(maxfun=30)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=1)
# convert to circuit if circuits should be used
if use_circuits:
x = ParameterVector('x', feature_map.feature_dimension)
feature_map = feature_map.construct_circuit(x)
theta = ParameterVector('theta', var_form.num_parameters)
var_form = var_form.construct_circuit(theta)
# set up algorithm
vqc = VQC(optimizer,
feature_map,
var_form,
training_input,
test_input,
minibatch_size=2)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def test_deprecated_variational_forms(self):
"""Test running the VQE on a deprecated VariationalForm object."""
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(2)
vqe = VQE(self.h2_op, wavefunction, L_BFGS_B())
warnings.filterwarnings('always', category=DeprecationWarning)
result = vqe.run(self.statevector_simulator)
self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy)
def test_create_from_matrix(self):
"""Test with matrix initialization."""
for num_qubits in range(1, 3):
m_size = np.power(2, num_qubits)
matrix = np.random.rand(m_size, m_size)
op = Operator(matrix=matrix)
depth = 1
var_form = RYRZ(op.num_qubits, depth)
circuit = var_form.construct_circuit(np.array(np.random.randn(var_form.num_parameters)))
backend = BasicAer.get_backend('statevector_simulator')
run_config = {'shots': 1}
non_matrix_mode = op.eval('paulis', circuit, backend, run_config=run_config)[0]
matrix_mode = op.eval('matrix', circuit, backend, run_config=run_config)[0]
self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
def setUp(self):
super().setUp()
self.seed = 50
aqua_globals.random_seed = self.seed
pauli_dict = {
'paulis': [{
"coeff": {
"imag": 0.0,
"real": -1.052373245772859
},
"label": "II"
}, {
"coeff": {
"imag": 0.0,
"real": 0.39793742484318045
},
"label": "IZ"
}, {
"coeff": {
"imag": 0.0,
"real": -0.39793742484318045
},
"label": "ZI"
}, {
"coeff": {
"imag": 0.0,
"real": -0.01128010425623538
},
"label": "ZZ"
}, {
"coeff": {
"imag": 0.0,
"real": 0.18093119978423156
},
"label": "XX"
}]
}
self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict).to_opflow()
num_qubits = self.qubit_op.num_qubits
ansatz = TwoLocal(num_qubits,
rotation_blocks=['ry', 'rz'],
entanglement_blocks='cz')
warnings.filterwarnings('ignore', category=DeprecationWarning)
self.ryrz_wavefunction = {
'wrapped': RYRZ(num_qubits),
'circuit': QuantumCircuit(num_qubits).compose(ansatz),
'library': ansatz
}
ansatz = ansatz.copy()
ansatz.rotation_blocks = 'ry'
self.ry_wavefunction = {
'wrapped': RY(num_qubits),
'circuit': QuantumCircuit(num_qubits).compose(ansatz),
'library': ansatz
}
warnings.filterwarnings('always', category=DeprecationWarning)
def test_vqe(self, var_form_type):
""" VQE test """
var_form = RYRZ(self.qubit_op.num_qubits)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
vqe = VQE(self.qubit_op, var_form, L_BFGS_B())
result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'),
basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
coupling_map=[[0, 1]],
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503)
np.testing.assert_array_almost_equal(result.eigenvalue.real, -1.85727503, 5)
self.assertEqual(len(result.optimal_point), 16)
self.assertIsNotNone(result.cost_function_evals)
self.assertIsNotNone(result.optimizer_time)
def getDefaultVQC(optimiser,feature_map):
var_form = RYRZ(
num_qubits=int(args.numberQbits),
depth=int(args.varFormDepth),
entanglement='full',
entanglement_gate='cx',
)
vqc = VQC(optimiser, feature_map, var_form, trainDict, testDict, max_evals_grouped=1,minibatch_size=int(args.minibatchsize))
return vqc
def make_varfor(var_str, feature_dim, vdepth):
if var_str == "ryrz":
var_form = RYRZ(num_qubits=feature_dim, depth=vdepth, entanglement='full', entanglement_gate='cz')
if var_str == "ry":
var_form = RY(num_qubits=feature_dim, depth=vdepth, entanglement='full', entanglement_gate='cz')
else:
print('error in building VARIATIONAL FORM {}'.format(var_str))
sys.exit(1)
return var_form
def test_vqe_2_iqpe(self):
""" vqe to iqpe test """
backend = BasicAer.get_backend('qasm_simulator')
num_qbits = self.algo_input.qubit_op.num_qubits
var_form = RYRZ(num_qbits, 3)
optimizer = SPSA(max_trials=10)
# optimizer.set_options(**{'max_trials': 500})
algo = VQE(self.algo_input.qubit_op, var_form, optimizer)
quantum_instance = QuantumInstance(backend,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.log.debug('VQE result: %s.', result)
ref_eigenval = -1.85727503
num_time_slices = 1
num_iterations = 6
state_in = VarFormBased(var_form, result['opt_params'])
iqpe = IQPE(self.algo_input.qubit_op,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=self.seed,
seed_simulator=self.seed)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: %s',
result['top_measurement_label'])
self.log.debug('top result in decimal: %s',
result['top_measurement_decimal'])
self.log.debug('stretch: %s', result['stretch'])
self.log.debug('translation: %s',
result['translation'])
self.log.debug('final eigenvalue from QPE: %s', result['energy'])
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result['translation']) *
result['stretch'])
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval + result['translation']) * result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result['energy'],
ref_eigenval,
significant=2)
def test_save_and_load_model(self):
""" save and load model test """
np.random.seed(self.random_seed)
aqua_globals.random_seed = self.random_seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = SPSA(max_trials=10, save_steps=1, c0=4.0, skip_calibration=True)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2)
var_form = RYRZ(num_qubits=num_qubits, depth=3)
vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.random_seed,
seed_transpiler=self.random_seed)
result = vqc.run(quantum_instance)
np.testing.assert_array_almost_equal(result['opt_params'],
self.ref_opt_params, decimal=4)
np.testing.assert_array_almost_equal(result['training_loss'],
self.ref_train_loss, decimal=8)
self.assertEqual(1.0, result['testing_accuracy'])
file_path = self._get_resource_path('vqc_test.npz')
vqc.save_model(file_path)
self.assertTrue(os.path.exists(file_path))
loaded_vqc = VQC(optimizer, feature_map, var_form, self.training_data, None)
loaded_vqc.load_model(file_path)
np.testing.assert_array_almost_equal(
loaded_vqc.ret['opt_params'], self.ref_opt_params, decimal=4)
loaded_test_acc = loaded_vqc.test(vqc.test_dataset[0],
vqc.test_dataset[1],
quantum_instance)
self.assertEqual(result['testing_accuracy'], loaded_test_acc)
predicted_probs, predicted_labels = loaded_vqc.predict(self.testing_data['A'],
quantum_instance)
np.testing.assert_array_almost_equal(predicted_probs,
self.ref_prediction_a_probs,
decimal=8)
np.testing.assert_array_equal(predicted_labels, self.ref_prediction_a_label)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
if os.path.exists(file_path):
try:
os.remove(file_path)
except Exception: # pylint: disable=broad-except
pass
def solve_maxcut_vqe(graph, solve_type):
backend = get_compute_backend(solve_type)
operator, offset = get_operator(graph)
vqe = VQE(
operator,
RYRZ(graph.number_of_nodes(), depth=3, entanglement="linear"),
L_BFGS_B(maxfun=6000),
)
result = vqe.run(QuantumInstance(backend))
return result
def test_vqe_2_iqpe(self):
backend = get_aer_backend('qasm_simulator')
num_qbits = self.algo_input.qubit_op.num_qubits
var_form = RYRZ(num_qbits, 3)
optimizer = SPSA(max_trials=10)
# optimizer.set_options(**{'max_trials': 500})
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis')
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.log.debug('VQE result: {}.'.format(result))
self.ref_eigenval = -1.85727503
num_time_slices = 50
num_iterations = 11
state_in = VarFormBased(var_form, result['opt_params'])
iqpe = IQPE(self.algo_input.qubit_op,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(backend,
shots=100,
pass_manager=PassManager(),
seed_mapper=self.random_seed)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from QPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary((self.ref_eigenval + result['translation']) *
result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(self.ref_eigenval,
result['energy'],
significant=2)
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel
# --- Exact copy of sample code ----------------------------------------
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.aqua.operators import Z2Symmetries
# Use PySCF, a classical computational chemistry software
# package, to compute the one-body and two-body integrals in
# molecular-orbital basis, necessary to form the Fermionic operator
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
molecule = driver.run()
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
# Build the qubit operator, which is the input to the VQE algorithm in Aqua
ferm_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
map_type = 'PARITY'
qubit_op = ferm_op.mapping(map_type)
qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, num_particles)
num_qubits = qubit_op.num_qubits
# setup a classical optimizer for VQE
from qiskit.aqua.components.optimizers import L_BFGS_B
optimizer = L_BFGS_B()
# setup the initial state for the variational form
from qiskit.chemistry.components.initial_states import HartreeFock
init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles)
# setup the variational form for VQE
from qiskit.aqua.components.variational_forms import RYRZ
var_form = RYRZ(num_qubits, initial_state=init_state)
# setup and run VQE
from qiskit.aqua.algorithms import VQE
algorithm = VQE(qubit_op, var_form, optimizer)
# set the backend for the quantum computation
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
result = algorithm.run(backend)
print(result['energy'])
# ----------------------------------------------------------------------
self.assertAlmostEqual(result['energy'], -1.8572750301938803, places=6)
def test_vqe_optimizers(self, optimizer_cls, places, max_evals_grouped):
""" VQE Optimizers test """
result = VQE(self.qubit_op,
RYRZ(self.qubit_op.num_qubits),
optimizer_cls(),
max_evals_grouped=max_evals_grouped).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places)
def test_vqc_minibatching_with_gradient_support(self, mode):
""" vqc minibatching with gradient support test """
n_dim = 2 # dimension of each data point
seed = 1024
aqua_globals.random_seed = seed
_, training_input, test_input, _ = ad_hoc_data(training_size=4,
test_size=2,
n=n_dim,
gap=0.3,
plot_data=False)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = L_BFGS_B(maxfun=30)
# set up data encoding circuit
data_preparation = self.data_preparation[mode]
# set up wavefunction
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(2, depth=1)
else:
wavefunction = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
theta = ParameterVector('theta', wavefunction.num_parameters)
resorted = []
for i in range(4):
layer = wavefunction.ordered_parameters[4 * i:4 * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
wavefunction.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
if mode == 'circuit':
wavefunction = QuantumCircuit(2).compose(wavefunction)
# set up algorithm
vqc = VQC(optimizer,
data_preparation,
wavefunction,
training_input,
test_input,
minibatch_size=2)
if mode in ['circuit', 'library']:
vqc._feature_map_params = self._sorted_data_params
vqc._var_form_params = list(theta)
else:
warnings.filterwarnings('always', category=DeprecationWarning)
quantum_instance = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
result = vqc.run(quantum_instance)
vqc_accuracy = 0.5
self.log.debug(result['testing_accuracy'])
self.assertAlmostEqual(result['testing_accuracy'],
vqc_accuracy,
places=3)
def test_real_eval(self):
depth = 1
var_form = RYRZ(self.qubitOp.num_qubits, depth)
circuit = var_form.construct_circuit(np.array(np.random.randn(var_form.num_parameters)))
# self.qubitOp.coloring = None
run_config_ref = {'shots': 1}
run_config = {'shots': 10000}
reference = self.qubitOp.eval('matrix', circuit, get_aer_backend(
'statevector_simulator'), run_config=run_config_ref)[0]
reference = reference.real
backend = get_aer_backend('qasm_simulator')
paulis_mode = self.qubitOp.eval('paulis', circuit, backend, run_config=run_config)
grouped_paulis_mode = self.qubitOp.eval('grouped_paulis', circuit, backend, run_config=run_config)
paulis_mode_p_3sigma = paulis_mode[0] + 3 * paulis_mode[1]
paulis_mode_m_3sigma = paulis_mode[0] - 3 * paulis_mode[1]
grouped_paulis_mode_p_3sigma = grouped_paulis_mode[0] + 3 * grouped_paulis_mode[1]
grouped_paulis_mode_m_3sigma = grouped_paulis_mode[0] - 3 * grouped_paulis_mode[1]
self.assertLessEqual(reference, paulis_mode_p_3sigma.real)
self.assertGreaterEqual(reference, paulis_mode_m_3sigma.real)
self.assertLessEqual(reference, grouped_paulis_mode_p_3sigma.real)
self.assertGreaterEqual(reference, grouped_paulis_mode_m_3sigma.real)
run_config = {'shots': 10000}
compile_config = {'pass_manager': PassManager()}
paulis_mode = self.qubitOp.eval('paulis', circuit, backend,
run_config=run_config, compile_config=compile_config)
grouped_paulis_mode = self.qubitOp.eval('grouped_paulis', circuit, backend,
run_config=run_config, compile_config=compile_config)
paulis_mode_p_3sigma = paulis_mode[0] + 3 * paulis_mode[1]
paulis_mode_m_3sigma = paulis_mode[0] - 3 * paulis_mode[1]
grouped_paulis_mode_p_3sigma = grouped_paulis_mode[0] + 3 * grouped_paulis_mode[1]
grouped_paulis_mode_m_3sigma = grouped_paulis_mode[0] - 3 * grouped_paulis_mode[1]
self.assertLessEqual(reference, paulis_mode_p_3sigma.real, "Without any pass manager")
self.assertGreaterEqual(reference, paulis_mode_m_3sigma.real, "Without any pass manager")
self.assertLessEqual(reference, grouped_paulis_mode_p_3sigma.real, "Without any pass manager")
self.assertGreaterEqual(reference, grouped_paulis_mode_m_3sigma.real, "Without any pass manager")
def test_vqe(self):
""" VQE test """
quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
basis_gates=['u1', 'u2', 'u3', 'cx', 'id'],
coupling_map=[[0, 1]],
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
vqe = VQE(var_form=RYRZ(self.qubit_op.num_qubits),
optimizer=L_BFGS_B(),
quantum_instance=quantum_instance)
output = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503)
