Merge pull request #1422 from manoelmarques/stable-0.8.1

[Stable] Qiskit Aqua Release 0.8.1

Author: manoelmarques

.github/actions/install-libraries/action.yml

@@ -26,5 +26,4 @@ runs:
           pip install -U pip
           pip install -U setuptools wheel
         fi
-        # sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
       shell: bash

.github/actions/install-master-dependencies/action.yml

@@ -24,7 +24,6 @@ runs:
         pip install https://github.com/Qiskit/qiskit-terra/archive/master.zip
         pip install https://github.com/Qiskit/qiskit-ignis/archive/master.zip
         pip install https://github.com/Qiskit/qiskit-ibmq-provider/archive/master.zip
-        # sudo apt-get -y update
         sudo apt-get -y install g++-7
         sudo apt-get -y install libopenblas-dev
         git clone https://github.com/Qiskit/qiskit-aer.git /tmp/qiskit-aer

.github/workflows/main.yml

@@ -250,8 +250,9 @@ jobs:
           if [ -f "$HOME/miniconda/etc/profile.d/conda.sh" ]; then
             source "$HOME/miniconda/etc/profile.d/conda.sh"
             conda activate
+            # PSI4 has problems with dataclasses
+            pip uninstall -y dataclasses
           fi
-          # sudo apt-get -y update
           sudo apt-get -y install libgfortran5
           pip install https://github.com/rpmuller/pyquante2/archive/master.zip
           pip install pyscf
@@ -461,7 +462,6 @@ jobs:
         shell: bash
       - name: Install Dependencies
         run: |
-          # sudo apt-get -y update
           sudo apt-get -y install libgfortran5
           pip install https://github.com/rpmuller/pyquante2/archive/master.zip
           pip install pyscf

qiskit/aqua/VERSION.txt

@@ -1 +1 @@
-0.8.0
+0.8.1

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

@@ -76,9 +76,10 @@ def train(self, data, labels):
         """
         scaling = 1.0 if self._qalgo.quantum_instance.is_statevector else None
         kernel_matrix = self._qalgo.construct_kernel_matrix(data)
+        lambda2 = self._qalgo.lambda2
         labels = labels * 2 - 1  # map label from 0 --> -1 and 1 --> 1
         labels = labels.astype(np.float)
-        [alpha, b, support] = optimize_svm(kernel_matrix, labels, scaling=scaling)
+        [alpha, b, support] = optimize_svm(kernel_matrix, labels, scaling=scaling, lambda2=lambda2)
         support_index = np.where(support)
         alphas = alpha[support_index]
         svms = data[support_index]

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

@@ -80,6 +80,7 @@ def __init__(self, feature_map: Union[QuantumCircuit, FeatureMap],
                  test_dataset: Optional[Dict[str, np.ndarray]] = None,
                  datapoints: Optional[np.ndarray] = None,
                  multiclass_extension: Optional[MulticlassExtension] = None,
+                 lambda2: float = 0.001,
                  quantum_instance: Optional[
                      Union[QuantumInstance, BaseBackend, Backend]] = None) -> None:
         """
