Native circuits (qiskit-community/qiskit-aqua#905)

* make compatible with current Terra

means no num_parameters keyword

* use circuit params as var_form_params

and prepare VQC for circuits

* make VQC work with circuits

* overwrite varform params on setter

* move patching to setter

* more tests, don't allow no parameters

if the varform has no parameters it breaks VQE since we divide by the number of parameters

* update docstrings

* add warning if feature dim is 0

* add test for feature dim = 0

* fix unused variable

* use params provided in circuit don't reassign

* begin adding circuit to qsvm

* num_parameters is now circuit attribute

* adjust to new circuit methods

num_parameters and assign_parameters is now available in the circuit base class

* run tests for varform and QC

* remove unused imports

* add VQC tests for circuits

* make QSVM run on circuits

* sort parameters in wine test for reproducibility

* adress Steve's comments

* add changelog, obey PEP and dont use `None or ..`

* remove the op+varform check to construct_circuit

Co-authored-by: Manoel Marques <[email protected]>
Co-authored-by: Donny Greenberg <[email protected]>

Author: 3 people

qiskit/aqua/algorithms/classifiers/qsvm/qsvm.py

@@ -41,8 +41,7 @@
 
 
 class QSVM(QuantumAlgorithm):
-    """
-    The Quantum SVM algorithm.
+    """Quantum SVM algorithm.
 
     A key concept in classification methods is that of a kernel. Data cannot typically be
     separated by a hyperplane in its original space. A common technique used to find such a
@@ -76,7 +75,7 @@ class QSVM(QuantumAlgorithm):
 
     BATCH_SIZE = 1000
 
-    def __init__(self, feature_map: FeatureMap,
+    def __init__(self, feature_map: Union[QuantumCircuit, FeatureMap],
                  training_dataset: Optional[Dict[str, np.ndarray]] = None,
                  test_dataset: Optional[Dict[str, np.ndarray]] = None,
                  datapoints: Optional[np.ndarray] = None,
@@ -122,6 +121,17 @@ def __init__(self, feature_map: FeatureMap,
         self.feature_map = feature_map
         self.num_qubits = self.feature_map.num_qubits
 
+        if isinstance(feature_map, QuantumCircuit):
+            # patch the feature dimension attribute to the circuit
+            self.feature_map.feature_dimension = len(feature_map.parameters)
+            if not hasattr(feature_map, 'ordered_parameters'):
+                self.feature_map.ordered_parameters = list(feature_map.parameters)
+            self.feature_map_params_x = ParameterVector('x', self.feature_map.feature_dimension)
+            self.feature_map_params_y = ParameterVector('y', self.feature_map.feature_dimension)
+        else:
+            self.feature_map_params_x = ParameterVector('x', feature_map.feature_dimension)
+            self.feature_map_params_y = ParameterVector('y', feature_map.feature_dimension)
+
         if multiclass_extension is None:
             qsvm_instance = _QSVM_Binary(self)
         else:
@@ -132,8 +142,7 @@ def __init__(self, feature_map: FeatureMap,
 
     @staticmethod
     def _construct_circuit(x, feature_map, measurement, is_statevector_sim=False):
-        """
-        If `is_statevector_sim` is True, we only build the circuits for Psi(x1)|0> rather than
+        """If `is_statevector_sim` is True, we only build the circuits for Psi(x1)|0> rather than
         Psi(x2)^dagger Psi(x1)|0>.
         """
         x1, x2 = x
@@ -145,9 +154,20 @@ def _construct_circuit(x, feature_map, measurement, is_statevector_sim=False):
         qc = QuantumCircuit(q, c)
 
         # write input state from sample distribution
-        qc += feature_map.construct_circuit(x1, q)
+        if isinstance(feature_map, FeatureMap):
+            qc += feature_map.construct_circuit(x1, q)
+        else:
+            psi_x1 = _assign_parameters(feature_map, x1)
+            qc.append(psi_x1.to_instruction(), qc.qubits)
+
         if not is_statevector_sim:
-            qc += feature_map.construct_circuit(x2, q).inverse()
+            # write input state from sample distribution
+            if isinstance(feature_map, FeatureMap):
+                qc += feature_map.construct_circuit(x2, q).inverse()
+            else:
+                psi_x2_dag = _assign_parameters(feature_map, x2)
+                qc.append(psi_x2_dag.to_instruction().inverse(), qc.qubits)
+
             if measurement:
                 qc.barrier(q)
                 qc.measure(q, c)
@@ -207,7 +227,10 @@ def get_kernel_matrix(quantum_instance, feature_map, x1_vec, x2_vec=None):
             numpy.ndarray: 2-D matrix, N1xN2
         """
 
-        use_parameterized_circuits = feature_map.support_parameterized_circuit
+        if isinstance(feature_map, QuantumCircuit):
+            use_parameterized_circuits = True
+        else:
+            use_parameterized_circuits = feature_map.support_parameterized_circuit
 
         if x2_vec is None:
             is_symmetric = True
@@ -488,3 +511,10 @@ def setup_datapoint(self, datapoints):
             if not isinstance(datapoints, np.ndarray):
                 datapoints = np.asarray(datapoints)
             self.datapoints = datapoints
+
+
+def _assign_parameters(circuit, params):
+    if not hasattr(circuit, 'ordered_parameters'):
+        raise AttributeError('Circuit needs the attribute `ordered_parameters`.')
+    param_dict = dict(zip(circuit.ordered_parameters, params))
+    return circuit.assign_parameters(param_dict)

qiskit/aqua/algorithms/classifiers/vqc.py

@@ -12,16 +12,17 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-""" The Variational Quantum Classifier algorithm """
+"""The Variational Quantum Classifier algorithm."""
 
 from typing import Optional, Callable, Dict, Union
+import warnings
 import logging
 import math
 import numpy as np
 
 from sklearn.utils import shuffle
 from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
-from qiskit.circuit import ParameterVector
+from qiskit.circuit import ParameterVector, ParameterExpression
 
 from qiskit.providers import BaseBackend
 from qiskit.aqua import QuantumInstance, AquaError
@@ -38,8 +39,7 @@
 
 
 class VQC(VQAlgorithm):
-    """
-    The Variational Quantum Classifier algorithm.
+    """The Variational Quantum Classifier algorithm.
 
     Similar to :class:`QSVM`, the VQC algorithm also applies to classification problems.
     VQC uses the variational method to solve such problems in a quantum processor.  Specifically,
@@ -50,8 +50,8 @@ class VQC(VQAlgorithm):
     def __init__(
             self,
             optimizer: Optimizer,
-            feature_map: FeatureMap,
-            var_form: VariationalForm,
+            feature_map: Union[QuantumCircuit, FeatureMap],
+            var_form: Union[QuantumCircuit, VariationalForm],
             training_dataset: Dict[str, np.ndarray],
             test_dataset: Optional[Dict[str, np.ndarray]] = None,
             datapoints: Optional[np.ndarray] = None,
@@ -75,11 +75,24 @@ def __init__(
                 These are: the evaluation count, parameters of the variational form,
                 the evaluated value, the index of data batch.
             quantum_instance: Quantum Instance or Backend
+
         Note:
             We use `label` to denotes numeric results and `class` the class names (str).
+
         Raises:
-            AquaError: invalid input
+            AquaError: Missing feature map or missing training dataset.
         """
+        # VariationalForm is not deprecated on level of the VQAlgorithm yet as UCCSD still
+        # derives from there, therefore we're adding a warning here
+        if isinstance(var_form, VariationalForm):
+            warnings.warn('The qiskit.aqua.components.variational_form.VariationalForm object as '
+                          'input for the VQC is deprecated as of 0.7.0 and will be removed no '
+                          'earlier than 3 months after the release. You should pass a '
+                          'QuantumCircuit object instead. '
+                          'See also qiskit.circuit.library.n_local for a collection of '
+                          'suitable circuits.',
+                          DeprecationWarning, stacklevel=2)
+
         super().__init__(
             var_form=var_form,
             optimizer=optimizer,
@@ -120,41 +133,61 @@ def __init__(
 
         self._eval_count = 0
         self._ret = {}
-        self._feature_map = feature_map
-        self._num_qubits = feature_map.num_qubits
-        self._var_form_params = ParameterVector('θ', self._var_form.num_parameters)
-        self._feature_map_params = ParameterVector('x', self._feature_map.feature_dimension)
         self._parameterized_circuits = None
 
+        self.feature_map = feature_map
+
     def construct_circuit(self, x, theta, measurement=False):
-        """
-        Construct circuit based on data and parameters in variational form.
+        """Construct circuit based on data and parameters in variational form.
 
         Args:
             x (numpy.ndarray): 1-D array with D dimension
             theta (list[numpy.ndarray]): list of 1-D array, parameters sets for variational form
             measurement (bool): flag to add measurement
+
         Returns:
             QuantumCircuit: the circuit
+
+        Raises:
+            AquaError: If ``x`` and ``theta`` share parameters with the same name.
         """
+        # check x and theta do not have parameters of the same name
+        x_names = [param.name for param in x if isinstance(param, ParameterExpression)]
+        theta_names = [param.name for param in theta if isinstance(param, ParameterExpression)]
+        if any(x_name in theta_names for x_name in x_names):
+            raise AquaError('Variational form and feature map are not allowed to share parameters '
+                            'with the same name!')
+
         qr = QuantumRegister(self._num_qubits, name='q')
         cr = ClassicalRegister(self._num_qubits, name='c')
         qc = QuantumCircuit(qr, cr)
-        qc += self._feature_map.construct_circuit(x, qr)
-        qc += self._var_form.construct_circuit(theta, qr)
+
+        if isinstance(self.feature_map, QuantumCircuit):
+            param_dict = dict(zip(self._feature_map_params, x))
+            circuit = self._feature_map.assign_parameters(param_dict, inplace=False)
+            qc.append(circuit.to_instruction(), qr)
+        else:
+            qc += self._feature_map.construct_circuit(x, qr)
+
+        if isinstance(self.var_form, QuantumCircuit):
+            param_dict = dict(zip(self._var_form_params, theta))
+            circuit = self._var_form.assign_parameters(param_dict, inplace=False)
+            qc.append(circuit.to_instruction(), qr)
+        else:
+            qc += self._var_form.construct_circuit(theta, qr)
 
         if measurement:
             qc.barrier(qr)
             qc.measure(qr, cr)
         return qc
 
     def _get_prediction(self, data, theta):
-        """
-        Make prediction on data based on each theta.
+        """Make prediction on data based on each theta.
 
         Args:
             data (numpy.ndarray): 2-D array, NxD, N data points, each with D dimension
             theta (list[numpy.ndarray]): list of 1-D array, parameters sets for variational form
+
         Returns:
             Union(numpy.ndarray or [numpy.ndarray], numpy.ndarray or [numpy.ndarray]):
                 list of NxK array, list of Nx1 array
@@ -165,10 +198,12 @@ def _get_prediction(self, data, theta):
         theta_sets = np.split(theta, num_theta_sets)
 
         def _build_parameterized_circuits():
-            if self._var_form.support_parameterized_circuit and \
-                    self._feature_map.support_parameterized_circuit and \
-                    self._parameterized_circuits is None:
+            var_form_support = isinstance(self._var_form, QuantumCircuit) \
+                or self._var_form.support_parameterized_circuit
+            feat_map_support = isinstance(self._feature_map, QuantumCircuit) \
+                or self._feature_map.support_parameterized_circuit
 
+            if var_form_support and feat_map_support and self._parameterized_circuits is None:
                 parameterized_circuits = self.construct_circuit(
                     self._feature_map_params, self._var_form_params,
                     measurement=not self._quantum_instance.is_statevector)
@@ -179,9 +214,9 @@ def _build_parameterized_circuits():
         for thet in theta_sets:
             for datum in data:
                 if self._parameterized_circuits is not None:
-                    curr_params = {self._feature_map_params: datum,
-                                   self._var_form_params: thet}
-                    circuit = self._parameterized_circuits.bind_parameters(curr_params)
+                    curr_params = dict(zip(self._feature_map_params, datum))
+                    curr_params.update(dict(zip(self._var_form_params, thet)))
+                    circuit = self._parameterized_circuits.assign_parameters(curr_params)
                 else:
                     circuit = self.construct_circuit(
                         datum, thet, measurement=not self._quantum_instance.is_statevector)
@@ -302,8 +337,10 @@ def train(self, data, labels, quantum_instance=None, minibatch_size=-1):
     # temporary fix: this code should be unified with the gradient api in optimizer.py
     def _gradient_function_wrapper(self, theta):
         """Compute and return the gradient at the point theta.
+
         Args:
             theta (numpy.ndarray): 1-d array
+
         Returns:
             numpy.ndarray: 1-d array with the same shape as theta. The  gradient computed
         """
@@ -352,6 +389,7 @@ def test(self, data, labels, quantum_instance=None, minibatch_size=-1, params=No
             quantum_instance (QuantumInstance): quantum backend with all setting
             minibatch_size (int): the size of each minibatched accuracy evaluation
             params (list): list of parameters to populate in the variational form
+
         Returns:
             float: classification accuracy
         """
@@ -391,6 +429,7 @@ def predict(self, data, quantum_instance=None, minibatch_size=-1, params=None):
             quantum_instance (QuantumInstance): quantum backend with all setting
             minibatch_size (int): the size of each minibatched accuracy evaluation
             params (list): list of parameters to populate in the variational form
+
         Returns:
             list: for each data point, generates the predicted probability for each class
             list: for each data point, generates the predicted label (that with the highest prob)
@@ -445,6 +484,9 @@ def get_optimal_circuit(self):
         if 'opt_params' not in self._ret:
             raise AquaError("Cannot find optimal circuit before running "
                             "the algorithm to find optimal params.")
+        if isinstance(self._var_form, QuantumCircuit):
+            param_dict = dict(zip(self._var_form_params, self._ret['opt_params']))
+            return self._var_form.assign_parameters(param_dict)
         return self._var_form.construct_circuit(self._ret['opt_params'])
 
     def get_optimal_vector(self):
@@ -469,6 +511,44 @@ def get_optimal_vector(self):
             self._ret['min_vector'] = ret.get_counts(qc)
         return self._ret['min_vector']
 
+    @property
+    def feature_map(self) -> Optional[Union[FeatureMap, QuantumCircuit]]:
+        """Return the feature map."""
+        return self._feature_map
+
+    @feature_map.setter
+    def feature_map(self, feature_map: Union[FeatureMap, QuantumCircuit]):
+        """Set the feature map.
+
+        Also sets the number of qubits, the internally stored feature map parameters and,
+        if the feature map is a circuit, the order of the parameters.
+        """
+        if isinstance(feature_map, QuantumCircuit):
+            # patch the feature dimension to the circuit
+            feature_map.feature_dimension = len(feature_map.parameters)
+
+            # store the parameters
+            self._num_qubits = feature_map.num_qubits
+            self._feature_map_params = list(feature_map.parameters)
+            self._feature_map = feature_map
+        elif isinstance(feature_map, FeatureMap):
+            warnings.warn('The qiskit.aqua.components.feature_maps.FeatureMap object is deprecated '
+                          'as of 0.7.0 and will be removed no earlier than 3 months after the '
+                          'release. You should pass a QuantumCircuit object instead. '
+                          'See also qiskit.circuit.library.data_preparation for a collection of '
+                          'suitable circuits.',
+                          DeprecationWarning, stacklevel=2)
+
+            self._num_qubits = feature_map.num_qubits
+            self._feature_map_params = ParameterVector('x', length=feature_map.feature_dimension)
+            self._feature_map = feature_map
+        else:
+            raise ValueError('Unsupported type {} of feature_map.'.format(type(feature_map)))
+
+        if self._feature_map and self._feature_map.feature_dimension == 0:
+            warnings.warn('The feature map has no parameters that can be optimized to represent '
+                          'the data. This will most likely cause the VQC to fail.')
+
     @property
     def optimal_params(self):
         """ returns optimal parameters """
@@ -570,15 +650,18 @@ def assign_label(measured_key, num_classes):
 
 
 def cost_estimate(probs, gt_labels, shots=None):  # pylint: disable=unused-argument
-    """Calculate cross entropy
-    # shots is kept since it may be needed in future.
+    """Calculate cross entropy.
 
     Args:
         shots (int): the number of shots used in quantum computing
         probs (numpy.ndarray): NxK array, N is the number of data and K is the number of class
         gt_labels (numpy.ndarray): Nx1 array
+
     Returns:
         float: cross entropy loss between estimated probs and gt_labels
+
+    Note:
+        shots is kept since it may be needed in future.
     """
     mylabels = np.zeros(probs.shape)
     for i in range(gt_labels.shape[0]):
@@ -603,6 +686,7 @@ def cost_estimate_sigmoid(shots, probs, gt_labels):
         shots (int): the number of shots used in quantum computing
         probs (numpy.ndarray): NxK array, N is the number of data and K is the number of class
         gt_labels (numpy.ndarray): Nx1 array
+
     Returns:
         float: sigmoid cross entropy loss between estimated probs and gt_labels
     """
@@ -619,6 +703,7 @@ def return_probabilities(counts, num_classes):
     Args:
         counts (list[dict]): N data and each with a dict recording the counts
         num_classes (int): number of classes
+
     Returns:
         numpy.ndarray: NxK array
     """