Supporting counts from raw samples

doc/introduction/measurements.rst

@@ -100,7 +100,6 @@ the measurement results always coincide, and the lists are therefore equal:
 >>> np.all(result[0] == result[1])
 True
 
-
 Tensor observables
 ------------------
 
@@ -125,6 +124,50 @@ accept observables as arguments,
 including :func:`~.pennylane.expval`, :func:`~.pennylane.var`,
 and :func:`~.pennylane.sample`.
 
+Counts
+------
+
+To avoid dealing with long arrays for the larger numbers of shots, one can pass an argument counts=True
+to :func:`~pennylane.sample`. In this case the result will be a dictionnary indicating numbers of occurences for each
+unique sample. The previous example will be modified as follows:
+
+.. code-block:: python
+
+    dev = qml.device("default.qubit", wires=2, shots=1000)
+
+    @qml.qnode(dev)
+    def circuit():
+        qml.Hadamard(wires=0)
+        qml.CNOT(wires=[0, 1])
+        # passing the counts flag
+        return qml.sample(qml.PauliZ(0), counts=True), qml.sample(qml.PauliZ(1), counts=True)
+
+After executing the circuit we can directly see how often each value was measured:
+
+>>> result = circuit()
+>>> print(result)
+[tensor({-1: 526, 1: 474}, dtype=object, requires_grad=True)
+ tensor({-1: 526, 1: 474}, dtype=object, requires_grad=True)]
+
+Similarly, if the observable is not provided, the occurencies of each state are returned.
+
+.. code-block:: python
+
+    dev = qml.device("default.qubit", wires=2, shots=1000)
+
+    @qml.qnode(dev)
+    def circuit():
+        qml.Hadamard(wires=0)
+        qml.CNOT(wires=[0, 1])
+        # passing the counts flag
+        return qml.sample(counts=True)
+
+And the result is:
+
+>>> result = circuit()
+>>> print(result)
+{'00': 495, '11': 505}
+
 Probability
 -----------
 

doc/releases/changelog-dev.md

