qadence 1.5.2__py3-none-any.whl → 1.6.1__py3-none-any.whl

qadence/extensions.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
 import importlib
+from logging import getLogger
 from string import Template
 
 from qadence.backend import Backend
 from qadence.blocks.abstract import TAbstractBlock
-from qadence.logger import get_logger
 from qadence.types import BackendName, DiffMode, Engine
 
 backends_namespace = Template("qadence.backends.$name")
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def _available_engines() -> dict:
@@ -24,7 +24,7 @@ def _available_engines() -> dict:
             res[engine] = DifferentiableBackendCls
         except (ImportError, ModuleNotFoundError):
             pass
-    logger.info(f"Found engines: {res.keys()}")
+    logger.debug(f"Found engines: {res.keys()}")
     return res
 
 
@@ -39,7 +39,7 @@ def _available_backends() -> dict:
             res[backend] = BackendCls
         except (ImportError, ModuleNotFoundError):
             pass
-    logger.info(f"Found backends: {res.keys()}")
+    logger.debug(f"Found backends: {res.keys()}")
     return res
 
 
@@ -77,16 +77,6 @@ def _validate_diff_mode(backend: Backend, diff_mode: DiffMode) -> None:
         raise TypeError(f"Backend {backend.name} does not support diff_mode {DiffMode.ADJOINT}.")
 
 
-def _validate_backend_config(backend: Backend) -> None:
-    if backend.config.use_gradient_checkpointing:
-        # FIXME: Remove in v1.5.0
-        msg = "use_gradient_checkpointing is deprecated."
-        import warnings
-
-        warnings.warn(msg, UserWarning)
-        logger.warn(msg)
-
-
 def _set_backend_config(backend: Backend, diff_mode: DiffMode) -> None:
     """Fallback function for native Qadence backends if extensions is not present.
 
@@ -96,7 +86,6 @@ def _set_backend_config(backend: Backend, diff_mode: DiffMode) -> None:
     """
 
     _validate_diff_mode(backend, diff_mode)
-    _validate_backend_config(backend)
 
     # (1) When using PSR with any backend or (2) we use the backends Pulser or Braket,
     # we have to use gate-level parameters

qadence/log_config.yaml

@@ -0,0 +1,24 @@
+version: 1
+disable_existing_loggers: false
+formatters:
+  base:
+    format: "%(levelname) -5s %(asctime)s - %(name)s: %(message)s"
+    datefmt: "%Y-%m-%d %H:%M:%S"
+handlers:
+  console:
+    class: logging.StreamHandler
+    formatter: base
+    stream: ext://sys.stderr
+loggers:
+  qadence:
+    level: INFO
+    handlers: [console]
+    propagate: yes
+  pyqtorch:
+    level: INFO
+    handlers: [console]
+    propagate: yes
+  script:
+    level: INFO
+    handlers: [console]
+    propagate: yes

qadence/logger.py

@@ -1,35 +1,17 @@
 from __future__ import annotations
 
 import logging
-import os
-import sys
-
-logging_levels = {
-    "DEBUG": logging.DEBUG,
-    "INFO": logging.INFO,
-    "WARNING": logging.WARNING,
-    "ERROR": logging.ERROR,
-    "CRITICAL": logging.CRITICAL,
-}
-
-LOG_STREAM_HANDLER = sys.stdout
-
-DEFAULT_LOGGING_LEVEL = logging.INFO
-
-# FIXME: introduce a better handling of the configuration
-LOGGING_LEVEL = os.environ.get("LOGGING_LEVEL", "warning").upper()
+from warnings import warn
 
 
 def get_logger(name: str) -> logging.Logger:
-    logger: logging.Logger = logging.getLogger(name)
-
-    level = logging_levels.get(LOGGING_LEVEL, DEFAULT_LOGGING_LEVEL)
-    logger.setLevel(level)
+    warn(
+        '"get_logger" will be deprected soon.\
+         Please use "get_script_logger" instead.',
+        DeprecationWarning,
+    )
+    return logging.getLogger(name)
 
-    formatter = logging.Formatter("%(levelname) -5s %(asctime)s: %(message)s", "%Y-%m-%d %H:%M:%S")
-    # formatter = logging.Formatter(LOG_FORMAT)
-    sh = logging.StreamHandler(LOG_STREAM_HANDLER)
-    sh.setFormatter(formatter)
-    logger.addHandler(sh)
 
-    return logger
+def get_script_logger(name: str = "") -> logging.Logger:
+    return logging.getLogger(f"script.{name}")

qadence/measurements/shadow.py

