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")