diff --git a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py b/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py index aa0397a6a0..a6722e7069 100644 --- a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py +++ b/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,6 +48,17 @@ 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) @@ -56,19 +66,29 @@ def __init__(self, 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 diff --git a/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py b/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py index 13a42dbf22..252581af44 100644 --- a/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py +++ b/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_) diff --git a/test/aqua/test_fixed_value_comparator.py b/test/aqua/test_fixed_value_comparator.py index c2c113a2b2..49086caf15 100644 --- a/test/aqua/test_fixed_value_comparator.py +++ b/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], diff --git a/test/aqua/test_qgan.py b/test/aqua/test_qgan.py index 38ffb1b09b..3eb92a7407 100644 --- a/test/aqua/test_qgan.py +++ b/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,14 +92,31 @@ 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) @@ -101,12 +124,27 @@ def test_sample_generation(self): 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: diff --git a/test/aqua/test_weighted_sum_operator.py b/test/aqua/test_weighted_sum_operator.py index 6f8ac6be9a..5a71a863d0 100644 --- a/test/aqua/test_weighted_sum_operator.py +++ b/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], diff --git a/test/chemistry/test_end2end_with_vqe.py b/test/chemistry/test_end2end_with_vqe.py index 2f7a854b88..4f85753d10 100644 --- a/test/chemistry/test_end2end_with_vqe.py +++ b/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__': diff --git a/test/finance/test_data_providers.py b/test/finance/test_data_providers.py index 2097f91f8d..08a1625663 100644 --- a/test/finance/test_data_providers.py +++ b/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 """ diff --git a/test/finance/test_european_call_expected_value.py b/test/finance/test_european_call_expected_value.py index 76312738ca..35ac004c2e 100644 --- a/test/finance/test_european_call_expected_value.py +++ b/test/finance/test_european_call_expected_value.py @@ -15,10 +15,13 @@ """ Test European Call Expected Value uncertainty problem """ from test.finance import QiskitFinanceTestCase +import warnings +from ddt import ddt, data import numpy as np from qiskit import BasicAer +from qiskit.circuit import ParameterVector from qiskit.aqua import aqua_globals, QuantumInstance from qiskit.aqua.algorithms import AmplitudeEstimation from qiskit.aqua.components.initial_states import Custom @@ -28,6 +31,7 @@ from qiskit.finance.components.uncertainty_problems import EuropeanCallExpectedValue +@ddt class TestEuropeanCallExpectedValue(QiskitFinanceTestCase): """Tests European Call Expected Value uncertainty problem """ @@ -36,8 +40,18 @@ def setUp(self): self.seed = 457 aqua_globals.random_seed = self.seed - def test_ecev(self): + def tearDown(self): + super().tearDown() + warnings.filterwarnings(action="always", category=DeprecationWarning) + + @data(False, True) + def test_ecev(self, use_circuits): """ European Call Expected Value test """ + if not use_circuits: + # ignore deprecation warnings from the deprecation of VariationalForm as input for + # the univariate variational distribution + warnings.filterwarnings("ignore", category=DeprecationWarning) + bounds = np.array([0., 7.]) num_qubits = [3] entangler_map = [] @@ -54,10 +68,17 @@ def test_ecev(self): var_form = RY(int(np.sum(num_qubits)), depth=1, initial_state=init_distribution, entangler_map=entangler_map, entanglement_gate='cz') + if use_circuits: + theta = ParameterVector('θ', var_form.num_parameters) + var_form = var_form.construct_circuit(theta) + uncertainty_model = UnivariateVariationalDistribution( int(sum(num_qubits)), var_form, g_params, low=bounds[0], high=bounds[1]) + if use_circuits: + uncertainty_model._var_form_params = theta + strike_price = 2 c_approx = 0.25 european_call = EuropeanCallExpectedValue(uncertainty_model, @@ -71,3 +92,6 @@ def test_ecev(self): result = algo.run(quantum_instance=BasicAer.get_backend('statevector_simulator')) self.assertAlmostEqual(result['estimation'], 1.2580, places=4) self.assertAlmostEqual(result['max_probability'], 0.8785, places=4) + + if not use_circuits: + warnings.filterwarnings(action="always", category=DeprecationWarning)