Expand logging configuration support in PennyLane, and also target Catalyst

doc/development/guide/logging.rst

@@ -29,24 +29,36 @@ To add logging support to components of PennyLane, we must define a module logge
 
 which will be used within the given module, and track directories,
 filenames and function names, as we have defined the appropriate types
-within the formatter configuration (see :class:`pennylane.logging.DefaultFormatter`). With the logger defined, we can selectively add to the logger by if-else statements, which compare the given module’s log-level to any log record
-message it receives. This step is not necessary, as the message will
-only output if the level is enabled, though if an expensive function
-call is required to build the string for the log-message, it can be
-faster to perform this check:
+within the formatter configuration (see :class:`pennylane.logging.DefaultFormatter`). With the logger defined, we can selectively add to the logger via two methods: 
 
-.. code:: python
+#. Using decorators on the required functions and methods in a given module:
+
+ .. code:: python
+
+ # debug_logger can be used to decorate any method or free function
+ # debug_logger_init can be used to decorate class __init__ methods.
+ from pennylane.logging import debug_logger, debug_logger_init
+
+ @debug_logger
+ def my_func(arg1, arg2):
+ return arg1 + arg2
 
- if logger.isEnabledFor(logging.DEBUG):
- logger.debug(
- """Entry with args=(arg_name_1=%s, arg_name_2=%s, ..., arg_name_n=%s)""",
- arg_name_1, arg_name_2, ..., arg_name_n,
- )
+#. Explicitly by if-else statements, which compare the given module’s log-level to any log record message it receives. This step is not necessary, as the message will
+ only output if the level is enabled, though if an expensive function
+ call is required to build the string for the log-message, it can be
+ faster to perform this check:
 
-The above line can be added below the function/method entry point,
-and the provided arguments can be used to populate the log message. This
-allows us a way to track the inputs and calls through the stack in the
-order they are executed, as is the basis for following a trail of
+ .. code:: python
+
+ if logger.isEnabledFor(logging.DEBUG):
+ logger.debug(
+ """Entry with args=(arg_name_1=%s, arg_name_2=%s, ..., arg_name_n=%s)""",
+ arg_name_1, arg_name_2, ..., arg_name_n,
+ )
+
+Both versions provide similar functionality, though the explicit logger call allows more custom message-formatting, such as expanding functions as string representation, filtering of data, and other useful processing for a valid record.
+
+These logging options allow us a way to track the inputs and calls through the stack in the order they are executed, as is the basis for following a trail of
 execution as needed.
 
 All debug log-statements currently added to the PennyLane execution
@@ -82,6 +94,8 @@ messages based on some criteria, we can add these to the respective
 handlers. As an example, we can go through the configuration file and
 explore the options.
 
+For ease-of-development, the function :func:`pennylane.logging.edit_system_config` opens an editor (if the ``EDITOR`` environment variable is set), or a viewer of the existing file configuration, which can be used to modify the existing options.
+
 Modifying the configuration options
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

doc/introduction/logging.rst

@@ -29,4 +29,7 @@ outputs to the default configured handler, which is directed to the standard out
  level = "DEBUG" # Set to TRACE for highest verbosity
  propagate = false
 
+
+Viewing the existing logging configuration file is possible by calling the :func:`pennylane.logging.edit_system_config` function which will open the file in an existing browser or editor window.
+
 For more info on the customization of the logging options, please see the logging development guide at :doc:`/development/guide/logging`, and the `Python logging documentation <https://docs.python.org/3/library/logging.html>`_.

doc/releases/changelog-dev.md

@@ -9,6 +9,9 @@
 
 <h3>Improvements 🛠</h3>
 
