Пример #1
0
    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_usage_in_vqc(self):
        """Test using the circuit the a single VQC iteration works."""

        # specify quantum instance and random seed
        random_seed = 12345
        quantum_instance = QuantumInstance(
            Aer.get_backend('statevector_simulator'),
            seed_simulator=random_seed,
            seed_transpiler=random_seed)
        np.random.seed(random_seed)

        # construct data
        num_samples = 10
        num_inputs = 4
        X = np.random.rand(num_samples, num_inputs)  # pylint: disable=invalid-name
        y = 1.0 * (np.sum(X, axis=1) <= 2)
        while len(np.unique(y, axis=0)) == 1:
            y = 1.0 * (np.sum(X, axis=1) <= 2)
        y = np.array([y, 1 - y]).transpose()

        feature_map = RawFeatureVector(feature_dimension=num_inputs)

        vqc = VQC(feature_map=feature_map,
                  ansatz=RealAmplitudes(feature_map.num_qubits, reps=1),
                  optimizer=COBYLA(maxiter=10),
                  quantum_instance=quantum_instance)

        vqc.fit(X, y)
        score = vqc.score(X, y)
        self.assertGreater(score, 0.5)
Пример #3
0
    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)
Пример #4
0
    def test_plain_circuits(self):
        """Test running the VQC on QuantumCircuit objects."""
        data_preparation = QuantumCircuit(2).compose(self.data_preparation)
        wavefunction = QuantumCircuit(2).compose(self.ryrz_wavefunction)
        vqc = VQC(self.spsa, data_preparation, wavefunction,
                  self.training_data, self.testing_data)

        self.assertSimpleClassificationIsCorrect(vqc)
    def test_warm_start(self, config):
        """Test VQC with warm_start=True."""
        opt, q_i = config

        if q_i == "statevector":
            quantum_instance = self.sv_quantum_instance
        elif q_i == "qasm":
            quantum_instance = self.qasm_quantum_instance
        else:
            quantum_instance = None

        if opt == "bfgs":
            optimizer = L_BFGS_B(maxiter=5)
        elif opt == "cobyla":
            optimizer = COBYLA(maxiter=25)
        else:
            optimizer = None

        num_inputs = 2
        feature_map = ZZFeatureMap(num_inputs)
        ansatz = RealAmplitudes(num_inputs, reps=1)

        # Construct the data.
        num_samples = 10
        # pylint: disable=invalid-name
        X = algorithm_globals.random.random((num_samples, num_inputs))
        y = 1.0 * (np.sum(X, axis=1) <= 1)
        while len(np.unique(y)) == 1:
            X = algorithm_globals.random.random((num_samples, num_inputs))
            y = 1.0 * (np.sum(X, axis=1) <= 1)
        y = np.array([y, 1 - y
                      ]).transpose()  # VQC requires one-hot encoded input.

        # Initialize the VQC.
        classifier = VQC(
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer=optimizer,
            warm_start=True,
            quantum_instance=quantum_instance,
        )

        # Fit the VQC to the first half of the data.
        num_start = num_samples // 2
        classifier.fit(X[:num_start, :], y[:num_start])
        first_fit_final_point = classifier._fit_result.x

        # Fit the VQC to the second half of the data with a warm start.
        classifier.fit(X[num_start:, :], y[num_start:])
        second_fit_initial_point = classifier._initial_point

        # Check the final optimization point from the first fit was used to start the second fit.
        np.testing.assert_allclose(first_fit_final_point,
                                   second_fit_initial_point)

        # Check score.
        score = classifier.score(X, y)
        self.assertGreater(score, 0.5)
Пример #6
0
    def test_basic_aer_qasm(self):
        """Run a basic test case on BasicAer's QASM simulator."""
        data_preparation = self.data_preparation
        wavefunction = self.ryrz_wavefunction
        optimizer = self.spsa
        vqc = VQC(optimizer, data_preparation, wavefunction,
                  self.training_data, self.testing_data)

        self.assertSimpleClassificationIsCorrect(vqc)
