Uncertainty models using circuits

qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py

@@ -12,8 +12,9 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-""" The Multivariate Variational Distribution. """
+"""The Multivariate Variational Distribution."""
 
+import warnings
 from typing import Optional, List, Union
 import numpy as np
 
@@ -25,13 +26,11 @@
 
 
 class MultivariateVariationalDistribution(MultivariateDistribution):
-    """
-    The Multivariate Variational Distribution.
-    """
+    """The Multivariate Variational Distribution."""
 
     def __init__(self,
                  num_qubits: Union[List[int], np.ndarray],
-                 var_form: VariationalForm,
+                 var_form: Union[QuantumCircuit, VariationalForm],
                  params: Union[List[float], np.ndarray],
                  low: Optional[Union[List[float], np.ndarray]] = None,
                  high: Optional[Union[List[float], np.ndarray]] = None) -> None:
@@ -49,26 +48,47 @@ def __init__(self,
             high = np.ones(len(num_qubits))
         self._num_qubits = num_qubits
         self._var_form = var_form
+        # fix the order of the parameters in the circuit
+        if isinstance(self._var_form, QuantumCircuit):
+            self._var_form_params = list(self._var_form.parameters)
+        else:
+            warnings.warn('The VariationalForm type is deprecated as argument of the '
+                          'MultivariateVariationalDistribution as of 0.7.0 and will be removed no '
+                          'earlier than 3 months after the release. You should pass an object '
+                          'of type QuantumCircuit instead (see qiskit.circuit.library for a '
+                          'collection of suitable objects).',
+                          DeprecationWarning, stacklevel=2)
+
         self.params = params
         probabilities = np.zeros(2 ** sum(num_qubits))
         super().__init__(num_qubits, probabilities, low, high)
         self._var_form = var_form
         self.params = params
 
     def build(self, qc, q, q_ancillas=None, params=None):
-        circuit_var_form = self._var_form.construct_circuit(self.params)
+        if isinstance(self._var_form, QuantumCircuit):
+            param_dict = dict(zip(self._var_form_params, self.params))
+            circuit_var_form = self._var_form.assign_parameters(param_dict)
+        else:
+            circuit_var_form = self._var_form.construct_circuit(self.params)
+
         qc.append(circuit_var_form.to_instruction(), q)
 
     def set_probabilities(self, quantum_instance):
-        """
-        Set Probabilities
+        """Set Probabilities
+
         Args:
             quantum_instance (QuantumInstance): Quantum Instance
         """
         q_ = QuantumRegister(self._num_qubits, name='q')
         qc_ = QuantumCircuit(q_)
-        circuit_var_form = self._var_form.construct_circuit(self.params, q_)
-        qc_ += circuit_var_form
+        if isinstance(self._var_form, QuantumCircuit):
+            param_dict = dict(zip(self._var_form_params, self.params))
+            circuit_var_form = self._var_form.assign_parameters(param_dict)
+        else:
+            circuit_var_form = self._var_form.construct_circuit(self.params)
+
+        qc_.append(circuit_var_form.to_instruction(), qc_.qubits)
 
         if quantum_instance.is_statevector:
             pass

qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py

@@ -12,27 +12,24 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""
-The Univariate Variational Distribution.
-"""
+"""The Univariate Variational Distribution."""
 
+import warnings
 from typing import Union, List
 import numpy as np
 
-from qiskit import ClassicalRegister
+from qiskit import ClassicalRegister, QuantumCircuit
 from qiskit.aqua.components.variational_forms import VariationalForm
 from qiskit.aqua.utils.validation import validate_min
 from .univariate_distribution import UnivariateDistribution
 
 
 class UnivariateVariationalDistribution(UnivariateDistribution):
-    """
-    The Univariate Variational Distribution.
-    """
+    """The Univariate Variational Distribution."""
 
     def __init__(self,
                  num_qubits: int,
-                 var_form: VariationalForm,
+                 var_form: Union[QuantumCircuit, VariationalForm],
                  params: Union[List[float], np.ndarray],
                  low: float = 0,
                  high: float = 1) -> None:
@@ -47,6 +44,18 @@ def __init__(self,
         validate_min('num_qubits', num_qubits, 1)
         self._num_qubits = num_qubits
         self._var_form = var_form
+
+        # fix the order of the parameters in the circuit
+        if isinstance(self._var_form, QuantumCircuit):
+            self._var_form_params = list(self._var_form.parameters)
+        else:
+            warnings.warn('The VariationalForm type is deprecated as argument of the '
+                          'UnivariateVariationalDistribution as of 0.7.0 and will be removed no '
+                          'earlier than 3 months after the release. You should pass an object '
+                          'of type QuantumCircuit instead (see qiskit.circuit.library for a '
+                          'collection of suitable objects).',
+                          DeprecationWarning, stacklevel=2)
+
         self.params = params
         if isinstance(num_qubits, int):
             probabilities = np.zeros(2 ** num_qubits)
@@ -57,16 +66,25 @@ def __init__(self,
         super().__init__(num_qubits, probabilities, low, high)
 
     def build(self, qc, q, q_ancillas=None, params=None):
-        circuit_var_form = self._var_form.construct_circuit(self.params)
+        if isinstance(self._var_form, QuantumCircuit):
+            param_dict = dict(zip(self._var_form_params, self.params))
+            circuit_var_form = self._var_form.assign_parameters(param_dict)
+        else:
+            circuit_var_form = self._var_form.construct_circuit(self.params)
+
         qc.append(circuit_var_form.to_instruction(), q)
 
     def set_probabilities(self, quantum_instance):
-        """
-        Set Probabilities
+        """Set Probabilities
+
         Args:
             quantum_instance (QuantumInstance): Quantum instance
         """
-        qc_ = self._var_form.construct_circuit(self.params)
+        if isinstance(self._var_form, QuantumCircuit):
+            param_dict = dict(zip(self._var_form_params, self.params))
+            qc_ = self._var_form.assign_parameters(param_dict)
+        else:
+            qc_ = self._var_form.construct_circuit(self.params)
 
         # q_ = QuantumRegister(self._num_qubits)
         # qc_ = QuantumCircuit(q_)

test/aqua/test_fixed_value_comparator.py

@@ -23,13 +23,19 @@
 from qiskit.aqua.circuits import FixedValueComparator as Comparator
 
 
-# ignore deprecation warnings from the change of the circuit factory to circuit library
-warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-
 @ddt
 class TestFixedValueComparator(QiskitAquaTestCase):
     """ Text Fixed Value Comparator """
+
+    def setUp(self):
+        super().setUp()
+        # ignore deprecation warnings from the change of the circuit factory to circuit library
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+    def tearDown(self):
+        super().tearDown()
+        warnings.filterwarnings(action="always", category=DeprecationWarning)
+
     @idata([
         # n, value, geq
         [1, 0, True],

test/aqua/test_qgan.py

@@ -11,13 +11,16 @@
 # 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.
-# =============================================================================
 
 """ Test QGAN """
 
-import unittest
 from test.aqua import QiskitAquaTestCase
+
+import warnings
+import unittest
+from ddt import ddt, data
 from qiskit import QuantumCircuit, QuantumRegister
+from qiskit.circuit import ParameterVector
 from qiskit.aqua.components.uncertainty_models import (UniformDistribution,
                                                        UnivariateVariationalDistribution)
 from qiskit.aqua.components.variational_forms import RY
@@ -28,10 +31,13 @@
 from qiskit import BasicAer
 
 
+@ddt
 class TestQGAN(QiskitAquaTestCase):
     """ Test QGAN """
+
     def setUp(self):
         super().setUp()
+
         self.seed = 7
         aqua_globals.random_seed = self.seed
         # Number training data samples
@@ -86,27 +92,59 @@ def setUp(self):
         # Set generator's initial parameters
         init_params = aqua_globals.random.rand(var_form._num_parameters) * 2 * 1e-2
         # Set generator circuit
-        g_circuit = UnivariateVariationalDistribution(sum(num_qubits), var_form, init_params,
-                                                      low=self._bounds[0],
-                                                      high=self._bounds[1])
-        # Set quantum generator
-        self.qgan.set_generator(generator_circuit=g_circuit)
+        self.g_var_form = UnivariateVariationalDistribution(sum(num_qubits), var_form, init_params,
+                                                            low=self._bounds[0],
+                                                            high=self._bounds[1])
+
+        theta = ParameterVector('θ', var_form.num_parameters)
+        var_form = var_form.construct_circuit(theta)
+        self.g_circuit = UnivariateVariationalDistribution(sum(num_qubits), var_form, init_params,
+                                                           low=self._bounds[0],
+                                                           high=self._bounds[1])
 
-    def test_sample_generation(self):
+    def tearDown(self):
+        super().tearDown()
+        warnings.filterwarnings(action="always", category=DeprecationWarning)
+
+    @data(False, True)
+    def test_sample_generation(self, use_circuits):
         """ sample generation test """
+        if use_circuits:
+            self.qgan.set_generator(generator_circuit=self.g_circuit)
+        else:
+            # ignore deprecation warnings from the deprecation of VariationalForm as input for
+            # the univariate variational distribution
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            self.qgan.set_generator(generator_circuit=self.g_var_form)
+
         _, weights_statevector = \
             self.qgan._generator.get_output(self.qi_statevector, shots=100)
         samples_qasm, weights_qasm = self.qgan._generator.get_output(self.qi_qasm, shots=100)
         samples_qasm, weights_qasm = zip(*sorted(zip(samples_qasm, weights_qasm)))
         for i, weight_q in enumerate(weights_qasm):
             self.assertAlmostEqual(weight_q, weights_statevector[i], delta=0.1)
 
-    def test_qgan_training(self):
+        if not use_circuits:
+            warnings.filterwarnings(action="always", category=DeprecationWarning)
+
+    @data(False, True)
+    def test_qgan_training(self, use_circuits):
         """ qgan training test """
+        if use_circuits:
+            self.qgan.set_generator(generator_circuit=self.g_circuit)
+        else:
+            # ignore deprecation warnings from the deprecation of VariationalForm as input for
+            # the univariate variational distribution
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            self.qgan.set_generator(generator_circuit=self.g_var_form)
+
         trained_statevector = self.qgan.run(self.qi_statevector)
         trained_qasm = self.qgan.run(self.qi_qasm)
         self.assertAlmostEqual(trained_qasm['rel_entr'], trained_statevector['rel_entr'], delta=0.1)
 
+        if not use_circuits:
+            warnings.filterwarnings(action="always", category=DeprecationWarning)
+
     def test_qgan_training_run_algo_torch(self):
         """ qgan training run algo torch test """
         try:

test/aqua/test_weighted_sum_operator.py

@@ -26,14 +26,20 @@
 from qiskit import QuantumRegister, QuantumCircuit, BasicAer, execute
 from qiskit.aqua.circuits import WeightedSumOperator
 
-# ignore deprecation warnings from the change of the circuit factory to circuit library
-warnings.filterwarnings("ignore", category=DeprecationWarning)
-
 
 @ddt
 class TestWeightedSumOperator(QiskitAquaTestCase):
     """ weighted sum operator test """
 
+    def setUp(self):
+        super().setUp()
+        # ignore deprecation warnings from the change of the circuit factory to circuit library
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+    def tearDown(self):
+        super().tearDown()
+        warnings.filterwarnings(action="always", category=DeprecationWarning)
+
     @idata([
         # n, weights, x, sum
         [1, [1], [0], 0],

test/chemistry/test_end2end_with_vqe.py

@@ -70,17 +70,20 @@ def test_end2end_h2(self, name, optimizer, backend, shots):
 
     def test_deprecated_algo_result(self):
         """ Test processing a deprecated dictionary result from algorithm """
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full')
-        vqe = VQE(self.qubit_op, ryrz, COBYLA(), aux_operators=self.aux_ops)
-        quantum_instance = QuantumInstance(qiskit.BasicAer.get_backend('statevector_simulator'))
-        result = vqe.run(quantum_instance)
-        keys = {'energy', 'energies', 'eigvals', 'eigvecs', 'aux_ops'}
-        dict_res = {key: result[key] for key in keys}
-        lines, result = self.core.process_algorithm_result(dict_res)
-        self.assertAlmostEqual(result['energy'], -1.137306, places=4)
-        self.assertEqual(len(lines), 19)
-        self.assertEqual(lines[8], '  Measured:: Num particles: 2.000, S: 0.000, M: 0.00000')
+        try:
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+            ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full')
+            vqe = VQE(self.qubit_op, ryrz, COBYLA(), aux_operators=self.aux_ops)
+            quantum_instance = QuantumInstance(qiskit.BasicAer.get_backend('statevector_simulator'))
+            result = vqe.run(quantum_instance)
+            keys = {'energy', 'energies', 'eigvals', 'eigvecs', 'aux_ops'}
+            dict_res = {key: result[key] for key in keys}
+            lines, result = self.core.process_algorithm_result(dict_res)
+            self.assertAlmostEqual(result['energy'], -1.137306, places=4)
+            self.assertEqual(len(lines), 19)
+            self.assertEqual(lines[8], '  Measured:: Num particles: 2.000, S: 0.000, M: 0.00000')
+        finally:
+            warnings.filterwarnings("always", category=DeprecationWarning)
 
 
 if __name__ == '__main__':

test/finance/test_data_providers.py

@@ -37,7 +37,7 @@ def setUp(self):
 
     def tearDown(self):
         super().tearDown()
-        warnings.filterwarnings(action="ignore", message="unclosed", category=ResourceWarning)
+        warnings.filterwarnings(action="always", message="unclosed", category=ResourceWarning)
 
     def test_wrong_use(self):
         """ wrong use test """