[Return-types #3] QNode integration, enable and disable functions

.github/workflows/tests.yml

@@ -193,6 +193,56 @@ jobs:
           name: qcut-coverage
           path: ./coverage.xml
 
+  return-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Cancel Previous Runs
+        uses: styfle/cancel-workflow-action@0.4.1
+        with:
+          access_token: ${{ github.token }}
+
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip && pip install wheel --upgrade
+          pip install -r requirements-ci.txt --upgrade
+          pip install -r requirements-dev.txt --upgrade
+
+      - name: Install PyTorch
+        run: pip3 install torch==$TORCH_VERSION -f https://download.pytorch.org/whl/torch_stable.html
+
+      - name: Install TensorFlow
+        run: pip3 install tensorflow~=$TF_VERSION keras~=$TF_VERSION
+
+      - name: Install JAX
+        run: pip3 install jax jaxlib
+
+      - name: Install PennyLane
+        run: |
+          python setup.py bdist_wheel
+          pip install dist/PennyLane*.whl
+
+      - name: Run tests
+        run: |
+          python -m pytest tests/returntypes --cov=pennylane $COVERAGE_FLAGS -n auto
+
+      - name: Adjust coverage file for Codecov
+        run: bash <(sed -i 's/filename=\"/filename=\"pennylane\//g' coverage.xml)
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: return-coverage
+          path: ./coverage.xml
+
   qchem-tests:
     runs-on: ubuntu-latest
 
@@ -305,7 +355,7 @@ jobs:
           path: ./coverage.xml
 
   upload-to-codecov:
-      needs: [core-and-interface-tests, all-interfaces-tests, qcut-tests, qchem-tests, device-tests]
+      needs: [core-and-interface-tests, all-interfaces-tests, qcut-tests, return-tests, qchem-tests, device-tests]
       runs-on: ubuntu-latest
       steps:
         - name: Checkout

pennylane/interfaces/execution.py

@@ -598,12 +598,12 @@ def cost_fn(params, x):
 
     if gradient_fn is None:
         # don't unwrap if it's an interface device
-        # if "passthru_interface" in device.capabilities():
-        #     return batch_fn(
-        #         qml.interfaces.cache_execute(
-        #             batch_execute, cache, return_tuple=False, expand_fn=expand_fn
-        #         )(tapes)
-        #     )
+        if "passthru_interface" in device.capabilities() or device.short_name == "default.mixed":
+            return batch_fn(
+                qml.interfaces.cache_execute(
+                    batch_execute, cache, return_tuple=False, expand_fn=expand_fn
+                )(tapes)
+            )
         with qml.tape.Unwrap(*tapes):
             res = qml.interfaces.cache_execute(
                 batch_execute, cache, return_tuple=False, expand_fn=expand_fn

pennylane/math/utils.py

@@ -404,7 +404,8 @@ def requires_grad(tensor, interface=None):
 
 def in_backprop(tensor, interface=None):
     """Returns True if the tensor is considered to be in a backpropagation environment, it works for Autograd,
-    Tensorflow and Jax.
+    Tensorflow and Jax. It is not only checking the differentiability of the tensor like :func:`~.requires_grad`, but
+    rather checking if the gradient is actually calculated.
 
     Args:
         tensor (tensor_like): input tensor
@@ -420,7 +421,7 @@ def in_backprop(tensor, interface=None):
     ...     print(requires_grad(x))
     True
 
-    .. seealso:: :func:`~~requires_grad`
+    .. seealso:: :func:`~.requires_grad`
     """
     interface = interface or get_interface(tensor)
 

pennylane/return_types.py

@@ -14,25 +14,22 @@
 """
 Class and functions for activating, deactivating and checking the new return types system
 """
-# pylint: disable=too-few-public-methods
-
-
-class ReturnType:
-    """Class to store the attribute `activated` which indicates if the new return type system is on. Default=False."""
-
-    activated = False
+# pylint: disable=global-statement
+__activated = False
 
 
 def enable_return():
     """Function that turns on the new return type system."""
-    ReturnType.activated = True
+    global __activated
+    __activated = True
 
 
 def disable_return():
     """Function that turns off the new return type system."""
-    ReturnType.activated = False
+    global __activated
+    __activated = False  # pragma: no cover
 
 
 def active_return():
     """Function that returns if the new return types system is activated."""
-    return ReturnType.activated
+    return __activated

tests/conftest.py

@@ -213,13 +213,17 @@ def pytest_collection_modifyitems(items, config):
         if "qchem" in rel_path.parts:
             mark = getattr(pytest.mark, "qchem")
             item.add_marker(mark)
+        if "returntypes" in rel_path.parts:
+            mark = getattr(pytest.mark, "return")
+            item.add_marker(mark)
 
     # Tests that do not have a specific suite marker are marked `core`
     for item in items:
         markers = {mark.name for mark in item.iter_markers()}
         if (
             not any(
-                elem in ["autograd", "torch", "tf", "jax", "qchem", "qcut", "all_interfaces"]
+                elem
+                in ["autograd", "torch", "tf", "jax", "qchem", "qcut", "all_interfaces", "return"]
                 for elem in markers
             )
             or not markers

tests/math/test_functions.py

@@ -1105,7 +1105,7 @@ class TestInBackprop:
 
     @pytest.mark.slow
     def test_jax(self):
-        """JAX DeviceArrays differentiability depends on the argnums argument"""
+        """The value of in_backprop for JAX DeviceArrays depends on the argnums argument"""
         res = None
 
         def cost_fn(t, s):
@@ -1126,21 +1126,22 @@ def cost_fn(t, s):
         assert res == [True, True]
 
     def test_autograd_backwards(self):
-        """Autograd trainability corresponds to the requires_grad attribute during the backwards pass."""
+        """The value of in_backprop for Autograd tensors corresponds to the requires_grad attribute during the backwards pass."""
         res = None
 
         def cost_fn(t, s):
             nonlocal res
             res = [fn.in_backprop(t), fn.in_backprop(s)]
             return np.sum(t * s)
 
-        t = np.array([1.0, 2.0, 3.0])
-        s = np.array([-2.0, -3.0, -4.0])
+        t = np.array([1.0, 2.0, 3.0], requires_grad=True)
+        s = np.array([-2.0, -3.0, -4.0], requires_grad=True)
 
         qml.grad(cost_fn)(t, s)
         assert res == [True, True]
 
         t.requires_grad = False
+        s.requires_grad = True
         qml.grad(cost_fn)(t, s)
         assert res == [False, True]
 
@@ -1156,7 +1157,7 @@ def cost_fn(t, s):
         assert res == [False, False]
 
     def test_tf(self):
-        """TensorFlow tensors will True *if* they are being watched by a gradient tape"""
+        """The value of in_backprop for TensorFlow tensors is True *if* they are being watched by a gradient tape"""
         t1 = tf.Variable([1.0, 2.0])
         t2 = tf.constant([1.0, 2.0])
         assert not fn.in_backprop(t1)
@@ -1178,8 +1179,8 @@ def test_tf_autograph(self):
         """TensorFlow tensors will True *if* they are being watched by a gradient tape with Autograph."""
         t1 = tf.Variable([1.0, 2.0])
         t2 = tf.constant([1.0, 2.0])
-        assert not fn.requires_grad(t1)
-        assert not fn.requires_grad(t2)
+        assert not fn.in_backprop(t1)
+        assert not fn.in_backprop(t2)
 
         @tf.function
         def f_pow(x):
@@ -1188,16 +1189,16 @@ def f_pow(x):
         with tf.GradientTape():
             # variables are automatically watched within a context,
             # but constants are not
+            y = f_pow(t1)
             assert fn.in_backprop(t1)
             assert not fn.in_backprop(t2)
-            y = f_pow(t1)
 
         with tf.GradientTape() as tape:
             # watching makes all tensors trainable
             tape.watch([t1, t2])
+            y = f_pow(t1)
             assert fn.in_backprop(t1)
             assert fn.in_backprop(t2)
-            y = f_pow(t1)
 
     @pytest.mark.torch
     def test_unknown_interface_in_backprop(self):

tests/pytest.ini

@@ -10,6 +10,7 @@ markers =
     gpu: marks tests run on a GPU (deselect with '-m "not gpu"')
     qchem: marks tests for the QChem module (deselect with '-m "not qchem"')
     qcut: marks tests for the QCut transform (deselect with '-m "not qcut"')
+    return: marks tests for the new return types (deselect with '-m "not return"')
 filterwarnings = 
     ignore::DeprecationWarning:autograd.numpy.numpy_wrapper
     ignore:Casting complex values to real::autograd.numpy.numpy_wrapper

tests/returntypes/conftest.py

@@ -0,0 +1,9 @@
+import pennylane as qml
+
+
+def pytest_sessionstart(session):
+    qml.enable_return()
+
+
+def pytest_sessionfinish(session, exitstatus):
+    qml.disable_return()