Пример #7
0
 def test_feature_map_without_parameters_warns(self):
     """Test that specifying a feature map with 0 parameters raises a warning."""
     algorithm_globals.random_seed = self.seed
     var_form = QuantumCircuit(1)
     var_form.ry(Parameter('a'), 0)
     feature_map = QuantumCircuit(1)
     optimizer = SPSA()
     with self.assertWarns(UserWarning):
         _ = VQC(optimizer, feature_map, var_form, self.training_data,
                 self.testing_data)
    def test_batches_with_incomplete_labels(self, config):
        """Test VQC when some batches do not include all possible labels."""
        opt, q_i = config

        if q_i == "statevector":
            quantum_instance = self.sv_quantum_instance
        elif q_i == "qasm":
            quantum_instance = self.qasm_quantum_instance
        else:
            quantum_instance = None

        if opt == "bfgs":
            optimizer = L_BFGS_B(maxiter=5)
        elif opt == "cobyla":
            optimizer = COBYLA(maxiter=25)
        else:
            optimizer = None

        num_inputs = 2
        feature_map = ZZFeatureMap(num_inputs)
        ansatz = RealAmplitudes(num_inputs, reps=1)

        # Construct the data.
        features = algorithm_globals.random.random((15, num_inputs))
        target = np.asarray([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2])
        num_classes = len(np.unique(target))

        # One-hot encode the target.
        target_onehot = np.zeros((target.size, int(target.max() + 1)))
        target_onehot[np.arange(target.size), target.astype(int)] = 1

        # Initialize the VQC.
        classifier = VQC(
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer=optimizer,
            warm_start=True,
            quantum_instance=quantum_instance,
        )

        classifier._get_interpret = self.get_num_classes(
            classifier._get_interpret)

        # Fit the VQC to the first third of the data.
        classifier.fit(features[:5, :], target_onehot[:5])

        # Fit the VQC to the second third of the data with a warm start.
        classifier.fit(features[5:10, :], target_onehot[5:10])

        # Fit the VQC to the third third of the data with a warm start.
        classifier.fit(features[10:, :], target_onehot[10:])

        # Check all batches assume the correct number of classes
        self.assertTrue(
            (np.asarray(self.num_classes_by_batch) == num_classes).all())
Пример #9
0
    def test_same_parameter_names_raises(self):
        """Test that the varform and feature map can have parameters with the same name."""
        algorithm_globals.random_seed = self.seed
        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(QiskitMachineLearningError):
            _ = vqc.run(BasicAer.get_backend('statevector_simulator'))
Пример #10
0
    def test_max_evals_grouped(self):
        """Test the VQC with the max_evals_grouped option."""
        data_preparation = self.data_preparation
        wavefunction = self.ryrz_wavefunction

        vqc = VQC(self.spsa,
                  data_preparation,
                  wavefunction,
                  self.training_data,
                  self.testing_data,
                  max_evals_grouped=2)

        self.assertSimpleClassificationIsCorrect(vqc)
    def test_vqc(self, config):
        """Test VQC."""

        opt, q_i = config

        if q_i == "statevector":
            quantum_instance = self.sv_quantum_instance
        elif q_i == "qasm":
            quantum_instance = self.qasm_quantum_instance
        else:
            quantum_instance = None

        if opt == "bfgs":
            optimizer = L_BFGS_B(maxiter=5)
        elif opt == "cobyla":
            optimizer = COBYLA(maxiter=25)
        else:
            optimizer = None

        num_inputs = 2
        feature_map = ZZFeatureMap(num_inputs)
        ansatz = RealAmplitudes(num_inputs, reps=1)
        # fix the initial point
        initial_point = np.array([0.5] * ansatz.num_parameters)

        # construct classifier - note: CrossEntropy requires eval_probabilities=True!
        classifier = VQC(
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer=optimizer,
            quantum_instance=quantum_instance,
            initial_point=initial_point,
        )

        # construct data
        num_samples = 5
        # pylint: disable=invalid-name
        X = algorithm_globals.random.random((num_samples, num_inputs))
        y = 1.0 * (np.sum(X, axis=1) <= 1)
        while len(np.unique(y)) == 1:
            X = algorithm_globals.random.random((num_samples, num_inputs))
            y = 1.0 * (np.sum(X, axis=1) <= 1)
        y = np.array([y,
                      1 - y]).transpose()  # VQC requires one-hot encoded input

        # fit to data
        classifier.fit(X, y)

        # score
        score = classifier.score(X, y)
        self.assertGreater(score, 0.5)
    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.utils import QuantumInstance, algorithm_globals
        from qiskit.algorithms.optimizers import COBYLA
        from qiskit.circuit.library import TwoLocal
        from qiskit_machine_learning.algorithms import VQC
        from qiskit_machine_learning.datasets import wine
        from qiskit_machine_learning.circuit.library import RawFeatureVector

        seed = 1376
        algorithm_globals.random_seed = seed

        # Use Wine data set for training and test data
        feature_dim = 4  # dimension of each data point
        training_size = 12
        test_size = 4

        # training features, training labels, test features, test labels as np.array,
        # one hot encoding for labels
        training_features, training_labels, test_features, test_labels = \
            wine(training_size=training_size, test_size=test_size, n=feature_dim)

        feature_map = RawFeatureVector(feature_dimension=feature_dim)
        ansatz = TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3)
        vqc = VQC(feature_map=feature_map,
                  ansatz=ansatz,
                  optimizer=COBYLA(maxiter=100),
                  quantum_instance=QuantumInstance(
                      BasicAer.get_backend('statevector_simulator'),
                      shots=1024,
                      seed_simulator=seed,
                      seed_transpiler=seed))
        vqc.fit(training_features, training_labels)

        score = vqc.score(test_features, test_labels)
        print('Testing accuracy: {:0.2f}'.format(score))

        # ----------------------------------------------------------------------

        self.assertGreater(score, 0.8)
    def _test_sparse_arrays(self, quantum_instance: QuantumInstance,
                            loss: str):
        classifier = VQC(num_qubits=2,
                         loss=loss,
                         quantum_instance=quantum_instance)
        features = scipy.sparse.csr_matrix([[0, 0], [1, 1]])
        labels = scipy.sparse.csr_matrix([[1, 0], [0, 1]])

        # fit to data
        classifier.fit(features, labels)

        # score
        score = classifier.score(features, labels)
        self.assertGreater(score, 0.5)