@@ -10,13 +10,7 @@ from torch import Tensor
 from qadence.backend import Backend
 from qadence.backends.pyqtorch import Backend as PyQBackend
 from qadence.blocks import AbstractBlock, chain, kron
-from qadence.blocks.block_to_tensor import (
-    HMAT,
-    IMAT,
-    SDAGMAT,
-    ZMAT,
-    block_to_tensor,
-)
+from qadence.blocks.block_to_tensor import HMAT, IMAT, SDAGMAT, ZMAT, block_to_tensor
 from qadence.blocks.composite import CompositeBlock
 from qadence.blocks.primitive import PrimitiveBlock
 from qadence.blocks.utils import get_pauli_blocks, unroll_block_with_scaling
@@ -24,8 +18,8 @@ from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.noise import Noise
 from qadence.operations import X, Y, Z
-from qadence.states import one_state, zero_state
 from qadence.types import Endianness
+from qadence.utils import P0_MATRIX, P1_MATRIX
 
 pauli_gates = [X, Y, Z]
 
@@ -37,13 +31,6 @@ UNITARY_TENSOR = [
 ]
 
 
-# Projector matrices in Big-Endian convention.
-PROJECTOR_MATRICES = {
-    "0": zero_state(n_qubits=1).t() @ zero_state(n_qubits=1),
-    "1": one_state(n_qubits=1).t() @ one_state(n_qubits=1),
-}
-
-
 def identity(n_qubits: int) -> Tensor:
     return torch.eye(2**n_qubits, dtype=torch.complex128)
 
@@ -113,7 +100,7 @@ def local_shadow(sample: Counter, unitary_ids: list) -> Tensor:
     bitstring = list(sample.keys())[0]
     local_density_matrices = []
     for bit, unitary_id in zip(bitstring, unitary_ids):
