Deprecating Legacy Devices

doc/development/deprecations.rst

@@ -9,6 +9,12 @@ deprecations are listed below.
 Pending deprecations
 --------------------
 
+* All of the legacy devices (any with the name ``default.qubit.{autograd,torch,tf,jax,legacy}``) are deprecated. Use ``default.qubit`` instead,
+  as it supports backpropagation for the many backends the legacy devices support.
+
+  - Deprecated in v0.38
+  - Will be removed in v0.39
+
 * The functions ``qml.transforms.sum_expand`` and ``qml.transforms.hamiltonian_expand`` are deprecated.
   Instead, ``qml.transforms.split_non_commuting`` can be used for equivalent behaviour.
 

doc/releases/changelog-dev.md

@@ -117,6 +117,10 @@
   Instead, use `pennylane.gradients.classical_fisher` and `pennylane.gradients.quantum_fisher`.
   [(#5985)](https://github.com/PennyLaneAI/pennylane/pull/5985)
 
+* The legacy devices `default.qubit.{autograd,torch,tf,jax,legacy}` are deprecated.
+  Instead, use `default.qubit` as it now supports backpropagation through the several backends.
+  [(#5997)](https://github.com/PennyLaneAI/pennylane/pull/5997)
+
 <h3>Documentation 📝</h3>
 
 * Improves the docstring for `QuantumScript.expand` and `qml.tape.tape.expand_tape`.

pennylane/devices/default_qubit_autograd.py

@@ -14,12 +14,15 @@
 """This module contains an autograd implementation of the :class:`~.DefaultQubitLegacy`
 reference plugin.
 """
+import warnings
+
+from pennylane import PennyLaneDeprecationWarning
 from pennylane import numpy as pnp
 from pennylane.devices import DefaultQubitLegacy
 
 
 class DefaultQubitAutograd(DefaultQubitLegacy):
-    """Simulator plugin based on ``"default.qubit.legacy"``, written using Autograd.
+    r"""Simulator plugin based on ``"default.qubit.legacy"``, written using Autograd.
 
     **Short name:** ``default.qubit.autograd``
 
@@ -34,6 +37,9 @@ class DefaultQubitAutograd(DefaultQubitLegacy):
 
         pip install autograd
 
+    .. warning::
+        This device is deprecated. Use :class:`~pennylane.devices.DefaultQubit` instead; for example through ``qml.device("default.qubit")``, which now supports backpropagation.
+
     **Example**
 
     The ``default.qubit.autograd`` is designed to be used with end-to-end classical backpropagation
@@ -104,6 +110,14 @@ def _const_mul(constant, array):
         return constant * array
 
     def __init__(self, wires, *, shots=None, analytic=None):
+        warnings.warn(
+            f"Use of '{self.short_name}' is deprecated. Instead, use 'default.qubit', "
+            "which supports backpropagation. "
+            "If you experience issues, reach out to the PennyLane team on "
+            "the discussion forum: https://discuss.pennylane.ai/",
+            PennyLaneDeprecationWarning,
+        )
+
         r_dtype = pnp.float64
         c_dtype = pnp.complex128
         super().__init__(wires, shots=shots, r_dtype=r_dtype, c_dtype=c_dtype, analytic=analytic)

pennylane/devices/default_qubit_jax.py

@@ -14,6 +14,8 @@
 """This module contains a jax implementation of the :class:`~.DefaultQubitLegacy`
 reference plugin.
 """
+import warnings
+
 # pylint: disable=ungrouped-imports
 import numpy as np
 
@@ -34,7 +36,7 @@
 
 
 class DefaultQubitJax(DefaultQubitLegacy):
-    """Simulator plugin based on ``"default.qubit.legacy"``, written using jax.
+    r"""Simulator plugin based on ``"default.qubit.legacy"``, written using jax.
 
     **Short name:** ``default.qubit.jax``
 
@@ -49,6 +51,9 @@ class DefaultQubitJax(DefaultQubitLegacy):
 
         pip install jax jaxlib
 
+    .. warning::
+        This device is deprecated. Use :class:`~pennylane.devices.DefaultQubit` instead; for example through ``qml.device("default.qubit")``, which now supports backpropagation.
+
     **Example**
 
     The ``default.qubit.jax`` device is designed to be used with end-to-end classical backpropagation
@@ -165,6 +170,14 @@ def circuit():
     operations = DefaultQubitLegacy.operations.union({"ParametrizedEvolution"})
 
     def __init__(self, wires, *, shots=None, prng_key=None, analytic=None):
+        warnings.warn(
+            f"Use of '{self.short_name}' is deprecated. Instead, use 'default.qubit', "
+            "which supports backpropagation. "
+            "If you experience issues, reach out to the PennyLane team on "
+            "the discussion forum: https://discuss.pennylane.ai/",
+            qml.PennyLaneDeprecationWarning,
+        )
+
         if jax.config.read("jax_enable_x64"):
             c_dtype = jnp.complex128
             r_dtype = jnp.float64

pennylane/devices/default_qubit_legacy.py

@@ -20,6 +20,7 @@
 """
 import functools
 import itertools
+import warnings
 from string import ascii_letters as ABC
 from typing import List
 
@@ -78,13 +79,13 @@ def _get_slice(index, axis, num_axes):
 
 # pylint: disable=unused-argument
 class DefaultQubitLegacy(QubitDevice):
-    """Default qubit device for PennyLane.
+    r"""Default qubit device for PennyLane.
 
     .. warning::
 
-        This is the legacy implementation of DefaultQubit. It has been replaced by
-        ``qml.devices.DefaultQubit``, which can be accessed with the familiar constructor,
-        ``qml.device("default.qubit")``.
+        This is the legacy implementation of DefaultQubit and is deprecated. It has been replaced by
+        :class:`~.devices.DefaultQubit`, which can be accessed with the familiar constructor,
+        ``qml.device("default.qubit")``, and now supports backpropagation.
 
         This change will not alter device behaviour for most workflows, but may have implications for
         plugin developers and users who directly interact with device methods. Please consult
@@ -207,6 +208,14 @@ class DefaultQubitLegacy(QubitDevice):
     def __init__(
         self, wires, *, r_dtype=np.float64, c_dtype=np.complex128, shots=None, analytic=None
     ):
+        warnings.warn(
+            f"Use of '{self.short_name}' is deprecated. Instead, use 'default.qubit', "
+            "which supports backpropagation. "
+            "If you experience issues, reach out to the PennyLane team on "
+            "the discussion forum: https://discuss.pennylane.ai/",
+            qml.PennyLaneDeprecationWarning,
+        )
+
         super().__init__(wires, shots, r_dtype=r_dtype, c_dtype=c_dtype, analytic=analytic)
         self._debugger = None
 

pennylane/devices/default_qubit_tf.py

@@ -15,6 +15,7 @@
 reference plugin.
 """
 import itertools
+import warnings
 
 import numpy as np
 from packaging.version import Version
@@ -42,7 +43,7 @@
 
 
 class DefaultQubitTF(DefaultQubitLegacy):
-    """Simulator plugin based on ``"default.qubit.legacy"``, written using TensorFlow.
+    r"""Simulator plugin based on ``"default.qubit.legacy"``, written using TensorFlow.
 
     **Short name:** ``default.qubit.tf``
 
@@ -57,6 +58,9 @@ class DefaultQubitTF(DefaultQubitLegacy):
 
         pip install tensorflow>=2.0
 
+    .. warning::
+        This device is deprecated. Use :class:`~pennylane.devices.DefaultQubit` instead; for example through ``qml.device("default.qubit")``, which now supports backpropagation.
+
     **Example**
 
     The ``default.qubit.tf`` is designed to be used with end-to-end classical backpropagation
@@ -162,6 +166,14 @@ def _asarray(array, dtype=None):
         return res
 
     def __init__(self, wires, *, shots=None, analytic=None):
+        warnings.warn(
+            f"Use of '{self.short_name}' is deprecated. Instead, use 'default.qubit', "
+            "which supports backpropagation. "
+            "If you experience issues, reach out to the PennyLane team on "
+            "the discussion forum: https://discuss.pennylane.ai/",
+            qml.PennyLaneDeprecationWarning,
+        )
+
         r_dtype = tf.float64
         c_dtype = tf.complex128
 

pennylane/devices/default_qubit_torch.py

@@ -34,6 +34,7 @@
 
 import numpy as np
 
+from pennylane import PennyLaneDeprecationWarning
 from pennylane.ops.qubit.attributes import diagonal_in_z_basis
 
 from . import DefaultQubitLegacy
@@ -43,7 +44,7 @@
 
 
 class DefaultQubitTorch(DefaultQubitLegacy):
-    """Simulator plugin based on ``"default.qubit.legacy"``, written using PyTorch.
+    r"""Simulator plugin based on ``"default.qubit.legacy"``, written using PyTorch.
 
     **Short name:** ``default.qubit.torch``
 
@@ -58,6 +59,10 @@ class DefaultQubitTorch(DefaultQubitLegacy):
 
         pip install torch>=1.8.0
 
+    .. warning::
+        This device is deprecated. Use :class:`~pennylane.devices.DefaultQubit` instead; for example through ``qml.device("default.qubit")``, which now supports backpropagation.
+
+
     **Example**
 
     The ``default.qubit.torch`` is designed to be used with end-to-end classical backpropagation
@@ -165,6 +170,13 @@ def circuit(x):
     _ndim = staticmethod(lambda tensor: tensor.ndim)
 
     def __init__(self, wires, *, shots=None, analytic=None, torch_device=None):
+        warnings.warn(
+            f"Use of '{self.short_name}' is deprecated. Instead, use 'default.qubit', "
+            "which supports backpropagation. "
+            "If you experience issues, reach out to the PennyLane team on "
+            "the discussion forum: https://discuss.pennylane.ai/",
+            PennyLaneDeprecationWarning,
+        )
         # Store if the user specified a Torch device. Otherwise the execute
         # method attempts to infer the Torch device from the gate parameters.
         self._torch_device_specified = torch_device is not None

pennylane/devices/qubit/simulate.py

@@ -230,7 +230,6 @@ def measure_final_state(circuit, state, is_state_batched, **execution_kwargs) ->
     mid_measurements = execution_kwargs.get("mid_measurements", None)
 
     # analytic case
-
     if not circuit.shots:
         if mid_measurements is not None:
             raise TypeError("Native mid-circuit measurements are only supported with finite shots.")
@@ -243,7 +242,6 @@ def measure_final_state(circuit, state, is_state_batched, **execution_kwargs) ->
         )
 
     # finite-shot case
-
     rng = default_rng(rng)
     results = measure_with_samples(
         circuit.measurements,

pennylane/drawer/tape_mpl.py

@@ -459,6 +459,7 @@ def tape_mpl(
     if update_style := (has_mpl and style != "rcParams"):
         restore_params = mpl.rcParams.copy()
         _set_style(style)
+
     try:
         return _tape_mpl(
             tape,

pennylane/gradients/pulse_gradient.py

@@ -392,7 +392,7 @@ def stoch_pulse_grad(
 
         jax.config.update("jax_enable_x64", True)
 
-        dev = qml.device("default.qubit.jax")
+        dev = qml.device("default.qubit")
 
         def sin(p, t):
             return jax.numpy.sin(p * t)

pennylane/gradients/pulse_gradient_odegen.py

@@ -484,7 +484,7 @@ def pulse_odegen(
 
     .. code-block:: python
 
-        dev = qml.device("default.qubit.jax")
+        dev = qml.device("default.qubit")
 
         @qml.qnode(dev, interface="jax", diff_method=qml.gradients.pulse_odegen)
         def circuit(params):

pennylane/ops/functions/evolve.py

@@ -129,7 +129,10 @@ def evolve(*args, **kwargs):  # pylint: disable=unused-argument
 
         import jax
 
-        dev = qml.device("default.qubit.jax", wires=4)
+        jax.config.update("jax_enable_x64", True)
+
+        dev = qml.device("default.qubit")
+
         @jax.jit
         @qml.qnode(dev, interface="jax")
         def circuit(params):
@@ -138,13 +141,13 @@ def circuit(params):
 
     >>> params = [1., 2., 3., 4.]
     >>> circuit(params)
-    Array(0.8627419, dtype=float32)
+    Array(0.86231063, dtype=float64)
 
     >>> jax.grad(circuit)(params)
-    [Array(50.690746, dtype=float32),
-    Array(-6.296886e-05, dtype=float32),
-    Array(-6.3341584e-05, dtype=float32),
-    Array(-7.052516e-05, dtype=float32)]
+    [Array(50.391273, dtype=float64),
+    Array(-9.42415807e-05, dtype=float64),
+    Array(-0.0001049, dtype=float64),
+    Array(-0.00010601, dtype=float64)]
 
     .. note::
         In the example above, the decorator ``@jax.jit`` is used to compile this execution just-in-time. This means

pennylane/pulse/__init__.py

@@ -236,7 +236,9 @@
 
     import jax
 
-    dev = qml.device("default.qubit.jax", wires=1)
+    jax.config.update("jax_enable_x64", True)
+
+    dev = qml.device("default.qubit", wires=1)
 
     @jax.jit
     @qml.qnode(dev, interface="jax")
@@ -246,10 +248,10 @@ def circuit(params):
 
 >>> params = [1.2]
 >>> circuit(params)
-Array(0.96632576, dtype=float32)
+Array(0.96632722, dtype=float64)
 
 >>> jax.grad(circuit)(params)
-[Array(2.3569832, dtype=float32)]
+[Array(2.35694829, dtype=float64)]
 
 We can use the decorator ``jax.jit`` to compile this execution just-in-time. This means the first execution
 will typically take a little longer with the benefit that all following executions will be significantly faster.

pennylane/pulse/convenience_functions.py

@@ -25,7 +25,7 @@
 
 # pylint: disable=unused-argument
 def constant(scalar, time):
-    """Returns the given ``scalar``, for use in defining a :class:`~.ParametrizedHamiltonian` with a
+    r"""Returns the given ``scalar``, for use in defining a :class:`~.ParametrizedHamiltonian` with a
     trainable coefficient.
 
     Args:
@@ -57,7 +57,12 @@ def constant(scalar, time):
 
     .. code-block:: python
 
-        dev = qml.device("default.qubit.jax", wires=1)
+        import jax
+
+        jax.config.update("jax_enable_x64", True)
+
+        dev = qml.device("default.qubit")
+
         @qml.qnode(dev, interface="jax")
         def circuit(params):
             qml.evolve(H)(params, t=2)
@@ -66,10 +71,10 @@ def circuit(params):
 
     >>> params = jnp.array([5.0])
     >>> circuit(params)
-    Array(0.40808904, dtype=float32)
+    Array(0.40808193, dtype=float64)
 
     >>> jax.grad(circuit)(params)
-    Array([-3.6517754], dtype=float32)
+    Array([-3.65178003], dtype=float64)
     """
     return scalar