Add QuantumKernel class using terra primitives

.pylintdict

@@ -6,6 +6,7 @@ ansatz
 ansatzes
 args
 asmatrix
+async
 autograd
 autosummary
 backend
@@ -62,6 +63,7 @@ et
 eval
 expressibility
 farrokh
+fidelities
 formatter
 func
 gambetta

qiskit_machine_learning/algorithms/classifiers/pegasos_qsvc.py

@@ -14,15 +14,19 @@
 
 import logging
 from datetime import datetime
-from typing import Optional, Dict
+from typing import Optional, Dict, Union
 
 import numpy as np
 from qiskit.utils import algorithm_globals
 from sklearn.base import ClassifierMixin
 
 from ...algorithms.serializable_model import SerializableModelMixin
 from ...exceptions import QiskitMachineLearningError
-from ...kernels.quantum_kernel import QuantumKernel
+from ...kernels import BaseKernel, FidelityQuantumKernel
+from ...kernels.quantum_kernel import QuantumKernel as QuantumKernelOld
+
+QuantumKernel = Union[QuantumKernelOld, BaseKernel]
+
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +42,7 @@ class PegasosQSVC(ClassifierMixin, SerializableModelMixin):
 
     .. code-block:: python
 
-        quantum_kernel = QuantumKernel()
+        quantum_kernel = FidelityQuantumKernel()
 
         pegasos_qsvc = PegasosQSVC(quantum_kernel=quantum_kernel)
         pegasos_qsvc.fit(sample_train, label_train)
@@ -64,7 +68,7 @@ def __init__(
     ) -> None:
         """
         Args:
-            quantum_kernel: QuantumKernel to be used for classification. Has to be ``None`` when
+            quantum_kernel: a quantum kernel to be used for classification. Has to be ``None`` when
                 a precomputed kernel is used.
             C: Positive regularization parameter. The strength of the regularization is inversely
                 proportional to C. Smaller ``C`` induce smaller weights which generally helps
@@ -85,17 +89,20 @@ def __init__(
                 - if ``quantum_kernel`` is passed and ``precomputed`` is set to ``True``. To use
                 a precomputed kernel, ``quantum_kernel`` has to be of the ``None`` type.
             TypeError:
-                - if ``quantum_instance`` neither instance of ``QuantumKernel`` nor ``None``.
+                - if ``quantum_kernel`` neither instance of
+                  :class:`~qiskit_machine_learning.kernels.BaseKernel` nor ``None``.
         """
 
         if precomputed:
             if quantum_kernel is not None:
                 raise ValueError("'quantum_kernel' has to be None to use a precomputed kernel")
         else:
             if quantum_kernel is None:
-                quantum_kernel = QuantumKernel()
-            elif not isinstance(quantum_kernel, QuantumKernel):
-                raise TypeError("'quantum_kernel' has to be of type None or QuantumKernel")
+                quantum_kernel = FidelityQuantumKernel()
+            elif not isinstance(quantum_kernel, QuantumKernelOld) and not isinstance(
+                quantum_kernel, BaseKernel
+            ):
+                raise TypeError("'quantum_kernel' has to be of type None or BaseKernel")
 
         self._quantum_kernel = quantum_kernel
         self._precomputed = precomputed