+* Logging now allows for an easier opt-in across the stack, and also extends control support to `catalyst`.
+ [(#5528)](https://github.com/PennyLaneAI/pennylane/pull/5528).
+
 * `ctrl` now works with tuple-valued `control_values` when applied to any already controlled operation.
  [(#5725)](https://github.com/PennyLaneAI/pennylane/pull/5725)
 

pennylane/devices/default_mixed.py

@@ -21,6 +21,7 @@
 
 import functools
 import itertools
+import logging
 from collections import defaultdict
 from string import ascii_letters as ABC
 
@@ -29,6 +30,7 @@
 import pennylane as qml
 import pennylane.math as qnp
 from pennylane import BasisState, DeviceError, QubitDensityMatrix, QubitDevice, Snapshot, StatePrep
+from pennylane.logging import debug_logger, debug_logger_init
 from pennylane.measurements import (
  CountsMP,
  DensityMatrixMP,
@@ -47,6 +49,9 @@
 
 from .._version import __version__
 
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
 ABC_ARRAY = np.array(list(ABC))
 tolerance = 1e-10
 
@@ -181,6 +186,7 @@ def _asarray(array, dtype=None):
  res = qnp.cast(array, dtype=dtype)
  return res
 
+ @debug_logger_init
  def __init__(
  self,
  wires,
@@ -252,6 +258,7 @@ def state(self):
  # User obtains state as a matrix
  return qnp.reshape(self._pre_rotated_state, (dim, dim))
 
+ @debug_logger
  def density_matrix(self, wires):
  """Returns the reduced density matrix over the given wires.
 
@@ -266,19 +273,22 @@ def density_matrix(self, wires):
  wires = self.map_wires(wires)
  return qml.math.reduce_dm(state, indices=wires, c_dtype=self.C_DTYPE)
 
+ @debug_logger
  def purity(self, mp, **kwargs): # pylint: disable=unused-argument
  """Returns the purity of the final state"""
  state = getattr(self, "state", None)
  wires = self.map_wires(mp.wires)
  return qml.math.purity(state, indices=wires, c_dtype=self.C_DTYPE)
 
+ @debug_logger
  def reset(self):
  """Resets the device"""
  super().reset()
 
  self._state = self._create_basis_state(0)
  self._pre_rotated_state = self._state
 
+ @debug_logger
  def analytic_probability(self, wires=None):
  if self._state is None:
  return None
@@ -706,6 +716,7 @@ def _apply_operation(self, operation):
 
  # pylint: disable=arguments-differ
 
+ @debug_logger
  def execute(self, circuit, **kwargs):
  """Execute a queue of quantum operations on the device and then
  measure the given observables.
@@ -760,6 +771,7 @@ def execute(self, circuit, **kwargs):
  self.measured_wires = qml.wires.Wires.all_wires(wires_list)
  return super().execute(circuit, **kwargs)
 
+ @debug_logger
  def apply(self, operations, rotations=None, **kwargs):
  rotations = rotations or []
 

pennylane/devices/default_qubit.py

@@ -16,7 +16,6 @@
 """
 
 import concurrent.futures
-import inspect
 import logging
 from dataclasses import replace
 from functools import partial
@@ -26,6 +25,7 @@
 import numpy as np
 
 import pennylane as qml
+from pennylane.logging import debug_logger, debug_logger_init
 from pennylane.measurements.mid_measure import MidMeasureMP
 from pennylane.ops.op_math.condition import Conditional
 from pennylane.tape import QuantumTape
@@ -419,6 +419,7 @@ def reset_prng_key(self):
  """
 
  # pylint:disable = too-many-arguments
+ @debug_logger_init
  def __init__(
  self,
  wires=None,
@@ -439,6 +440,7 @@ def __init__(
  self._rng = np.random.default_rng(seed)
  self._debugger = None
 
+ @debug_logger
  def supports_derivatives(
  self,
  execution_config: Optional[ExecutionConfig] = None,
@@ -475,6 +477,7 @@ def supports_derivatives(
  return _supports_adjoint(circuit=circuit)
  return False
 
+ @debug_logger
  def preprocess(
  self,
  execution_config: ExecutionConfig = DefaultExecutionConfig,
@@ -566,20 +569,13 @@ def _setup_execution_config(self, execution_config: ExecutionConfig) -> Executio
  updated_values["device_options"][option] = getattr(self, f"_{option}")
  return replace(execution_config, **updated_values)
 
+ @debug_logger
  def execute(
  self,
  circuits: QuantumTape_or_Batch,
  execution_config: ExecutionConfig = DefaultExecutionConfig,
  ) -> Result_or_ResultBatch:
  self.reset_prng_key()
- if logger.isEnabledFor(logging.DEBUG):
- logger.debug(
- """Entry with args=(circuits=%s) called by=%s""",
- circuits,
- "::L".join(
- str(i) for i in inspect.getouterframes(inspect.currentframe(), 2)[1][1:3]
- ),
- )
 
  max_workers = execution_config.device_options.get("max_workers", self._max_workers)
  self._state_cache = {} if execution_config.use_device_jacobian_product else None
@@ -618,6 +614,7 @@ def execute(
 
  return results
 
+ @debug_logger
  def compute_derivatives(
  self,
  circuits: QuantumTape_or_Batch,
@@ -637,6 +634,7 @@ def compute_derivatives(
 
  return res
 
+ @debug_logger
  def execute_and_compute_derivatives(
  self,
  circuits: QuantumTape_or_Batch,
@@ -659,6 +657,7 @@ def execute_and_compute_derivatives(
 
  return tuple(zip(*results))
 
+ @debug_logger
  def supports_jvp(
  self,
  execution_config: Optional[ExecutionConfig] = None,
@@ -678,6 +677,7 @@ def supports_jvp(
  """
  return self.supports_derivatives(execution_config, circuit)
 
+ @debug_logger
  def compute_jvp(
  self,
  circuits: QuantumTape_or_Batch,
@@ -697,6 +697,7 @@ def compute_jvp(
 
  return res
 
+ @debug_logger
  def execute_and_compute_jvp(
  self,
  circuits: QuantumTape_or_Batch,
@@ -724,6 +725,7 @@ def execute_and_compute_jvp(
 
  return tuple(zip(*results))
 
+ @debug_logger
  def supports_vjp(
  self,
  execution_config: Optional[ExecutionConfig] = None,
@@ -743,6 +745,7 @@ def supports_vjp(
  """
  return self.supports_derivatives(execution_config, circuit)
 
+ @debug_logger
  def compute_vjp(
  self,
  circuits: QuantumTape_or_Batch,
@@ -810,6 +813,7 @@ def _state(circuit):
 
  return res
 
+ @debug_logger
  def execute_and_compute_vjp(
  self,
  circuits: QuantumTape_or_Batch,

pennylane/devices/default_qutrit.py

@@ -19,16 +19,21 @@
 simulation of qutrit-based quantum computing.
 """
 import functools
+import logging
 
 import numpy as np
 
 import pennylane as qml # pylint: disable=unused-import
 from pennylane import DeviceError, QutritBasisState, QutritDevice
 from pennylane.devices.default_qubit_legacy import _get_slice
+from pennylane.logging import debug_logger, debug_logger_init
 from pennylane.wires import WireError
 
 from .._version import __version__
 
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
 # tolerance for numerical errors
 tolerance = 1e-10
 
@@ -118,6 +123,7 @@ def _asarray(array, dtype=None):
  res = qml.math.cast(array, dtype=dtype)
  return res
 
+ @debug_logger_init
  def __init__(
  self,
  wires,
@@ -165,6 +171,7 @@ def define_wire_map(self, wires):
  wire_map = zip(wires, consecutive_wires)
  return dict(wire_map)
 
+ @debug_logger
  def apply(self, operations, rotations=None, **kwargs): # pylint: disable=arguments-differ
  rotations = rotations or []
 
@@ -403,6 +410,7 @@ def _create_basis_state(self, index):
  def state(self):
  return self._flatten(self._pre_rotated_state)
 
+ @debug_logger
  def density_matrix(self, wires):
  """Returns the reduced density matrix of a given set of wires.
 
@@ -460,6 +468,7 @@ def _apply_unitary(self, state, mat, wires):
  inv_perm = np.argsort(perm) # argsort gives inverse permutation
  return self._transpose(tdot, inv_perm)
 
+ @debug_logger
  def reset(self):
  """Reset the device"""
  super().reset()
@@ -468,6 +477,7 @@ def reset(self):
  self._state = self._create_basis_state(0)
  self._pre_rotated_state = self._state
 
+ @debug_logger
  def analytic_probability(self, wires=None):
  if self._state is None:
  return None