-        proj_mat = PROJECTOR_MATRICES[bit]
+        proj_mat = P0_MATRIX if bit == "0" else P1_MATRIX
         unitary_tensor = UNITARY_TENSOR[unitary_id].squeeze(dim=0)
         local_density_matrices.append(
             3 * (unitary_tensor.adjoint() @ proj_mat @ unitary_tensor) - identity(1)

qadence/ml_tools/config.py

@@ -38,6 +38,16 @@ class TrainConfig:
     """
     checkpoint_best_only: bool = False
     """Write model/optimizer checkpoint only if a metric has improved."""
+    val_every: int | None = None
+    """Calculate validation metric.
+
+    If None, validation check is not performed.
+    """
+    val_epsilon: float = 1e-5
+    """Safety margin to check if validation loss is smaller than the lowest.
+
+    validation loss across previous iterations.
+    """
     validation_criterion: Optional[Callable] = None
     """A boolean function which evaluates a given validation metric is satisfied."""
     trainstop_criterion: Optional[Callable] = None
@@ -59,4 +69,4 @@ class TrainConfig:
         if self.trainstop_criterion is None:
             self.trainstop_criterion = lambda x: x <= self.max_iter
         if self.validation_criterion is None:
-            self.validation_criterion = lambda x: False
+            self.validation_criterion = lambda *x: False

qadence/ml_tools/models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Any, Counter, List
 
 import numpy as np
@@ -8,14 +9,13 @@ from torch import Tensor
 from torch.nn import Parameter as TorchParam
 
 from qadence.backend import ConvertedObservable
-from qadence.logger import get_logger
 from qadence.measurements import Measurements
 from qadence.ml_tools import promote_to_tensor
 from qadence.models import QNN, QuantumModel
 from qadence.noise import Noise
 from qadence.utils import Endianness
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def _set_fixed_operation(
@@ -310,3 +310,11 @@ class TransformedModule(torch.nn.Module):
         except Exception as e:
             logger.warning(f"Unable to move {self} to {args}, {kwargs} due to {e}.")
         return self
+
+    @property
+    def device(self) -> torch.device:
+        return (
+            self.model.device
+            if isinstance(self.model, QuantumModel)
+            else self._input_scaling.device
+        )

qadence/ml_tools/printing.py

@@ -11,9 +11,7 @@ def print_metrics(loss: float | None, metrics: dict, iteration: int) -> None:
     print(msg)
 
 
-def write_tensorboard(
-    writer: SummaryWriter, loss: float | None, metrics: dict, iteration: int
-) -> None:
+def write_tensorboard(writer: SummaryWriter, loss: float, metrics: dict, iteration: int) -> None:
     writer.add_scalar("loss", loss, iteration)
     for key, arg in metrics.items():
         writer.add_scalar(key, arg, iteration)

qadence/ml_tools/saveload.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import re
+from logging import getLogger
 from pathlib import Path
 from typing import Any
 
@@ -10,9 +11,7 @@ from nevergrad.optimization.base import Optimizer as NGOptimizer
 from torch.nn import Module
 from torch.optim import Optimizer
 
-from qadence.logger import get_logger
-
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def get_latest_checkpoint_name(folder: Path, type: str) -> Path:
@@ -54,13 +53,31 @@ def load_checkpoint(
 
 
 def write_checkpoint(
-    folder: Path, model: Module, optimizer: Optimizer | NGOptimizer, iteration: int
+    folder: Path, model: Module, optimizer: Optimizer | NGOptimizer, iteration: int | str
 ) -> None:
     from qadence.ml_tools.models import TransformedModule
     from qadence.models import QNN, QuantumModel
 
-    model_checkpoint_name: str = f"model_{type(model).__name__}_ckpt_" + f"{iteration:03n}" + ".pt"
-    opt_checkpoint_name: str = f"opt_{type(optimizer).__name__}_ckpt_" + f"{iteration:03n}" + ".pt"
+    device = None
+    try:
+        # We extract the device from the pyqtorch native circuit
+        device = str(model.device).split(":")[0]  # in case of using several CUDA devices
+    except Exception:
+        pass
+
+    iteration_substring = f"{iteration:03n}" if isinstance(iteration, int) else iteration
+    model_checkpoint_name: str = (
+        f"model_{type(model).__name__}_ckpt_"
+        + f"{iteration_substring}"
+        + f"_device_{device}"
+        + ".pt"
+    )
+    opt_checkpoint_name: str = (
+        f"opt_{type(optimizer).__name__}_ckpt_"
+        + f"{iteration_substring}"
+        + f"_device_{device}"
+        + ".pt"
+    )
     try:
         d = (
             model._to_dict(save_params=True)

qadence/ml_tools/train_grad.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import math
+from logging import getLogger
 from typing import Callable, Union
 
 from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn, TimeRemainingColumn
@@ -11,14 +13,13 @@ from torch.optim import Optimizer
 from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 
-from qadence.logger import get_logger
 from qadence.ml_tools.config import TrainConfig
-from qadence.ml_tools.data import DictDataLoader
+from qadence.ml_tools.data import DictDataLoader, data_to_device
 from qadence.ml_tools.optimize_step import optimize_step
 from qadence.ml_tools.printing import print_metrics, write_tensorboard
 from qadence.ml_tools.saveload import load_checkpoint, write_checkpoint
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def train(
@@ -125,6 +126,22 @@ def train(
     # initialize tensorboard
     writer = SummaryWriter(config.folder, purge_step=init_iter)
 
+    perform_val = isinstance(config.val_every, int)
+    if perform_val:
+        if not isinstance(dataloader, DictDataLoader):
+            raise ValueError(
+                "If `config.val_every` is provided as an integer, dataloader must"
+                "be an instance of `DictDataLoader`."
+            )
+        iter_keys = dataloader.dataloaders.keys()
+        if "train" not in iter_keys or "val" not in iter_keys:
+            raise ValueError(
+                "If `config.val_every` is provided as an integer, the dictdataloader"
+                "must have `train` and `val` keys to access the respective dataloaders."
+            )
+        val_dataloader = dataloader.dataloaders["val"]
+        dataloader = dataloader.dataloaders["train"]
+
     ## Training
     progress = Progress(
         TextColumn("[progress.description]{task.description}"),
@@ -135,8 +152,12 @@ def train(
     data_dtype = None
     if dtype:
         data_dtype = float64 if dtype == complex128 else float32
+
+    best_val_loss = math.inf
     with progress:
         dl_iter = iter(dataloader) if dataloader is not None else None
+        if perform_val:
+            dl_iter_val = iter(val_dataloader) if val_dataloader is not None else None
 
         # outer epoch loop
         for iteration in progress.track(range(init_iter, init_iter + config.max_iter)):
@@ -177,16 +198,28 @@ def train(
                 if iteration % config.write_every == 0:
                     write_tensorboard(writer, loss, metrics, iteration)
 
+                if perform_val:
+                    if iteration % config.val_every == 0:
+                        xs = next(dl_iter_val)
+                        xs_to_device = data_to_device(xs, device=device, dtype=data_dtype)
+                        val_loss, _ = loss_fn(model, xs_to_device)
+                        if config.validation_criterion(val_loss, best_val_loss, config.val_epsilon):  # type: ignore[misc]
+                            best_val_loss = val_loss
+                            if config.folder and config.checkpoint_best_only:
+                                write_checkpoint(config.folder, model, optimizer, iteration="best")
+                            metrics["val_loss"] = val_loss
+                            write_tensorboard(writer, math.nan, metrics, iteration)
+
                 if config.folder:
-                    if iteration % config.checkpoint_every == 0:
+                    if iteration % config.checkpoint_every == 0 and not config.checkpoint_best_only:
                         write_checkpoint(config.folder, model, optimizer, iteration)
 
             except KeyboardInterrupt:
-                print("Terminating training gracefully after the current iteration.")
+                logger.info("Terminating training gracefully after the current iteration.")
                 break
 
     # Final writing and checkpointing
-    if config.folder:
+    if config.folder and not config.checkpoint_best_only:
         write_checkpoint(config.folder, model, optimizer, iteration)
     write_tensorboard(writer, loss, metrics, iteration)
     writer.close()

qadence/ml_tools/train_no_grad.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Callable
 
 import nevergrad as ng
@@ -10,7 +11,6 @@ from torch.nn import Module
 from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 
-from qadence.logger import get_logger
 from qadence.ml_tools.config import TrainConfig
 from qadence.ml_tools.data import DictDataLoader
 from qadence.ml_tools.parameters import get_parameters, set_parameters
@@ -18,7 +18,7 @@ from qadence.ml_tools.printing import print_metrics, write_tensorboard
 from qadence.ml_tools.saveload import load_checkpoint, write_checkpoint
 from qadence.ml_tools.tensors import promote_to_tensor
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def train(

qadence/models/quantum_model.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 from collections import Counter, OrderedDict
 from dataclasses import asdict
+from logging import getLogger
 from pathlib import Path
 from typing import Any, Callable, Optional, Sequence
 
@@ -21,14 +22,13 @@ from qadence.blocks.abstract import AbstractBlock
 from qadence.blocks.utils import chain, unique_parameters
 from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
-from qadence.logger import get_logger
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import Noise
 from qadence.parameters import Parameter
 from qadence.types import DiffMode, Endianness
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class QuantumModel(nn.Module):
@@ -44,6 +44,7 @@ class QuantumModel(nn.Module):
     _params: nn.ParameterDict
     _circuit: ConvertedCircuit
     _observable: list[ConvertedObservable] | None
+    logger.debug("Initialised")
 
     def __init__(
         self,
@@ -185,8 +186,6 @@ class QuantumModel(nn.Module):
         params = self.embedding_fn(self._params, values)
         if noise is None:
             noise = self._noise
-        else:
-            self._noise = noise
         if mitigation is None:
             mitigation = self._mitigation
         return self.backend.sample(
@@ -316,7 +315,7 @@ class QuantumModel(nn.Module):
         try:
             torch.save(self._to_dict(save_params), folder / Path(file_name))
         except Exception as e:
-            print(f"Unable to write QuantumModel to disk due to {e}")
+            logger.error(f"Unable to write QuantumModel to disk due to {e}")
 
     @classmethod
     def load(
@@ -333,7 +332,7 @@ class QuantumModel(nn.Module):
         try:
             qm_pt = torch.load(file_path, map_location=map_location)
         except Exception as e:
-            print(f"Unable to load QuantumModel due to {e}")
+            logger.error(f"Unable to load QuantumModel due to {e}")
         return cls._from_dict(qm_pt, as_torch)
 
     def assign_parameters(self, values: dict[str, Tensor]) -> Any:
@@ -365,3 +364,11 @@ class QuantumModel(nn.Module):
         except Exception as e:
             logger.warning(f"Unable to move {self} to {args}, {kwargs} due to {e}.")
         return self
+
+    @property
+    def device(self) -> torch.device:
+        return (
+            self._circuit.native.device
+            if self.backend.backend.name == "pyqtorch"  # type: ignore[union-attr]
+            else torch.device("cpu")
+        )

qadence/noise/readout.py

@@ -2,14 +2,13 @@ from __future__ import annotations
 
 from collections import Counter
 from enum import Enum
+from logging import getLogger
 
 import torch
 from torch import Tensor
 from torch.distributions import normal, poisson, uniform
 
-from qadence.logger import get_logger
-
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class WhiteNoise(Enum):

qadence/operations/__init__.py

@@ -10,7 +10,6 @@ from .analog import (
     AnalogSWAP,
     ConstantAnalogRotation,
     entangle,
-    wait,
 )
 from .control_ops import (
     CNOT,
@@ -89,7 +88,6 @@ __all__ = [
     "CSWAP",
     "MCPHASE",
     "Toffoli",
-    "wait",
     "entangle",
     "AnalogEntanglement",
     "AnalogInteraction",

qadence/operations/analog.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from logging import getLogger
 from typing import Any, Tuple
 
 import numpy as np
@@ -19,7 +20,6 @@ from qadence.blocks.utils import (
     add,  # noqa
     kron,
 )
-from qadence.logger import get_logger
 from qadence.parameters import (
     Parameter,
     ParamMap,
@@ -29,7 +29,7 @@ from qadence.types import PI, OpName, TNumber, TParameter
 from .ham_evo import HamEvo
 from .primitive import I, X, Z
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class AnalogSWAP(HamEvo):
@@ -84,16 +84,6 @@ def AnalogInteraction(
     return InteractionBlock(parameters=ps, qubit_support=q, add_pattern=add_pattern)
 
 
-# FIXME: Remove in v1.5.0
-def wait(
-    duration: TNumber | sympy.Basic,
-    qubit_support: str | QubitSupport | tuple = "global",
-    add_pattern: bool = True,
-) -> InteractionBlock:
-    logger.warning("The alias `wait` is deprecated, please use `AnalogInteraction`")
-    return AnalogInteraction(duration, qubit_support, add_pattern)
-
-
 # FIXME: clarify the usage of this gate, rename more formally, and implement in PyQ
 @dataclass(eq=False, repr=False)
 class AnalogEntanglement(AnalogBlock):

qadence/operations/control_ops.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from logging import getLogger
+
 import sympy
 import torch
 from rich.console import Console, RenderableType
@@ -16,7 +18,6 @@ from qadence.blocks.utils import (
     chain,
     kron,
 )
-from qadence.logger import get_logger
 from qadence.parameters import (
     Parameter,
     evaluate,
@@ -26,7 +27,7 @@ from qadence.types import OpName, TNumber, TParameter
 from .parametric import PHASE, RX, RY, RZ
 from .primitive import SWAP, I, N, X, Y, Z
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class CNOT(ControlBlock):

qadence/operations/ham_evo.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from copy import deepcopy
 from functools import cached_property
+from logging import getLogger
 from typing import Any, Union
 
 import numpy as np
@@ -9,10 +10,7 @@ import sympy
 import torch
 from torch import Tensor
 
-from qadence.blocks import (
-    AbstractBlock,
-    TimeEvolutionBlock,
-)
+from qadence.blocks import AbstractBlock, TimeEvolutionBlock
 from qadence.blocks.block_to_tensor import block_to_tensor
 from qadence.blocks.utils import (
     add,  # noqa
@@ -22,7 +20,6 @@ from qadence.blocks.utils import (
     expressions,
 )
 from qadence.decompose import lie_trotter_suzuki
-from qadence.logger import get_logger
 from qadence.parameters import (
     Parameter,
     ParamMap,
@@ -30,9 +27,8 @@ from qadence.parameters import (
     extract_original_param_entry,
 )
 from qadence.types import LTSOrder, OpName, TGenerator, TParameter
-from qadence.utils import eigenvalues
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class HamEvo(TimeEvolutionBlock):
@@ -112,6 +108,8 @@ class HamEvo(TimeEvolutionBlock):
     def eigenvalues_generator(
         self, max_num_evals: int | None = None, max_num_gaps: int | None = None
     ) -> Tensor:
+        from qadence.utils import eigenvalues
+
         if isinstance(self.generator, AbstractBlock):
             generator_tensor = block_to_tensor(self.generator)
         elif isinstance(self.generator, Tensor):

qadence/operations/parametric.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from logging import getLogger
+
 import numpy as np
 import sympy
 import torch
@@ -13,7 +15,6 @@ from qadence.blocks.utils import (
     add,  # noqa
     chain,
 )
-from qadence.logger import get_logger
 from qadence.parameters import (
     Parameter,
     ParamMap,
@@ -23,7 +24,7 @@ from qadence.types import OpName, TNumber, TParameter
 
 from .primitive import I, X, Y, Z
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class PHASE(ParametricBlock):

qadence/operations/primitive.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Union
 
 import numpy as np
@@ -17,13 +18,12 @@ from qadence.blocks.utils import (
     chain,
     kron,
 )
-from qadence.logger import get_logger
 from qadence.parameters import (
     Parameter,
 )
 from qadence.types import OpName, TNumber
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class X(PrimitiveBlock):