@@ -44,7 +44,43 @@
   [(#2709)](https://github.com/PennyLaneAI/pennylane/pull/2709)
 
 <h3>Improvements</h3>
+
+* Added the possibility to group samples into counts providing `counts=True` flag in `qml.sample` function. This required
+  creation of a new measurement type `Counts` in `measurements.py`.
+  [(#2686)](https://github.com/PennyLaneAI/pennylane/pull/2686)
+
+  It can be used with states:
+
+  ```pycon
+  >>> dev = qml.device("default.qubit", wires=2, shots=1000)
 
+  >>> @qml.qnode(dev)
+  >>> def circuit():
+  ...     qml.Hadamard(wires=0)
+  ...     qml.CNOT(wires=[0, 1])
+  ...     # passing the counts flag
+  ...     return qml.sample(counts=True)   
+  >>> result = circuit()
+  >>> print(result)
+  {'00': 495, '11': 505}
+  ```
+
+  And with operators:
+
+  ```pycon
+  >>> dev = qml.device("default.qubit", wires=2, shots=1000)
+
+  >>> @qml.qnode(dev)
+  >>> def circuit():
+  ...   qml.Hadamard(wires=0)
+  ...   qml.CNOT(wires=[0, 1])
+  ...   return qml.sample(qml.PauliZ(0), counts=True), qml.sample(qml.PauliZ(1), counts=True)
+  >>> result = circuit()
+  >>> print(result)
+  [tensor({-1: 526, 1: 474}, dtype=object, requires_grad=True)
+   tensor({-1: 526, 1: 474}, dtype=object, requires_grad=True)]
+  ```
+
 * Adds a new function to compare operators. `qml.equal` can be used to compare equality of parametric operators taking into account their interfaces and trainability.
   [(#2651)](https://github.com/PennyLaneAI/pennylane/pull/2651)
 
@@ -58,4 +94,4 @@
 
 This release contains contributions from (in alphabetical order):
 
-Ankit Khandelwal, Ixchel Meza Chavez, Moritz Willmann
+Ankit Khandelwal, Bogdan Reznychenko, Ixchel Meza Chavez, Moritz Willmann

pennylane/_qubit_device.py

@@ -29,13 +29,15 @@
 from pennylane.operation import operation_derivative
 from pennylane.measurements import (
     Sample,
+    Counts,
     Variance,
     Expectation,
     Probability,
     State,
     VnEntropy,
     MutualInfo,
 )
+
 from pennylane import Device
 from pennylane.math import sum as qmlsum
 from pennylane.math import multiply as qmlmul
@@ -301,6 +303,8 @@ def execute(self, circuit, **kwargs):
                 if circuit.measurements[0].return_type is qml.measurements.State:
                     # State: assumed to only be allowed if it's the only measurement
                     results = self._asarray(results, dtype=self.C_DTYPE)
+                elif circuit.measurements[0].return_type is qml.measurements.Counts:
+                    results = self._asarray(results)
                 else:
                     # Measurements with expval, var or probs
                     results = self._asarray(results, dtype=self.R_DTYPE)
@@ -475,7 +479,14 @@ def statistics(self, observables, shot_range=None, bin_size=None):
                 results.append(self.var(obs, shot_range=shot_range, bin_size=bin_size))
 
             elif obs.return_type is Sample:
-                results.append(self.sample(obs, shot_range=shot_range, bin_size=bin_size))
+                results.append(
+                    self.sample(obs, shot_range=shot_range, bin_size=bin_size, counts=False)
+                )
+
+            elif obs.return_type is Counts:
+                results.append(
+                    self.sample(obs, shot_range=shot_range, bin_size=bin_size, counts=True)
+                )
 
             elif obs.return_type is Probability:
                 results.append(
@@ -960,7 +971,27 @@ def var(self, observable, shot_range=None, bin_size=None):
         samples = self.sample(observable, shot_range=shot_range, bin_size=bin_size)
         return np.squeeze(np.var(samples, axis=0))
 
-    def sample(self, observable, shot_range=None, bin_size=None):
+    def _samples_to_counts(self, samples):
+        """Group the obtained samples into a dictionary.
+
+        Example:
+            >>> samples
+            tensor([[0, 0, 1],
+                    [0, 0, 1],
+                    [1, 1, 1]], requires_grad=True)
+            >>> self._samples_to_counts(samples)
+             {'111':1, '001':2}
+        """
+        try:
+            # Express the states as strings
+            samples = ["".join(self._asarray(sample, dtype=str)) for sample in samples]
+        except TypeError:
+            # Evaluation of an observable
+            pass
+        states, counts = np.unique(samples, return_counts=True)
+        return dict(zip(states, counts))
+
+    def sample(self, observable, shot_range=None, bin_size=None, counts=False):
 
         # translate to wire labels used by device
         device_wires = self.map_wires(observable.wires)
@@ -1000,6 +1031,8 @@ def sample(self, observable, shot_range=None, bin_size=None):
                 ) from e
 
         if bin_size is None:
+            if counts:
+                return self._samples_to_counts(samples)
             return samples
 
         return samples.reshape((bin_size, -1))

pennylane/measurements.py

@@ -38,6 +38,7 @@ class ObservableReturnTypes(Enum):
     """Enumeration class to represent the return types of an observable."""
 
     Sample = "sample"
+    Counts = "counts"
     Variance = "var"
     Expectation = "expval"
     Probability = "probs"
@@ -54,6 +55,10 @@ def __repr__(self):
 Sample = ObservableReturnTypes.Sample
 """Enum: An enumeration which represents sampling an observable."""
 
+Counts = ObservableReturnTypes.Counts
+"""Enum: An enumeration which represents returning the number of times
+ each sample was obtained."""
+
 Variance = ObservableReturnTypes.Variance
 """Enum: An enumeration which represents returning the variance of
 an observable on specified wires."""
@@ -236,7 +241,7 @@ def shape(self, device=None):
             return shape
 
         # Then: handle return types that require a device; no shot vector
-        if device is None and self.return_type in (Probability, State, Sample):
+        if device is None and self.return_type in (Probability, State, Sample, Counts):
             raise MeasurementShapeError(
                 f"The device argument is required to obtain the shape of the measurement process; got return type {self.return_type}."
             )
@@ -578,7 +583,7 @@ def circuit(x):
     return MeasurementProcess(Variance, obs=op)
 
 
-def sample(op=None, wires=None):
+def sample(op=None, wires=None, counts=False):
     r"""Sample from the supplied observable, with the number of shots
     determined from the ``dev.shots`` attribute of the corresponding device.
     If no observable is provided then basis state samples are returned directly
@@ -590,6 +595,7 @@ def sample(op=None, wires=None):
     Args:
         op (Observable or None): a quantum observable object
         wires (Sequence[int] or int or None): the wires we wish to sample from, ONLY set wires if op is None
+        counts (bool): return the result as numbers of counts
 
     Raises:
         QuantumFunctionError: `op` is not an instance of :class:`~.Observable`
@@ -655,16 +661,17 @@ def circuit(x):
             f"{op.name} is not an observable: cannot be used with sample"
         )
 
+    sample_or_counts = Counts if counts else Sample
+
     if wires is not None:
         if op is not None:
             raise ValueError(
                 "Cannot specify the wires to sample if an observable is "
                 "provided. The wires to sample will be determined directly from the observable."
             )
+        return MeasurementProcess(sample_or_counts, obs=op, wires=qml.wires.Wires(wires))
 
-        return MeasurementProcess(Sample, obs=op, wires=qml.wires.Wires(wires))
-
-    return MeasurementProcess(Sample, obs=op)
+    return MeasurementProcess(sample_or_counts, obs=op)
 
 
 def probs(wires=None, op=None):