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)