def test_vqe_callback(self, var_form_type):
""" VQE Callback test """
history = {'eval_count': [], 'parameters': [], 'mean': [], 'std': []}
def store_intermediate_result(eval_count, parameters, mean, std):
history['eval_count'].append(eval_count)
history['parameters'].append(parameters)
history['mean'].append(mean)
history['std'].append(std)
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, depth=1, initial_state=init_state)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
optimizer = COBYLA(maxiter=3)
algo = VQE(self.qubit_op, var_form, optimizer,
callback=store_intermediate_result, auto_conversion=False)
aqua_globals.random_seed = 50
quantum_instance = QuantumInstance(backend,
seed_transpiler=50,
shots=1024,
seed_simulator=50)
algo.run(quantum_instance)
self.assertTrue(all(isinstance(count, int) for count in history['eval_count']))
self.assertTrue(all(isinstance(mean, float) for mean in history['mean']))
self.assertTrue(all(isinstance(std, float) for std in history['std']))
for params in history['parameters']:
self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_callback(self, use_circuits):
""" vqc callback test """
history = {
'eval_count': [],
'parameters': [],
'cost': [],
'batch_index': []
}
def store_intermediate_result(eval_count, parameters, cost,
batch_index):
history['eval_count'].append(eval_count)
history['parameters'].append(parameters)
history['cost'].append(cost)
history['batch_index'].append(batch_index)
aqua_globals.random_seed = self.seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = COBYLA(maxiter=3)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits,
depth=2)
var_form = RY(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)
vqc = VQC(optimizer,
feature_map,
var_form,
self.training_data,
self.testing_data,
callback=store_intermediate_result)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.seed,
seed_transpiler=self.seed)
vqc.run(quantum_instance)
self.assertTrue(
all(isinstance(count, int) for count in history['eval_count']))
self.assertTrue(
all(isinstance(cost, float) for cost in history['cost']))
self.assertTrue(
all(isinstance(index, int) for index in history['batch_index']))
for params in history['parameters']:
self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqe_caching_direct(self, max_evals_grouped):
self._build_refrence_result(backends=['statevector_simulator'])
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
max_evals_grouped=max_evals_grouped)
quantum_instance_caching = QuantumInstance(
backend,
circuit_caching=True,
skip_qobj_deepcopy=True,
skip_qobj_validation=True,
optimization_level=self.optimization_level)
result_caching = algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0)
self.assertAlmostEqual(
self.reference_vqe_result['statevector_simulator']['energy'],
result_caching['energy'])
speedup_min = 3
speedup = result_caching['eval_time'] / self.reference_vqe_result[
'statevector_simulator']['eval_time']
self.assertLess(speedup, speedup_min)
def test_set_packing_vqe(self):
""" set packing vqe test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 50
result = VQE(self.qubit_op,
RY(self.qubit_op.num_qubits,
depth=5,
entanglement='linear'),
SPSA(max_trials=200),
max_evals_grouped=2).run(
QuantumInstance(
Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
ising_sol = set_packing.get_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_vqe_qasm(self, var_form_type):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, depth=3)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
def test_vqe_reuse(self):
""" Test vqe reuse """
vqe = VQE()
with self.assertRaises(AquaError):
_ = vqe.run()
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, depth=3)
vqe.var_form = var_form
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.operator = self.qubit_op
with self.assertRaises(AquaError):
_ = vqe.run()
qinst = QuantumInstance(BasicAer.get_backend('statevector_simulator'))
vqe.quantum_instance = qinst
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5)
operator = MatrixOperator(np.array([[1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]]))
vqe.operator = operator
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
def test_h2_one_qubit_qasm(self):
"""Test H2 with tapering and qasm backend"""
two_qubit_reduction = True
qubit_mapping = 'parity'
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=two_qubit_reduction,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = core.run(self.molecule)
num_orbitals = core.molecule_info['num_orbitals']
num_particles = core.molecule_info['num_particles']
# tapering
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
# know the sector
tapered_op = z2_symmetries.taper(qubit_op)[1]
var_form = RY(tapered_op.num_qubits, depth=1)
optimizer = SPSA(max_trials=50)
eom_vqe = QEomVQE(tapered_op, var_form, optimizer, num_orbitals=num_orbitals,
num_particles=num_particles, qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=tapered_op.z2_symmetries, untapered_op=qubit_op)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=65536)
result = eom_vqe.run(quantum_instance)
np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=2)
def test_vqe_caching_direct(self, batch_mode=True):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
'matrix',
batch_mode=batch_mode)
quantum_instance_caching = QuantumInstance(backend,
circuit_caching=True,
skip_qobj_deepcopy=True,
skip_qobj_validation=True)
result_caching = algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0)
self.assertAlmostEqual(
self.reference_vqe_result['statevector_simulator']['energy'],
result_caching['energy'])
speedup_check = 3
self.log.info(
result_caching['eval_time'],
self.reference_vqe_result['statevector_simulator']['eval_time'] /
speedup_check)
def test_saving_and_loading(self):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'matrix')
fd, cache_tmp_file = tempfile.mkstemp(suffix='.inp')
os.close(fd)
quantum_instance_caching = QuantumInstance(backend,
circuit_caching=True,
cache_file=cache_tmp_file,
skip_qobj_deepcopy=True,
skip_qobj_validation=True)
algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses, 0)
is_file_exist = os.path.exists(cache_tmp_file)
self.assertTrue(is_file_exist, "Does not store content successfully.")
circuit_cache_new = CircuitCache(skip_qobj_deepcopy=True,
cache_file=cache_tmp_file)
self.assertEqual(quantum_instance_caching.circuit_cache.mappings,
circuit_cache_new.mappings)
self.assertLessEqual(circuit_cache_new.misses, 0)
if is_file_exist:
os.remove(cache_tmp_file)
def test_saving_and_loading_e2e(self):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 1, initial_state=init_state)
optimizer = L_BFGS_B(maxiter=10)
algo = VQE(self.algo_input.qubit_op, var_form, optimizer)
with tempfile.NamedTemporaryFile(suffix='.inp',
delete=True) as cache_tmp_file:
cache_tmp_file_name = cache_tmp_file.name
quantum_instance_caching = QuantumInstance(
backend,
circuit_caching=True,
cache_file=cache_tmp_file_name,
skip_qobj_deepcopy=True,
skip_qobj_validation=True,
optimization_level=self.optimization_level)
algo.run(quantum_instance_caching)
self.assertLessEqual(quantum_instance_caching.circuit_cache.misses,
0)
is_file_exist = os.path.exists(cache_tmp_file_name)
self.assertTrue(is_file_exist,
"Does not store content successfully.")
circuit_cache_new = CircuitCache(skip_qobj_deepcopy=True,
cache_file=cache_tmp_file_name)
self.assertEqual(quantum_instance_caching.circuit_cache.mappings,
circuit_cache_new.mappings)
self.assertLessEqual(circuit_cache_new.misses, 0)
def test_vqe_callback(self):
tmp_filename = 'vqe_callback_test.csv'
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def store_intermediate_result(eval_count, parameters, mean, std):
with open(self._get_resource_path(tmp_filename), 'a') as f:
content = "{},{},{:.5f},{:.5f}".format(eval_count, parameters,
mean, std)
print(content, file=f, flush=True)
backend = get_aer_backend('qasm_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 1, initial_state=init_state)
optimizer = COBYLA(maxiter=3)
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
'paulis',
callback=store_intermediate_result)
algo.random_seed = 50
run_config = RunConfig(shots=1024, seed=50)
quantum_instance = QuantumInstance(backend,
seed_mapper=50,
run_config=run_config)
algo.run(quantum_instance)
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
self.assertTrue(is_file_exist, "Does not store content successfully.")
# check the content
ref_content = [[
"1", "[-0.03391886 -1.70850424 -1.53640265 -0.65137839]",
"-0.59622", "0.01546"
],
[
"2",
"[ 0.96608114 -1.70850424 -1.53640265 -0.65137839]",
"-0.77452", "0.01692"
],
[
"3",
"[ 0.96608114 -0.70850424 -1.53640265 -0.65137839]",
"-0.80327", "0.01519"
]]
with open(self._get_resource_path(tmp_filename)) as f:
idx = 0
for record in f.readlines():
eval_count, parameters, mean, std = record.split(",")
self.assertEqual(eval_count.strip(), ref_content[idx][0])
self.assertEqual(parameters, ref_content[idx][1])
self.assertEqual(mean.strip(), ref_content[idx][2])
self.assertEqual(std.strip(), ref_content[idx][3])
idx += 1
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def test_nft(self):
""" Test NFT optimizer by using it """
result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits), NFT()).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result.eigenvalue.real, -1.857275, places=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 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_qasm(self):
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
var_form = RY(num_qubits, 3)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=10000, optimization_level=0)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=2)
def test_aqgd(self):
""" test AQGD optimizer by using it """
result = VQE(self.qubit_op, RY(self.qubit_op.num_qubits),
AQGD(momentum=0.0)).run(
QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result['energy'], -1.85727, places=5)
def test_qsvm_variational_callback(self):
tmp_filename = 'qsvm_callback_test.csv'
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def store_intermediate_result(eval_count, parameters, cost, batch_index):
with open(self._get_resource_path(tmp_filename), 'a') as f:
content = "{},{},{:.5f},{}".format(eval_count, parameters, cost, batch_index)
print(content, file=f, flush=True)
np.random.seed(self.random_seed)
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = COBYLA(maxiter=3)
feature_map = SecondOrderExpansion(num_qubits=num_qubits, depth=2)
var_form = RY(num_qubits=num_qubits, depth=1)
svm = QSVMVariational(optimizer, feature_map, var_form, self.training_data,
self.testing_data, callback=store_intermediate_result)
svm.random_seed = self.random_seed
quantum_instance = QuantumInstance(backend, shots=1024, seed=self.random_seed, seed_mapper=self.random_seed)
svm.run(quantum_instance)
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
self.assertTrue(is_file_exist, "Does not store content successfully.")
# check the content
# ref_content = [
# ["0", "[ 0.18863864 -1.08197582 1.74432295 1.29765602]", "0.53367", "0"],
# ["1", "[ 1.18863864 -1.08197582 1.74432295 1.29765602]", "0.57261", "1"],
# ["2", "[ 0.18863864 -0.08197582 1.74432295 1.29765602]", "0.47137", "2"]
# ]
ref_content = [
['0', '[ 0.18863864 -1.08197582 1.74432295 1.29765602]', '0.54802', '0'],
['1', '[ 1.18863864 -1.08197582 1.74432295 1.29765602]', '0.53862', '1'],
['2', '[ 1.18863864 -0.08197582 1.74432295 1.29765602]', '0.47278', '2'],
]
try:
with open(self._get_resource_path(tmp_filename)) as f:
idx = 0
for record in f.readlines():
eval_count, parameters, cost, batch_index = record.split(",")
self.assertEqual(eval_count.strip(), ref_content[idx][0])
self.assertEqual(parameters, ref_content[idx][1])
self.assertEqual(cost.strip(), ref_content[idx][2])
self.assertEqual(batch_index.strip(), ref_content[idx][3])
idx += 1
finally:
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def test_vqe_direct(self, max_evals_grouped):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis', max_evals_grouped=max_evals_grouped)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
def test_vqe_callback(self):
""" VQE Callback test """
tmp_filename = 'vqe_callback_test.csv'
is_file_exist = os.path.exists(self.get_resource_path(tmp_filename))
if is_file_exist:
os.remove(self.get_resource_path(tmp_filename))
def store_intermediate_result(eval_count, parameters, mean, std):
with open(self.get_resource_path(tmp_filename), 'a') as file:
content = "{},{},{:.5f},{:.5f}".format(eval_count, parameters, mean, std)
print(content, file=file, flush=True)
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 1, initial_state=init_state)
optimizer = COBYLA(maxiter=3)
algo = VQE(self.qubit_op, var_form, optimizer,
callback=store_intermediate_result, auto_conversion=False)
aqua_globals.random_seed = 50
quantum_instance = QuantumInstance(backend,
seed_transpiler=50,
shots=1024,
seed_simulator=50)
algo.run(quantum_instance)
is_file_exist = os.path.exists(self.get_resource_path(tmp_filename))
self.assertTrue(is_file_exist, "Does not store content successfully.")
# check the content
ref_content = [['1',
'[-0.03391886 -1.70850424 -1.53640265 -0.65137839]',
'-0.61121', '0.01572'],
['2',
'[ 0.96608114 -1.70850424 -1.53640265 -0.65137839]',
'-0.79235', '0.01722'],
['3',
'[ 0.96608114 -0.70850424 -1.53640265 -0.65137839]',
'-0.82829', '0.01529']
]
try:
with open(self.get_resource_path(tmp_filename)) as file:
idx = 0
for record in file.readlines():
eval_count, parameters, mean, std = record.split(",")
self.assertEqual(eval_count.strip(), ref_content[idx][0])
self.assertEqual(parameters, ref_content[idx][1])
self.assertEqual(mean.strip(), ref_content[idx][2])
self.assertEqual(std.strip(), ref_content[idx][3])
idx += 1
finally:
if is_file_exist:
os.remove(self.get_resource_path(tmp_filename))
def test_vqe_qasm(self):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, 3)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
def test_partition_vqe(self):
""" Partition VQE test """
aqua_globals.random_seed = 100
result = VQE(self.qubit_op,
RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'),
SPSA(max_trials=200),
max_evals_grouped=2).run(
QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
self.assertNotEqual(x[0], x[1])
self.assertNotEqual(x[2], x[1]) # hardcoded oracle
def test_vqc_callback(self):
""" vqc callback test """
tmp_filename = 'qvqc_callback_test.csv'
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def store_intermediate_result(eval_count, parameters, cost, batch_index):
with open(self._get_resource_path(tmp_filename), 'a') as file:
content = "{},{},{:.5f},{}".format(eval_count, parameters, cost, batch_index)
print(content, file=file, flush=True)
np.random.seed(self.random_seed)
aqua_globals.random_seed = self.random_seed
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = 2
optimizer = COBYLA(maxiter=3)
feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2)
var_form = RY(num_qubits=num_qubits, depth=1)
vqc = VQC(optimizer, feature_map, var_form, self.training_data,
self.testing_data, callback=store_intermediate_result)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.random_seed,
seed_transpiler=self.random_seed)
vqc.run(quantum_instance)
is_file_exist = os.path.exists(self._get_resource_path(tmp_filename))
self.assertTrue(is_file_exist, "Does not store content successfully.")
# check the content
ref_content = [
['0', '[-0.58205563 -2.97987177 -0.73153057 1.06577518]', '0.46841', '0'],
['1', '[ 0.41794437 -2.97987177 -0.73153057 1.06577518]', '0.31861', '1'],
['2', '[ 0.41794437 -1.97987177 -0.73153057 1.06577518]', '0.45975', '2'],
]
try:
with open(self._get_resource_path(tmp_filename)) as file:
idx = 0
for record in file.readlines():
eval_count, parameters, cost, batch_index = record.split(",")
self.assertEqual(eval_count.strip(), ref_content[idx][0])
self.assertEqual(parameters, ref_content[idx][1])
self.assertEqual(cost.strip(), ref_content[idx][2])
self.assertEqual(batch_index.strip(), ref_content[idx][3])
idx += 1
finally:
if is_file_exist:
os.remove(self._get_resource_path(tmp_filename))
def test_vqe_direct(self, batch_mode):
backend = get_aer_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
'paulis',
batch_mode=batch_mode)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503)
def test_vqe_qasm_snapshot_mode(self, var_form_type):
""" VQE Aer qasm_simulator snapshot mode test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex)))
return
backend = Aer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, depth=3, initial_state=init_state)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
optimizer = L_BFGS_B()
algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6)
def test_vqe_aer_mode(self):
try:
from qiskit import Aer
except Exception as e:
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(e)))
return
backend = Aer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=6)
def test_clique_vqe(self):
""" VQE Clique test """
aqua_globals.random_seed = 10598
result = VQE(self.qubit_op,
RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'),
COBYLA(),
max_evals_grouped=2).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
ising_sol = clique.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1])
oracle = self._brute_force()
self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k), oracle)
def test_vqe_qasm(self):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, num_qubits)
optimizer = SPSA(max_trials=300, last_avg=5)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
vqe = VQE(var_form=var_form,
optimizer=optimizer,
max_evals_grouped=1,
quantum_instance=quantum_instance)
output = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503, places=1)
def test_vqe_var_forms(self, depth, places):
""" VQE Var Forms test """
aqua_globals.random_seed = self.seed
result = VQE(
self.qubit_op,
RY(self.qubit_op.num_qubits,
depth=depth,
entanglement='sca',
entanglement_gate='crx',
skip_final_ry=True),
L_BFGS_B()).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result['energy'], -1.85727503, places=places)
def test_vqe_qasm_snapshot_mode(self):
""" VQE Aer qasm_simulator snapshot mode test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex)))
return
backend = Aer.get_backend('qasm_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=1)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=6)
def setUp(self):
super().setUp()
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
self.npme = NumPyMinimumEigensolver()
self.vqe = VQE(var_form=RY(2))
self.vqe.set_backend(BasicAer.get_backend('statevector_simulator'))
self.reference_energy = -1.137306