Пример #14
0
    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)
Пример #15
0
    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)
Пример #16
0
    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_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.utils import QuantumInstance, algorithm_globals
        from qiskit.algorithms.optimizers import COBYLA
        from qiskit.circuit.library import TwoLocal
        from qiskit_machine_learning.algorithms import VQC
        from qiskit_machine_learning.datasets import wine
        from qiskit_machine_learning.circuit.library import RawFeatureVector

        seed = 1376
        algorithm_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_vqc(self, config):
        """ Test VQC."""

        opt, q_i = config

        if q_i == 'statevector':
            quantum_instance = self.sv_quantum_instance
        else:
            quantum_instance = self.qasm_quantum_instance

        if opt == 'bfgs':
            optimizer = L_BFGS_B(maxiter=5)
        else:
            optimizer = COBYLA(maxiter=25)

        num_inputs = 2
        feature_map = ZZFeatureMap(num_inputs)
        ansatz = RealAmplitudes(num_inputs, reps=1)

        # construct classifier - note: CrossEntropy requires eval_probabilities=True!
        classifier = VQC(feature_map=feature_map,
                         ansatz=ansatz,
                         optimizer=optimizer,
                         quantum_instance=quantum_instance)

        # construct data
        num_samples = 5
        X = np.random.rand(num_samples, num_inputs)  # pylint: disable=invalid-name
        y = 1.0 * (np.sum(X, axis=1) <= 1)
        while len(np.unique(y)) == 1:
            X = np.random.rand(num_samples, num_inputs)  # pylint: disable=invalid-name
            y = 1.0 * (np.sum(X, axis=1) <= 1)
        y = np.array([y,
                      1 - y]).transpose()  # VQC requires one-hot encoded input

        # fit to data
        classifier.fit(X, y)

        # score
        score = classifier.score(X, y)
        self.assertGreater(score, 0.5)
Пример #19
0
    def test_wine(self):
        """Test VQC 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)
        algorithm_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)
Пример #20
0
    def test_raw_feature_vector_on_wine(self, ):
        """Test VQC 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)

        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)

        self.log.debug(result['testing_accuracy'])
        self.assertGreater(result['testing_accuracy'], 0.7)
    def test_default_parameters(self, config):
        """Test VQC instantiation with default parameters."""

        provide_num_qubits, provide_feature_map, provide_ansatz = config
        num_inputs = 2

        num_qubits, feature_map, ansatz = None, None, None

        if provide_num_qubits:
            num_qubits = num_inputs
        if provide_feature_map:
            feature_map = ZZFeatureMap(num_inputs)
        if provide_ansatz:
            ansatz = RealAmplitudes(num_inputs, reps=1)

        classifier = VQC(
            num_qubits=num_qubits,
            feature_map=feature_map,
            ansatz=ansatz,
            quantum_instance=self.qasm_quantum_instance,
        )

        # construct data
        num_samples = 5
        # pylint: disable=invalid-name
        X = algorithm_globals.random.random((num_samples, num_inputs))
        y = 1.0 * (np.sum(X, axis=1) <= 1)
        while len(np.unique(y)) == 1:
            X = algorithm_globals.random.random((num_samples, num_inputs))
            y = 1.0 * (np.sum(X, axis=1) <= 1)
        y = np.array([y,
                      1 - y]).transpose()  # VQC requires one-hot encoded input

        # fit to data
        classifier.fit(X, y)

        # score
        score = classifier.score(X, y)
        self.assertGreater(score, 0.5)
