def test_callback(self): """Test the callback function of the VQC.""" history = {'eval_count': [], 'parameters': [], 'cost': [], 'batch_index': []} def store_intermediate_result(eval_count, parameters, cost, batch_index): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['cost'].append(cost) history['batch_index'].append(batch_index) optimizer = COBYLA(maxiter=3) data_preparation = self.data_preparation wavefunction = self.ryrz_wavefunction # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data, callback=store_intermediate_result) vqc.run(self.qasm_simulator) with self.subTest('eval count'): self.assertTrue(all(isinstance(count, int) for count in history['eval_count'])) with self.subTest('cost'): self.assertTrue(all(isinstance(cost, float) for cost in history['cost'])) with self.subTest('batch index'): self.assertTrue(all(isinstance(index, int) for index in history['batch_index'])) for params in history['parameters']: with self.subTest('params'): self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_callback(self, mode): """ vqc callback test """ history = { 'eval_count': [], 'parameters': [], 'cost': [], 'batch_index': [] } def store_intermediate_result(eval_count, parameters, cost, batch_index): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['cost'].append(cost) history['batch_index'].append(batch_index) aqua_globals.random_seed = self.seed backend = BasicAer.get_backend('qasm_simulator') optimizer = COBYLA(maxiter=3) data_preparation = self.data_preparation[mode] wavefunction = self.ryrz_wavefunction[mode] if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data, callback=store_intermediate_result) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.seed, seed_transpiler=self.seed) vqc.run(quantum_instance) with self.subTest('eval count'): self.assertTrue( all(isinstance(count, int) for count in history['eval_count'])) with self.subTest('cost'): self.assertTrue( all(isinstance(cost, float) for cost in history['cost'])) with self.subTest('batch index'): self.assertTrue( all( isinstance(index, int) for index in history['batch_index'])) for params in history['parameters']: with self.subTest('params'): self.assertTrue( all(isinstance(param, float) for param in params))
def test_vqc_callback(self, use_circuits): """ vqc callback test """ history = { 'eval_count': [], 'parameters': [], 'cost': [], 'batch_index': [] } def store_intermediate_result(eval_count, parameters, cost, batch_index): history['eval_count'].append(eval_count) history['parameters'].append(parameters) history['cost'].append(cost) history['batch_index'].append(batch_index) aqua_globals.random_seed = self.seed backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 optimizer = COBYLA(maxiter=3) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RY(num_qubits=num_qubits, depth=1) # convert to circuit if circuits should be used if use_circuits: x = ParameterVector('x', feature_map.feature_dimension) feature_map = feature_map.construct_circuit(x) theta = ParameterVector('theta', var_form.num_parameters) var_form = var_form.construct_circuit(theta) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, callback=store_intermediate_result) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.seed, seed_transpiler=self.seed) vqc.run(quantum_instance) self.assertTrue( all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue( all(isinstance(cost, float) for cost in history['cost'])) self.assertTrue( all(isinstance(index, int) for index in history['batch_index'])) for params in history['parameters']: self.assertTrue(all(isinstance(param, float) for param in params))
def test_vqc_callback(self): """ vqc callback test """ tmp_filename = 'qvqc_callback_test.csv' is_file_exist = os.path.exists(self._get_resource_path(tmp_filename)) if is_file_exist: os.remove(self._get_resource_path(tmp_filename)) def store_intermediate_result(eval_count, parameters, cost, batch_index): with open(self._get_resource_path(tmp_filename), 'a') as file: content = "{},{},{:.5f},{}".format(eval_count, parameters, cost, batch_index) print(content, file=file, flush=True) np.random.seed(self.random_seed) aqua_globals.random_seed = self.random_seed backend = BasicAer.get_backend('qasm_simulator') num_qubits = 2 optimizer = COBYLA(maxiter=3) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RY(num_qubits=num_qubits, depth=1) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, callback=store_intermediate_result) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.random_seed, seed_transpiler=self.random_seed) vqc.run(quantum_instance) is_file_exist = os.path.exists(self._get_resource_path(tmp_filename)) self.assertTrue(is_file_exist, "Does not store content successfully.") # check the content ref_content = [ ['0', '[-0.58205563 -2.97987177 -0.73153057 1.06577518]', '0.46841', '0'], ['1', '[ 0.41794437 -2.97987177 -0.73153057 1.06577518]', '0.31861', '1'], ['2', '[ 0.41794437 -1.97987177 -0.73153057 1.06577518]', '0.45975', '2'], ] try: with open(self._get_resource_path(tmp_filename)) as file: idx = 0 for record in file.readlines(): eval_count, parameters, cost, batch_index = record.split(",") self.assertEqual(eval_count.strip(), ref_content[idx][0]) self.assertEqual(parameters, ref_content[idx][1]) self.assertEqual(cost.strip(), ref_content[idx][2]) self.assertEqual(batch_index.strip(), ref_content[idx][3]) idx += 1 finally: if is_file_exist: os.remove(self._get_resource_path(tmp_filename))
def test_vqc_minibatching_no_gradient_support(self): """ vqc minibatching with no 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=6, test_size=3, n=n_dim, gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = COBYLA(maxiter=40) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=3) vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed, optimization_level=0) result = vqc.run(quantum_instance) self.log.debug(result['testing_accuracy']) self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_vqc_minibatching_no_gradient_support(self): """ vqc minibatching with no gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 np.random.seed(seed) _, training_input, test_input, _ = _ad_hoc_data(training_size=8, test_size=4, n=n_dim, gap=0.3) aqua_globals.random_seed = seed backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = COBYLA() feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=3) vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = vqc.run(quantum_instance) vqc_accuracy_threshold = 0.8 self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], vqc_accuracy_threshold)
def test_vqc_with_max_evals_grouped(self): """ 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) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, max_evals_grouped=2) 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_minibatching_gradient_based(self): """Test the minibatching option with a gradient-based optimizer.""" n_dim = 2 # dimension of each data point _, training_input, test_input, _ = ad_hoc_data(training_size=4, test_size=2, n=n_dim, gap=0.3, plot_data=False) optimizer = L_BFGS_B(maxfun=30) data_preparation = self.data_preparation wavefunction = TwoLocal(2, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, minibatch_size=2) result = vqc.run(self.statevector_simulator) self.log.debug(result['testing_accuracy']) self.assertAlmostEqual(result['testing_accuracy'], 0.75, places=3)
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_statevector(self, mode): """ vqc statevector test """ aqua_globals.random_seed = 10598 optimizer = COBYLA() data_preparation = self.data_preparation[mode] wavefunction = self.ryrz_wavefunction[mode] if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) if mode in ['circuit', 'library']: vqc._feature_map_params = self._sorted_data_params vqc._var_form_params = self._sorted_wavefunction_params else: warnings.filterwarnings('always', category=DeprecationWarning) 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)
def test_raw_feature_vector_on_wine(self, mode): """Test VQE on the wine dataset using the ``RawFeatureVector`` as data preparation.""" feature_dim = 4 # dimension of each data point training_dataset_size = 8 testing_dataset_size = 4 _, training_input, test_input, _ = wine( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim, plot_data=False) if mode == 'component': warnings.filterwarnings('ignore', category=DeprecationWarning) feature_map = LegacyRawFeatureVector(feature_dimension=feature_dim) else: feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run(self.statevector_simulator) if mode == 'component': warnings.filterwarnings('always', category=DeprecationWarning) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.7)
def test_vqc_minibatching_with_gradient_support(self): """ 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) vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) 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_with_raw_feature_vector_on_wine(self): """ vqc with raw features vector on wine test """ feature_dim = 4 # dimension of each data point training_dataset_size = 8 testing_dataset_size = 4 _, training_input, test_input, _ = _wine_data( training_size=training_dataset_size, test_size=testing_dataset_size, n=feature_dim ) aqua_globals.random_seed = self.seed feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, RYRZ(feature_map.num_qubits, depth=3), training_input, test_input) 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.assertGreater(result['testing_accuracy'], 0.8)
def test_vqc_minibatching_with_gradient_support(self): n_dim = 2 # dimension of each data point seed = 1024 np.random.seed(seed) sample_Total, training_input, test_input, class_labels = ad_hoc_data( training_size=8, test_size=4, n=n_dim, gap=0.3) aqua_globals.random_seed = seed backend = BasicAer.get_backend('statevector_simulator') num_qubits = n_dim optimizer = L_BFGS_B(maxfun=100) feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) var_form = RYRZ(num_qubits=num_qubits, depth=2) vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) # TODO: cache only work with optimization_level 0 quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed, optimization_level=0) result = vqc.run(quantum_instance) vqc_accuracy_threshold = 0.8 self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], vqc_accuracy_threshold)
def test_vqc_statevector(self, mode): """ vqc statevector test """ aqua_globals.random_seed = 2752 optimizer = SPSA(max_trials=100, save_steps=1, c0=4.0, c1=0.1, c2=0.602, c3=0.101, c4=0.0, skip_calibration=True) data_preparation = self.data_preparation[mode] wavefunction = self.ryrz_wavefunction[mode] if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) 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) with self.subTest('training loss'): self.assertGreater(result['training_loss'], 0.10, 2) with self.subTest('accuracy'): self.assertEqual(result['testing_accuracy'], 0.0 if mode == 'wrapped' else 0.5)
def test_vqc_minibatching_no_gradient_support(self, mode): """ vqc minibatching with no 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=6, test_size=3, n=n_dim, gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') optimizer = COBYLA(maxiter=40) data_preparation = self.data_preparation[mode] wavefunction = self.ryrz_wavefunction[mode] if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, minibatch_size=2) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed, optimization_level=0) result = vqc.run(quantum_instance) self.assertGreaterEqual(result['testing_accuracy'], 0.5)
def test_save_and_load_model(self): """Test saving and loading a model with the VQC.""" data_preparation = self.data_preparation wavefunction = self.ryrz_wavefunction vqc = VQC(self.spsa, data_preparation, wavefunction, self.training_data, self.testing_data) result = vqc.run(self.qasm_simulator) with self.subTest( msg='check optimal params, training loss and testing accuracy' ): 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(0.5, result['testing_accuracy']) file_path = self.get_resource_path('vqc_test.npz') vqc.save_model(file_path) with self.subTest(msg='assert saved file exists'): self.assertTrue(os.path.exists(file_path)) loaded_vqc = VQC(self.spsa, data_preparation, wavefunction, self.training_data, None) loaded_vqc.load_model(file_path) loaded_test_acc = loaded_vqc.test(vqc.test_dataset[0], vqc.test_dataset[1], self.qasm_simulator) with self.subTest( msg= 'check optimal parameters and testing accuracy of loaded model' ): np.testing.assert_array_almost_equal(loaded_vqc.ret['opt_params'], self.ref_opt_params, decimal=4) self.assertEqual(result['testing_accuracy'], loaded_test_acc) predicted_probs, predicted_labels = loaded_vqc.predict( self.testing_data['A'], self.qasm_simulator) with self.subTest(msg='check probs and labels of predicted labels'): 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
def test_save_and_load_model(self): """ save and load model test """ np.random.seed(self.random_seed) aqua_globals.random_seed = self.random_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) vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data) quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.random_seed, seed_transpiler=self.random_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) 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 quantum_instance.has_circuit_caching: self.assertLess(quantum_instance._circuit_cache.misses, 3) if os.path.exists(file_path): try: os.remove(file_path) except Exception: # pylint: disable=broad-except pass
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_same_parameter_names_raises(self): """Test that the varform and feature map can have parameters with the same name.""" var_form = QuantumCircuit(1) var_form.ry(Parameter('a'), 0) feature_map = QuantumCircuit(1) feature_map.rz(Parameter('a'), 0) optimizer = SPSA() vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data) with self.assertRaises(AquaError): _ = vqc.run(BasicAer.get_backend('statevector_simulator'))
def test_statevector(self): """Test running the VQC on BasicAer's Statevector simulator.""" optimizer = L_BFGS_B(maxfun=200) data_preparation = self.data_preparation wavefunction = self.ryrz_wavefunction vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) result = vqc.run(self.statevector_simulator) with self.subTest(msg='check training loss'): self.assertLess(result['training_loss'], 0.12) with self.subTest(msg='check testing accuracy'): self.assertEqual(result['testing_accuracy'], 0.5)
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_usage_in_vqc(self): """Test using the circuit the a single VQC iteration works.""" feature_dim = 4 _, training_input, test_input, _ = wine(training_size=1, test_size=1, n=feature_dim, plot_data=False) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=1), feature_map, EfficientSU2(feature_map.num_qubits, reps=1), training_input, test_input) backend = Aer.get_backend('qasm_simulator') result = vqc.run(backend) self.assertTrue(result['eval_count'] > 0)
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_minibatching_gradient_free(self): """Test the minibatching option with a gradient-free optimizer.""" n_dim = 2 # dimension of each data point _, training_input, test_input, _ = ad_hoc_data(training_size=6, test_size=3, n=n_dim, gap=0.3, plot_data=False) optimizer = COBYLA(maxiter=40) data_preparation = self.data_preparation wavefunction = self.ryrz_wavefunction vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, minibatch_size=2) result = vqc.run(self.qasm_simulator) self.log.debug(result['testing_accuracy']) self.assertAlmostEqual(result['testing_accuracy'], 0.3333333333333333)
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) 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 == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = vqc.run(quantum_instance) self.assertGreater(result['testing_accuracy'], 0.2)
def test_vqc_with_max_evals_grouped(self, mode): """ 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) data_preparation = self.data_preparation[mode] wavefunction = self.ryrz_wavefunction[mode] if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data, max_evals_grouped=2) if mode == 'wrapped': warnings.filterwarnings('always', category=DeprecationWarning) 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) with self.subTest('opt params'): np.testing.assert_array_almost_equal(result['opt_params'], self.ref_opt_params[mode], decimal=8) with self.subTest('training loss'): np.testing.assert_array_almost_equal(result['training_loss'], self.ref_train_loss[mode], decimal=8) with self.subTest('accuracy'): self.assertEqual(1.0 if mode == 'wrapped' else 0.5, result['testing_accuracy'])
def test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel,redefined-builtin def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # --- Exact copy of sample code ---------------------------------------- from qiskit import BasicAer from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.algorithms import VQC from qiskit.aqua.components.optimizers import COBYLA from qiskit.aqua.components.feature_maps import RawFeatureVector from qiskit.ml.datasets import wine from qiskit.circuit.library import TwoLocal seed = 1376 aqua_globals.random_seed = seed # Use Wine data set for training and test data feature_dim = 4 # dimension of each data point _, training_input, test_input, _ = wine(training_size=12, test_size=4, n=feature_dim) feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, seed_simulator=seed, seed_transpiler=seed)) print('Testing accuracy: {:0.2f}'.format(result['testing_accuracy'])) # ---------------------------------------------------------------------- self.assertGreater(result['testing_accuracy'], 0.8)
def test_wine(self): """Test VQE on the wine dataset.""" 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 data_preparation = ZZFeatureMap(feature_dim) wavefunction = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=2) vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction, training_input, test_input) result = vqc.run(self.statevector_simulator) self.log.debug(result['testing_accuracy']) self.assertGreater(result['testing_accuracy'], 0.3)
def test_vqc(self, mode): """ vqc 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) data_preparation = self.data_preparation[mode] wavefunction = self.ryrz_wavefunction[mode] if mode == 'wrapped': warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) if mode in ['circuit', 'library']: vqc._feature_map_params = self._sorted_data_params vqc._var_form_params = self._sorted_wavefunction_params else: warnings.filterwarnings('always', category=DeprecationWarning) 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'])