Cache tape executions

pennylane/beta/interfaces/autograd.py

@@ -115,6 +115,8 @@ def get_parameters(self, trainable_only=True):  # pylint: disable=missing-functi
                 for idx, p in enumerate(self._all_parameter_values)
                 if idx in self.trainable_params
             ]
+        else:
+            params = self._all_parameter_values
 
         return autograd.builtins.list(params)
 

pennylane/beta/tapes/qnode.py

@@ -15,6 +15,7 @@
 This module contains the QNode class and qnode decorator.
 """
 from collections.abc import Sequence
+from collections import OrderedDict
 from functools import lru_cache, update_wrapper
 import warnings
 
@@ -97,6 +98,12 @@ class QNode:
             * ``"finite-diff"``: Uses numerical finite-differences for all quantum operation
               arguments.
 
+        caching (int): number of device executions to store in a cache to speed up subsequent
+            executions. A value of ``0`` indicates that no caching will take place. Once filled,
+            older elements of the cache are removed and replaced with the most recent device
+            executions to keep the cache up to date. In caching mode, the quantum circuit
+            being executed must have a constant structure and only its parameters can be varied.
+
     Keyword Args:
         h=1e-7 (float): step size for the finite difference method
         order=1 (int): The order of the finite difference method to use. ``1`` corresponds
@@ -113,9 +120,11 @@ class QNode:
     >>> qnode = QNode(circuit, dev)
     """
 
-    # pylint:disable=too-many-instance-attributes
+    # pylint:disable=too-many-instance-attributes,too-many-arguments
 
