specs transform

.github/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 <h3>New features since last release</h3>
 
+* The `specs` QNode transform creates a function that produces the specifications for a circuit
+  at given arguments and keywords. The QNode property `specs` can also provide this information
+  after QNode execution.  The tape property `specs` provides a subset of the same quantities.
+  The tape functions `get_resources` and `get_depth` are supereded by `specs` and will be
+  deprecated after one release cycle.
+  [(#1245)](https://github.com/PennyLaneAI/pennylane/pull/1245)
+
+  For example:
+
+  ```python
+  dev = qml.device('default.qubit', wires=4)
+
+  @qml.qnode(dev, diff_method='parameter-shift')
+  def circuit(x, y):
+      qml.RX(x[0], wires=0)
+      qml.Toffoli(wires=(0, 1, 2))
+      qml.CRY(x[1], wires=(0, 1))
+      qml.Rot(x[2], x[3], y, wires=2)
+      return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
+
+  x = np.array([0.05, 0.1, 0.2, 0.3], requires_grad=True)
+  y = np.array(0.4, requires_grad=False)
+
+  specs_func = qml.specs(circuit)
+  info = specs_func(x, y)
+  ```
+
+  ```pycon
+  >>> info
+  {'by_size': defaultdict(int, {1: 2, 3: 1, 2: 1}),
+ 'by_name': defaultdict(int, {'RX': 1, 'Toffoli': 1, 'CRY': 1, 'Rot': 1}),
+ 'total_operations': 4,
+ 'total_observables': 2,
+ 'num_tape_wires': 3,
+ 'depth': 3,
+ 'num_trainable_params': 4,
+ 'num_parameter_shift_executions': 7,
+ 'num_device_wires': 4,
+ 'device_name': 'default.qubit',
+ 'diff_method': 'parameter-shift'}
+  ```
+
 * The ``argnum`` keyword argument can now be specified for a QNode to define a
   subset of trainable parameters used to estimate the Jacobian.
   [(#1371)](https://github.com/PennyLaneAI/pennylane/pull/1371)

pennylane/__init__.py

@@ -49,6 +49,7 @@
     ctrl,
     measurement_grouping,
     metric_tensor,
+    specs,
     qfunc_transform,
     single_tape_transform,
     quantum_monte_carlo,

pennylane/qnode.py

@@ -720,6 +720,63 @@ def circuit():
             charset=charset, wire_order=wire_order, show_all_wires=show_all_wires
         )
 
+    @property
+    def specs(self):
+        """
+        Returns:
+            A dictionary of information about qnode structure
+
+        **Example**
+
+        .. code-block:: python3
+
+            dev = qml.device('default.qubit', wires=2)
+            @qml.qnode(dev)
+            def circuit(x):
+                qml.RX(x[0], wires=0)
+                qml.RY(x[1], wires=1)
+                qml.CNOT(wires=(0,1))
+                return qml.probs(wires=(0,1))
+
+            x = np.array([0.1, 0.2])
+            res = circuit(x)
+
+        >>> circuit.specs
+        {'by_size': defaultdict(int, {1: 2, 2: 1}),
+        'by_name': defaultdict(int, {'RX': 1, 'RY': 1, 'CNOT': 1}),
+        'total_operations': 3,
+        'total_observables': 1,
+        'num_tape_wires': 2,
+        'depth': 2,
+        'num_device_wires': 2,
+        'device_name': 'default.qubit.autograd',
+        'diff_method': 'backprop'}
+
+        """
+        if self.qtape is None:
+            raise qml.QuantumFunctionError(
+                "The QNode specifications can only be calculated after its quantum tape has been constructed."
+            )
+
+        info = self.qtape.specs.copy()
+
+        info["num_device_wires"] = self.device.num_wires
+        info["device_name"] = self.device.short_name
+
+        # TODO: use self.diff_method when that value gets updated
+        if self.diff_method != "best":
+            info["diff_method"] = self.diff_method
+        else:
+            info["diff_method"] = self.qtape.jacobian_options["method"]
+
+        # tape's do not accurately track parameters for backprop
+        # TODO: calculate number of trainable parameters in backprop
+        # find better syntax for determining if backprop
+        if info["diff_method"] == "backprop":
+            del info["num_trainable_params"]
+
+        return info
+
     def to_tf(self, dtype=None):
         """Apply the TensorFlow interface to the internal quantum tape.
 

pennylane/tape/qubit_param_shift.py

@@ -379,3 +379,22 @@ def processing_fn(results):
             return np.apply_along_axis(dot, 0, results)
 
         return tapes, processing_fn
+
+    @property
+    def specs(self):
+
+        if "grad_method" not in self._par_info[0]:
+            self._update_gradient_info()
+
+        # Initialize with the forward pass execution
+        num_executions = 1
+        # Loop over all variables
+        for _, info in self._par_info.items():
+
+            if info["grad_method"] == "A":
+                num_executions += len(info["op"].get_parameter_shift(info["p_idx"]))
+
+        info = super().specs
+        info["num_parameter_shift_executions"] = num_executions
+
+        return info

pennylane/tape/tape.py

@@ -15,10 +15,11 @@
 This module contains the base quantum tape.
 """
 # pylint: disable=too-many-instance-attributes,protected-access,too-many-branches,too-many-public-methods
-from collections import Counter, deque
+from collections import Counter, deque, defaultdict
 import contextlib
 import copy
 from threading import RLock
+import warnings
 
 import numpy as np
 
@@ -317,7 +318,7 @@ def __init__(self, name=None, do_queue=True):
 
         self._trainable_params = set()
         self._graph = None
-        self._resources = None
+        self._specs = None
         self._depth = None
         self._output_dim = 0
 
@@ -500,7 +501,7 @@ def _update_trainable_params(self):
     def _update(self):
         """Update all internal tape metadata regarding processed operations and observables"""
         self._graph = None
-        self._resources = None
+        self._specs = None
         self._depth = None
         self._update_circuit_info()
         self._update_par_info()
@@ -1002,23 +1003,23 @@ def get_resources(self):
 
         >>> tape.get_resources()
         {'Hadamard': 2, 'RZ': 1, 'CNOT': 2, 'Rot': 1}
+
         """
-        if self._resources is None:
-            self._resources = {}
 
-            for op in self.operations:
-                if op.name not in self._resources.keys():
-                    self._resources[op.name] = 1
-                else:
-                    self._resources[op.name] += 1
+        warnings.warn(
+            "``tape.get_resources`` will be deprecated after v0.16 "
+            "Please use the more general ``tape.specs`` instead.",
+            UserWarning,
+        )
 
-        return self._resources
+        return self.specs["by_name"]
 
     def get_depth(self):
         """Depth of the quantum circuit.
 
         Returns:
-            int: Circuit depth, computed as the longest path in the circuit's directed acyclic graph representation.
+            int: Circuit depth, computed as the longest path in the
+            circuit's directed acyclic graph representation.
 
         **Example**
 
@@ -1036,12 +1037,70 @@ def get_depth(self):
 
         >>> tape.get_depth()
         4
+
         """
+
+        warnings.warn(
+            "``tape.get_depth`` will be deprecated after v0.16 "
+            "Please use the more general ``tape.specs`` instead.",
+            UserWarning,
+        )
+
         if self._depth is None:
             self._depth = self.graph.get_depth()
 
         return self._depth
 
+    @property
+    def specs(self):
+        """Resource requirements of a quantum circuit.
+
+        Returns:
+            dict[str, Union[defaultdict,int]]: how many times constituent operations are applied
+
+        **Example**
+
+        .. code-block:: python3
+
+            with qml.tape.QuantumTape() as tape:
+                qml.Hadamard(wires=0)
+                qml.RZ(0.26, wires=1)
+                qml.CNOT(wires=[1, 0])
+                qml.Rot(1.8, -2.7, 0.2, wires=0)
+                qml.Hadamard(wires=1)
+                qml.CNOT(wires=[0, 1])
+                qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
+
+        Asking for the resources produces a dictionary as shown below:
+
+        >>> tape.specs['by_size']
+        defaultdict(int, {1: 4, 2: 2})
+        >>> tape.specs['by_name']
+        defaultdict(int, {'Hadamard': 2, 'RZ': 1, 'CNOT': 2, 'Rot': 1})
+
+        As `defaultdict` objects, any key not present in the dictionary returns 0.
+
+        >>> tape.specs['by_name']['RX']
+        0
+
+        """
+        if self._specs is None:
+            self._specs = {"by_size": defaultdict(int), "by_name": defaultdict(int)}
+
+            for op in self.operations:
+                # don't use op.num_wires to allow for flexible gate classes like hermitian
+                self._specs["by_size"][len(op.wires)] += 1
+
+                self._specs["by_name"][op.name] += 1
+
+            self._specs["total_operations"] = len(self.operations)
+            self._specs["total_observables"] = len(self.observables)
+            self._specs["num_tape_wires"] = self.num_wires
+            self._specs["depth"] = self.graph.get_depth()
+            self._specs["num_trainable_params"] = self.num_params
+
+        return self._specs
+
     def draw(self, charset="unicode", wire_order=None, show_all_wires=False):
         """Draw the quantum tape as a circuit diagram.
 

pennylane/transforms/__init__.py

@@ -32,6 +32,7 @@
     ~transforms.classical_jacobian
     ~draw
     ~metric_tensor
+    ~specs
 
 Transforms that act on quantum functions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -81,5 +82,6 @@
 from .invisible import invisible
 from .measurement_grouping import measurement_grouping
 from .metric_tensor import metric_tensor, metric_tensor_tape
+from .specs import specs
 from .qfunc_transforms import make_tape, single_tape_transform, qfunc_transform
 from .qmc import quantum_monte_carlo

pennylane/transforms/draw.py

@@ -30,7 +30,7 @@ def draw(qnode, charset="unicode", wire_order=None, show_all_wires=False):
         show_all_wires (bool): If True, all wires, including empty wires, are printed.
 
     Returns:
-        A function that has the same arguement signature as ``qnode``. When called,
+        A function that has the same argument signature as ``qnode``. When called,
         the function will draw the QNode.
 
     **Example**

pennylane/transforms/specs.py

@@ -0,0 +1,95 @@
+# Copyright 2018-2021 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Code for resource estimation"""
+
+
+def specs(qnode, max_expansion=None):
+    """
+
+    Args:
+        qnode (.QNode): the QNode to calculation the specifications for
+
+    Keyword Args:
+        max_expansion=None (int): The number of times the internal circuit should be expanded when
+            executed on a device. Expansion occurs when an operation or measurement is not
+            supported, and results in a gate decomposition. If any operations in the decomposition
+            remain unsupported by the device, another expansion occurs. Defaults to
+            ``qnode.max_expansion``.
+
+    Returns:
+        A function that has the same argument signature as ``qnode``. This function
+        returns a dictionary of information about qnode structure
+
+    **Example**
+
+    .. code-block:: python3
+
+        x = np.array([0.1, 0.2])
+
+        dev = qml.device('default.qubit', wires=2)
+        @qml.qnode(dev)
+        def circuit(x, add_ry=True):
+            qml.RX(x[0], wires=0)
+            qml.CNOT(wires=(0,1))
+            if add_ry:
+                qml.RY(x[1], wires=1)
+            return qml.probs(wires=(0,1))
+
+    >>> info = qml.specs(circuit)(x, add_ry=False)
+    {'by_size': defaultdict(int, {1: 1, 2: 1}),
+    'by_name': defaultdict(int, {'RX': 1, 'CNOT': 1}),
+    'total_operations': 2,
+    'total_observables': 1,
+    'num_tape_wires': 2,
+    'depth': 2,
+    'num_device_wires': 2,
+    'device_name': 'default.qubit.autograd',
+    'diff_method': 'backprop'}
+
+    """
+
+    def specs_qnode(*args, **kwargs):
+        """Returns information on the structure and makeup of provided QNode.
+
+        Dictionary keys:
+            * ``"total_operations"``
+            * ``"total_observables"``
+            * ``"by_size"``: dictionary mapping gate number of wires to number of occurances
+            * ``"by_name"``: dictionary mapping gate types to number of occurances
+            * ``"num_tape_wires"``: number of wires used by the circuit
+            * ``"num_wires"``: number of wires in device
+            * ``"depth"``: longest path in directed acyclic graph representation
+            * ``"dev_short_name"``: name of QNode device
+            * ``"diff_method"``
+
+        Potential Additional Information:
+            * ``"num_trainable_params"``: number of individual scalars that are trainable
+            * ``"num_parameter_shift_executions"``: number of times circuit will execute when
+                    calculating the derivative
+
+        Returns:
+            dict: information about qnode structure
+        """
+        if max_expansion is not None:
+            initial_max_expansion = qnode.max_expansion
+            qnode.max_expansion = max_expansion
+
+        qnode.construct(args, kwargs)
+
+        if max_expansion is not None:
+            qnode.max_expansion = initial_max_expansion
+
+        return qnode.specs
+
+    return specs_qnode