@@ -90,6 +91,7 @@ def __init__(self, feature_map: Union[QuantumCircuit, FeatureMap],
             datapoints: Prediction dataset.
             multiclass_extension: If number of classes is greater than 2 then a multiclass scheme
                 must be supplied, in the form of a multiclass extension.
+            lambda2: L2 norm regularization factor
             quantum_instance: Quantum Instance or Backend
 
         Raises:
@@ -118,6 +120,7 @@ def __init__(self, feature_map: Union[QuantumCircuit, FeatureMap],
         self.setup_training_data(training_dataset)
         self.setup_test_data(test_dataset)
         self.setup_datapoint(datapoints)
+        self.lambda2 = lambda2
 
         self.feature_map = feature_map
         self.num_qubits = self.feature_map.num_qubits

qiskit/aqua/algorithms/minimum_eigen_solvers/qaoa/var_form.py

@@ -16,7 +16,7 @@
 
 import numpy as np
 
-from qiskit.aqua.operators import (OperatorBase, X, I, H, Zero, CircuitStateFn,
+from qiskit.aqua.operators import (OperatorBase, X, I, H, CircuitStateFn,
                                    EvolutionFactory, LegacyBaseOperator)
 from qiskit.aqua.components.variational_forms import VariationalForm
 from qiskit.aqua.components.initial_states import InitialState
@@ -80,13 +80,12 @@ def construct_circuit(self, parameters, q=None):
                 self.num_parameters, len(parameters)
             ))
 
-        circuit = (H ^ self._num_qubits)
         # initialize circuit, possibly based on given register/initial state
         if self._initial_state is not None:
-            init_state = CircuitStateFn(self._initial_state.construct_circuit('circuit'))
+            stateVector = CircuitStateFn(self._initial_state.construct_circuit('circuit'))
+            circuit = stateVector.to_circuit_op()
         else:
-            init_state = Zero
-        circuit = circuit.compose(init_state)
+            circuit = (H ^ self._num_qubits)
 
         for idx in range(self._p):
             circuit = (self._cost_operator * parameters[idx]).exp_i().compose(circuit)

qiskit/aqua/algorithms/quantum_algorithm.py

@@ -60,8 +60,8 @@ def run(self,
             AquaError: If a quantum instance or backend has not been provided
         """
         if quantum_instance is None and self.quantum_instance is None:
-            raise AquaError("Quantum device or backend "
-                            "is needed since you are running quantum algorithm.")
+            raise AquaError("A QuantumInstance or Backend "
+                            "must be supplied to run the quantum algorithm.")
         if isinstance(quantum_instance, (BaseBackend, Backend)):
             self.set_backend(quantum_instance, **kwargs)
         else:

qiskit/aqua/components/neural_networks/pytorch_discriminator.py

@@ -90,7 +90,7 @@ def load_model(self, load_dir: str):
         Args:
             load_dir: file with stored pytorch discriminator model to be loaded
         """
-        torch.load(load_dir)
+        self._discriminator = torch.load(load_dir)
 
     @property
     def discriminator_net(self):

qiskit/aqua/components/optimizers/nlopts/nloptimizer.py

@@ -93,6 +93,8 @@ def optimize(self, num_vars, objective_function, gradient_function=None,
                  variable_bounds=None, initial_point=None):
         super().optimize(num_vars, objective_function,
                          gradient_function, variable_bounds, initial_point)
+        if variable_bounds is None:
+            variable_bounds = [(None, None)] * num_vars
         return self._minimize(self._optimizer_names[self.get_nlopt_optimizer()],
                               objective_function,
                               variable_bounds,
@@ -101,7 +103,7 @@ def optimize(self, num_vars, objective_function, gradient_function=None,
     def _minimize(self,
                   name: str,
                   objective_function: Callable,
-                  variable_bounds: Optional[List[Tuple[float, float]]] = None,
+                  variable_bounds: Optional[List[Tuple[float, float]]],
                   initial_point: Optional[np.ndarray] = None,
                   max_evals: int = 1000) -> Tuple[float, float, int]:
         """Minimize using objective function

qiskit/aqua/operators/converters/circuit_sampler.py

@@ -21,7 +21,7 @@
 from qiskit.providers import Backend
 from qiskit.circuit import QuantumCircuit, Parameter, ParameterExpression
 from qiskit import QiskitError
-from qiskit.aqua import QuantumInstance
+from qiskit.aqua import QuantumInstance, AquaError
 from qiskit.aqua.utils.backend_utils import is_aer_provider, is_statevector_backend
 from qiskit.aqua.operators.operator_base import OperatorBase
 from qiskit.aqua.operators.list_ops.list_op import ListOp
@@ -165,6 +165,8 @@ def convert(self,
 
         Returns:
             The converted Operator with CircuitStateFns replaced by DictStateFns or VectorStateFns.
+        Raises:
+            AquaError: if extracted circuits are empty.
         """
         if self._last_op is None or id(operator) != id(self._last_op):
             # Clear caches
@@ -181,6 +183,11 @@ def convert(self,
         if not self._circuit_ops_cache:
             self._circuit_ops_cache = {}
             self._extract_circuitstatefns(self._reduced_op_cache)
+            if not self._circuit_ops_cache:
+                raise AquaError(
+                    'Circuits are empty. '
+                    'Check that the operator is an instance of CircuitStateFn or its ListOp.'
+                )
 
         if params:
             p_0 = list(params.values())[0]  # type: ignore
@@ -243,8 +250,13 @@ def sample_circuits(self,
 
         Returns:
             The dictionary mapping ids of the CircuitStateFns to their replacement StateFns.
+        Raises:
+            AquaError: if extracted circuits are empty.
         """
-        if circuit_sfns or not self._transpiled_circ_cache:
+        if not circuit_sfns and not self._transpiled_circ_cache:
+            raise AquaError('CircuitStateFn is empty and there is no cache.')
+
+        if circuit_sfns:
             if self._statevector:
                 circuits = [op_c.to_circuit(meas=False) for op_c in circuit_sfns]
             else:
@@ -266,14 +278,14 @@ def sample_circuits(self,
                 start_time = time()
                 ready_circs = self._prepare_parameterized_run_config(param_bindings)
                 end_time = time()
-                logger.info('Parameter conversion %.5f (ms)', (end_time - start_time) * 1000)
+                logger.debug('Parameter conversion %.5f (ms)', (end_time - start_time) * 1000)
             else:
                 start_time = time()
                 ready_circs = [circ.assign_parameters(binding)
                                for circ in self._transpiled_circ_cache
                                for binding in param_bindings]
                 end_time = time()
-                logger.info('Parameter binding %.5f (ms)', (end_time - start_time) * 1000)
+                logger.debug('Parameter binding %.5f (ms)', (end_time - start_time) * 1000)
         else:
             ready_circs = self._transpiled_circ_cache
 

qiskit/aqua/operators/evolutions/trotterizations/trotter.py

@@ -26,4 +26,4 @@ def __init__(self,
         Args:
             reps: The number of times to repeat the Trotterization circuit.
         """
-        super().__init__(order=1, reps=1)
+        super().__init__(order=1, reps=reps)

qiskit/aqua/operators/legacy/weighted_pauli_operator.py

@@ -101,9 +101,19 @@ def to_opflow(self, reverse_endianness=False):
         pauli_ops = []
         for [w, p] in self.paulis:
             pauli = Pauli.from_label(str(p)[::-1]) if reverse_endianness else p
-            # Adding the imaginary is necessary to handle the imaginary coefficients in UCCSD.
-            # TODO fix these or add support for them in Terra.
-            pauli_ops += [PrimitiveOp(pauli, coeff=np.real(w) + np.imag(w))]
+            # This weighted pauli operator has the coeff stored as a complex type
+            # irrespective of whether the value has any imaginary part or not.
+            # For many operators the coeff will be real. Hence below the coeff is made real,
+            # when creating the PrimitiveOp, since it can be stored then as a float, if its
+            # value is real, i.e. has no imaginary part. This avoids any potential issues around
+            # complex - but if there are complex coeffs then maybe that using the opflow
+            # later will fail if it happens to be used where complex is not supported.
+            # Now there are imaginary coefficients in UCCSD that would need to be handled
+            # when this is converted to opflow (evolution of hopping operators) where currently
+            # Terra does not handle complex.
+            # TODO fix these or add support for them in Terra
+            coeff = np.real(w) if np.isreal(w) else w
+            pauli_ops += [PrimitiveOp(pauli, coeff=coeff)]
         return sum(pauli_ops)
 
     @property

qiskit/aqua/operators/primitive_ops/circuit_op.py

@@ -35,9 +35,8 @@ class CircuitOp(PrimitiveOp):
     """
 
     def __init__(self,
-                 primitive: Union[Instruction, QuantumCircuit] = None,
-                 coeff: Optional[Union[int, float, complex,
-                                       ParameterExpression]] = 1.0) -> None:
+                 primitive: Union[Instruction, QuantumCircuit],
+                 coeff: Union[int, float, complex, ParameterExpression] = 1.0) -> None:
         """
         Args:
             primitive: The QuantumCircuit which defines the

qiskit/aqua/operators/primitive_ops/matrix_op.py

@@ -12,7 +12,7 @@
 
 """ MatrixOp Class """
 
-from typing import Union, Optional, Set, Dict, List, cast
+from typing import Union, Optional, Set, Dict, List, cast, get_type_hints
 import logging
 import numpy as np
 from scipy.sparse import spmatrix
@@ -40,8 +40,8 @@ class MatrixOp(PrimitiveOp):
     """
 
     def __init__(self,
-                 primitive: Union[list, np.ndarray, spmatrix, Operator] = None,
-                 coeff: Optional[Union[int, float, complex, ParameterExpression]] = 1.0) -> None:
+                 primitive: Union[list, np.ndarray, spmatrix, Operator],
+                 coeff: Union[int, float, complex, ParameterExpression] = 1.0) -> None:
         """
         Args:
             primitive: The matrix-like object which defines the behavior of the underlying function.
@@ -51,16 +51,18 @@ def __init__(self,
             TypeError: invalid parameters.
             ValueError: invalid parameters.
         """
+        primitive_orig = primitive
         if isinstance(primitive, spmatrix):
             primitive = primitive.toarray()
 
         if isinstance(primitive, (list, np.ndarray)):
             primitive = Operator(primitive)
 
         if not isinstance(primitive, Operator):
-            raise TypeError(
-                'MatrixOp can only be instantiated with MatrixOperator, '
-                'not {}'.format(type(primitive)))
+            type_hints = get_type_hints(MatrixOp.__init__).get('primitive')
+            valid_cls = [cls.__name__ for cls in type_hints.__args__]
+            raise TypeError(f"MatrixOp can only be instantiated with {valid_cls}, "
+                            f"not '{primitive_orig.__class__.__name__}'")
 
         if not primitive.input_dims() == primitive.output_dims():
             raise ValueError('Cannot handle non-square matrices yet.')

qiskit/aqua/operators/primitive_ops/pauli_op.py

@@ -39,7 +39,7 @@ class PauliOp(PrimitiveOp):
     """
 
     def __init__(self,
-                 primitive: Union[Pauli] = None,
+                 primitive: Union[Pauli],
                  coeff: Union[int, float, complex, ParameterExpression] = 1.0) -> None:
         """
             Args:

qiskit/aqua/operators/primitive_ops/primitive_op.py

@@ -48,8 +48,9 @@ class PrimitiveOp(OperatorBase):
     @staticmethod
     # pylint: disable=unused-argument
     def __new__(cls,
-                primitive: Union[Instruction, QuantumCircuit, List,
-                                 np.ndarray, spmatrix, MatrixOperator, Pauli] = None,
+                primitive:
+                Optional[Union[Instruction, QuantumCircuit, List,
+                               np.ndarray, spmatrix, MatrixOperator, Pauli]] = None,
                 coeff: Union[int, float, complex, ParameterExpression] = 1.0) -> 'PrimitiveOp':
         """ A factory method to produce the correct type of PrimitiveOp subclass
         based on the primitive passed in. Primitive and coeff arguments are passed into
@@ -85,9 +86,10 @@ def __new__(cls,
                         'factory constructor'.format(type(primitive)))
 
     def __init__(self,
-                 primitive: Union[Instruction, QuantumCircuit, List,
-                                  np.ndarray, spmatrix, MatrixOperator, Pauli] = None,
-                 coeff: Optional[Union[int, float, complex, ParameterExpression]] = 1.0) -> None:
+                 primitive:
+                 Optional[Union[Instruction, QuantumCircuit, List,
+                                np.ndarray, spmatrix, MatrixOperator, Pauli]] = None,
+                 coeff: Union[int, float, complex, ParameterExpression] = 1.0) -> None:
         """
             Args:
                 primitive: The operator primitive being wrapped.

qiskit/aqua/operators/state_fns/dict_state_fn.py

@@ -252,7 +252,7 @@ def sample(self,
                shots: int = 1024,
                massive: bool = False,
                reverse_endianness: bool = False) -> dict:
-        probs = np.array(list(self.primitive.values()))**2
+        probs = np.square(np.abs(np.array(list(self.primitive.values()))))
         unique, counts = np.unique(aqua_globals.random.choice(list(self.primitive.keys()),
                                                               size=shots,
                                                               p=(probs / sum(probs))),

qiskit/aqua/operators/state_fns/operator_state_fn.py

@@ -34,7 +34,7 @@ class OperatorStateFn(StateFn):
 
     # TODO allow normalization somehow?
     def __init__(self,
-                 primitive: Union[OperatorBase] = None,
+                 primitive: OperatorBase = None,
                  coeff: Union[int, float, complex, ParameterExpression] = 1.0,
                  is_measurement: bool = False) -> None:
         """