diff --git a/.pylintdict b/.pylintdict index 7f1bd9d668..b744736dfd 100644 --- a/.pylintdict +++ b/.pylintdict @@ -8,6 +8,7 @@ ae aer Aer's aerjob +Äquivalenzverbot aij al algo @@ -688,6 +689,7 @@ trotterized trotterizing trunc ub +Über ucc uccd UCCS @@ -753,8 +755,6 @@ zmatrix zv ZZ zzz -äguivalenzverbot -über ucc uccd UCCS @@ -763,5 +763,6 @@ versioning vir Watrous's wf +vir Ze -vir \ No newline at end of file +Zoufal \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 0b39515c79..ec99b9ab8e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -105,6 +105,8 @@ Removed - arithmetic circuits in qiskit/aqua/circuits (#895) - boolean logic gates (#896) - quantum Fourier transformation (#909) + - the RY, RYRZ and SwapRZ variational forms (#920) + - the PauliExpansion, First- and SecondOrderExpansion feature maps (#920) Fixed ----- diff --git a/README.md b/README.md index 7b50d9c0cc..a1bfb730fa 100644 --- a/README.md +++ b/README.md @@ -219,8 +219,8 @@ from qiskit.chemistry.components.initial_states import HartreeFock init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles) # setup the variational form for VQE -from qiskit.aqua.components.variational_forms import RYRZ -var_form = RYRZ(num_qubits, initial_state=init_state) +from qiskit.circuit.library import TwoLocal +var_form = TwoLocal(num_qubits, ['ry', 'rz'], 'cz', initial_state=init_state) # setup and run VQE from qiskit.aqua.algorithms import VQE diff --git a/qiskit/aqua/algorithms/classifiers/qsvm/qsvm.py b/qiskit/aqua/algorithms/classifiers/qsvm/qsvm.py index bf7e72aefb..7d82342dfd 100644 --- a/qiskit/aqua/algorithms/classifiers/qsvm/qsvm.py +++ b/qiskit/aqua/algorithms/classifiers/qsvm/qsvm.py @@ -15,6 +15,7 @@ """The Quantum SVM algorithm.""" from typing import Dict, Optional, Union +import warnings import logging import sys @@ -29,7 +30,7 @@ from qiskit.aqua import AquaError from qiskit.aqua.utils.dataset_helper import get_num_classes from qiskit.aqua.utils import split_dataset_to_data_and_labels -from qiskit.aqua.components.feature_maps import FeatureMap +from qiskit.aqua.components.feature_maps import FeatureMap, RawFeatureVector from qiskit.aqua.components.multiclass_extensions import MulticlassExtension from ._qsvm_estimator import _QSVM_Estimator from ._qsvm_binary import _QSVM_Binary @@ -129,6 +130,14 @@ def __init__(self, feature_map: Union[QuantumCircuit, FeatureMap], 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: + if not isinstance(feature_map, RawFeatureVector): + warnings.warn(""" + The {} object as input for the QSVM 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.""".format(type(feature_map)), + DeprecationWarning, stacklevel=2) self.feature_map_params_x = ParameterVector('x', feature_map.feature_dimension) self.feature_map_params_y = ParameterVector('y', feature_map.feature_dimension) diff --git a/qiskit/aqua/algorithms/classifiers/vqc.py b/qiskit/aqua/algorithms/classifiers/vqc.py index aaac89af58..91e53af4a9 100644 --- a/qiskit/aqua/algorithms/classifiers/vqc.py +++ b/qiskit/aqua/algorithms/classifiers/vqc.py @@ -30,7 +30,7 @@ from qiskit.aqua.utils import split_dataset_to_data_and_labels from qiskit.aqua.algorithms import VQAlgorithm from qiskit.aqua.components.optimizers import Optimizer -from qiskit.aqua.components.feature_maps import FeatureMap +from qiskit.aqua.components.feature_maps import FeatureMap, RawFeatureVector from qiskit.aqua.components.variational_forms import VariationalForm logger = logging.getLogger(__name__) @@ -85,12 +85,12 @@ def __init__( # 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.', + warnings.warn(""" + The {} 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.""".format(type(feature_map)), DeprecationWarning, stacklevel=2) super().__init__( @@ -532,12 +532,14 @@ def feature_map(self, feature_map: Union[FeatureMap, QuantumCircuit]): 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) + # raw feature vector is not yet replaced + if not isinstance(feature_map, RawFeatureVector): + 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) diff --git a/qiskit/aqua/algorithms/distribution_learners/qgan.py b/qiskit/aqua/algorithms/distribution_learners/qgan.py index d76a0d3bd0..f9c018d8f9 100644 --- a/qiskit/aqua/algorithms/distribution_learners/qgan.py +++ b/qiskit/aqua/algorithms/distribution_learners/qgan.py @@ -12,11 +12,7 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -""" -Quantum Generative Adversarial Network. -`Quantum Generative Adversarial Networks for learning and loading random distributions - `_ -""" +"""Quantum Generative Adversarial Network.""" from typing import Optional, Union import csv @@ -26,6 +22,7 @@ import numpy as np from scipy.stats import entropy +from qiskit.circuit import QuantumCircuit from qiskit.providers import BaseBackend from qiskit.aqua import QuantumInstance, AquaError, aqua_globals from qiskit.aqua.algorithms import QuantumAlgorithm @@ -33,6 +30,9 @@ from qiskit.aqua.components.neural_networks.generative_network import GenerativeNetwork from qiskit.aqua.components.neural_networks.quantum_generator import QuantumGenerator from qiskit.aqua.components.neural_networks.numpy_discriminator import NumPyDiscriminator +from qiskit.aqua.components.optimizers import Optimizer +from qiskit.aqua.components.uncertainty_models import UnivariateVariationalDistribution +from qiskit.aqua.components.uncertainty_models import MultivariateVariationalDistribution from qiskit.aqua.utils.dataset_helper import discretize_and_truncate from qiskit.aqua.utils.validation import validate_min @@ -42,11 +42,9 @@ class QGAN(QuantumAlgorithm): - """ - The Quantum Generative Adversarial Network algorithm. + """The Quantum Generative Adversarial Network algorithm. - `qGAN `__ is a hybrid quantum-classical algorithm used - for generative modeling tasks. + The qGAN [1] is a hybrid quantum-classical algorithm used for generative modeling tasks. This adaptive algorithm uses the interplay of a generative :class:`~qiskit.aqua.components.neural_networks.GenerativeNetwork` and a @@ -59,6 +57,12 @@ class QGAN(QuantumAlgorithm): samples. Eventually, the quantum generator learns the training data's underlying probability distribution. The trained quantum generator loads a quantum state which is a model of the target distribution. + + **References:** + + [1] Zoufal et al., + `Quantum Generative Adversarial Networks for learning and loading random distributions + `_ """ def __init__(self, data: np.ndarray, bounds: Optional[np.ndarray] = None, @@ -188,16 +192,19 @@ def generator(self): return self._generator # pylint: disable=unused-argument - def set_generator(self, generator_circuit=None, - generator_init_params=None, generator_optimizer=None): - """ - Initialize generator. + def set_generator(self, generator_circuit: Optional[Union[QuantumCircuit, + UnivariateVariationalDistribution, + MultivariateVariationalDistribution] + ] = None, + generator_init_params: Optional[np.ndarray] = None, + generator_optimizer: Optional[Optimizer] = None): + """Initialize generator. Args: - generator_circuit (VariationalForm): parameterized quantum circuit which sets + generator_circuit: parameterized quantum circuit which sets the structure of the quantum generator - generator_init_params(numpy.ndarray): initial parameters for the generator circuit - generator_optimizer (Optimizer): optimizer to be used for the training of the generator + generator_init_params: initial parameters for the generator circuit + generator_optimizer: optimizer to be used for the training of the generator """ self._generator = QuantumGenerator(self._bounds, self._num_qubits, generator_circuit, generator_init_params, diff --git a/qiskit/aqua/algorithms/minimum_eigen_solvers/vqe.py b/qiskit/aqua/algorithms/minimum_eigen_solvers/vqe.py index 46a9a0a404..ea37cd3cb6 100755 --- a/qiskit/aqua/algorithms/minimum_eigen_solvers/vqe.py +++ b/qiskit/aqua/algorithms/minimum_eigen_solvers/vqe.py @@ -25,13 +25,14 @@ from qiskit import ClassicalRegister, QuantumCircuit from qiskit.circuit import Parameter +from qiskit.circuit.library import RealAmplitudes from qiskit.providers import BaseBackend from qiskit.aqua import QuantumInstance, AquaError from qiskit.aqua.algorithms import QuantumAlgorithm from qiskit.aqua.operators import (OperatorBase, ExpectationBase, ExpectationFactory, StateFn, CircuitStateFn, LegacyBaseOperator, ListOp, I, CircuitSampler) from qiskit.aqua.components.optimizers import Optimizer, SLSQP -from qiskit.aqua.components.variational_forms import VariationalForm, RY +from qiskit.aqua.components.variational_forms import VariationalForm from qiskit.aqua.utils.validation import validate_min from ..vq_algorithm import VQAlgorithm, VQResult from .minimum_eigen_solver import MinimumEigensolver, MinimumEigensolverResult @@ -117,10 +118,8 @@ def __init__(self, """ validate_min('max_evals_grouped', max_evals_grouped, 1) if var_form is None: - # TODO after ansatz refactor num qubits can be set later so we do not have to have - # an operator to create a default if operator is not None: - var_form = RY(operator.num_qubits) + var_form = RealAmplitudes() if optimizer is None: optimizer = SLSQP() @@ -227,6 +226,7 @@ def _check_operator_varform(self): # try to set the number of qubits on the variational form, if possible try: self.var_form.num_qubits = self.operator.num_qubits + self._var_form_params = list(self.var_form.parameters) except AttributeError: raise AquaError("The number of qubits of the variational form does not match " "the operator, and the variational form does not allow setting " @@ -311,8 +311,7 @@ def construct_circuit(self, if not self.expectation: self._try_set_expectation_value_from_factory() - observable_meas = self.expectation.convert(StateFn(self.operator, - is_measurement=True)) + observable_meas = self.expectation.convert(StateFn(self.operator, is_measurement=True)) ansatz_circuit_op = CircuitStateFn(wave_function) return observable_meas.compose(ansatz_circuit_op).reduce() @@ -331,6 +330,8 @@ def _run(self) -> 'VQEResult': if self.operator is None: raise AquaError("The operator was never provided.") + self._check_operator_varform() + self._quantum_instance.circuit_summary = True self._eval_count = 0 @@ -345,6 +346,7 @@ def _run(self) -> 'VQEResult': self._ret['min_val'] = vqresult.optimal_value self._ret['opt_params'] = vqresult.optimal_point self._ret['eval_time'] = vqresult.optimizer_time + self._ret['opt_params_dict'] = vqresult.optimal_parameters if self._ret['num_optimizer_evals'] is not None and \ self._eval_count >= self._ret['num_optimizer_evals']: @@ -396,7 +398,6 @@ def compute_minimum_eigenvalue( super().compute_minimum_eigenvalue(operator, aux_operators) return self._run() - # This is the objective function to be passed to the optimizer that is used for evaluation def _energy_evaluation(self, parameters: Union[List[float], np.ndarray] ) -> Union[float, List[float]]: """Evaluate energy at given parameters for the variational form. @@ -408,11 +409,18 @@ def _energy_evaluation(self, parameters: Union[List[float], np.ndarray] Returns: Energy of the hamiltonian of each parameter. + + + Raises: + RuntimeError: If the variational form has no parameters. """ if not self._expect_op: self._expect_op = self.construct_circuit(self._var_form_params) num_parameters = self.var_form.num_parameters + if self._var_form.num_parameters == 0: + raise RuntimeError('The var_form cannot have 0 parameters.') + parameter_sets = np.reshape(parameters, (-1, num_parameters)) # Create dict associating each parameter with the lists of parameterization values for it param_bindings = dict(zip(self._var_form_params, parameter_sets.transpose().tolist())) @@ -448,10 +456,9 @@ def get_optimal_circuit(self) -> QuantumCircuit: 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']) + if isinstance(self.var_form, VariationalForm): + return self._var_form.construct_circuit(self._ret['opt_params']) + return self.var_form.assign_parameters(self._ret['opt_params_dict']) def get_optimal_vector(self) -> Union[List[float], Dict[str, int]]: """Get the simulation outcome of the optimal circuit. """ diff --git a/qiskit/aqua/algorithms/vq_algorithm.py b/qiskit/aqua/algorithms/vq_algorithm.py index f74938a163..8bd5e30cf4 100644 --- a/qiskit/aqua/algorithms/vq_algorithm.py +++ b/qiskit/aqua/algorithms/vq_algorithm.py @@ -31,7 +31,7 @@ from qiskit.circuit import QuantumCircuit, ParameterVector from qiskit.providers import BaseBackend -from qiskit.aqua import QuantumInstance, AquaError +from qiskit.aqua import QuantumInstance from qiskit.aqua.algorithms import AlgorithmResult, QuantumAlgorithm from qiskit.aqua.components.optimizers import Optimizer, SLSQP from qiskit.aqua.components.variational_forms import VariationalForm @@ -73,6 +73,7 @@ def __init__(self, self._cost_fn = cost_fn self._initial_point = initial_point self._var_form = var_form + self._var_form_params = None if var_form is not None: self.var_form = var_form @@ -97,12 +98,7 @@ def var_form(self, var_form: Optional[Union[QuantumCircuit, VariationalForm]]): self._var_form_params = None self._var_form = var_form else: - raise ValueError( - "Unsupported type '{}' of var_form".format( - type(var_form) if var_form else var_form)) - - if var_form is not None and len(self._var_form_params) == 0: - raise AquaError('Passing a variational form with no parameters is not supported.') + raise ValueError('Unsupported type "{}" of var_form'.format(type(var_form))) @property def optimizer(self) -> Optional[Optimizer]: @@ -164,7 +160,7 @@ def find_minimum(self, nparms = var_form.num_parameters - if hasattr(var_form, 'parameter_bounds'): + if hasattr(var_form, 'parameter_bounds') and var_form.parameter_bounds is not None: bounds = var_form.parameter_bounds else: bounds = [(None, None)] * nparms @@ -210,6 +206,7 @@ def find_minimum(self, result.optimizer_time = eval_time result.optimal_value = opt_val result.optimal_point = opt_params + result.optimal_parameters = dict(zip(self._var_form_params, opt_params)) return result @@ -311,6 +308,16 @@ def optimal_point(self, value: np.ndarray) -> None: """ Sets optimal point """ self.data['optimal_point'] = value + @property + def optimal_parameters(self) -> dict: + """ Returns the optimal parameters in a dictionary """ + return self.get('optimal_parameters') + + @optimal_parameters.setter + def optimal_parameters(self, value: dict) -> None: + """ Sets optimal parameters """ + self.data['optimal_parameters'] = value + def __getitem__(self, key: object) -> object: if key == 'num_optimizer_evals': warnings.warn('num_optimizer_evals deprecated, use optimizer_evals property.', diff --git a/qiskit/aqua/components/feature_maps/feature_map.py b/qiskit/aqua/components/feature_maps/feature_map.py index 40a5d6fbd7..85964bd8a7 100644 --- a/qiskit/aqua/components/feature_maps/feature_map.py +++ b/qiskit/aqua/components/feature_maps/feature_map.py @@ -22,9 +22,7 @@ class FeatureMap(ABC): - - """ - Base class for FeatureMap. + """Base class for FeatureMap. This method should initialize the module and use an exception if a component of the module is not diff --git a/qiskit/aqua/components/feature_maps/first_order_expansion.py b/qiskit/aqua/components/feature_maps/first_order_expansion.py index ae5ece72ae..cfedbb326c 100644 --- a/qiskit/aqua/components/feature_maps/first_order_expansion.py +++ b/qiskit/aqua/components/feature_maps/first_order_expansion.py @@ -11,10 +11,10 @@ # 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. -""" -First Order Expansion feature map. -""" +"""First Order Expansion feature map.""" + +import warnings from typing import Callable import numpy as np from qiskit.aqua.utils.validation import validate_min @@ -23,8 +23,7 @@ class FirstOrderExpansion(PauliZExpansion): - """ - First Order Expansion feature map. + """DEPRECATED. First Order Expansion feature map. This is a sub-class of :class:`PauliZExpansion` where *z_order* is fixed at 1. As a result the first order expansion will be a feature map without entangling gates. @@ -41,5 +40,10 @@ def __init__(self, data_map_func: A mapping function for data x which can be supplied to override the default mapping from :meth:`self_product`. """ + warnings.warn('The qiskit.aqua.components.feature_maps.FirstOrderExpansion object is ' + 'deprecated as of 0.7.0 and will be removed no sooner than 3 months after ' + 'the release. You should use qiskit.circuit.library.ZFeatureMap instead.', + DeprecationWarning, stacklevel=2) + validate_min('depth', depth, 1) super().__init__(feature_dimension, depth, z_order=1, data_map_func=data_map_func) diff --git a/qiskit/aqua/components/feature_maps/pauli_expansion.py b/qiskit/aqua/components/feature_maps/pauli_expansion.py index 3270aacd49..cbba2e8fd8 100644 --- a/qiskit/aqua/components/feature_maps/pauli_expansion.py +++ b/qiskit/aqua/components/feature_maps/pauli_expansion.py @@ -12,10 +12,9 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -""" -The Pauli Expansion feature map. -""" +"""The Pauli Expansion feature map.""" +import warnings from typing import Optional, Callable, List import itertools import logging @@ -36,8 +35,7 @@ class PauliExpansion(FeatureMap): - r""" - The Pauli Expansion feature map. + r"""DEPRECATED. The Pauli Expansion feature map. Refer to https://arxiv.org/abs/1804.11326 for details. @@ -83,6 +81,11 @@ def __init__(self, data_map_func: A mapping function for data x which can be supplied to override the default mapping from :meth:`self_product`. """ + warnings.warn('The qiskit.aqua.components.feature_maps.PauliExpansion object is ' + 'deprecated as of 0.7.0 and will be removed no sooner than 3 months after ' + 'the release. You should use qiskit.circuit.library.PauliFeatureMap instead.', + DeprecationWarning, stacklevel=2) + paulis = paulis if paulis is not None else ['Z', 'ZZ'] validate_min('depth', depth, 1) validate_in_set('entanglement', entanglement, {'full', 'linear'}) @@ -134,8 +137,7 @@ def _extract_data_for_rotation(self, pauli, x): return x[where_non_i] def construct_circuit(self, x, qr=None, inverse=False): - """ - Construct the second order expansion based on given data. + """Construct the second order expansion based on given data. Args: x (Union(numpy.ndarray, list[Parameter], ParameterVector)): 1-D to-be-transformed data. diff --git a/qiskit/aqua/components/feature_maps/pauli_z_expansion.py b/qiskit/aqua/components/feature_maps/pauli_z_expansion.py index 07e42686ee..9e46b3c4a8 100644 --- a/qiskit/aqua/components/feature_maps/pauli_z_expansion.py +++ b/qiskit/aqua/components/feature_maps/pauli_z_expansion.py @@ -11,10 +11,10 @@ # 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. -""" -The Pauli Z Expansion feature map. -""" +"""The Pauli Z Expansion feature map.""" + +import warnings from typing import Optional, Callable, List import numpy as np from qiskit.aqua.utils.validation import validate_min, validate_in_set @@ -23,8 +23,7 @@ class PauliZExpansion(PauliExpansion): - """ - The Pauli Z Expansion feature map. + """DEPRECATED. The Pauli Z Expansion feature map. This is a sub-class of the general :class:`PauliExpansion` but where the pauli string is fixed to only contain Z and where *paulis* is now created for the superclass as per the given @@ -56,6 +55,12 @@ def __init__(self, data_map_func: A mapping function for data x which can be supplied to override the default mapping from :meth:`self_product`. """ + # extra warning since this class will be removed entirely + warnings.warn('The qiskit.aqua.components.feature_maps.PauliZExpansion class is deprecated ' + 'as of 0.7.0 and will be removed no sooner than 3 months after the release. ' + 'You should use qiskit.circuit.library.PauliFeatureMap instead.', + DeprecationWarning, stacklevel=2) + validate_min('depth', depth, 1) validate_in_set('entanglement', entanglement, {'full', 'linear'}) validate_min('z_order', z_order, 1) diff --git a/qiskit/aqua/components/feature_maps/second_order_expansion.py b/qiskit/aqua/components/feature_maps/second_order_expansion.py index b059998f21..8f705c9cee 100644 --- a/qiskit/aqua/components/feature_maps/second_order_expansion.py +++ b/qiskit/aqua/components/feature_maps/second_order_expansion.py @@ -15,6 +15,7 @@ Second Order Expansion feature map. """ +import warnings from typing import Optional, Callable, List import numpy as np from qiskit.aqua.utils.validation import validate_min, validate_in_set @@ -23,8 +24,7 @@ class SecondOrderExpansion(PauliZExpansion): - """ - Second Order Expansion feature map. + """DEPRECATED. Second Order Expansion feature map. This is a sub-class of :class:`PauliZExpansion` where *z_order* is fixed at 2. """ @@ -49,6 +49,10 @@ def __init__(self, data_map_func: A mapping function for data x which can be supplied to override the default mapping from :meth:`self_product`. """ + warnings.warn('The qiskit.aqua.components.feature_maps.SecondOrderExpansion object is ' + 'deprecated as of 0.7.0 and will be removed no sooner than 3 months after ' + 'the release. You should use qiskit.circuit.library.ZZFeatureMap instead.', + DeprecationWarning, stacklevel=2) validate_min('depth', depth, 1) validate_in_set('entanglement', entanglement, {'full', 'linear'}) super().__init__(feature_dimension, depth, entangler_map, entanglement, diff --git a/qiskit/aqua/components/initial_states/var_form_based.py b/qiskit/aqua/components/initial_states/var_form_based.py index 8bc92b3e78..17670d41f7 100644 --- a/qiskit/aqua/components/initial_states/var_form_based.py +++ b/qiskit/aqua/components/initial_states/var_form_based.py @@ -14,15 +14,16 @@ """The variational form based initial state""" -from typing import Union, List +from typing import Union, List, Dict import numpy as np +from qiskit import QuantumCircuit +from qiskit.circuit import Parameter from qiskit.aqua import AquaError from qiskit.aqua.components.variational_forms import VariationalForm class VarFormBased: - """ - The variational form based initial state. + """The variational form based initial state. This can been useful, say for example, if you have been doing experiments using a :class:`~qiskit.aqua.components.variational_forms.VariationalForm` and have parameters for @@ -37,8 +38,8 @@ class VarFormBased: """ def __init__(self, - var_form: VariationalForm, - params: Union[List[float], np.ndarray]) -> None: + var_form: Union[VariationalForm, QuantumCircuit], + params: Union[List[float], np.ndarray, Dict[Parameter, float]]) -> None: """ Args: var_form: The variational form. @@ -73,6 +74,9 @@ def construct_circuit(self, mode='circuit', register=None): raise RuntimeError('Initial state based on variational ' 'form does not support vector mode.') if mode == 'circuit': - return self._var_form.construct_circuit(self._var_form_params, q=register) + if isinstance(self._var_form, VariationalForm): + return self._var_form.construct_circuit(self._var_form_params, q=register) + return self._var_form.assign_parameters(self._var_form_params) + else: raise AquaError('Mode should be either "vector" or "circuit"') diff --git a/qiskit/aqua/components/neural_networks/quantum_generator.py b/qiskit/aqua/components/neural_networks/quantum_generator.py index 82660e6bd1..86d5e45c35 100644 --- a/qiskit/aqua/components/neural_networks/quantum_generator.py +++ b/qiskit/aqua/components/neural_networks/quantum_generator.py @@ -12,22 +12,20 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -""" -Quantum Generator -""" +"""Quantum Generator.""" from typing import Optional, List, Union from copy import deepcopy import numpy as np from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit +from qiskit.circuit.library import TwoLocal from qiskit.aqua import aqua_globals from qiskit.aqua.components.optimizers import ADAM from qiskit.aqua.components.uncertainty_models import \ UniformDistribution, MultivariateUniformDistribution from qiskit.aqua.components.uncertainty_models import UnivariateVariationalDistribution, \ MultivariateVariationalDistribution -from qiskit.aqua.components.variational_forms import RY from qiskit.aqua import AquaError from qiskit.aqua.components.neural_networks.generative_network import GenerativeNetwork from qiskit.aqua.components.initial_states import Custom @@ -36,8 +34,7 @@ class QuantumGenerator(GenerativeNetwork): - """ - Quantum Generator. + """Quantum Generator. The quantum generator is a parametrized quantum circuit which can be trained with the :class:`~qiskit.aqua.algorithms.QGAN` algorithm @@ -96,9 +93,9 @@ def __init__(self, init_dist.build(qc, q) init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc) # Set variational form - var_form = RY(sum(num_qubits), depth=1, - initial_state=init_distribution, entangler_map=entangler_map, - entanglement_gate='cz') + var_form = TwoLocal(sum(num_qubits), 'ry', 'cz', reps=1, + initial_state=init_distribution, + entanglement=entangler_map) if init_params is None: init_params = aqua_globals.random.rand(var_form.num_parameters) * 2 * 1e-2 # Set generator circuit @@ -111,9 +108,9 @@ def __init__(self, qc = QuantumCircuit(q) init_dist.build(qc, q) init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc) - var_form = RY(sum(num_qubits), depth=1, initial_state=init_distribution, - entangler_map=entangler_map, - entanglement_gate='cz') + var_form = TwoLocal(sum(num_qubits), 'ry', 'cz', reps=1, + initial_state=init_distribution, + entanglement=entangler_map) if init_params is None: init_params = aqua_globals.random.rand(var_form.num_parameters) * 2 * 1e-2 # Set generator circuit @@ -352,10 +349,11 @@ def train(self, quantum_instance=None, shots=None): self._optimizer._maxiter = 1 self._optimizer._t = 0 objective = self._get_objective_function(quantum_instance, self._discriminator) - self.generator_circuit.params, loss, _ = \ - self._optimizer.optimize(num_vars=len(self.generator_circuit.params), - objective_function=objective, - initial_point=self.generator_circuit.params) + self.generator_circuit.params, loss, _ = self._optimizer.optimize( + num_vars=len(self.generator_circuit.params), + objective_function=objective, + initial_point=self.generator_circuit.params + ) self._ret['loss'] = loss self._ret['params'] = self.generator_circuit.params diff --git a/qiskit/aqua/components/variational_forms/ry.py b/qiskit/aqua/components/variational_forms/ry.py index 5c291583ed..13bfe7c3ec 100644 --- a/qiskit/aqua/components/variational_forms/ry.py +++ b/qiskit/aqua/components/variational_forms/ry.py @@ -14,6 +14,7 @@ """Layers of Y rotations followed by entangling gates.""" +import warnings from typing import Optional, List import numpy as np from qiskit import QuantumRegister, QuantumCircuit @@ -23,8 +24,7 @@ class RY(VariationalForm): - r""" - The RY Variational Form. + r"""DEPRECATED. The RY Variational Form. The RY trial wave function is layers of :math:`y` rotations with entanglements. When none of qubits are unentangled to other qubits the number of parameters @@ -91,6 +91,12 @@ def __init__(self, skip_unentangled_qubits: Skip the qubits not in the entangler_map skip_final_ry: Skip the final layer of Y rotations """ + warnings.warn('The qiskit.aqua.components.variational_forms.RY object is deprecated as of ' + '0.7.0 and will be removed no sooner than 3 months after the release. You ' + 'should use qiskit.circuit.library.RealAmplitudes (uses CX entangling) or ' + 'qiskit.circuit.library.TwoLocal instead.', + DeprecationWarning, stacklevel=2) + validate_min('num_qubits', num_qubits, 1) validate_min('depth', depth, 1) validate_in_set('entanglement', entanglement, {'full', 'linear', 'sca'}) @@ -131,8 +137,7 @@ def __init__(self, self._support_parameterized_circuit = True def construct_circuit(self, parameters, q=None): - """ - Construct the variational form, given its parameters. + """Construct the variational form, given its parameters. Args: parameters (Union(numpy.ndarray, list[Parameter], ParameterVector)): circuit parameters. diff --git a/qiskit/aqua/components/variational_forms/ryrz.py b/qiskit/aqua/components/variational_forms/ryrz.py index 701fec02dc..6223630d4a 100644 --- a/qiskit/aqua/components/variational_forms/ryrz.py +++ b/qiskit/aqua/components/variational_forms/ryrz.py @@ -14,6 +14,7 @@ """Layers of Y+Z rotations followed by entangling gates.""" +import warnings from typing import Optional, List import numpy as np from qiskit import QuantumRegister, QuantumCircuit @@ -23,8 +24,7 @@ class RYRZ(VariationalForm): - r""" - The RYRZ Variational Form. + r"""DEPRECATED. The RYRZ Variational Form. The RYRZ trial wave function is layers of :math:`y` plus :math:`z` rotations with entanglements. When none of qubits are unentangled to other qubits, the number of optimizer parameters this @@ -62,6 +62,12 @@ def __init__(self, entanglement_gate: ('cz' | 'cx') skip_unentangled_qubits: Skip the qubits not in the entangler_map """ + warnings.warn('The qiskit.aqua.components.variational_forms.RYRZ object is deprecated as ' + 'of 0.7.0 and will be removed no sooner than 3 months after the release. You ' + 'should use qiskit.circuit.library.EfficientSU2 (uses CX entangling) or ' + 'qiskit.circuit.library.TwoLocal instead.', + DeprecationWarning, stacklevel=2) + validate_min('num_qubits', num_qubits, 1) validate_min('depth', depth, 1) validate_in_set('entanglement', entanglement, {'full', 'linear'}) diff --git a/qiskit/aqua/components/variational_forms/swaprz.py b/qiskit/aqua/components/variational_forms/swaprz.py index 470ac98ecc..e96386eb9a 100644 --- a/qiskit/aqua/components/variational_forms/swaprz.py +++ b/qiskit/aqua/components/variational_forms/swaprz.py @@ -14,6 +14,7 @@ """Layers of Swap+Z rotations followed by entangling gates.""" +import warnings from typing import Optional, List import numpy as np from qiskit import QuantumRegister, QuantumCircuit @@ -23,8 +24,7 @@ class SwapRZ(VariationalForm): - r""" - The SwapRZ Variational Form. + r"""DEPRECATED. The SwapRZ Variational Form. This trial wave function is layers of swap plus :math:`z` rotations with entanglements. It was designed principally to be a particle-preserving variational form for @@ -72,6 +72,11 @@ def __init__(self, initial_state: An initial state object skip_unentangled_qubits: Skip the qubits not in the entangler_map """ + warnings.warn('The qiskit.aqua.components.variational_forms.SwapRZ object is deprecated as ' + 'of 0.7.0 and will be removed no sooner than 3 months after the release. You ' + 'should use the qiskit.circuit.library.ExcitationPreserving object instead.', + DeprecationWarning, stacklevel=2) + validate_min('num_qubits', num_qubits, 1) validate_min('depth', depth, 1) validate_in_set('entanglement', entanglement, {'full', 'linear'}) @@ -100,8 +105,7 @@ def __init__(self, self._support_parameterized_circuit = True def construct_circuit(self, parameters, q=None): - """ - Construct the variational form, given its parameters. + """Construct the variational form, given its parameters. Args: parameters (Union(numpy.ndarray, list[Parameter], ParameterVector)): circuit parameters diff --git a/qiskit/chemistry/algorithms/eigen_solvers/q_eom_vqe.py b/qiskit/chemistry/algorithms/eigen_solvers/q_eom_vqe.py index d8b448ee71..bfb2cf3417 100644 --- a/qiskit/chemistry/algorithms/eigen_solvers/q_eom_vqe.py +++ b/qiskit/chemistry/algorithms/eigen_solvers/q_eom_vqe.py @@ -18,6 +18,7 @@ from typing import Union, List, Optional, Callable import numpy as np +from qiskit.circuit import QuantumCircuit from qiskit.providers import BaseBackend from qiskit.aqua import QuantumInstance from qiskit.aqua.algorithms import VQE @@ -33,7 +34,8 @@ class QEomVQE(VQE): """ QEomVQE algorithm """ - def __init__(self, operator: LegacyBaseOperator, var_form: VariationalForm, + def __init__(self, operator: LegacyBaseOperator, + var_form: Union[QuantumCircuit, VariationalForm], optimizer: Optimizer, num_orbitals: int, num_particles: Union[List[int], int], initial_point: Optional[np.ndarray] = None, @@ -105,7 +107,7 @@ def _run(self): self._quantum_instance.circuit_summary = True opt_params = self._ret['opt_params'] logger.info("opt params:\n%s", opt_params) - wave_fn = self._var_form.construct_circuit(opt_params) + wave_fn = self.get_optimal_circuit() excitation_energies_gap, eom_matrices = self.qeom.calculate_excited_states( wave_fn, quantum_instance=self._quantum_instance) excitation_energies = excitation_energies_gap + self._ret['energy'] diff --git a/qiskit/chemistry/fermionic_operator.py b/qiskit/chemistry/fermionic_operator.py index f9d9162851..6bb820e792 100644 --- a/qiskit/chemistry/fermionic_operator.py +++ b/qiskit/chemistry/fermionic_operator.py @@ -38,7 +38,7 @@ class FermionicOperator: References: - - *E. Wigner and P. Jordan., Über das Paulische Äguivalenzverbot, + - *E. Wigner and P. Jordan., Über das Paulische Äquivalenzverbot, Z. Phys., 47:631 (1928).* - *S. Bravyi and A. Kitaev. Fermionic quantum computation, Ann. of Phys., 298(1):210–226 (2002).* diff --git a/test/aqua/test_optimizer_aqqd.py b/test/aqua/test_optimizer_aqqd.py index e056fba71a..7d9380bf95 100644 --- a/test/aqua/test_optimizer_aqqd.py +++ b/test/aqua/test_optimizer_aqqd.py @@ -17,9 +17,9 @@ from test.aqua import QiskitAquaTestCase from qiskit import BasicAer +from qiskit.circuit.library import RealAmplitudes from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.operators import WeightedPauliOperator -from qiskit.aqua.components.variational_forms import RY from qiskit.aqua.components.optimizers import AQGD from qiskit.aqua.algorithms import VQE @@ -45,9 +45,9 @@ def test_aqgd(self): """ test AQGD optimizer by using it """ result = VQE(self.qubit_op, - RY(self.qubit_op.num_qubits), + RealAmplitudes(), AQGD(momentum=0.0)).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) - self.assertAlmostEqual(result.eigenvalue.real, -1.85727, places=5) + self.assertAlmostEqual(result.eigenvalue.real, -1.857275, places=5) diff --git a/test/aqua/test_optimizer_nft.py b/test/aqua/test_optimizer_nft.py index d9ec5f439b..fb6977a48e 100644 --- a/test/aqua/test_optimizer_nft.py +++ b/test/aqua/test_optimizer_nft.py @@ -16,10 +16,10 @@ from test.aqua import QiskitAquaTestCase from qiskit import BasicAer +from qiskit.circuit.library import RealAmplitudes from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.operators import WeightedPauliOperator -from qiskit.aqua.components.variational_forms import RY from qiskit.aqua.components.optimizers import NFT from qiskit.aqua.algorithms import VQE @@ -45,7 +45,7 @@ def test_nft(self): """ Test NFT optimizer by using it """ result = VQE(self.qubit_op, - RY(self.qubit_op.num_qubits), + RealAmplitudes(), NFT()).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, diff --git a/test/aqua/test_qgan.py b/test/aqua/test_qgan.py index 3eb92a7407..6a28ff1331 100644 --- a/test/aqua/test_qgan.py +++ b/test/aqua/test_qgan.py @@ -20,7 +20,7 @@ import unittest from ddt import ddt, data from qiskit import QuantumCircuit, QuantumRegister -from qiskit.circuit import ParameterVector +from qiskit.circuit.library import RealAmplitudes from qiskit.aqua.components.uncertainty_models import (UniformDistribution, UnivariateVariationalDistribution) from qiskit.aqua.components.variational_forms import RY @@ -83,39 +83,47 @@ def setUp(self): qc = QuantumCircuit(q) init_dist.build(qc, q) init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc) + + # Set generator's initial parameters + init_params = aqua_globals.random.rand(2 * sum(num_qubits)) * 2 * 1e-2 + # Set variational form + warnings.filterwarnings('ignore', category=DeprecationWarning) var_form = RY(sum(num_qubits), depth=1, initial_state=init_distribution, entangler_map=entangler_map, - entanglement_gate='cz') - # Set generator's initial parameters - init_params = aqua_globals.random.rand(var_form._num_parameters) * 2 * 1e-2 - # Set generator 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 tearDown(self): - super().tearDown() - warnings.filterwarnings(action="always", category=DeprecationWarning) - - @data(False, True) - def test_sample_generation(self, use_circuits): + entanglement_gate='cx') + dist_var_form = UnivariateVariationalDistribution(sum(num_qubits), var_form, init_params, + low=self._bounds[0], + high=self._bounds[1]) + warnings.filterwarnings('always', category=DeprecationWarning) + + library = RealAmplitudes(sum(num_qubits), reps=1, initial_state=init_distribution, + entanglement=entangler_map) + dist_library = UnivariateVariationalDistribution(sum(num_qubits), library, init_params, + low=self._bounds[0], + high=self._bounds[1]) + circuit = QuantumCircuit(sum(num_qubits)).compose(library) + dist_circuit = UnivariateVariationalDistribution(sum(num_qubits), circuit, init_params, + low=self._bounds[0], + high=self._bounds[1]) + + self.generator_circuits = {'wrapped': dist_var_form, + 'circuit': dist_circuit, + 'library': dist_library} + + @data('wrapped', 'circuit', 'library') + def test_sample_generation(self, mode): """ sample generation test """ - if use_circuits: - self.qgan.set_generator(generator_circuit=self.g_circuit) - else: + if mode == 'wrapped': # 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) + warnings.filterwarnings('ignore', category=DeprecationWarning) + self.qgan.set_generator(generator_circuit=self.generator_circuits[mode]) + warnings.filterwarnings('always', category=DeprecationWarning) + else: + self.qgan.set_generator(generator_circuit=self.generator_circuits[mode]) _, weights_statevector = \ self.qgan._generator.get_output(self.qi_statevector, shots=100) @@ -124,27 +132,22 @@ 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): + @data('wrapped', 'circuit', 'library') + def test_qgan_training(self, mode): """ qgan training test """ - if use_circuits: - self.qgan.set_generator(generator_circuit=self.g_circuit) - else: + if mode == 'wrapped': # 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) + warnings.filterwarnings('ignore', category=DeprecationWarning) + self.qgan.set_generator(generator_circuit=self.generator_circuits[mode]) + warnings.filterwarnings('always', category=DeprecationWarning) + else: + self.qgan.set_generator(generator_circuit=self.generator_circuits[mode]) 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_qsvm.py b/test/aqua/test_qsvm.py index 3c98b15a3e..58cc651e77 100644 --- a/test/aqua/test_qsvm.py +++ b/test/aqua/test_qsvm.py @@ -15,18 +15,18 @@ """ Test QSVM """ import os +import warnings from test.aqua import QiskitAquaTestCase import numpy as np from ddt import ddt, data -from qiskit import BasicAer -from qiskit.circuit import ParameterVector +from qiskit import BasicAer, QuantumCircuit +from qiskit.circuit.library import ZZFeatureMap from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.components.feature_maps import SecondOrderExpansion from qiskit.aqua.components.multiclass_extensions import (ErrorCorrectingCode, AllPairs, OneAgainstRest) from qiskit.aqua.algorithms import QSVM -from qiskit.aqua.utils import get_feature_dimension @ddt @@ -45,8 +45,28 @@ def setUp(self): self.testing_data = {'A': np.asarray([[3.83274304, 2.45044227]]), 'B': np.asarray([[3.89557489, 0.31415927]])} - @data(False, True) - def test_qsvm_binary(self, use_circuits): + num_qubits = 2 + + warnings.filterwarnings('ignore', category=DeprecationWarning) + # data encoding using a FeatureMap type + feature_map = SecondOrderExpansion(feature_dimension=num_qubits, + depth=2, + entangler_map=[[0, 1]]) + warnings.filterwarnings('always', category=DeprecationWarning) + + # data encoding using a circuit library object + library_circuit = ZZFeatureMap(feature_dimension=num_qubits, reps=2) + + # data encoding using a plain QuantumCircuit + circuit = QuantumCircuit(num_qubits).compose(library_circuit) + circuit.ordered_parameters = library_circuit.ordered_parameters + + self.data_preparation = {'wrapped': feature_map, + 'circuit': circuit, + 'library': library_circuit} + + @data('wrapped', 'circuit', 'library') + def test_qsvm_binary(self, data_preparation_type): """ QSVM Binary test """ ref_kernel_training = np.array([[1., 0.85366667, 0.12341667, 0.36408333], [0.85366667, 1., 0.11141667, 0.45491667], @@ -65,21 +85,17 @@ def test_qsvm_binary(self, use_circuits): [4.08407045, 2.26194671], [4.46106157, 2.38761042]]) backend = BasicAer.get_backend('qasm_simulator') - num_qubits = 2 - feature_map = SecondOrderExpansion(feature_dimension=num_qubits, - depth=2, - entangler_map=[[0, 1]]) - - if use_circuits: - x = ParameterVector('x', num_qubits) - feature_map = feature_map.construct_circuit(x) - feature_map.ordered_parameters = list(x) - - svm = QSVM(feature_map, self.training_data, self.testing_data, None) + data_preparation = self.data_preparation[data_preparation_type] + if data_preparation_type == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + svm = QSVM(data_preparation, self.training_data, self.testing_data, None) + if data_preparation_type == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, shots=self.shots, seed_simulator=self.random_seed, seed_transpiler=self.random_seed) + try: result = svm.run(quantum_instance) np.testing.assert_array_almost_equal( @@ -98,8 +114,8 @@ def test_qsvm_binary(self, use_circuits): except NameError as ex: self.skipTest(str(ex)) - @data(False, True) - def test_qsvm_binary_directly_statevector(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_qsvm_binary_directly_statevector(self, data_preparation_type): """ QSVM Binary Directly Statevector test """ ref_kernel_testing = np. array([[0.1443953, 0.18170069, 0.47479649, 0.14691763], [0.33041779, 0.37663733, 0.02115561, 0.16106199]]) @@ -108,19 +124,15 @@ def test_qsvm_binary_directly_statevector(self, use_circuits): [4.08407045, 2.26194671], [4.46106157, 2.38761042]]) backend = BasicAer.get_backend('statevector_simulator') - num_qubits = 2 - feature_map = SecondOrderExpansion(feature_dimension=num_qubits, - depth=2, - entangler_map=[[0, 1]]) - if use_circuits: - x = ParameterVector('x', num_qubits) - feature_map = feature_map.construct_circuit(x) - feature_map.ordered_parameters = list(x) - - svm = QSVM(feature_map, self.training_data, self.testing_data, None) - + data_preparation = self.data_preparation[data_preparation_type] + if data_preparation_type == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + svm = QSVM(data_preparation, self.training_data, self.testing_data, None) + if data_preparation_type == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, seed_transpiler=self.random_seed, seed_simulator=self.random_seed) + file_path = self.get_resource_path('qsvm_test.npz') try: result = svm.run(quantum_instance) @@ -165,8 +177,8 @@ def test_qsvm_binary_directly_statevector(self, use_circuits): except Exception: # pylint: disable=broad-except pass - @data(False, True) - def test_qsvm_setup_data(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_qsvm_setup_data(self, data_preparation_type): """ QSVM Setup Data test """ ref_kernel_testing = np. array([[0.1443953, 0.18170069, 0.47479649, 0.14691763], [0.33041779, 0.37663733, 0.02115561, 0.16106199]]) @@ -175,17 +187,14 @@ def test_qsvm_setup_data(self, use_circuits): [4.08407045, 2.26194671], [4.46106157, 2.38761042]]) backend = BasicAer.get_backend('statevector_simulator') - num_qubits = 2 - feature_map = SecondOrderExpansion(feature_dimension=num_qubits, - depth=2, - entangler_map=[[0, 1]]) - if use_circuits: - x = ParameterVector('x', num_qubits) - feature_map = feature_map.construct_circuit(x) - feature_map.ordered_parameters = list(x) + data_preparation = self.data_preparation[data_preparation_type] try: - svm = QSVM(feature_map) + if data_preparation_type == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + svm = QSVM(data_preparation) + if data_preparation_type == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) svm.setup_training_data(self.training_data) svm.setup_test_data(self.testing_data) @@ -204,8 +213,8 @@ def test_qsvm_setup_data(self, use_circuits): except NameError as ex: self.skipTest(str(ex)) - @data(False, True) - def test_qsvm_multiclass_one_against_all(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_qsvm_multiclass_one_against_all(self, data_preparation_type): """ QSVM Multiclass One Against All test """ training_input = {'A': np.asarray([[0.6560706, 0.17605998], [0.25776033, 0.47628296], [0.8690704, 0.70847635]]), @@ -224,17 +233,14 @@ def test_qsvm_multiclass_one_against_all(self, use_circuits): total_array = np.concatenate((test_input['A'], test_input['B'], test_input['C'])) aqua_globals.random_seed = self.random_seed - feature_map = SecondOrderExpansion(feature_dimension=get_feature_dimension(training_input), - depth=2, - entangler_map=[[0, 1]]) - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - feature_map.ordered_parameters = list(x) - + data_preparation = self.data_preparation[data_preparation_type] try: - svm = QSVM(feature_map, training_input, test_input, total_array, + if data_preparation_type == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + svm = QSVM(data_preparation, training_input, test_input, total_array, multiclass_extension=OneAgainstRest()) + if data_preparation_type == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=self.shots, seed_simulator=aqua_globals.random_seed, @@ -247,8 +253,8 @@ def test_qsvm_multiclass_one_against_all(self, use_circuits): except NameError as ex: self.skipTest(str(ex)) - @data(False, True) - def test_qsvm_multiclass_all_pairs(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_qsvm_multiclass_all_pairs(self, data_preparation_type): """ QSVM Multiclass All Pairs test """ training_input = {'A': np.asarray([[0.6560706, 0.17605998], [0.25776033, 0.47628296], [0.8690704, 0.70847635]]), @@ -267,17 +273,14 @@ def test_qsvm_multiclass_all_pairs(self, use_circuits): total_array = np.concatenate((test_input['A'], test_input['B'], test_input['C'])) aqua_globals.random_seed = self.random_seed - feature_map = SecondOrderExpansion(feature_dimension=get_feature_dimension(training_input), - depth=2, - entangler_map=[[0, 1]]) - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - feature_map.ordered_parameters = list(x) - + data_preparation = self.data_preparation[data_preparation_type] try: - svm = QSVM(feature_map, training_input, test_input, total_array, + if data_preparation_type == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + svm = QSVM(data_preparation, training_input, test_input, total_array, multiclass_extension=AllPairs()) + if data_preparation_type == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=self.shots, @@ -290,8 +293,8 @@ def test_qsvm_multiclass_all_pairs(self, use_circuits): except NameError as ex: self.skipTest(str(ex)) - @data(False, True) - def test_qsvm_multiclass_error_correcting_code(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_qsvm_multiclass_error_correcting_code(self, data_preparation_type): """ QSVM Multiclass error Correcting Code test """ training_input = {'A': np.asarray([[0.6560706, 0.17605998], [0.25776033, 0.47628296], [0.8690704, 0.70847635]]), @@ -310,17 +313,14 @@ def test_qsvm_multiclass_error_correcting_code(self, use_circuits): total_array = np.concatenate((test_input['A'], test_input['B'], test_input['C'])) aqua_globals.random_seed = self.random_seed - feature_map = SecondOrderExpansion(feature_dimension=get_feature_dimension(training_input), - depth=2, - entangler_map=[[0, 1]]) - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - feature_map.ordered_parameters = list(x) - + data_preparation = self.data_preparation[data_preparation_type] try: - svm = QSVM(feature_map, training_input, test_input, total_array, + if data_preparation_type == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + svm = QSVM(data_preparation, training_input, test_input, total_array, multiclass_extension=ErrorCorrectingCode(code_size=5)) + if data_preparation_type == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=self.shots, diff --git a/test/aqua/test_ry.py b/test/aqua/test_ry.py deleted file mode 100644 index 2ac71d9787..0000000000 --- a/test/aqua/test_ry.py +++ /dev/null @@ -1,69 +0,0 @@ -# -*- coding: utf-8 -*- - -# This code is part of Qiskit. -# -# (C) Copyright IBM 2018, 2020. -# -# 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. - -""" Test RYCRX """ - -import unittest -from test.aqua import QiskitAquaTestCase - -from ddt import ddt, idata, unpack -from qiskit import BasicAer - -from qiskit.aqua import aqua_globals, QuantumInstance -from qiskit.aqua.algorithms import VQE -from qiskit.aqua.components.variational_forms import RY -from qiskit.aqua.components.optimizers import L_BFGS_B -from qiskit.aqua.operators import WeightedPauliOperator - - -@ddt -class TestRYCRX(QiskitAquaTestCase): - """ Test RYCRX """ - - def setUp(self): - super().setUp() - self.seed = 99 - aqua_globals.random_seed = self.seed - pauli_dict = { - 'paulis': [{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"}, - {"coeff": {"imag": 0.0, "real": 0.39793742484318045}, "label": "IZ"}, - {"coeff": {"imag": 0.0, "real": -0.39793742484318045}, "label": "ZI"}, - {"coeff": {"imag": 0.0, "real": -0.01128010425623538}, "label": "ZZ"}, - {"coeff": {"imag": 0.0, "real": 0.18093119978423156}, "label": "XX"} - ] - } - self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict) - - @idata([ - [2, 5], - [3, 5], - [4, 5] - ]) - @unpack - def test_vqe_var_forms(self, depth, places): - """ VQE Var Forms test """ - aqua_globals.random_seed = self.seed - result = VQE(self.qubit_op, - RY(self.qubit_op.num_qubits, - depth=depth, entanglement='sca', - entanglement_gate='crx', skip_final_ry=True), - L_BFGS_B()).run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), - shots=1, - seed_simulator=aqua_globals.random_seed, - seed_transpiler=aqua_globals.random_seed)) - self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places) - - -if __name__ == '__main__': - unittest.main() diff --git a/test/aqua/test_vqc.py b/test/aqua/test_vqc.py index 3fab1b40a6..e9874a596c 100644 --- a/test/aqua/test_vqc.py +++ b/test/aqua/test_vqc.py @@ -16,18 +16,19 @@ import os import unittest +import warnings from test.aqua import QiskitAquaTestCase import numpy as np from ddt import ddt, data from qiskit import BasicAer from qiskit.circuit import ParameterVector, QuantumCircuit, Parameter +from qiskit.circuit.library import TwoLocal, ZZFeatureMap from qiskit.aqua import QuantumInstance, aqua_globals, AquaError from qiskit.aqua.algorithms import VQC from qiskit.aqua.components.optimizers import SPSA, COBYLA from qiskit.aqua.components.feature_maps import SecondOrderExpansion, RawFeatureVector -from qiskit.aqua.components.variational_forms import RYRZ, RY +from qiskit.aqua.components.variational_forms import RYRZ from qiskit.aqua.components.optimizers import L_BFGS_B -from qiskit.aqua.utils import get_feature_dimension from qiskit.ml.datasets import wine, ad_hoc_data @@ -52,30 +53,57 @@ def setUp(self): self.ref_prediction_a_probs = [[0.79882812, 0.20117188]] self.ref_prediction_a_label = [0] - @data(False, True) - def test_vqc(self, use_circuits): + # ignore warnings from creating VariationalForm and FeatureMap objects + warnings.filterwarnings('ignore', category=DeprecationWarning) + var_form_ryrz = RYRZ(2, depth=3) + feature_map = SecondOrderExpansion(2, depth=2) + warnings.filterwarnings('always', category=DeprecationWarning) + + library_ryrz = TwoLocal(2, ['ry', 'rz'], 'cz', reps=3, insert_barriers=True) + theta = ParameterVector('theta', var_form_ryrz.num_parameters) + circuit_ryrz = var_form_ryrz.construct_circuit(theta) + resorted = [] + for i in range(4): + layer = library_ryrz.ordered_parameters[4*i:4*(i+1)] + resorted += layer[::2] + resorted += layer[1::2] + library_ryrz.assign_parameters(dict(zip(resorted, theta)), inplace=True) + self._sorted_wavefunction_params = list(theta) + + self.ryrz_wavefunction = {'wrapped': var_form_ryrz, + 'circuit': circuit_ryrz, + 'library': library_ryrz} + + library_circuit = ZZFeatureMap(2, reps=2) + x = ParameterVector('x', 2) + circuit = feature_map.construct_circuit(x) + self._sorted_data_params = list(x) + library_circuit.assign_parameters(x, inplace=True) + + self.data_preparation = {'wrapped': feature_map, + 'circuit': circuit, + 'library': library_circuit} + + @data('wrapped', 'circuit', 'library') + def test_vqc(self, mode): """ vqc test """ aqua_globals.random_seed = self.seed optimizer = SPSA(max_trials=10, save_steps=1, c0=4.0, c1=0.1, c2=0.602, c3=0.101, c4=0.0, skip_calibration=True) - feature_map = SecondOrderExpansion( - feature_dimension=get_feature_dimension(self.training_data), depth=2) - var_form = RYRZ(num_qubits=feature_map.num_qubits, depth=3) + data_preparation = self.data_preparation[mode] + wavefunction = self.ryrz_wavefunction[mode] - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm - vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data) + vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) - # sort parameters for reproducibility - if use_circuits: - vqc._feature_map_params = list(x) - vqc._var_form_params = list(theta) + if mode in ['circuit', 'library']: + vqc._feature_map_params = self._sorted_data_params + vqc._var_form_params = self._sorted_wavefunction_params + else: + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=1024, @@ -90,31 +118,26 @@ def test_vqc(self, use_circuits): self.assertEqual(1.0, result['testing_accuracy']) - @data(False, True) - def test_vqc_with_max_evals_grouped(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_vqc_with_max_evals_grouped(self, mode): """ vqc with max evals grouped test """ aqua_globals.random_seed = self.seed optimizer = SPSA(max_trials=10, save_steps=1, c0=4.0, c1=0.1, c2=0.602, c3=0.101, c4=0.0, skip_calibration=True) - feature_map = SecondOrderExpansion( - feature_dimension=get_feature_dimension(self.training_data), depth=2) - var_form = RYRZ(num_qubits=feature_map.num_qubits, depth=3) - - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) + data_preparation = self.data_preparation[mode] + wavefunction = self.ryrz_wavefunction[mode] + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm - vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data, + vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data, max_evals_grouped=2) - # sort parameters for reproducibility - if use_circuits: - vqc._feature_map_params = list(x) - vqc._var_form_params = list(theta) + if mode in ['circuit', 'library']: + vqc._feature_map_params = self._sorted_data_params + vqc._var_form_params = self._sorted_wavefunction_params + else: + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'), shots=1024, @@ -128,29 +151,24 @@ def test_vqc_with_max_evals_grouped(self, use_circuits): self.assertEqual(1.0, result['testing_accuracy']) - @data(False, True) - def test_vqc_statevector(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_vqc_statevector(self, mode): """ vqc statevector test """ aqua_globals.random_seed = 10598 optimizer = COBYLA() - feature_map = SecondOrderExpansion( - feature_dimension=get_feature_dimension(self.training_data), depth=2) - var_form = RYRZ(num_qubits=feature_map.num_qubits, depth=3) - - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) + data_preparation = self.data_preparation[mode] + wavefunction = self.ryrz_wavefunction[mode] + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm - vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data) + vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) - # sort parameters for reproducibility - if use_circuits: - vqc._feature_map_params = list(x) - vqc._var_form_params = list(theta) + if mode in ['circuit', 'library']: + vqc._feature_map_params = self._sorted_data_params + vqc._var_form_params = self._sorted_wavefunction_params + else: + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, @@ -162,8 +180,8 @@ def test_vqc_statevector(self, use_circuits): self.assertEqual(result['testing_accuracy'], 0.5) # we use the ad_hoc dataset (see the end of this file) to test the accuracy. - @data(False, True) - def test_vqc_minibatching_no_gradient_support(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_vqc_minibatching_no_gradient_support(self, mode): """ vqc minibatching with no gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 @@ -174,25 +192,22 @@ def test_vqc_minibatching_no_gradient_support(self, use_circuits): gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') - num_qubits = n_dim optimizer = COBYLA(maxiter=40) - feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) - var_form = RYRZ(num_qubits=num_qubits, depth=3) + data_preparation = self.data_preparation[mode] + wavefunction = self.ryrz_wavefunction[mode] - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm - vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) + vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, + minibatch_size=2) - # sort parameters for reproducibility - if use_circuits: - vqc._feature_map_params = list(x) - vqc._var_form_params = list(theta) + if mode in ['circuit', 'library']: + vqc._feature_map_params = self._sorted_data_params + vqc._var_form_params = self._sorted_wavefunction_params + else: + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed, optimization_level=0) @@ -200,8 +215,8 @@ def test_vqc_minibatching_no_gradient_support(self, use_circuits): self.log.debug(result['testing_accuracy']) self.assertGreaterEqual(result['testing_accuracy'], 0.5) - @data(False, True) - def test_vqc_minibatching_with_gradient_support(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_vqc_minibatching_with_gradient_support(self, mode): """ vqc minibatching with gradient support test """ n_dim = 2 # dimension of each data point seed = 1024 @@ -212,25 +227,37 @@ def test_vqc_minibatching_with_gradient_support(self, use_circuits): gap=0.3, plot_data=False) backend = BasicAer.get_backend('statevector_simulator') - num_qubits = n_dim optimizer = L_BFGS_B(maxfun=30) - feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) - var_form = RYRZ(num_qubits=num_qubits, depth=1) - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) + # set up data encoding circuit + data_preparation = self.data_preparation[mode] + + # set up wavefunction + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + wavefunction = RYRZ(2, depth=1) + else: + wavefunction = TwoLocal(2, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) + theta = ParameterVector('theta', wavefunction.num_parameters) + resorted = [] + for i in range(4): + layer = wavefunction.ordered_parameters[4*i:4*(i+1)] + resorted += layer[::2] + resorted += layer[1::2] + wavefunction.assign_parameters(dict(zip(resorted, theta)), inplace=True) + + if mode == 'circuit': + wavefunction = QuantumCircuit(2).compose(wavefunction) # set up algorithm - vqc = VQC(optimizer, feature_map, var_form, training_input, test_input, minibatch_size=2) + vqc = VQC(optimizer, data_preparation, wavefunction, training_input, test_input, + minibatch_size=2) - # sort parameters for reproducibility - if use_circuits: - vqc._feature_map_params = list(x) + if mode in ['circuit', 'library']: + vqc._feature_map_params = self._sorted_data_params vqc._var_form_params = list(theta) + else: + warnings.filterwarnings('always', category=DeprecationWarning) quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed) result = vqc.run(quantum_instance) @@ -238,31 +265,24 @@ def test_vqc_minibatching_with_gradient_support(self, use_circuits): self.log.debug(result['testing_accuracy']) self.assertAlmostEqual(result['testing_accuracy'], vqc_accuracy, places=3) - @data(False, True) - def test_save_and_load_model(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_save_and_load_model(self, mode): """ save and load model test """ aqua_globals.random_seed = self.seed backend = BasicAer.get_backend('qasm_simulator') - num_qubits = 2 optimizer = SPSA(max_trials=10, save_steps=1, c0=4.0, skip_calibration=True) - feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) - var_form = RYRZ(num_qubits=num_qubits, depth=3) - - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) + data_preparation = self.data_preparation[mode] + wavefunction = self.ryrz_wavefunction[mode] + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) # set up algorithm - vqc = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data) + vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data) - # sort parameters for reproducibility - if use_circuits: - vqc._feature_map_params = list(x) - vqc._var_form_params = list(theta) + if mode in ['circuit', 'library']: + vqc._feature_map_params = self._sorted_data_params + vqc._var_form_params = self._sorted_wavefunction_params quantum_instance = QuantumInstance(backend, shots=1024, @@ -282,12 +302,14 @@ def test_save_and_load_model(self, use_circuits): self.assertTrue(os.path.exists(file_path)) - loaded_vqc = VQC(optimizer, feature_map, var_form, self.training_data, None) + loaded_vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, None) # sort parameters for reproducibility - if use_circuits: - loaded_vqc._feature_map_params = list(x) - loaded_vqc._var_form_params = list(theta) + if mode in ['circuit', 'library']: + loaded_vqc._feature_map_params = self._sorted_data_params + loaded_vqc._var_form_params = self._sorted_wavefunction_params + else: + warnings.filterwarnings('always', category=DeprecationWarning) loaded_vqc.load_model(file_path) @@ -312,8 +334,8 @@ def test_save_and_load_model(self, use_circuits): except Exception: # pylint: disable=broad-except pass - @data(False, True) - def test_vqc_callback(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_vqc_callback(self, mode): """ vqc callback test """ history = {'eval_count': [], 'parameters': [], 'cost': [], 'batch_index': []} @@ -326,20 +348,23 @@ def store_intermediate_result(eval_count, parameters, cost, batch_index): aqua_globals.random_seed = self.seed backend = BasicAer.get_backend('qasm_simulator') - num_qubits = 2 optimizer = COBYLA(maxiter=3) - feature_map = SecondOrderExpansion(feature_dimension=num_qubits, depth=2) - var_form = RY(num_qubits=num_qubits, depth=1) - - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) - - vqc = VQC(optimizer, feature_map, var_form, self.training_data, - self.testing_data, callback=store_intermediate_result) + data_preparation = self.data_preparation[mode] + wavefunction = self.ryrz_wavefunction[mode] + + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + + # set up algorithm + vqc = VQC(optimizer, data_preparation, wavefunction, self.training_data, self.testing_data, + callback=store_intermediate_result) + + if mode in ['circuit', 'library']: + vqc._feature_map_params = self._sorted_data_params + vqc._var_form_params = self._sorted_wavefunction_params + else: + warnings.filterwarnings('always', category=DeprecationWarning) + quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=self.seed, @@ -374,8 +399,8 @@ def test_feature_map_without_parameters_warns(self): with self.assertWarns(UserWarning): _ = VQC(optimizer, feature_map, var_form, self.training_data, self.testing_data) - @data(False, True) - def test_vqc_on_wine(self, use_circuits): + @data('wrapped', 'circuit', 'library') + def test_vqc_on_wine(self, mode): """Test VQE on the wine test using circuits as feature map and variational form.""" feature_dim = 4 # dimension of each data point training_dataset_size = 6 @@ -386,26 +411,34 @@ def test_vqc_on_wine(self, use_circuits): n=feature_dim, plot_data=False) aqua_globals.random_seed = self.seed - feature_map = SecondOrderExpansion(feature_dimension=feature_dim) - var_form = RYRZ(feature_map.num_qubits, depth=1) - - # convert to circuit if circuits should be used - if use_circuits: - x = ParameterVector('x', feature_map.feature_dimension) - feature_map = feature_map.construct_circuit(x) - theta = ParameterVector('theta', var_form.num_parameters) - var_form = var_form.construct_circuit(theta) - - vqc = VQC(COBYLA(maxiter=100), - feature_map, - var_form, - training_input, - test_input) + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + data_preparation = SecondOrderExpansion(feature_dim) + wavefunction = RYRZ(feature_dim, depth=1) + else: + data_preparation = ZZFeatureMap(feature_dim) + x = data_preparation.ordered_parameters + wavefunction = TwoLocal(feature_dim, ['ry', 'rz'], 'cz', reps=1, insert_barriers=True) + theta = ParameterVector('theta', wavefunction.num_parameters) + resorted = [] + for i in range(2 * feature_dim): + layer = wavefunction.ordered_parameters[2 * feature_dim * i:2 * feature_dim * (i+1)] + resorted += layer[::2] + resorted += layer[1::2] + wavefunction.assign_parameters(dict(zip(resorted, theta)), inplace=True) + + if mode == 'circuit': + data_preparation = QuantumCircuit(feature_dim).compose(data_preparation) + wavefunction = QuantumCircuit(feature_dim).compose(wavefunction) + + vqc = VQC(COBYLA(maxiter=100), data_preparation, wavefunction, training_input, test_input) # sort parameters for reproducibility - if use_circuits: + if mode in ['circuit', 'library']: vqc._feature_map_params = list(x) vqc._var_form_params = list(theta) + else: + warnings.filterwarnings('always', category=DeprecationWarning) result = vqc.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1024, @@ -429,7 +462,7 @@ def test_vqc_with_raw_feature_vector_on_wine(self): feature_map = RawFeatureVector(feature_dimension=feature_dim) vqc = VQC(COBYLA(maxiter=100), feature_map, - RYRZ(feature_map.num_qubits, depth=3), + TwoLocal(feature_map.num_qubits, ['ry', 'rz'], 'cz', reps=3), training_input, test_input) result = vqc.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), diff --git a/test/aqua/test_vqe.py b/test/aqua/test_vqe.py index 19883b9a48..ae0067c7c5 100644 --- a/test/aqua/test_vqe.py +++ b/test/aqua/test_vqe.py @@ -15,17 +15,17 @@ """ Test VQE """ import unittest +import warnings from test.aqua import QiskitAquaTestCase import numpy as np from ddt import ddt, unpack, data from qiskit import BasicAer, QuantumCircuit -from qiskit.circuit import ParameterVector +from qiskit.circuit.library import TwoLocal from qiskit.aqua import QuantumInstance, aqua_globals, AquaError from qiskit.aqua.operators import WeightedPauliOperator, PrimitiveOp -from qiskit.aqua.components.variational_forms import RY, RYRZ, VariationalForm +from qiskit.aqua.components.variational_forms import RY, RYRZ from qiskit.aqua.components.optimizers import L_BFGS_B, COBYLA, SPSA, SLSQP -from qiskit.aqua.components.initial_states import Zero from qiskit.aqua.algorithms import VQE @@ -47,15 +47,30 @@ def setUp(self): } self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict).to_opflow() - @data(VariationalForm, QuantumCircuit) - def test_vqe(self, var_form_type): + num_qubits = self.qubit_op.num_qubits + ansatz = TwoLocal(num_qubits, rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') + warnings.filterwarnings('ignore', category=DeprecationWarning) + self.ryrz_wavefunction = {'wrapped': RYRZ(num_qubits), + 'circuit': QuantumCircuit(num_qubits).compose(ansatz), + 'library': ansatz} + + ansatz = ansatz.copy() + ansatz.rotation_blocks = 'ry' + self.ry_wavefunction = {'wrapped': RY(num_qubits), + 'circuit': QuantumCircuit(num_qubits).compose(ansatz), + 'library': ansatz} + warnings.filterwarnings('always', category=DeprecationWarning) + + @data('wrapped', 'circuit', 'library') + def test_vqe(self, mode): """ VQE test """ - var_form = RYRZ(self.qubit_op.num_qubits) - if var_form_type is QuantumCircuit: - params = ParameterVector('θ', var_form.num_parameters) - var_form = var_form.construct_circuit(params) + wavefunction = self.ryrz_wavefunction[mode] + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + vqe = VQE(self.qubit_op, wavefunction, L_BFGS_B()) + if mode == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) - vqe = VQE(self.qubit_op, var_form, L_BFGS_B()) result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), basis_gates=['u1', 'u2', 'u3', 'cx', 'id'], coupling_map=[[0, 1]], @@ -75,8 +90,9 @@ def test_vqe_no_varform_params(self): circuit.cx(i, (i + 1) % circuit.num_qubits) circuit.rx(0.2, i) - with self.assertRaises(AquaError): - _ = VQE(self.qubit_op, circuit) + vqe = VQE(self.qubit_op, circuit) + with self.assertRaises(RuntimeError): + vqe.run(BasicAer.get_backend('statevector_simulator')) @data( (SLSQP, 5, 4), @@ -88,7 +104,7 @@ def test_vqe_no_varform_params(self): def test_vqe_optimizers(self, optimizer_cls, places, max_evals_grouped): """ VQE Optimizers test """ result = VQE(self.qubit_op, - RYRZ(self.qubit_op.num_qubits), + TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz'), optimizer_cls(), max_evals_grouped=max_evals_grouped).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, @@ -97,47 +113,28 @@ def test_vqe_optimizers(self, optimizer_cls, places, max_evals_grouped): self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places) - @data( - (RY, 5, VariationalForm), - (RYRZ, 5, VariationalForm), - (RY, 5, QuantumCircuit), - (RYRZ, 5, QuantumCircuit), - ) - @unpack - def test_vqe_var_forms(self, var_form_cls, places, var_form_type): - """ VQE Var Forms test """ - var_form = var_form_cls(self.qubit_op.num_qubits) - if var_form_type is QuantumCircuit: - params = ParameterVector('θ', var_form.num_parameters) - var_form = var_form.construct_circuit(params) - - vqe = VQE(self.qubit_op, var_form, L_BFGS_B()) - result = vqe.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), shots=1, - seed_simulator=aqua_globals.random_seed, - seed_transpiler=aqua_globals.random_seed)) - self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=places) - - @data(VariationalForm, QuantumCircuit) - def test_vqe_qasm(self, var_form_type): + @data('wrapped', 'circuit', 'library') + def test_vqe_qasm(self, mode): """ VQE QASM test """ backend = BasicAer.get_backend('qasm_simulator') - num_qubits = self.qubit_op.num_qubits - var_form = RY(num_qubits, depth=3) - if var_form_type is QuantumCircuit: - params = ParameterVector('θ', var_form.num_parameters) - var_form = var_form.construct_circuit(params) - optimizer = SPSA(max_trials=300, last_avg=5) - algo = VQE(self.qubit_op, var_form, optimizer) + wavefunction = self.ry_wavefunction[mode] + + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + vqe = VQE(self.qubit_op, wavefunction, optimizer, max_evals_grouped=1) + if mode == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) + # TODO benchmark this later. quantum_instance = QuantumInstance(backend, shots=1000, seed_simulator=self.seed, seed_transpiler=self.seed) - result = algo.run(quantum_instance) + result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.86823, places=2) - @data(VariationalForm, QuantumCircuit) - def test_vqe_statevector_snapshot_mode(self, var_form_type): + @data('wrapped', 'circuit', 'library') + def test_vqe_statevector_snapshot_mode(self, mode): """ VQE Aer statevector_simulator snapshot mode test """ try: # pylint: disable=import-outside-toplevel @@ -146,23 +143,23 @@ def test_vqe_statevector_snapshot_mode(self, var_form_type): self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend('statevector_simulator') - num_qubits = self.qubit_op.num_qubits - init_state = Zero(num_qubits) - var_form = RY(num_qubits, depth=3, initial_state=init_state) - if var_form_type is QuantumCircuit: - params = ParameterVector('θ', var_form.num_parameters) - var_form = var_form.construct_circuit(params) - + wavefunction = self.ry_wavefunction[mode] optimizer = L_BFGS_B() - algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1) + + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + vqe = VQE(self.qubit_op, wavefunction, optimizer, max_evals_grouped=1) + if mode == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) + quantum_instance = QuantumInstance(backend, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) - result = algo.run(quantum_instance) + result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6) - @data(VariationalForm, QuantumCircuit) - def test_vqe_qasm_snapshot_mode(self, var_form_type): + @data('wrapped', 'circuit', 'library') + def test_vqe_qasm_snapshot_mode(self, mode): """ VQE Aer qasm_simulator snapshot mode test """ try: # pylint: disable=import-outside-toplevel @@ -171,23 +168,23 @@ def test_vqe_qasm_snapshot_mode(self, var_form_type): self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex))) return backend = Aer.get_backend('qasm_simulator') - num_qubits = self.qubit_op.num_qubits - init_state = Zero(num_qubits) - var_form = RY(num_qubits, depth=3, initial_state=init_state) - if var_form_type is QuantumCircuit: - params = ParameterVector('θ', var_form.num_parameters) - var_form = var_form.construct_circuit(params) - optimizer = L_BFGS_B() - algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1) + wavefunction = self.ry_wavefunction[mode] + + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + vqe = VQE(self.qubit_op, wavefunction, optimizer, max_evals_grouped=1) + if mode == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) + quantum_instance = QuantumInstance(backend, shots=1, seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed) - result = algo.run(quantum_instance) + result = vqe.run(quantum_instance) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=6) - @data(VariationalForm, QuantumCircuit) - def test_vqe_callback(self, var_form_type): + @data('wrapped', 'circuit', 'library') + def test_vqe_callback(self, mode): """ VQE Callback test """ history = {'eval_count': [], 'parameters': [], 'mean': [], 'std': []} @@ -198,21 +195,20 @@ def store_intermediate_result(eval_count, parameters, mean, std): history['std'].append(std) backend = BasicAer.get_backend('qasm_simulator') - num_qubits = self.qubit_op.num_qubits - init_state = Zero(num_qubits) - var_form = RY(num_qubits, depth=1, initial_state=init_state) - if var_form_type is QuantumCircuit: - params = ParameterVector('θ', var_form.num_parameters) - var_form = var_form.construct_circuit(params) optimizer = COBYLA(maxiter=3) - algo = VQE(self.qubit_op, var_form, optimizer, - callback=store_intermediate_result) - aqua_globals.random_seed = 50 + wavefunction = self.ry_wavefunction[mode] + + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + vqe = VQE(self.qubit_op, wavefunction, optimizer, callback=store_intermediate_result) + if mode == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) + quantum_instance = QuantumInstance(backend, seed_transpiler=50, shots=1024, seed_simulator=50) - algo.run(quantum_instance) + vqe.run(quantum_instance) self.assertTrue(all(isinstance(count, int) for count in history['eval_count'])) self.assertTrue(all(isinstance(mean, float) for mean in history['mean'])) @@ -226,8 +222,7 @@ def test_vqe_reuse(self): with self.assertRaises(AquaError): _ = vqe.run() - num_qubits = self.qubit_op.num_qubits - var_form = RY(num_qubits, depth=3) + var_form = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') vqe.var_form = var_form with self.assertRaises(AquaError): _ = vqe.run() @@ -251,7 +246,8 @@ def test_vqe_reuse(self): def test_vqe_mes(self): """ Test vqe minimum eigen solver interface """ - vqe = VQE(var_form=RY(self.qubit_op.num_qubits, depth=3), optimizer=COBYLA()) + ansatz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') + vqe = VQE(var_form=ansatz, optimizer=COBYLA()) vqe.set_backend(BasicAer.get_backend('statevector_simulator')) result = vqe.compute_minimum_eigenvalue(self.qubit_op) self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5) @@ -262,11 +258,11 @@ def test_ibmq_vqe(self): from qiskit import IBMQ provider = IBMQ.load_account() backend = provider.get_backend('ibmq_qasm_simulator') - var_form = RYRZ(self.qubit_op.num_qubits) + ansatz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') opt = SLSQP(maxiter=1) opt.set_max_evals_grouped(100) - vqe = VQE(self.qubit_op, var_form, SLSQP(maxiter=2)) + vqe = VQE(self.qubit_op, ansatz, SLSQP(maxiter=2)) result = vqe.run(backend) print(result) diff --git a/test/aqua/test_vqe2iqpe.py b/test/aqua/test_vqe2iqpe.py index 127c67b0fc..023786e174 100644 --- a/test/aqua/test_vqe2iqpe.py +++ b/test/aqua/test_vqe2iqpe.py @@ -14,11 +14,15 @@ """ Test VQE to IQPE """ +import warnings import unittest from test.aqua import QiskitAquaTestCase import numpy as np -from qiskit import BasicAer +from ddt import ddt, data +from qiskit import BasicAer, QuantumCircuit +from qiskit.circuit import ParameterVector +from qiskit.circuit.library import TwoLocal from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.utils import decimal_to_binary @@ -30,12 +34,13 @@ from qiskit.aqua.algorithms import IQPE +@ddt class TestVQE2IQPE(QiskitAquaTestCase): """ Test VQE to IQPE """ def setUp(self): super().setUp() - self.seed = 0 + self.seed = 8 aqua_globals.random_seed = self.seed pauli_dict = { 'paulis': [{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"}, @@ -47,14 +52,30 @@ def setUp(self): } self.qubit_op = WeightedPauliOperator.from_dict(pauli_dict) - def test_vqe_2_iqpe(self): + @data('wrapped', 'circuit', 'library') + def test_vqe_2_iqpe(self, wavefunction_type): """ vqe to iqpe test """ backend = BasicAer.get_backend('qasm_simulator') num_qbits = self.qubit_op.num_qubits - var_form = RYRZ(num_qbits, 3) + if wavefunction_type == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + wavefunction = RYRZ(num_qbits, 3) + else: + wavefunction = TwoLocal(num_qbits, ['ry', 'rz'], 'cz', reps=3, insert_barriers=True) + theta = ParameterVector('theta', wavefunction.num_parameters) + wavefunction.assign_parameters(theta, inplace=True) + + if wavefunction_type == 'circuit': + wavefunction = QuantumCircuit(num_qbits).compose(wavefunction) + optimizer = SPSA(max_trials=10) - # optimizer.set_options(**{'max_trials': 500}) - algo = VQE(self.qubit_op, var_form, optimizer) + algo = VQE(self.qubit_op, wavefunction, optimizer) + if wavefunction_type == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) + else: + # fix parameter order for reproducibility + algo._var_form_params = theta + quantum_instance = QuantumInstance(backend, seed_simulator=self.seed, seed_transpiler=self.seed) result = algo.run(quantum_instance) @@ -66,7 +87,12 @@ def test_vqe_2_iqpe(self): num_time_slices = 1 num_iterations = 6 - state_in = VarFormBased(var_form, result.optimal_point) + if wavefunction_type == 'wrapped': + param_dict = result.optimal_point + else: + param_dict = result.optimal_parameters + state_in = VarFormBased(wavefunction, param_dict) + iqpe = IQPE(self.qubit_op, state_in, num_time_slices, num_iterations, expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True) diff --git a/test/chemistry/test_app_mgse.py b/test/chemistry/test_app_mgse.py index b2b01dc849..1149a5210d 100644 --- a/test/chemistry/test_app_mgse.py +++ b/test/chemistry/test_app_mgse.py @@ -20,10 +20,10 @@ import numpy as np from qiskit import BasicAer +from qiskit.circuit.library import TwoLocal from qiskit.aqua import QuantumInstance from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE, IQPE from qiskit.aqua.components.optimizers import SLSQP -from qiskit.aqua.components.variational_forms import RY from qiskit.chemistry import QiskitChemistryError from qiskit.chemistry.applications import MolecularGroundStateEnergy from qiskit.chemistry.components.initial_states import HartreeFock @@ -48,7 +48,7 @@ def setUp(self): self.npme = NumPyMinimumEigensolver() - self.vqe = VQE(var_form=RY(2)) + self.vqe = VQE(var_form=TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')) self.vqe.set_backend(BasicAer.get_backend('statevector_simulator')) self.reference_energy = -1.137306 diff --git a/test/chemistry/test_end2end_with_vqe.py b/test/chemistry/test_end2end_with_vqe.py index 765ed7e2c7..e00366a71e 100644 --- a/test/chemistry/test_end2end_with_vqe.py +++ b/test/chemistry/test_end2end_with_vqe.py @@ -20,9 +20,9 @@ from test.chemistry import QiskitChemistryTestCase from ddt import ddt, idata, unpack import qiskit +from qiskit.circuit.library import TwoLocal from qiskit.aqua import QuantumInstance from qiskit.aqua.algorithms import VQE -from qiskit.aqua.components.variational_forms import RYRZ from qiskit.aqua.components.optimizers import COBYLA, SPSA from qiskit.chemistry.drivers import HDF5Driver from qiskit.chemistry.core import Hamiltonian, TransformationType, QubitMappingType @@ -62,7 +62,7 @@ def test_end2end_h2(self, name, optimizer, backend, shots): elif optimizer == 'SPSA': optimizer = SPSA(max_trials=2000) - ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full') + ryrz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz') vqe = VQE(self.qubit_op, ryrz, optimizer, aux_operators=self.aux_ops) quantum_instance = QuantumInstance(backend, shots=shots) result = vqe.run(quantum_instance) @@ -73,7 +73,7 @@ def test_deprecated_algo_result(self): """ Test processing a deprecated dictionary result from algorithm """ try: warnings.filterwarnings("ignore", category=DeprecationWarning) - ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full') + ryrz = TwoLocal(self.qubit_op.num_qubits, ['ry', 'rz'], 'cz', reps=3) 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) diff --git a/test/chemistry/test_qeom_vqe.py b/test/chemistry/test_qeom_vqe.py index 19c51d0838..5b257b1d32 100644 --- a/test/chemistry/test_qeom_vqe.py +++ b/test/chemistry/test_qeom_vqe.py @@ -19,9 +19,9 @@ from test.aqua import QiskitAquaTestCase import numpy as np from qiskit import BasicAer +from qiskit.circuit.library import RealAmplitudes from qiskit.aqua import QuantumInstance, aqua_globals -from qiskit.aqua.components.variational_forms import RY from qiskit.aqua.components.optimizers import COBYLA, SPSA from qiskit.aqua.algorithms import NumPyEigensolver from qiskit.aqua.operators import Z2Symmetries @@ -35,6 +35,7 @@ class TestEomVQE(QiskitAquaTestCase): """Test Eom VQE.""" + def setUp(self): """Setup.""" super().setUp() @@ -52,7 +53,7 @@ def setUp(self): qubit_op, _ = core.run(self.molecule) exact_eigensolver = NumPyEigensolver(qubit_op, k=2 ** qubit_op.num_qubits) result = exact_eigensolver.run() - self.reference = result['eigvals'].real + self.reference = result.eigenvalues.real except QiskitChemistryError: self.skipTest('PYSCF driver does not appear to be installed') @@ -146,7 +147,7 @@ def test_h2_one_qubit_qasm(self): # know the sector tapered_op = z2_symmetries.taper(qubit_op)[1] - var_form = RY(tapered_op.num_qubits, depth=1) + var_form = RealAmplitudes(tapered_op.num_qubits, reps=1) optimizer = SPSA(max_trials=50) eom_vqe = QEomVQE(tapered_op, var_form, optimizer, num_orbitals=num_orbitals, diff --git a/test/chemistry/test_readme_sample.py b/test/chemistry/test_readme_sample.py index ec5a41222e..18af2dde28 100644 --- a/test/chemistry/test_readme_sample.py +++ b/test/chemistry/test_readme_sample.py @@ -85,8 +85,8 @@ def print(*args): init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles) # setup the variational form for VQE - from qiskit.aqua.components.variational_forms import RYRZ - var_form = RYRZ(num_qubits, initial_state=init_state) + from qiskit.circuit.library import TwoLocal + var_form = TwoLocal(num_qubits, ['ry', 'rz'], 'cz', initial_state=init_state) # setup and run VQE from qiskit.aqua.algorithms import VQE diff --git a/test/chemistry/test_swaprz.py b/test/chemistry/test_swaprz.py index 5384848a92..eebb3f21bc 100644 --- a/test/chemistry/test_swaprz.py +++ b/test/chemistry/test_swaprz.py @@ -12,10 +12,13 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -""" Test of SWAPRZ from core aqua """ +"""Test of SWAPRZ from the circuit library.""" +import warnings from test.chemistry import QiskitChemistryTestCase +from ddt import ddt, data from qiskit import BasicAer +from qiskit.circuit.library import ExcitationPreserving from qiskit.aqua import QuantumInstance, aqua_globals from qiskit.aqua.algorithms import VQE from qiskit.aqua.components.optimizers import SLSQP @@ -25,6 +28,7 @@ from qiskit.chemistry.core import Hamiltonian, QubitMappingType +@ddt class TestSwapRZ(QiskitChemistryTestCase): """ SwapRZ was designed to preserve particles. We test it here from @@ -39,7 +43,8 @@ def setUp(self): aqua_globals.random_seed = self.seed self.reference_energy = -1.137305593252385 - def test_swaprz(self): + @data('wrapped', 'library') + def test_swaprz(self, mode): """ SwapRZ variational form test """ driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5')) @@ -54,8 +59,18 @@ def test_swaprz(self): operator.molecule_info['num_particles'], qubit_mapping=operator._qubit_mapping, two_qubit_reduction=operator._two_qubit_reduction) - var_form = SwapRZ(qubit_op.num_qubits, initial_state=initial_state) - algo = VQE(qubit_op, var_form, optimizer) + + if mode == 'wrapped': + warnings.filterwarnings('ignore', category=DeprecationWarning) + wavefunction = SwapRZ(qubit_op.num_qubits, initial_state=initial_state) + else: + wavefunction = ExcitationPreserving(qubit_op.num_qubits, initial_state=initial_state) + + algo = VQE(qubit_op, wavefunction, optimizer) + + if mode == 'wrapped': + warnings.filterwarnings('always', category=DeprecationWarning) + result = algo.run(QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) diff --git a/test/optimization/test_exact_cover.py b/test/optimization/test_exact_cover.py index 04c7670fa3..e522e6cbe3 100755 --- a/test/optimization/test_exact_cover.py +++ b/test/optimization/test_exact_cover.py @@ -19,13 +19,12 @@ from test.optimization import QiskitOptimizationTestCase import numpy as np from qiskit import BasicAer - +from qiskit.circuit.library import EfficientSU2 from qiskit.aqua import aqua_globals, QuantumInstance from qiskit.optimization.applications.ising import exact_cover from qiskit.optimization.applications.ising.common import sample_most_likely from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE from qiskit.aqua.components.optimizers import COBYLA -from qiskit.aqua.components.variational_forms import RYRZ class TestExactCover(QiskitOptimizationTestCase): @@ -71,7 +70,7 @@ def test_exact_cover_vqe(self): """ Exact Cover VQE test """ aqua_globals.random_seed = 10598 result = VQE(self.qubit_op, - RYRZ(self.qubit_op.num_qubits, depth=5), + EfficientSU2(self.qubit_op.num_qubits, reps=5), COBYLA(), max_evals_grouped=2).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), diff --git a/test/optimization/test_graph_partition.py b/test/optimization/test_graph_partition.py index 6e5ca0c817..58ceb0813f 100755 --- a/test/optimization/test_graph_partition.py +++ b/test/optimization/test_graph_partition.py @@ -18,11 +18,11 @@ from test.optimization import QiskitOptimizationTestCase import numpy as np from qiskit import BasicAer +from qiskit.circuit.library import RealAmplitudes from qiskit.aqua import aqua_globals, QuantumInstance from qiskit.optimization.applications.ising import graph_partition from qiskit.optimization.applications.ising.common import random_graph, sample_most_likely from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE -from qiskit.aqua.components.variational_forms import RY from qiskit.aqua.components.optimizers import SPSA @@ -72,16 +72,18 @@ def test_graph_partition(self): def test_graph_partition_vqe(self): """ Graph Partition VQE test """ - aqua_globals.random_seed = 10598 + aqua_globals.random_seed = 10213 + wavefunction = RealAmplitudes(self.qubit_op.num_qubits, insert_barriers=True, + reps=5, entanglement='linear') result = VQE(self.qubit_op, - RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'), + wavefunction, SPSA(max_trials=300), max_evals_grouped=2).run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) - x = sample_most_likely(result['eigvecs'][0]) + x = sample_most_likely(result.eigenstate) # check against the oracle ising_sol = graph_partition.get_graph_solution(x) self.assertEqual(graph_partition.objective_value(np.array([0, 1, 0, 1]), self.w),