Fix to MultivariateDistribution class, Add Data Discretization & Truncation function

CHANGELOG.md

@@ -47,6 +47,7 @@ Added
 Fixed
 -------
 
+-   fix parameter ordering in the init of the multivariate distribution class (#741)
 -   fix bug in list concatenation in VQC algorithm (#733)
 -   A bug where `UCCSD` might generate an empty operator and try to evolve it. (#680)
 -   Decompose causes DAG failure using feature maps. (#719)

qiskit/aqua/algorithms/adaptive/qgan/qgan.py

@@ -16,7 +16,6 @@
 Quantum Generative Adversarial Network.
 """
 
-from copy import deepcopy
 import csv
 import os
 import logging
@@ -29,6 +28,7 @@
 from qiskit.aqua.algorithms import QuantumAlgorithm
 from qiskit.aqua.components.neural_networks.quantum_generator import QuantumGenerator
 from qiskit.aqua.components.neural_networks.numpy_discriminator import NumpyDiscriminator
+from qiskit.aqua.utils.dataset_helper import discretize_and_truncate
 
 logger = logging.getLogger(__name__)
 
@@ -145,15 +145,13 @@ def __init__(self, data, bounds=None, num_qubits=None, batch_size=500, num_epoch
         if np.ndim(data) > 1:
             if self._num_qubits is None:
                 self._num_qubits = np.ones[len(data[0])]*3
-            self._prob_data = \
-                np.zeros(int(np.prod(np.power(np.ones(len(self._data[0]))*2, self._num_qubits))))
         else:
             if self._num_qubits is None:
                 self._num_qubits = np.array([3])
-            self._prob_data = np.zeros(int(np.prod(np.power(np.array([2]), self._num_qubits))))
-        self._data_grid = []
-        self._grid_elements = None
-        self._prepare_data()
+        self._data, self._data_grid, self._grid_elements, self._prob_data = \
+            discretize_and_truncate(self._data, self._bounds, self._num_qubits,
+                                    return_data_grid_elements=True,
+                                    return_prob=True, prob_non_zero=True)
         self._batch_size = batch_size
         self._num_epochs = num_epochs
         self._snapshot_dir = snapshot_dir
@@ -302,77 +300,13 @@ def rel_entr(self):
         """ returns relative entropy """
         return self._rel_entr
 
-    def _prepare_data(self):
-        """
-        Discretize and truncate the input data such that it
-        is compatible wih the chosen data resolution.
-        """
-        # Truncate the data
-        if np.ndim(self._bounds) == 1:
-            bounds = np.reshape(self._bounds, (1, len(self._bounds)))
-        else:
-            bounds = self._bounds
-        self._data = self._data.reshape((len(self._data), len(self._num_qubits)))
-        temp = []
-        for i, data_sample in enumerate(self._data):
-            append = True
-            for j, entry in enumerate(data_sample):
-                if entry < bounds[j, 0]:
-                    append = False
-                if entry > bounds[j, 1]:
-                    append = False
-            if append:
-                temp.append(list(data_sample))
-        self._data = np.array(temp)
-
-        # Fit the data to the data resolution. i.e. grid
-        for j, prec in enumerate(self._num_qubits):
-            data_row = self._data[:, j]  # dim j of all data samples
-            # prepare data grid for dim j
-            grid = np.linspace(bounds[j, 0], bounds[j, 1], (2 ** prec))
-            # find index for data sample in grid
-            index_grid = np.searchsorted(grid, data_row-(grid[1]-grid[0])*0.5)
-            for k, index in enumerate(index_grid):
-                self._data[k, j] = grid[index]
-            if j == 0:
-                if len(self._num_qubits) > 1:
-                    self._data_grid = [grid]
-                else:
-                    self._data_grid = grid
-                self._grid_elements = grid
-            elif j == 1:
-                self._data_grid.append(grid)
-                temp = []
-                for g_e in self._grid_elements:
-                    for g in grid:
-                        temp0 = [g_e]
-                        temp0.append(g)
-                        temp.append(temp0)
-                self._grid_elements = temp
-            else:
-                self._data_grid.append(grid)
-                temp = []
-                for g_e in self._grid_elements:
-                    for g in grid:
-                        temp0 = deepcopy(g_e)
-                        temp0.append(g)
-                        temp.append(temp0)
-                self._grid_elements = deepcopy(temp)
-        self._data_grid = np.array(self._data_grid)
-        self._data = np.reshape(self._data, (len(self._data), len(self._data[0])))
-        for data in self._data:
-            for i, element in enumerate(self._grid_elements):
-                if all(data == element):
-                    self._prob_data[i] += 1 / len(self._data)
-        self._prob_data = [1e-10 if x == 0 else x for x in self._prob_data]
-
     def get_rel_entr(self):
         """ get relative entropy """
         samples_gen, prob_gen = self._generator.get_output(self._quantum_instance)
         temp = np.zeros(len(self._grid_elements))
         for j, sample in enumerate(samples_gen):
             for i, element in enumerate(self._grid_elements):
-                if all(sample == element):
+                if sample == element:
                     temp[i] += prob_gen[j]
         prob_gen = temp
         prob_gen = [1e-8 if x == 0 else x for x in prob_gen]

qiskit/aqua/components/optimizers/aqgd.py

@@ -111,7 +111,6 @@ def deriv(self, j, params, obj):
             params (array): Current value of the parameters to evaluate
                             the objective function at.
             obj (callable): Objective function.
-
         Returns:
             float: The derivative of the objective function w.r.t. j
         """

qiskit/aqua/components/uncertainty_models/multivariate_distribution.py

@@ -34,7 +34,7 @@ class MultivariateDistribution(UncertaintyModel, ABC):
     def get_section_key_name(cls):
         return Pluggable.SECTION_KEY_MULTIVARIATE_DIST
 
-    def __init__(self, num_qubits, low, high, probabilities=None):
+    def __init__(self, num_qubits, probabilities=None, low=None, high=None):
         """
         Constructor.
 

qiskit/aqua/components/uncertainty_models/multivariate_log_normal_distribution.py

@@ -101,7 +101,7 @@ def __init__(self, num_qubits, low=None, high=None, mu=None, cov=None):
         self.cov = cov
         probs, values = self._compute_probabilities([], [], num_qubits, low, high)
         probs = np.asarray(probs) / np.sum(probs)
-        super().__init__(num_qubits, low, high, probs)
+        super().__init__(num_qubits, probs, low, high)
         self._values = values
 
     def _compute_probabilities(self, probs, values, num_qubits, low, high, x=None):

qiskit/aqua/components/uncertainty_models/multivariate_normal_distribution.py

@@ -107,7 +107,7 @@ def __init__(self, num_qubits, low=None, high=None, mu=None, sigma=None):
         self.sigma = sigma
         probs = self._compute_probabilities([], num_qubits, low, high)
         probs = np.asarray(probs) / np.sum(probs)
-        super().__init__(num_qubits, low, high, probs)
+        super().__init__(num_qubits, probs, low, high)
 
     def _compute_probabilities(self, probs, num_qubits, low, high, x=None):
 

qiskit/aqua/components/uncertainty_models/multivariate_uniform_distribution.py

@@ -79,7 +79,7 @@ def __init__(self, num_qubits, low=None, high=None):
 
         num_values = np.prod([2**n for n in num_qubits])
         probabilities = np.ones(num_values)
-        super().__init__(num_qubits, low, high, probabilities)
+        super().__init__(num_qubits, probabilities, low, high)
 
     def build(self, qc, q, q_ancillas=None, params=None):
         if params is None or params['i_state'] is None:

qiskit/aqua/components/uncertainty_models/univariate_distribution.py

@@ -34,7 +34,7 @@ class UnivariateDistribution(UncertaintyModel, ABC):
     def get_section_key_name(cls):
         return Pluggable.SECTION_KEY_UNIVARIATE_DIST
 
-    def __init__(self, num_target_qubits, probabilities, low=0, high=1):
+    def __init__(self, num_target_qubits, probabilities=None, low=0, high=1):
         """
         Abstract univariate distribution class
         Args:
@@ -53,8 +53,9 @@ def __init__(self, num_target_qubits, probabilities, low=0, high=1):
         self._low = low
         self._high = high
         self._values = np.linspace(low, high, self.num_values)
-        if self.num_values != len(probabilities):
-            raise AquaError('num qubits and length of probabilities vector do not match!')
+        if probabilities is not None:
+            if self.num_values != len(probabilities):
+                raise AquaError('num qubits and length of probabilities vector do not match!')
 
     @property
     def low(self):

qiskit/aqua/components/uncertainty_models/univariate_variational_distribution.py

@@ -71,7 +71,12 @@ def __init__(self, num_qubits, var_form, params, low=0, high=1):
         self._num_qubits = num_qubits
         self._var_form = var_form
         self.params = params
-        probabilities = list(np.zeros(2**num_qubits))
+        if isinstance(num_qubits, int):
+            probabilities = np.zeros(2 ** num_qubits)
+        elif isinstance(num_qubits, float):
+            probabilities = np.zeros(2 ** int(num_qubits))
+        else:
+            probabilities = np.zeros(2 ** sum(num_qubits))
         super().__init__(num_qubits, probabilities, low, high)
 
     @classmethod

qiskit/aqua/utils/dataset_helper.py

@@ -15,7 +15,7 @@
 """ Data set helper """
 
 import operator
-
+from copy import deepcopy
 import numpy as np
 from sklearn.decomposition import PCA
 
@@ -133,3 +133,107 @@ def reduce_dim_to_via_pca(x, dim):
     """
     x_reduced = PCA(n_components=dim).fit_transform(x)
     return x_reduced
+
+
+def discretize_and_truncate(data, bounds, num_qubits, return_data_grid_elements=False,
+                            return_prob=False, prob_non_zero=True):
+    """
+    Discretize & truncate classical data to enable digital encoding in qubit registers
+    whereby the data grid is [[grid elements dim 0],..., [grid elements dim k]]
+
+    Args:
+        data (list or array or np.array): training data (int or float) of dimension k
+        bounds (list or array or np.array):  k min/max data values
+            [[min_0,max_0],...,[min_k-1,max_k-1]] if univariate data: [min_0,max_0]
+        num_qubits (list or array or np.array): k numbers of qubits to determine
+            representation resolution, i.e. n qubits enable the representation of 2**n
+            values [num_qubits_0,..., num_qubits_k-1]
+        return_data_grid_elements (Bool): if True - return an array with the data grid
+            elements
+        return_prob (Bool): if True - return a normalized frequency count of the discretized and
+            truncated data samples
+        prob_non_zero (Bool): if True - set 0 values in the prob_data to 10^-1 to avoid potential
+            problems when using the probabilities in loss functions - division by 0
+
+    Returns:
+        array: discretized and truncated data
+        array: data grid [[grid elements dim 0],..., [grid elements dim k]]
+        array: grid elements, Product_j=0^k-1 2**num_qubits_j element vectors
+        array: data probability, normalized frequency count sorted from smallest to biggest element
+
+    """
+    # Truncate the data
+    if np.ndim(bounds) == 1:
+        bounds = np.reshape(bounds, (1, len(bounds)))
+
+    data = data.reshape((len(data), len(num_qubits)))
+    temp = []
+    for i, data_sample in enumerate(data):
+        append = True
+        for j, entry in enumerate(data_sample):
+            if entry < bounds[j, 0]:
+                append = False
+            if entry > bounds[j, 1]:
+                append = False
+        if append:
+            temp.append(list(data_sample))
+    data = np.array(temp)
+
+    # Fit the data to the data element grid
+    for j, prec in enumerate(num_qubits):
+        data_row = data[:, j]  # dim j of all data samples
+        # prepare element grid for dim j
+        elements_current_dim = np.linspace(bounds[j, 0], bounds[j, 1], (2 ** prec))
+        # find index for data sample in grid
+        index_grid = np.searchsorted(elements_current_dim,
+                                     data_row-(elements_current_dim[1]-elements_current_dim[0])*0.5)
+        for k, index in enumerate(index_grid):
+            data[k, j] = elements_current_dim[index]
+        if j == 0:
+            if len(num_qubits) > 1:
+                data_grid = [elements_current_dim]
+            else:
+                data_grid = elements_current_dim
+            grid_elements = elements_current_dim
+        elif j == 1:
+            temp = []
+            for grid_element in grid_elements:
+                for element_current in elements_current_dim:
+                    temp.append([grid_element, element_current])
+            grid_elements = temp
+            data_grid.append(elements_current_dim)
+        else:
+            temp = []
+            for grid_element in grid_elements:
+                for element_current in elements_current_dim:
+                    temp.append(deepcopy(grid_element).append(element_current))
+            grid_elements = deepcopy(temp)
+            data_grid.append(elements_current_dim)
+    data_grid = np.array(data_grid)
+
+    data = np.reshape(data, (len(data), len(data[0])))
+
+    if return_prob:
+        if np.ndim(data) > 1:
+            prob_data = np.zeros(int(np.prod(np.power(np.ones(len(data[0])) * 2, num_qubits))))
+        else:
+            prob_data = np.zeros(int(np.prod(np.power(np.array([2]), num_qubits))))
+        for data_element in data:
+            for i, element in enumerate(grid_elements):
+                if all(data_element == element):
+                    prob_data[i] += 1 / len(data)
+        if prob_non_zero:
+            # add epsilon to avoid 0 entries which can be problematic in loss functions (division)
+            prob_data = [1e-10 if x == 0 else x for x in prob_data]
+
+        if return_data_grid_elements:
+            return data, data_grid, grid_elements, prob_data
+        else:
+            return data, data_grid, prob_data
+
+    else:
+        if return_data_grid_elements:
+            return data, data_grid, grid_elements
+
+        else:
+            return data, data_grid