Deprecate device(..., shots=...) base (#7979)

**Context:**
`device(..., shots=...)` has been a popular user interface almost
everywhere, therefore its deprecation should be taking much longer than
a usual one.
To ease our work, here is the base PR to help set up the basics: define
the deprecation message and **suppress** the deprecation as error for
this specific deprecation for now.

**Description of the Change:**
Source code: 
- Initialization of a `Device` with `shots=` kwarg will raise a
`PennyLaneDeprecationWarning`
- within PennyLane codebase, shots extraction from devices will be
replaced with QNode shots
 - `quantum_fisher` use `tape.shots` isntead of `device.shots`
- `ShotAdaptiveOptimizer` in `optimize/shot_adaptive.py` checks
finite-shots status of qnode instead of `check_device`
 - Updated docstring of `CoutnsMP` and `SampleMP`

Tests:
- Whoever used `device(..., shots=...)` have been changed with
`set_shots`

**Benefits:**

**Possible Drawbacks:**
 - We did not update the legacy device interface
 - Note that `capture` is still using device shots as a hard requirement
- Similarly, the python compiler based on xdsl also requires device
shots

**Related GitHub Issues:**
[sc-90927]

---------

Co-authored-by: Andrija Paurevic <[email protected]>
Co-authored-by: Christina Lee <[email protected]>

Author: 3 people

doc/development/deprecations.rst

@@ -9,6 +9,21 @@ deprecations are listed below.
 Pending deprecations
 --------------------
 
+* Setting shots on a device through the `shots=` kwarg is deprecated.
+  Please use the :func:`pennylane.set_shots` transform on the :class:`~.QNode` instead.
+
+  .. code-block:: python
+  
+    dev = qml.device("default.qubit", wires=2)
+    @qml.set_shots(1000)
+    @qml.qnode(dev)
+    def circuit(x):
+        qml.RX(x, wires=0)
+        return qml.expval(qml.Z(0))
+
+  - Deprecated in v0.43
+  - Will be removed in a future version
+
 * Maintenance support for the ``tensorflow`` interface has been deprecated and will be dropped in PennyLane v0.44.
   Future versions of PennyLane are not guaranteed to work with TensorFlow.
   Instead, we recommend using the :doc:`jax </introduction/interfaces/jax>` or :doc:`torch </introduction/interfaces/torch>` interface for

doc/releases/changelog-dev.md

@@ -364,6 +364,20 @@
 
 <h3>Deprecations 👋</h3>
 
+* Setting shots on a device through the `shots=` kwarg, e.g. `qml.device("default.qubit", wires=2, shots=1000)`, is deprecated. Please use the `set_shots` transform on the `QNode` instead.
+
+  ```python
+  dev = qml.device("default.qubit", wires=2)
+
+  @qml.set_shots(1000)
+  @qml.qnode(dev)
+  def circuit(x):
+      qml.RX(x, wires=0)
+      return qml.expval(qml.Z(0))
+  ```
+
+  [(#7979)](https://github.com/PennyLaneAI/pennylane/pull/7979)
+
 * Support for using TensorFlow with PennyLane has been deprecated and will be dropped in Pennylane v0.44.
   Future versions of PennyLane are not guaranteed to work with TensorFlow.
   Instead, we recommend using the :doc:`JAX </introduction/interfaces/jax>` or :doc:`PyTorch </introduction/interfaces/torch>` interface for

pennylane/devices/device_api.py

@@ -16,12 +16,14 @@
 """
 
 import abc
+import warnings
 from collections.abc import Iterable
 from dataclasses import replace
 from numbers import Number
 from typing import overload
 
 import pennylane as qml
+from pennylane.exceptions import PennyLaneDeprecationWarning
 from pennylane.measurements import Shots
 from pennylane.tape import QuantumScript, QuantumScriptOrBatch
 from pennylane.tape.qscript import QuantumScriptBatch
@@ -187,6 +189,11 @@ def name(self) -> str:
     def __init__(self, wires=None, shots=None) -> None:
         # each instance should have its own Tracker.
         self.tracker = Tracker()
+        if shots is not None and shots != Shots():
+            warnings.warn(
+                "Setting shots on device is deprecated. Please use the `set_shots` transform on the respective QNode instead.",
+                PennyLaneDeprecationWarning,
+            )
         self._shots = Shots(shots)
 
         if wires is not None:

pennylane/devices/legacy_facade.py

@@ -16,13 +16,15 @@
 new interface.
 """
 
+import warnings
+
 # pylint: disable=not-callable
 from contextlib import contextmanager
 from copy import copy, deepcopy
 from dataclasses import replace
 
 import pennylane as qml
-from pennylane.exceptions import DeviceError
+from pennylane.exceptions import DeviceError, PennyLaneDeprecationWarning
 from pennylane.math import get_canonical_interface_name, requires_grad
 from pennylane.measurements import MidMeasureMP, Shots
 from pennylane.transforms.core.transform_program import TransformProgram
@@ -167,6 +169,12 @@ def __init__(self, device: "qml.devices.LegacyDevice"):
         self._device = device
         self.config_filepath = getattr(self._device, "config_filepath", None)
 
+        if self._device.shots:
+            warnings.warn(
+                "Setting shots on device is deprecated. Please use the `set_shots` transform on the respective QNode instead.",
+                PennyLaneDeprecationWarning,
+            )
+
     @property
     def tracker(self):
         """A :class:`~pennylane.Tracker` that can store information about device executions, shots, batches,

pennylane/gradients/fisher.py

@@ -387,7 +387,7 @@ def circ(params):
 
     """
 
-    if device.shots or not isinstance(device, DefaultQubit):
+    if tape.shots or not isinstance(device, DefaultQubit):
         tapes, processing_fn = metric_tensor(tape, *args, **kwargs)
 
         def processing_fn_multiply(res):

pennylane/measurements/counts.py

@@ -308,7 +308,7 @@ def counts(
     all_outcomes=False,
 ) -> CountsMP:
     r"""Sample from the supplied observable, with the number of shots
-    determined from the ``dev.shots`` attribute of the corresponding device,
+    determined from QNode,
     returning the number of counts for each sample. If no observable is provided then basis state
     samples are returned directly from the device.
 

pennylane/measurements/sample.py

@@ -191,7 +191,7 @@ def sample(
     wires=None,
 ) -> SampleMP:
     r"""Sample from the supplied observable, with the number of shots
-    determined from the ``dev.shots`` attribute of the corresponding device,
+    determined from QNode,
     returning raw samples. If no observable is provided then basis state samples are returned
     directly from the device.
 

pennylane/optimize/shot_adaptive.py

@@ -284,22 +284,6 @@ def cost(*args, **kwargs):
 
         return [np.concatenate(i) for i in zip(*grads)]
 
-    @staticmethod
-    def check_device(dev):
-        r"""Verifies that the device used by the objective function is non-analytic.
-
-        Args:
-            dev (.devices.Device): the device to verify
-
-        Raises:
-            ValueError: if the device is analytic
-        """
-        if not dev.shots:
-            raise ValueError(
-                "The Rosalin optimizer can only be used with devices "
-                "that estimate expectation values with a finite number of shots."
-            )
-
     def check_learning_rate(self, coeffs):
         r"""Verifies that the learning rate is less than 2 over the Lipschitz constant,
         where the Lipschitz constant is given by :math:`\sum |c_i|` for Hamiltonian
@@ -318,9 +302,12 @@ def check_learning_rate(self, coeffs):
 
     def _single_shot_qnode_gradients(self, qnode, args, kwargs):
         """Compute the single shot gradients of a QNode."""
-        self.check_device(qnode.device)
-
         tape = construct_tape(qnode)(*args, **kwargs)
+        if not tape.shots:
+            raise ValueError(
+                "The Rosalin optimizer can only be used with qnodes "
+                "that estimate expectation values with a finite number of shots."
+            )
         [expval] = tape.measurements
         coeffs, observables = (
             expval.obs.terms()

pennylane/workflow/construct_batch.py

@@ -446,6 +446,14 @@ def circuit(x):
 
     def batch_constructor(*args, **kwargs) -> tuple[QuantumScriptBatch, PostprocessingFn]:
         """Create a batch of tapes and a post processing function."""
+        # Check if shots is being passed as parameter for deprecation warning
+        if "shots" in kwargs:
+            warnings.warn(
+                "'shots' specified on call to a QNode is deprecated and will be removed in v0.44. Use qml.set_shots instead.",
+                PennyLaneDeprecationWarning,
+                stacklevel=2,
+            )
+
         if "shots" in kwargs and qnode._shots_override_device:  # pylint: disable=protected-access
             warnings.warn(
                 "Both 'shots=' parameter and 'set_shots' transform are specified. "

tests/capture/autograph/test_autograph.py

@@ -428,8 +428,9 @@ def circuit(x):
     )
     def test_mcm_one_shot(self, seed):
         """Test if mcm one-shot miss transforms."""
-        dev = qml.device("default.qubit", wires=5, shots=20, seed=seed)
+        dev = qml.device("default.qubit", wires=5, seed=seed)
 
+        @qml.set_shots(20)
         @qml.qnode(dev, mcm_method="one-shot", postselect_mode="hw-like")
         def circ(x):
             qml.RX(x, wires=0)