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_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 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 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_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_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 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_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 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_vqc_on_wine(self, use_circuits):
"""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
feature_map = SecondOrderExpansion(feature_dimension=feature_dim)
var_form = RYRZ(feature_map.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(COBYLA(maxiter=100), feature_map, var_form, training_input,
test_input)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
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_vqc_statevector(self, use_circuits):
""" vqc statevector test """
aqua_globals.random_seed = 10598
optimizer = COBYLA()
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)
# 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('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = vqc.run(quantum_instance)
ref_train_loss = 0.1059404
np.testing.assert_array_almost_equal(result['training_loss'],
ref_train_loss,
decimal=4)
self.assertEqual(result['testing_accuracy'], 0.5)
class TestWeightedPauliOperator(QiskitAquaTestCase):
"""WeightedPauliOperator tests."""
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_sample(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 test_from_to_file(self):
""" from to file test """
paulis = [
Pauli.from_label(x)
for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
weights = [
0.2 + -1j * 0.8, 0.6 + -1j * 0.6, 0.8 + -1j * 0.2,
-0.2 + -1j * 0.8, -0.6 - -1j * 0.6, -0.8 - -1j * 0.2
]
op = WeightedPauliOperator.from_list(paulis, weights)
file_path = self._get_resource_path('temp_op.json')
op.to_file(file_path)
self.assertTrue(os.path.exists(file_path))
load_op = WeightedPauliOperator.from_file(file_path)
self.assertEqual(op, load_op)
os.remove(file_path)
def test_num_qubits(self):
""" num qubits test """
op = WeightedPauliOperator(paulis=[])
self.assertEqual(op.num_qubits, 0)
self.assertEqual(self.qubit_op.num_qubits, self.num_qubits)
def test_is_empty(self):
""" is empty test """
op = WeightedPauliOperator(paulis=[])
self.assertTrue(op.is_empty())
self.assertFalse(self.qubit_op.is_empty())
def test_str(self):
""" str test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
op_a += op_b
self.assertEqual("Representation: paulis, qubits: 4, size: 2",
str(op_a))
op_a = WeightedPauliOperator(paulis=[pauli_term_a], name='ABC')
self.assertEqual("ABC: Representation: paulis, qubits: 4, size: 1",
str(op_a))
def test_multiplication(self):
""" multiplication test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
new_op = op_a * op_b
self.assertEqual(1, len(new_op.paulis))
self.assertEqual(-0.25, new_op.paulis[0][0])
self.assertEqual('ZZYY', new_op.paulis[0][1].to_label())
new_op = -2j * new_op
self.assertEqual(0.5j, new_op.paulis[0][0])
new_op = new_op * 0.3j
self.assertEqual(-0.15, new_op.paulis[0][0])
def test_iadd(self):
""" iadd test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
ori_op_a = op_a.copy()
ori_op_b = op_b.copy()
op_a += op_b
self.assertNotEqual(op_a, ori_op_a)
self.assertEqual(op_b, ori_op_b)
self.assertEqual(2, len(op_a.paulis))
pauli_c = 'IXYZ'
coeff_c = 0.25
pauli_term_c = [coeff_c, Pauli.from_label(pauli_c)]
op_a += WeightedPauliOperator(paulis=[pauli_term_c])
self.assertEqual(2, len(op_a.paulis))
self.assertEqual(0.75, op_a.paulis[0][0])
def test_add(self):
""" add test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
ori_op_a = op_a.copy()
ori_op_b = op_b.copy()
new_op = op_a + op_b
self.assertEqual(op_a, ori_op_a)
self.assertEqual(op_b, ori_op_b)
self.assertEqual(1, len(op_a.paulis))
self.assertEqual(2, len(new_op.paulis))
pauli_c = 'IXYZ'
coeff_c = 0.25
pauli_term_c = [coeff_c, Pauli.from_label(pauli_c)]
new_op = new_op + WeightedPauliOperator(paulis=[pauli_term_c])
self.assertEqual(2, len(new_op.paulis))
self.assertEqual(0.75, new_op.paulis[0][0])
def test_sub(self):
""" sub test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
ori_op_a = op_a.copy()
ori_op_b = op_b.copy()
new_op = op_a - op_b
self.assertEqual(op_a, ori_op_a)
self.assertEqual(op_b, ori_op_b)
self.assertEqual(1, len(op_a.paulis))
self.assertEqual(2, len(new_op.paulis))
self.assertEqual(0.5, new_op.paulis[0][0])
self.assertEqual(-0.5, new_op.paulis[1][0])
pauli_c = 'IXYZ'
coeff_c = 0.25
pauli_term_c = [coeff_c, Pauli.from_label(pauli_c)]
new_op = new_op - WeightedPauliOperator(paulis=[pauli_term_c])
self.assertEqual(2, len(new_op.paulis))
self.assertEqual(0.25, new_op.paulis[0][0])
def test_isub(self):
""" isub test """
pauli_a = 'IXYZ'
pauli_b = 'ZYIX'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
ori_op_a = op_a.copy()
ori_op_b = op_b.copy()
op_a -= op_b
self.assertNotEqual(op_a, ori_op_a)
self.assertEqual(op_b, ori_op_b)
self.assertEqual(2, len(op_a.paulis))
pauli_c = 'IXYZ'
coeff_c = 0.5
pauli_term_c = [coeff_c, Pauli.from_label(pauli_c)]
op_a -= WeightedPauliOperator(paulis=[pauli_term_c])
# sub does not remove zero weights.
self.assertEqual(2, len(op_a.paulis))
def test_equal_operator(self):
""" equal operator test """
paulis = [
Pauli.from_label(x)
for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op1 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op2 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [-0.2, -0.6, -0.8, 0.2, 0.6, 0.8]
op3 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [-0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op4 = WeightedPauliOperator.from_list(paulis, coeffs)
self.assertEqual(op1, op2)
self.assertNotEqual(op1, op3)
self.assertNotEqual(op1, op4)
self.assertNotEqual(op3, op4)
def test_negation_operator(self):
""" negation operator test """
paulis = [
Pauli.from_label(x)
for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op1 = WeightedPauliOperator.from_list(paulis, coeffs)
coeffs = [-0.2, -0.6, -0.8, 0.2, 0.6, 0.8]
op2 = WeightedPauliOperator.from_list(paulis, coeffs)
self.assertNotEqual(op1, op2)
self.assertEqual(op1, -op2)
self.assertEqual(-op1, op2)
op1 = op1 * -1.0
self.assertEqual(op1, op2)
def test_simplify(self):
""" simplify test """
pauli_a = 'IXYZ'
pauli_b = 'IXYZ'
coeff_a = 0.5
coeff_b = -0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a])
op_b = WeightedPauliOperator(paulis=[pauli_term_b])
new_op = op_a + op_b
new_op.simplify()
self.assertEqual(0, len(new_op.paulis),
"{}".format(new_op.print_details()))
self.assertTrue(new_op.is_empty())
paulis = [
Pauli.from_label(x)
for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op1 = WeightedPauliOperator.from_list(paulis, coeffs)
for i, pauli in enumerate(paulis):
tmp_op = WeightedPauliOperator(paulis=[[-coeffs[i], pauli]])
op1 += tmp_op
op1.simplify()
self.assertEqual(len(paulis) - (i + 1), len(op1.paulis))
def test_simplify_same_paulis(self):
""" simplify same paulis test """
pauli_a = 'IXYZ'
pauli_b = 'IXYZ'
coeff_a = 0.5
coeff_b = 0.5
pauli_term_a = [coeff_a, Pauli.from_label(pauli_a)]
pauli_term_b = [coeff_b, Pauli.from_label(pauli_b)]
op_a = WeightedPauliOperator(paulis=[pauli_term_a, pauli_term_b])
self.assertEqual(1, len(op_a.paulis),
"{}".format(op_a.print_details()))
self.assertEqual(1, len(op_a.basis))
self.assertEqual(0, op_a.basis[0][1][0])
def test_chop_real(self):
""" chop real test """
paulis = [
Pauli.from_label(x)
for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8]
op = WeightedPauliOperator.from_list(paulis, coeffs)
ori_op = op.copy()
for threshold, num_paulis in zip([0.4, 0.7, 0.9], [4, 2, 0]):
op = ori_op.copy()
op1 = op.chop(threshold=threshold, copy=True)
self.assertEqual(len(op.paulis), 6,
"\n{}".format(op.print_details()))
self.assertEqual(len(op1.paulis), num_paulis,
"\n{}".format(op1.print_details()))
op1 = op.chop(threshold=threshold, copy=False)
self.assertEqual(len(op.paulis), num_paulis,
"\n{}".format(op.print_details()))
self.assertEqual(len(op1.paulis), num_paulis,
"\n{}".format(op1.print_details()))
def test_chop_complex(self):
""" chop complex test """
paulis = [
Pauli.from_label(x)
for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY']
]
coeffs = [
0.2 + -0.5j, 0.6 - 0.3j, 0.8 - 0.6j, -0.5 + -0.2j, -0.3 + 0.6j,
-0.6 + 0.8j
]
op = WeightedPauliOperator.from_list(paulis, coeffs)
ori_op = op.copy()
for threshold, num_paulis in zip([0.4, 0.7, 0.9], [6, 2, 0]):
op = ori_op.copy()
op1 = op.chop(threshold=threshold, copy=True)
self.assertEqual(len(op.paulis), 6,
"\n{}".format(op.print_details()))
self.assertEqual(len(op1.paulis), num_paulis,
"\n{}".format(op1.print_details()))
op1 = op.chop(threshold=threshold, copy=False)
self.assertEqual(len(op.paulis), num_paulis,
"\n{}".format(op.print_details()))
self.assertEqual(len(op1.paulis), num_paulis,
"\n{}".format(op1.print_details()))
def test_evaluate_single_pauli_qasm(self):
""" evaluate single pauli qasm test """
# X
op = WeightedPauliOperator.from_list([Pauli.from_label('X')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=False)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=False)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Y
op = WeightedPauliOperator.from_list([Pauli.from_label('Y')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=False)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=False)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Z
op = WeightedPauliOperator.from_list([Pauli.from_label('Z')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=False)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=False)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
def test_evaluate_single_pauli_statevector(self):
""" evaluate single pauli statevector test """
# X
op = WeightedPauliOperator.from_list([Pauli.from_label('X')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Y
op = WeightedPauliOperator.from_list([Pauli.from_label('Y')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Z
op = WeightedPauliOperator.from_list([Pauli.from_label('Z')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
def test_evaluate_qasm_mode(self):
""" evaluate qasm mode test """
wave_function = self.var_form.construct_circuit(
np.array(aqua_globals.random.randn(self.var_form.num_parameters)))
circuits = self.qubit_op.construct_evaluation_circuit(
wave_function=wave_function, statevector_mode=True)
reference = self.qubit_op.evaluate_with_result(
result=self.quantum_instance_statevector.execute(circuits),
statevector_mode=True)
circuits = self.qubit_op.construct_evaluation_circuit(
wave_function=wave_function, statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
actual_value = self.qubit_op.evaluate_with_result(
result=result, statevector_mode=False)
self.assertGreaterEqual(
reference[0].real, actual_value[0].real - 3 * actual_value[1].real)
self.assertLessEqual(reference[0].real,
actual_value[0].real + 3 * actual_value[1].real)
def test_evaluate_statevector_mode(self):
""" evaluate statevector mode test """
wave_function = self.var_form.construct_circuit(
np.array(aqua_globals.random.randn(self.var_form.num_parameters)))
wave_fn_statevector = \
self.quantum_instance_statevector.execute(wave_function).get_statevector(wave_function)
# use matrix operator as reference:
reference = self.qubit_op.evaluate_with_statevector(
wave_fn_statevector)
circuits = self.qubit_op.construct_evaluation_circuit(
wave_function=wave_function, statevector_mode=True)
actual_value = self.qubit_op.evaluate_with_result(
result=self.quantum_instance_statevector.execute(circuits),
statevector_mode=True)
self.assertAlmostEqual(reference[0], actual_value[0], places=10)
def test_evaluate_with_aer_mode(self):
""" evaluate with aer 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
statevector_simulator = Aer.get_backend('statevector_simulator')
quantum_instance_statevector = QuantumInstance(statevector_simulator,
shots=1)
wave_function = self.var_form.construct_circuit(
np.array(aqua_globals.random.randn(self.var_form.num_parameters)))
circuits = self.qubit_op.construct_evaluation_circuit(
wave_function=wave_function, statevector_mode=True)
reference = self.qubit_op.evaluate_with_result(
result=quantum_instance_statevector.execute(circuits),
statevector_mode=True)
circuits = self.qubit_op.construct_evaluation_circuit(
wave_function=wave_function,
statevector_mode=True,
use_simulator_snapshot_mode=True)
actual_value = self.qubit_op.evaluate_with_result(
result=quantum_instance_statevector.execute(circuits),
statevector_mode=True,
use_simulator_snapshot_mode=True)
self.assertAlmostEqual(reference[0], actual_value[0], places=10)
@parameterized.expand([['trotter', 1, 3], ['suzuki', 1, 3]])
def test_evolve(self, expansion_mode, evo_time, num_time_slices):
""" evolve test """
expansion_orders = [1, 2, 3, 4] if expansion_mode == 'suzuki' else [1]
num_qubits = 2
paulis = [
Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ', repeat=num_qubits)
]
weights = aqua_globals.random.random_sample(len(paulis))
pauli_op = WeightedPauliOperator.from_list(paulis, weights)
matrix_op = op_converter.to_matrix_operator(pauli_op)
state_in = Custom(num_qubits, state='random')
# get the exact state_out from raw matrix multiplication
state_out_exact = matrix_op.evolve(
state_in=state_in.construct_circuit('vector'),
evo_time=evo_time,
num_time_slices=0)
# self.log.debug('exact:\n%s', state_out_exact)
self.log.debug('Under %s expansion mode:', expansion_mode)
for expansion_order in expansion_orders:
# assure every time the operator from the original one
if expansion_mode == 'suzuki':
self.log.debug('With expansion order %s:', expansion_order)
state_out_matrix = matrix_op.evolve(
state_in=state_in.construct_circuit('vector'),
evo_time=evo_time,
num_time_slices=num_time_slices,
expansion_mode=expansion_mode,
expansion_order=expansion_order)
quantum_registers = QuantumRegister(pauli_op.num_qubits, name='q')
qc = QuantumCircuit(quantum_registers)
qc += state_in.construct_circuit('circuit', quantum_registers)
qc += pauli_op.copy().evolve(
evo_time=evo_time,
num_time_slices=num_time_slices,
quantum_registers=quantum_registers,
expansion_mode=expansion_mode,
expansion_order=expansion_order,
)
state_out_circuit = self.quantum_instance_statevector.execute(
qc).get_statevector(qc)
self.log.debug('The fidelity between exact and matrix: %s',
state_fidelity(state_out_exact, state_out_matrix))
self.log.debug('The fidelity between exact and circuit: %s',
state_fidelity(state_out_exact, state_out_circuit))
f_mc = state_fidelity(state_out_matrix, state_out_circuit)
self.log.debug('The fidelity between matrix and circuit: %s', f_mc)
self.assertAlmostEqual(f_mc, 1)
class TestTPBGroupedWeightedPauliOperator(QiskitAquaTestCase):
"""TPBGroupedWeightedPauliOperator tests."""
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 test_sorted_grouping(self):
"""Test with color grouping approach."""
num_qubits = 2
paulis = [
Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ', repeat=num_qubits)
]
weights = aqua_globals.random.random(len(paulis))
op = WeightedPauliOperator.from_list(paulis, weights)
grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator(
op, TPBGroupedWeightedPauliOperator.sorted_grouping)
# check all paulis are still existed.
for g_p in grouped_op.paulis:
passed = False
for pauli in op.paulis:
if pauli[1] == g_p[1]:
passed = pauli[0] == g_p[0]
break
self.assertTrue(
passed, "non-existed paulis in grouped_paulis: {}".format(
g_p[1].to_label()))
# check the number of basis of grouped
# one should be less than and equal to the original one.
self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_unsorted_grouping(self):
"""Test with normal grouping approach."""
num_qubits = 4
paulis = [
Pauli.from_label(pauli_label)
for pauli_label in itertools.product('IXYZ', repeat=num_qubits)
]
weights = aqua_globals.random.random(len(paulis))
op = WeightedPauliOperator.from_list(paulis, weights)
grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator(
op, TPBGroupedWeightedPauliOperator.unsorted_grouping)
for g_p in grouped_op.paulis:
passed = False
for pauli in op.paulis:
if pauli[1] == g_p[1]:
passed = pauli[0] == g_p[0]
break
self.assertTrue(
passed, "non-existed paulis in grouped_paulis: {}".format(
g_p[1].to_label()))
self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_chop(self):
""" chop test """
paulis = [
Pauli.from_label(x)
for x in ['IIXX', 'ZZXX', 'ZZZZ', 'XXZZ', 'XXXX', 'IXXX']
]
coeffs = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
op = WeightedPauliOperator.from_list(paulis, coeffs)
grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator(
op, TPBGroupedWeightedPauliOperator.sorted_grouping)
original_num_basis = len(grouped_op.basis)
chopped_grouped_op = grouped_op.chop(0.35, copy=True)
self.assertLessEqual(len(chopped_grouped_op.basis), 3)
self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis)
# ZZXX group is remove
for b, _ in chopped_grouped_op.basis:
self.assertFalse(b.to_label() == 'ZZXX')
chopped_grouped_op = grouped_op.chop(0.55, copy=True)
self.assertLessEqual(len(chopped_grouped_op.basis), 1)
self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis)
for b, _ in chopped_grouped_op.basis:
self.assertFalse(b.to_label() == 'ZZXX')
self.assertFalse(b.to_label() == 'ZZZZ')
self.assertFalse(b.to_label() == 'XXZZ')
def test_evaluate_qasm_mode(self):
""" evaluate qasm mode test """
wave_function = self.var_form.construct_circuit(
np.array(
aqua_globals.random.standard_normal(
self.var_form.num_parameters)))
wave_fn_statevector = \
self.quantum_instance_statevector.execute(wave_function).get_statevector(wave_function)
reference = self.qubit_op.copy().evaluate_with_statevector(
wave_fn_statevector)
shots = 65536 // len(self.qubit_op.paulis)
self.quantum_instance_qasm.set_config(shots=shots)
circuits = self.qubit_op.construct_evaluation_circuit(
wave_function=wave_function, statevector_mode=False)
result = self.quantum_instance_qasm.execute(circuits)
pauli_value = self.qubit_op.evaluate_with_result(
result=result, statevector_mode=False)
grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator(
self.qubit_op, TPBGroupedWeightedPauliOperator.sorted_grouping)
shots = 65536 // grouped_op.num_groups
self.quantum_instance_qasm.set_config(shots=shots)
circuits = grouped_op.construct_evaluation_circuit(
wave_function=wave_function, statevector_mode=False)
grouped_pauli_value = grouped_op.evaluate_with_result(
result=self.quantum_instance_qasm.execute(circuits),
statevector_mode=False)
self.assertGreaterEqual(
reference[0].real,
grouped_pauli_value[0].real - 3 * grouped_pauli_value[1].real)
self.assertLessEqual(
reference[0].real,
grouped_pauli_value[0].real + 3 * grouped_pauli_value[1].real)
# this check assure the std of grouped pauli is
# less than pauli mode under a fixed amount of total shots
self.assertLessEqual(grouped_pauli_value[1].real, pauli_value[1].real)
def test_equal(self):
""" equal test """
gop_1 = op_converter.to_tpb_grouped_weighted_pauli_operator(
self.qubit_op, TPBGroupedWeightedPauliOperator.sorted_grouping)
gop_2 = op_converter.to_tpb_grouped_weighted_pauli_operator(
self.qubit_op, TPBGroupedWeightedPauliOperator.unsorted_grouping)
self.assertEqual(gop_1, gop_2)
def test_save_and_load_model(self, use_circuits):
""" save and load model test """
aqua_globals.random_seed = self.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)
# 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)
# sort parameters for reproducibility
if use_circuits:
vqc._feature_map_params = list(x)
vqc._var_form_params = list(theta)
quantum_instance = QuantumInstance(backend,
shots=1024,
seed_simulator=self.seed,
seed_transpiler=self.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)
# sort parameters for reproducibility
if use_circuits:
loaded_vqc._feature_map_params = list(x)
loaded_vqc._var_form_params = list(theta)
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 os.path.exists(file_path):
try:
os.remove(file_path)
except Exception: # pylint: disable=broad-except
pass
num_qubits = args.q
if args.var_form == 'RYRZ':
var_form = RYRZ(args.q,
depth=args.d,
entanglement='linear',
entanglement_gate='cx')
num_parameters = var_form._num_parameters
elif args.var_form == 'QAOA':
A = nx.adjacency_matrix(nx.random_regular_graph(4, args.q)).todense()
qubitOp, shift = get_maxcut_qubitops(A)
var_form = QAOAVarForm(qubitOp, args.d)
num_parameters = var_form.num_parameters
parameters = np.random.uniform(0, np.pi, num_parameters)
qc = var_form.construct_circuit(parameters)
if not qc.cregs:
c = ClassicalRegister(num_qubits, name='c')
qc.add_register(c)
qc.measure(qc.qregs[0], qc.cregs[0])
# Select the QasmSimulator from the Aer provider
simulator = Aer.get_backend('qasm_simulator')
# Define the simulation method
backend_opts_mps = {"method": "matrix_product_state"}
start_time = timeit.default_timer()
result = execute(qc, simulator, backend_options=backend_opts_mps).result()
runtime = timeit.default_timer() - start_time
print("Finished in: {:.2f} sec with {} qubits, {} depth".format(
def setUp(self):
super().setUp()
self.seed = 1376
aqua_globals.random_seed = self.seed
self.training_data = {
'A': np.asarray([[2.95309709, 2.51327412],
[3.14159265, 4.08407045]]),
'B': np.asarray([[4.08407045, 2.26194671],
[4.46106157, 2.38761042]])
}
self.testing_data = {
'A': np.asarray([[3.83274304, 2.45044227]]),
'B': np.asarray([[3.89557489, 0.31415927]])
}
self.ref_opt_params = np.array([
10.03814083, -12.22048954, -7.58026833, -2.42392954, 12.91555293,
13.44064652, -2.89951454, -10.20639406, 0.81414546, -1.00551752,
-4.7988307, 14.00831419, 8.26008064, -7.07543736, 11.43368677,
-5.74857438
])
self.ref_train_loss = 0.69366523
self.ref_prediction_a_probs = [[0.79882812, 0.20117188]]
self.ref_prediction_a_label = [0]
# ignore warnings from creating VariationalForm and FeatureMap objects
warnings.filterwarnings('ignore', category=DeprecationWarning)
var_form_ryrz = RYRZ(2, depth=3)
feature_map = SecondOrderExpansion(2, depth=2)
warnings.filterwarnings('always', category=DeprecationWarning)
library_ryrz = TwoLocal(2, ['ry', 'rz'],
'cz',
reps=3,
insert_barriers=True)
theta = ParameterVector('theta', var_form_ryrz.num_parameters)
circuit_ryrz = var_form_ryrz.construct_circuit(theta)
resorted = []
for i in range(4):
layer = library_ryrz.ordered_parameters[4 * i:4 * (i + 1)]
resorted += layer[::2]
resorted += layer[1::2]
library_ryrz.assign_parameters(dict(zip(resorted, theta)),
inplace=True)
self._sorted_wavefunction_params = list(theta)
self.ryrz_wavefunction = {
'wrapped': var_form_ryrz,
'circuit': circuit_ryrz,
'library': library_ryrz
}
library_circuit = ZZFeatureMap(2, reps=2)
x = ParameterVector('x', 2)
circuit = feature_map.construct_circuit(x)
self._sorted_data_params = list(x)
library_circuit.assign_parameters(x, inplace=True)
self.data_preparation = {
'wrapped': feature_map,
'circuit': circuit,
'library': library_circuit
}
def test_real_eval(self):
""" real 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_ref = RunConfig(shots=1)
run_config = RunConfig(shots=10000)
reference = self.qubit_op.eval(
'matrix',
circuit,
BasicAer.get_backend('statevector_simulator'),
run_config=run_config_ref)[0]
reference = reference.real
backend = BasicAer.get_backend('qasm_simulator')
paulis_mode = self.qubit_op.eval('paulis',
circuit,
backend,
run_config=run_config)
grouped_paulis_mode = self.qubit_op.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 = RunConfig(shots=10000)
compile_config = {'pass_manager': PassManager()}
paulis_mode = self.qubit_op.eval('paulis',
circuit,
backend,
run_config=run_config,
compile_config=compile_config)
grouped_paulis_mode = self.qubit_op.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")
