From 06f482079d430a9419734f607b72d518a6dd29a8 Mon Sep 17 00:00:00 2001 From: Cryoris Date: Tue, 21 Apr 2020 19:05:05 +0200 Subject: [PATCH 1/7] make variational UMs accept circuits --- .../multivariate_variational_distribution.py | 32 +++++++++++------ .../univariate_variational_distribution.py | 34 ++++++++++++------- 2 files changed, 44 insertions(+), 22 deletions(-) diff --git a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py b/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py index aa0397a6a0..c2b7f7b208 100644 --- a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py +++ b/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py @@ -12,7 +12,7 @@ # 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.""" from typing import Optional, List, Union import numpy as np @@ -25,13 +25,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 +47,10 @@ 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) + self.params = params probabilities = np.zeros(2 ** sum(num_qubits)) super().__init__(num_qubits, probabilities, low, high) @@ -56,19 +58,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..f150a825ef 100644 --- a/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py +++ b/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py @@ -12,27 +12,23 @@ # 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.""" 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 +43,11 @@ 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) + self.params = params if isinstance(num_qubits, int): probabilities = np.zeros(2 ** num_qubits) @@ -57,16 +58,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_) From e9c61c1fdf4ab62ee81a1fa2a8492935d48cb839 Mon Sep 17 00:00:00 2001 From: Cryoris Date: Tue, 21 Apr 2020 19:21:37 +0200 Subject: [PATCH 2/7] test circuit variants --- test/aqua/test_qgan.py | 38 ++++++++++++++----- .../test_european_call_expected_value.py | 13 ++++++- 2 files changed, 41 insertions(+), 10 deletions(-) diff --git a/test/aqua/test_qgan.py b/test/aqua/test_qgan.py index 38ffb1b09b..0bb5fcf6a8 100644 --- a/test/aqua/test_qgan.py +++ b/test/aqua/test_qgan.py @@ -11,13 +11,15 @@ # 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 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,8 +30,10 @@ from qiskit import BasicAer +@ddt class TestQGAN(QiskitAquaTestCase): """ Test QGAN """ + def setUp(self): super().setUp() self.seed = 7 @@ -86,14 +90,24 @@ 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]) - def test_sample_generation(self): + 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]) + + @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: + 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,8 +115,14 @@ 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): + @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: + 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) diff --git a/test/finance/test_european_call_expected_value.py b/test/finance/test_european_call_expected_value.py index 76312738ca..b494f91862 100644 --- a/test/finance/test_european_call_expected_value.py +++ b/test/finance/test_european_call_expected_value.py @@ -15,10 +15,12 @@ """ Test European Call Expected Value uncertainty problem """ from test.finance import QiskitFinanceTestCase +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 +30,7 @@ from qiskit.finance.components.uncertainty_problems import EuropeanCallExpectedValue +@ddt class TestEuropeanCallExpectedValue(QiskitFinanceTestCase): """Tests European Call Expected Value uncertainty problem """ @@ -36,7 +39,8 @@ def setUp(self): self.seed = 457 aqua_globals.random_seed = self.seed - def test_ecev(self): + @data(False, True) + def test_ecev(self, use_circuits): """ European Call Expected Value test """ bounds = np.array([0., 7.]) num_qubits = [3] @@ -54,10 +58,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, From 5cbb3eecaca24df2af17954230a142497ab0e38b Mon Sep 17 00:00:00 2001 From: Cryoris Date: Tue, 21 Apr 2020 22:11:45 +0200 Subject: [PATCH 3/7] add deprecation warnings if varform is passed --- .../multivariate_variational_distribution.py | 8 ++++++++ .../univariate_variational_distribution.py | 8 ++++++++ 2 files changed, 16 insertions(+) diff --git a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py b/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py index c2b7f7b208..c2a878e7fd 100644 --- a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py +++ b/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py @@ -14,6 +14,7 @@ """The Multivariate Variational Distribution.""" +import warnings from typing import Optional, List, Union import numpy as np @@ -50,6 +51,13 @@ def __init__(self, # 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 probabilities = np.zeros(2 ** sum(num_qubits)) diff --git a/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py b/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py index f150a825ef..252581af44 100644 --- a/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py +++ b/qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py @@ -14,6 +14,7 @@ """The Univariate Variational Distribution.""" +import warnings from typing import Union, List import numpy as np @@ -47,6 +48,13 @@ def __init__(self, # 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): From 5513a42b5b8c0c42ef76cef63d55ecac09582b65 Mon Sep 17 00:00:00 2001 From: Cryoris Date: Wed, 22 Apr 2020 15:48:07 +0200 Subject: [PATCH 4/7] fix typo Uni -> Multi --- .../uncertainty_models/multivariate_variational_distribution.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py b/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py index c2a878e7fd..a6722e7069 100644 --- a/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py +++ b/qiskit/aqua/components/uncertainty_models/multivariate_variational_distribution.py @@ -53,7 +53,7 @@ def __init__(self, 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 ' + '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).', From b8b5e6624835b17f6254cb11158e583244192a70 Mon Sep 17 00:00:00 2001 From: Manoel Marques Date: Wed, 22 Apr 2020 10:53:33 -0400 Subject: [PATCH 5/7] fix warning filters --- test/aqua/test_fixed_value_comparator.py | 14 +++++++++---- test/aqua/test_weighted_sum_operator.py | 12 +++++++++--- test/chemistry/test_end2end_with_vqe.py | 25 +++++++++++++----------- test/finance/test_data_providers.py | 2 +- 4 files changed, 34 insertions(+), 19 deletions(-) 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_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 """ From 9009702d7db0b432c0e0bb0843c6915cef286cda Mon Sep 17 00:00:00 2001 From: Cryoris Date: Wed, 22 Apr 2020 22:40:15 +0200 Subject: [PATCH 6/7] filter deprecation warnings on univ. var. dist --- test/aqua/test_qgan.py | 10 ++++++++++ test/finance/test_european_call_expected_value.py | 8 ++++++++ 2 files changed, 18 insertions(+) diff --git a/test/aqua/test_qgan.py b/test/aqua/test_qgan.py index 0bb5fcf6a8..d996db5145 100644 --- a/test/aqua/test_qgan.py +++ b/test/aqua/test_qgan.py @@ -16,6 +16,7 @@ from test.aqua import QiskitAquaTestCase +import warnings import unittest from ddt import ddt, data from qiskit import QuantumCircuit, QuantumRegister @@ -36,6 +37,11 @@ class TestQGAN(QiskitAquaTestCase): def setUp(self): super().setUp() + + # ignore deprecation warnings from the deprecation of VariationalForm as input for + # the univariate variational distribution + warnings.filterwarnings("ignore", category=DeprecationWarning) + self.seed = 7 aqua_globals.random_seed = self.seed # Number training data samples @@ -100,6 +106,10 @@ def setUp(self): low=self._bounds[0], high=self._bounds[1]) + def tearDown(self): + super().tearDown() + warnings.filterwarnings(action="always", category=DeprecationWarning) + @data(False, True) def test_sample_generation(self, use_circuits): """ sample generation test """ diff --git a/test/finance/test_european_call_expected_value.py b/test/finance/test_european_call_expected_value.py index b494f91862..429f3105af 100644 --- a/test/finance/test_european_call_expected_value.py +++ b/test/finance/test_european_call_expected_value.py @@ -15,6 +15,7 @@ """ Test European Call Expected Value uncertainty problem """ from test.finance import QiskitFinanceTestCase +import warnings from ddt import ddt, data import numpy as np @@ -36,9 +37,16 @@ class TestEuropeanCallExpectedValue(QiskitFinanceTestCase): def setUp(self): super().setUp() + # ignore deprecation warnings from the deprecation of VariationalForm as input for + # the univariate variational distribution + warnings.filterwarnings("ignore", category=DeprecationWarning) self.seed = 457 aqua_globals.random_seed = self.seed + 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 """ From 54f109f324f4d84aa3cabdae030d61690594eb49 Mon Sep 17 00:00:00 2001 From: Cryoris Date: Wed, 22 Apr 2020 23:42:35 +0200 Subject: [PATCH 7/7] only filter warnings locally --- test/aqua/test_qgan.py | 16 ++++++++++++---- .../finance/test_european_call_expected_value.py | 11 ++++++++--- 2 files changed, 20 insertions(+), 7 deletions(-) diff --git a/test/aqua/test_qgan.py b/test/aqua/test_qgan.py index d996db5145..3eb92a7407 100644 --- a/test/aqua/test_qgan.py +++ b/test/aqua/test_qgan.py @@ -38,10 +38,6 @@ class TestQGAN(QiskitAquaTestCase): def setUp(self): super().setUp() - # ignore deprecation warnings from the deprecation of VariationalForm as input for - # the univariate variational distribution - warnings.filterwarnings("ignore", category=DeprecationWarning) - self.seed = 7 aqua_globals.random_seed = self.seed # Number training data samples @@ -116,6 +112,9 @@ def test_sample_generation(self, use_circuits): 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 = \ @@ -125,18 +124,27 @@ def test_sample_generation(self, use_circuits): for i, weight_q in enumerate(weights_qasm): self.assertAlmostEqual(weight_q, weights_statevector[i], delta=0.1) + 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/finance/test_european_call_expected_value.py b/test/finance/test_european_call_expected_value.py index 429f3105af..35ac004c2e 100644 --- a/test/finance/test_european_call_expected_value.py +++ b/test/finance/test_european_call_expected_value.py @@ -37,9 +37,6 @@ class TestEuropeanCallExpectedValue(QiskitFinanceTestCase): def setUp(self): super().setUp() - # ignore deprecation warnings from the deprecation of VariationalForm as input for - # the univariate variational distribution - warnings.filterwarnings("ignore", category=DeprecationWarning) self.seed = 457 aqua_globals.random_seed = self.seed @@ -50,6 +47,11 @@ def tearDown(self): @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 = [] @@ -90,3 +92,6 @@ def test_ecev(self, use_circuits): 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)