@@ -130,7 +137,8 @@ def fit(
         """Fit the model according to the given training data.
 
         Args:
-            X: Train features. For a callable kernel (an instance of ``QuantumKernel``) the shape
+            X: Train features. For a callable kernel (an instance of
+               :class:`~qiskit_machine_learning.kernels.BaseKernel`) the shape
                should be ``(n_samples, n_features)``, for a precomputed kernel the shape should be
                ``(n_samples, n_samples)``.
             y: shape (n_samples), train labels . Must not contain more than two unique labels.
@@ -206,7 +214,8 @@ def predict(self, X: np.ndarray) -> np.ndarray:
         Perform classification on samples in X.
 
         Args:
-            X: Features. For a callable kernel (an instance of ``QuantumKernel``) the shape
+            X: Features. For a callable kernel (an instance of
+               :class:`~qiskit_machine_learning.kernels.BaseKernel`) the shape
                should be ``(m_samples, n_features)``, for a precomputed kernel the shape should be
                ``(m_samples, n_samples)``. Where ``m`` denotes the set to be predicted and ``n`` the
                size of the training set. In that case, the kernel values in X have to be calculated
@@ -234,7 +243,8 @@ def decision_function(self, X: np.ndarray) -> np.ndarray:
         Evaluate the decision function for the samples in X.
 
         Args:
-            X: Features. For a callable kernel (an instance of ``QuantumKernel``) the shape
+            X: Features. For a callable kernel (an instance of
+               :class:`~qiskit_machine_learning.kernels.BaseKernel`) the shape
                should be ``(m_samples, n_features)``, for a precomputed kernel the shape should be
                ``(m_samples, n_samples)``. Where ``m`` denotes the set to be predicted and ``n`` the
                size of the training set. In that case, the kernel values in X have to be calculated
@@ -340,14 +350,15 @@ def precomputed(self) -> bool:
     @precomputed.setter
     def precomputed(self, precomputed: bool):
         """Sets the pre-computed kernel flag. If ``True`` is passed then the previous kernel is
-        cleared. If ``False`` is passed then a new instance of ``QuantumKernel`` is created."""
+        cleared. If ``False`` is passed then a new instance of
+        :class:`~qiskit_machine_learning.kernels.BaseKernel` is created."""
         self._precomputed = precomputed
         if precomputed:
             # remove the kernel, a precomputed will
             self._quantum_kernel = None
         else:
             # re-create a new default quantum kernel
-            self._quantum_kernel = QuantumKernel()
+            self._quantum_kernel = FidelityQuantumKernel()
 
         # reset training status
         self._reset_state()

qiskit_machine_learning/algorithms/classifiers/qsvc.py

@@ -13,14 +13,17 @@
 """Quantum Support Vector Classifier"""
 
 import warnings
-from typing import Optional
+from typing import Optional, Union
 
 from qiskit.utils.algorithm_globals import algorithm_globals
 from sklearn.svm import SVC
 
 from qiskit_machine_learning.algorithms.serializable_model import SerializableModelMixin
 from qiskit_machine_learning.exceptions import QiskitMachineLearningWarning
-from qiskit_machine_learning.kernels.quantum_kernel import QuantumKernel
+from qiskit_machine_learning.kernels import BaseKernel, FidelityQuantumKernel
+from qiskit_machine_learning.kernels import QuantumKernel as QuantumKernelOld
+
+QuantumKernel = Union[QuantumKernelOld, BaseKernel]
 
 
 class QSVC(SVC, SerializableModelMixin):
@@ -65,7 +68,7 @@ def __init__(self, *args, quantum_kernel: Optional[QuantumKernel] = None, **kwar
             # if we don't delete, then this value clashes with our quantum kernel
             del kwargs["kernel"]
 
-        self._quantum_kernel = quantum_kernel if quantum_kernel else QuantumKernel()
+        self._quantum_kernel = quantum_kernel if quantum_kernel else FidelityQuantumKernel()
 
         if "random_state" not in kwargs:
             kwargs["random_state"] = algorithm_globals.random_seed

qiskit_machine_learning/algorithms/regressors/qsvr.py

@@ -13,13 +13,16 @@
 """Quantum Support Vector Regressor"""
 
 import warnings
-from typing import Optional
+from typing import Optional, Union
 
 from sklearn.svm import SVR
 
-from ..serializable_model import SerializableModelMixin
-from ...exceptions import QiskitMachineLearningWarning
-from ...kernels.quantum_kernel import QuantumKernel
+from qiskit_machine_learning.algorithms.serializable_model import SerializableModelMixin
+from qiskit_machine_learning.exceptions import QiskitMachineLearningWarning
+from qiskit_machine_learning.kernels import BaseKernel, FidelityQuantumKernel
+from qiskit_machine_learning.kernels import QuantumKernel as QuantumKernelOld
+
+QuantumKernel = Union[QuantumKernelOld, BaseKernel]
 
 
 class QSVR(SVR, SerializableModelMixin):
@@ -64,7 +67,7 @@ def __init__(self, *args, quantum_kernel: Optional[QuantumKernel] = None, **kwar
             # if we don't delete, then this value clashes with our quantum kernel
             del kwargs["kernel"]
 
-        self._quantum_kernel = quantum_kernel if quantum_kernel else QuantumKernel()
+        self._quantum_kernel = quantum_kernel if quantum_kernel else FidelityQuantumKernel()
 
         super().__init__(kernel=self._quantum_kernel.evaluate, *args, **kwargs)
 

qiskit_machine_learning/kernels/__init__.py

@@ -23,6 +23,10 @@
    :nosignatures:
 
    QuantumKernel
+   BaseKernel
+   FidelityQuantumKernel
+   TrainableKernelMixin
+   TrainableFidelityQuantumKernel
 
 Submodules
 ==========
@@ -34,5 +38,15 @@
 """
 
 from .quantum_kernel import QuantumKernel
-
-__all__ = ["QuantumKernel"]
+from .base_kernel import BaseKernel
+from .fidelity_quantum_kernel import FidelityQuantumKernel
+from .trainable_kernel_mixin import TrainableKernelMixin
+from .trainable_fidelity_quantum_kernel import TrainableFidelityQuantumKernel
+
+__all__ = [
+    "QuantumKernel",
+    "BaseKernel",
+    "FidelityQuantumKernel",
+    "TrainableKernelMixin",
+    "TrainableFidelityQuantumKernel",
+]

qiskit_machine_learning/kernels/algorithms/quantum_kernel_trainer.py

@@ -11,6 +11,7 @@
 # that they have been altered from the originals.
 
 """Quantum Kernel Trainer"""
+
 import copy
 from functools import partial
 from typing import Union, Optional, Sequence
@@ -22,7 +23,11 @@
 from qiskit.algorithms.variational_algorithm import VariationalResult
 from qiskit_machine_learning.utils.loss_functions import KernelLoss, SVCLoss
 
-from qiskit_machine_learning.kernels import QuantumKernel
+from qiskit_machine_learning.kernels import QuantumKernel as QuantumKernelOld
+from qiskit_machine_learning.kernels import TrainableFidelityQuantumKernel
+
+
+QuantumKernel = Union[QuantumKernelOld, TrainableFidelityQuantumKernel]
 
 
 class QuantumKernelTrainerResult(VariationalResult):

qiskit_machine_learning/kernels/base_kernel.py

@@ -0,0 +1,134 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Base kernel"""
+
+from __future__ import annotations
+
+from abc import abstractmethod, ABC
+
+import numpy as np
+from qiskit import QuantumCircuit
+from qiskit.circuit.library import ZZFeatureMap
+
+
+class BaseKernel(ABC):
+    r"""
+    Abstract class defining the Kernel interface.
+
+    The general task of machine learning is to find and study patterns in data. For many
+    algorithms, the datapoints are better understood in a higher dimensional feature space,
+    through the use of a kernel function:
+
+    .. math::
+
+        K(x, y) = \langle f(x), f(y)\rangle.
+
+    Here K is the kernel function, x, y are n dimensional inputs. f is a map from n-dimension
+    to m-dimension space. :math:`\langle x, y \rangle` denotes the dot product.
+    Usually m is much larger than n.
+
+    The quantum kernel algorithm calculates a kernel matrix, given datapoints x and y and feature
+    map f, all of n dimension. This kernel matrix can then be used in classical machine learning
+    algorithms such as support vector classification, spectral clustering or ridge regression.
+    """
+
+    def __init__(self, feature_map: QuantumCircuit = None, enforce_psd: bool = True) -> None:
+        """
+        Args:
+            feature_map: Parameterized circuit to be used as the feature map. If ``None`` is given,
+                :class:`~qiskit.circuit.library.ZZFeatureMap` is used with two qubits. If there's
+                a mismatch in the number of qubits of the feature map and the number of features
+                in the dataset, then the kernel will try to adjust the feature map to reflect the
+                number of features.
+            enforce_psd: Project to closest positive semidefinite matrix if ``x = y``.
+                Default ``True``.
+        """
+        if feature_map is None:
+            feature_map = ZZFeatureMap(2)
+
+        self._feature_map = feature_map
+        self._enforce_psd = enforce_psd
+
+    @abstractmethod
+    def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray | None = None) -> np.ndarray:
+        r"""
+        Construct kernel matrix for given data.
+
+        If y_vec is None, self inner product is calculated.
+
+        Args:
+            x_vec: 1D or 2D array of datapoints, NxD, where N is the number of datapoints,
+                D is the feature dimension
+            y_vec: 1D or 2D array of datapoints, MxD, where M is the number of datapoints,
+                D is the feature dimension
+
+        Returns:
+            2D matrix, NxM
+        """
+        raise NotImplementedError()
+
+    def _validate_input(
+        self, x_vec: np.ndarray, y_vec: np.ndarray | None
+    ) -> tuple[np.ndarray, np.ndarray | None]:
+        x_vec = np.asarray(x_vec)
+
+        if x_vec.ndim > 2:
+            raise ValueError("x_vec must be a 1D or 2D array")
+
+        if x_vec.ndim == 1:
+            x_vec = np.reshape(x_vec, (-1, len(x_vec)))
+
+        if x_vec.shape[1] != self._feature_map.num_parameters:
+            # before raising an error we try to adjust the feature map
+            # to the required number of qubit.
+            try:
+                self._feature_map.num_qubits = x_vec.shape[1]
+            except AttributeError as a_e:
+                raise ValueError(
+                    f"x_vec and class feature map have incompatible dimensions.\n"
+                    f"x_vec has {x_vec.shape[1]} dimensions, "
+                    f"but feature map has {self._feature_map.num_parameters}."
+                ) from a_e
+
+        if y_vec is not None:
+            y_vec = np.asarray(y_vec)
+
+            if y_vec.ndim == 1:
+                y_vec = np.reshape(y_vec, (-1, len(y_vec)))
+
+            if y_vec.ndim > 2:
+                raise ValueError("y_vec must be a 1D or 2D array")
+
+            if y_vec.shape[1] != x_vec.shape[1]:
+                raise ValueError(
+                    "x_vec and y_vec have incompatible dimensions.\n"
+                    f"x_vec has {x_vec.shape[1]} dimensions, but y_vec has {y_vec.shape[1]}."
+                )
+
+        return x_vec, y_vec
+
+    # pylint: disable=invalid-name
+    def _make_psd(self, kernel_matrix: np.ndarray) -> np.ndarray:
+        r"""
+        Find the closest positive semi-definite approximation to symmetric kernel matrix.
+        The (symmetric) matrix should always be positive semi-definite by construction,
+        but this can be violated in case of noise, such as sampling noise.
+
+        Args:
+            kernel_matrix: symmetric 2D array of the kernel entries
+
+        Returns:
+            the closest positive semi-definite matrix.
+        """
+        d, u = np.linalg.eig(kernel_matrix)
+        return u @ np.diag(np.maximum(0, d)) @ u.transpose()