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_vqc_on_wine(self, mode):
"""Test VQE on the wine test using circuits as feature map and variational form."""
feature_dim = 4 # dimension of each data point
training_dataset_size = 6
testing_dataset_size = 3
_, training_input, test_input, _ = wine(
training_size=training_dataset_size,
test_size=testing_dataset_size,
n=feature_dim,
plot_data=False)
aqua_globals.random_seed = self.seed
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
data_preparation = SecondOrderExpansion(feature_dim)
wavefunction = RYRZ(feature_dim, depth=1)
else:
data_preparation = ZZFeatureMap(feature_dim)
x = data_preparation.ordered_parameters
wavefunction = TwoLocal(feature_dim, ['ry', 'rz'],
'cz',
reps=1,
insert_barriers=True)
theta = ParameterVector('theta', wavefunction.num_parameters)
resorted = []
for i in range(2 * feature_dim):
layer = wavefunction.ordered_parameters[2 * feature_dim * i:2 *
feature_dim * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
wavefunction.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
if mode == 'circuit':
data_preparation = QuantumCircuit(feature_dim).compose(
data_preparation)
wavefunction = QuantumCircuit(feature_dim).compose(wavefunction)
vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction,
training_input, test_input)
# sort parameters for reproducibility
if mode in ['circuit', 'library']:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
else:
warnings.filterwarnings('always', category=DeprecationWarning)
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.assertLess(result['testing_accuracy'], 0.6)
def test_vqe_2_iqpe(self, wavefunction_type):
""" vqe to iqpe test """
backend = BasicAer.get_backend('qasm_simulator')
num_qbits = self.qubit_op.num_qubits
if wavefunction_type == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = RYRZ(num_qbits, 3)
else:
wavefunction = TwoLocal(num_qbits, ['ry', 'rz'],
'cz',
reps=3,
insert_barriers=True)
theta = ParameterVector('theta', wavefunction.num_parameters)
wavefunction.assign_parameters(theta, inplace=True)
if wavefunction_type == 'circuit':
wavefunction = QuantumCircuit(num_qbits).compose(wavefunction)
optimizer = SPSA(max_trials=10)
algo = VQE(self.qubit_op, wavefunction, optimizer)
if wavefunction_type == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
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 # Known reference value
num_time_slices = 1
num_iterations = 6
if wavefunction_type == 'wrapped':
param_dict = result.optimal_point
else:
param_dict = result.optimal_parameters
state_in = VarFormBased(wavefunction, param_dict)
iqpe = IQPE(self.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.eigenvalue)
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.real + result.translation) * result.stretch,
max_num_digits=num_iterations + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result.eigenvalue.real,
ref_eigenval,
significant=2)