Пример #22
0
    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)
Пример #23
0
    def test_usage_in_vqc(self):
        """Test using the circuit the a single VQC iteration works."""

        # specify quantum instance and random seed
        algorithm_globals.random_seed = 12345
        quantum_instance = QuantumInstance(
            Aer.get_backend("aer_simulator_statevector"),
            seed_simulator=algorithm_globals.random_seed,
            seed_transpiler=algorithm_globals.random_seed,
        )

        # construct data
        num_samples = 10
        num_inputs = 4
        X = algorithm_globals.random.random(  # pylint: disable=invalid-name
            (num_samples, num_inputs))
        y = 1.0 * (np.sum(X, axis=1) <= 2)
        while len(np.unique(y, axis=0)) == 1:
            y = 1.0 * (np.sum(X, axis=1) <= 2)
        y = np.array([y, 1 - y]).transpose()

        feature_map = RawFeatureVector(feature_dimension=num_inputs)
        ansatz = RealAmplitudes(feature_map.num_qubits, reps=1)
        # classification may fail sometimes, so let's fix initial point
        initial_point = np.array([0.5] * ansatz.num_parameters)

        vqc = VQC(
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer=COBYLA(maxiter=10),
            quantum_instance=quantum_instance,
            initial_point=initial_point,
        )

        vqc.fit(X, y)
        score = vqc.score(X, y)
        self.assertGreater(score, 0.5)
    def test_multiclass(self, config):
        """Test multiclass VQC."""
        opt, q_i = config

        if q_i == "statevector":
            quantum_instance = self.sv_quantum_instance
        elif q_i == "qasm":
            quantum_instance = self.qasm_quantum_instance
        else:
            quantum_instance = None

        if opt == "bfgs":
            optimizer = L_BFGS_B(maxiter=5)
        elif opt == "cobyla":
            optimizer = COBYLA(maxiter=25)
        else:
            optimizer = None

        num_inputs = 2
        feature_map = ZZFeatureMap(num_inputs)
        ansatz = RealAmplitudes(num_inputs, reps=1)
        # fix the initial point
        initial_point = np.array([0.5] * ansatz.num_parameters)

        # construct classifier - note: CrossEntropy requires eval_probabilities=True!
        classifier = VQC(
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer=optimizer,
            quantum_instance=quantum_instance,
            initial_point=initial_point,
        )

        # construct data
        num_samples = 5
        num_classes = 5
        # pylint: disable=invalid-name

        # We create a dataset that is random, but has some training signal, as follows:
        # First, we create a random feature matrix X, but sort it by the row-wise sum in ascending
        # order.
        X = algorithm_globals.random.random((num_samples, num_inputs))
        X = X[X.sum(1).argsort()]

        # Next we create an array which contains all class labels, multiple times if num_samples <
        # num_classes, and in ascending order (e.g. [0, 0, 1, 1, 2]). So now we have a dataset
        # where the row-sum of X is correlated with the class label (i.e. smaller row-sum is more
        # likely to belong to class 0, and big row-sum is more likely to belong to class >0)
        y_indices = (np.digitize(np.arange(0, 1, 1 / num_samples),
                                 np.arange(0, 1, 1 / num_classes)) - 1)

        # Third, we random shuffle both X and y_indices
        permutation = np.random.permutation(np.arange(num_samples))
        X = X[permutation]
        y_indices = y_indices[permutation]

        # Lastly we create a 1-hot label matrix y
        y = np.zeros((num_samples, num_classes))
        for e, index in enumerate(y_indices):
            y[e, index] = 1

        # fit to data
        classifier.fit(X, y)

        # score
        score = classifier.score(X, y)
        self.assertGreater(score, 1 / num_classes)
from qiskit_machine_learning.datasets import ad_hoc_data
from qiskit_machine_learning.algorithms import VQC
from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit.providers.aer import QasmSimulator
X_train, y_train, X_test, y_test = ad_hoc_data(20, 10, 2, 0.1)
num_qubits = 2
vqc = VQC(feature_map=ZZFeatureMap(num_qubits),
          ansatz=RealAmplitudes(num_qubits, reps=1),
          loss='cross_entropy',
          optimizer=L_BFGS_B(),
          quantum_instance=QasmSimulator())

vqc.fit(X_train, y_train)
vqc.score(X_test, y_test)