-    def __init__(self, func, device, interface="autograd", diff_method="best", **diff_options):
+    def __init__(
+        self, func, device, interface="autograd", diff_method="best", caching=0, **diff_options
+    ):
 
         if interface is not None and interface not in self.INTERFACE_MAP:
             raise QuantumFunctionError(
@@ -137,6 +146,22 @@ def __init__(self, func, device, interface="autograd", diff_method="best", **dif
         self.dtype = np.float64
         self.max_expansion = 2
 
+        self._caching = caching
+        """float: number of device executions to store in a cache to speed up subsequent
+        executions. If set to zero, no caching occurs."""
+
+        if caching != 0:
+            warnings.warn(
+                "Caching mode activated. The quantum circuit being executed by the QNode must have "
+                "a fixed structure.",
+            )
+            if self.diff_method == "backprop":
+                raise ValueError('Caching mode is incompatible with the "backprop" diff_method')
+
+        self._cache_execute = OrderedDict()
+        """OrderedDict[int: Any]: A copy of the ``_cache_execute`` dictionary from the quantum
+        tape"""
+
     @staticmethod
     def get_tape(device, interface, diff_method="best"):
         """Determine the best QuantumTape, differentiation method, and interface
@@ -318,7 +343,7 @@ def _get_parameter_shift_method(device, interface):
     def construct(self, args, kwargs):
         """Call the quantum function with a tape context, ensuring the operations get queued."""
 
-        self.qtape = self._tape()
+        self.qtape = self._tape(caching=self._caching)
 
         # apply the interface (if any)
         if self.interface is not None:
@@ -362,8 +387,16 @@ def __call__(self, *args, **kwargs):
         # construct the tape
         self.construct(args, kwargs)
 
+        if self._caching:
+            self.qtape._cache_execute = self._cache_execute
+
         # execute the tape
-        return self.qtape.execute(device=self.device)
+        res = self.qtape.execute(device=self.device)
+
+        if self._caching:
+            self._cache_execute = self.qtape._cache_execute
+
+        return res
 
     def to_tf(self, dtype=None):
         """Apply the TensorFlow interface to the internal quantum tape.
@@ -435,10 +468,20 @@ def to_autograd(self):
         if self.qtape is not None:
             AutogradInterface.apply(self.qtape)
 
+    @property
+    def caching(self):
+        """float: number of device executions to store in a cache to speed up subsequent
+        executions. If set to zero, no caching occurs."""
+        return self._caching
+
+    @caching.setter
+    def caching(self, value):
+        self._caching = value
+
     INTERFACE_MAP = {"autograd": to_autograd, "torch": to_torch, "tf": to_tf}
 
 
-def qnode(device, interface="autograd", diff_method="best", **diff_options):
+def qnode(device, interface="autograd", diff_method="best", caching=0, **diff_options):
     """Decorator for creating QNodes.
 
     This decorator is used to indicate to PennyLane that the decorated function contains a
@@ -509,6 +552,12 @@ def qnode(device, interface="autograd", diff_method="best", **diff_options):
             * ``"finite-diff"``: Uses numerical finite-differences for all quantum
               operation arguments.
 
+        caching (int): number of device executions to store in a cache to speed up subsequent
+            executions. A value of ``0`` indicates that no caching will take place. Once filled,
+            older elements of the cache are removed and replaced with the most recent device
+            executions to keep the cache up to date. In caching mode, the quantum circuit
+            being executed must have a constant structure and only its parameters can be varied.
+
     Keyword Args:
         h=1e-7 (float): Step size for the finite difference method.
         order=1 (int): The order of the finite difference method to use. ``1`` corresponds
@@ -528,7 +577,14 @@ def qnode(device, interface="autograd", diff_method="best", **diff_options):
     @lru_cache()
     def qfunc_decorator(func):
         """The actual decorator"""
-        qn = QNode(func, device, interface=interface, diff_method=diff_method, **diff_options)
+        qn = QNode(
+            func,
+            device,
+            interface=interface,
+            diff_method=diff_method,
+            caching=caching,
+            **diff_options,
+        )
         return update_wrapper(qn, func)
 
     return qfunc_decorator

pennylane/beta/tapes/tape.py

@@ -15,11 +15,13 @@
 This module contains the base quantum tape.
 """
 # pylint: disable=too-many-instance-attributes,protected-access,too-many-branches
+from collections import OrderedDict
 import contextlib
 
 import numpy as np
 
 import pennylane as qml
+from pennylane.utils import _hash_iterable
 
 from pennylane.beta.queuing import AnnotatedQueue, QueuingContext
 from pennylane.beta.queuing import mock_operations
@@ -132,6 +134,7 @@ def expand_tape(tape, depth=1, stop_at=None, expand_measurements=False):
     return new_tape
 
 
+# pylint: disable=too-many-public-methods
 class QuantumTape(AnnotatedQueue):
     """A quantum tape recorder, that records, validates, executes,
     and differentiates variational quantum programs.
@@ -144,6 +147,13 @@ class QuantumTape(AnnotatedQueue):
 
         >>> from pennylane.beta.queuing import expval, var, sample, probs
 
+    Args:
+        name (str): a name given to the quantum tape
+        caching (int): number of device executions to store in a cache to speed up subsequent
+            executions. A value of ``0`` indicates that no caching will take place. Once filled,
+            older elements of the cache are removed and replaced with the most recent device
+            executions to keep the cache up to date.
+
     **Example**
 
     .. code-block:: python
@@ -215,7 +225,7 @@ class QuantumTape(AnnotatedQueue):
     [[-0.45478169]]
     """
 
-    def __init__(self, name=None):
+    def __init__(self, name=None, caching=0):
         super().__init__()
         self.name = name
 
@@ -247,6 +257,14 @@ def __init__(self, name=None):
 
         self._stack = None
 
+        self._caching = caching
+        """float: number of device executions to store in a cache to speed up subsequent
+        executions. If set to zero, no caching occurs."""
+
+        self._cache_execute = OrderedDict()
+        """OrderedDict[int: Any]: Mapping from hashes of the input parameters to results of
+        executing the device."""
+
     def __repr__(self):
         return f"<{self.__class__.__name__}: wires={self.wires.tolist()}, params={self.num_params}>"
 
@@ -912,6 +930,13 @@ def execute_device(self, params, device):
         # temporarily mutate the in-place parameters
         self.set_parameters(params)
 
+        if self._caching:
+            all_parameters = self.get_parameters(trainable_only=False)
+            hashed_params = _hash_iterable(all_parameters)
+            if hashed_params in self._cache_execute:
+                self.set_parameters(saved_parameters)
+                return self._cache_execute[hashed_params]
+
         if isinstance(device, qml.QubitDevice):
             res = device.execute(self)
         else:
@@ -936,6 +961,12 @@ def execute_device(self, params, device):
 
         # restore original parameters
         self.set_parameters(saved_parameters)
+
+        if self._caching and hashed_params not in self._cache_execute:
+            self._cache_execute[hashed_params] = res
+            if len(self._cache_execute) > self._caching:
+                self._cache_execute.popitem(last=False)
+
         return res
 
     # interfaces can optionally override the _execute method
@@ -1324,3 +1355,13 @@ def jacobian(self, device, params=None, **options):
             jac[:, idx] = g.flatten()
 
         return jac
+
+    @property
+    def caching(self):
+        """float: number of device executions to store in a cache to speed up subsequent
+        executions. If set to zero, no caching occurs."""
+        return self._caching
+
+    @caching.setter
+    def caching(self, value):
+        self._caching = value

pennylane/utils.py

@@ -433,3 +433,22 @@ def expand_vector(vector, original_wires, expanded_wires):
     expanded_tensor = np.moveaxis(expanded_tensor, original_indices, wire_indices)
 
     return expanded_tensor.reshape(2 ** M)
+
+
+def _hash_iterable(iterable):
+    """Returns a single hash of an input iterable.
+
+    The iterable must be flat and can contain only numbers and NumPy arrays.
+
+    Args:
+        iterable (Iterable): the iterable to generate a hash for
+
+    Returns:
+        int: the resulting hash
+    """
+    hashes = []
+    for obj in iterable:
+        to_hash = (obj.tobytes(), obj.shape) if isinstance(obj, np.ndarray) else obj
+        obj_hash = hash(to_hash)
+        hashes.append(obj_hash)
+    return hash(tuple(hashes))

tests/beta/interfaces/test_tape_autograd.py

@@ -34,8 +34,8 @@ def test_interface_str(self):
         assert isinstance(tape, AutogradInterface)
 
     def test_get_parameters(self):
-        """Test that the get_parameters function correctly sets and returns the
-        trainable parameters"""
+        """Test that the get_parameters function correctly gets the trainable parameters and all
+        parameters, depending on the trainable_only argument"""
         a = np.array(0.1, requires_grad=True)
         b = np.array(0.2, requires_grad=False)
         c = np.array(0.3, requires_grad=True)
@@ -48,7 +48,8 @@ def test_get_parameters(self):
             expval(qml.PauliX(0))
 
         assert tape.trainable_params == {0, 2}
-        assert np.all(tape.get_parameters() == [a, c])
+        assert np.all(tape.get_parameters(trainable_only=True) == [a, c])
+        assert np.all(tape.get_parameters(trainable_only=False) == [a, b, c, d])
 
     def test_execution(self):
         """Test execution"""