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

qadence/constructors/__init__.py

@@ -2,13 +2,10 @@
 
 from .feature_maps import (
     feature_map,
-    chebyshev_feature_map,
-    fourier_feature_map,
-    tower_feature_map,
     exp_fourier_feature_map,
 )
 
-from .ansatze import hea, build_qnn
+from .ansatze import hea
 
 from .iia import identity_initialized_ansatz
 
@@ -17,7 +14,6 @@ from .daqc import daqc_transform
 from .hamiltonians import (
     hamiltonian_factory,
     ising_hamiltonian,
-    single_z,
     total_magnetization,
     zz_hamiltonian,
 )
@@ -30,16 +26,11 @@ from .qft import qft
 # Modules to be automatically added to the qadence namespace
 __all__ = [
     "feature_map",
-    "chebyshev_feature_map",
-    "fourier_feature_map",
-    "tower_feature_map",
     "exp_fourier_feature_map",
     "hea",
     "identity_initialized_ansatz",
-    "build_qnn",
     "hamiltonian_factory",
     "ising_hamiltonian",
-    "single_z",
     "total_magnetization",
     "zz_hamiltonian",
     "qft",

qadence/constructors/ansatze.py

@@ -1,15 +1,13 @@
 from __future__ import annotations
 
 import itertools
-import warnings
-from typing import Any, Optional, Type, Union
+from typing import Any, Type, Union
 
 from qadence.blocks import AbstractBlock, block_is_qubit_hamiltonian, chain, kron, tag
 from qadence.operations import CNOT, CPHASE, CRX, CRY, CRZ, CZ, RX, RY, HamEvo
 from qadence.types import Interaction, Strategy
 
 from .hamiltonians import hamiltonian_factory
-from .utils import build_idx_fms
 
 DigitalEntanglers = Union[CNOT, CZ, CRZ, CRY, CRX]
 
@@ -322,65 +320,3 @@ def hea_bDAQC(*args: Any, **kwargs: Any) -> Any:
 
 def hea_analog(*args: Any, **kwargs: Any) -> Any:
     raise NotImplementedError
-
-
-#########
-## QNN ##
-#########
-
-
-# FIXME: Remove in v1.5.0
-def build_qnn(
-    n_qubits: int,
-    n_features: int,
-    depth: int = None,
-    ansatz: Optional[AbstractBlock] = None,
-    fm_pauli: Type[RY] = RY,
-    spectrum: str = "simple",
-    basis: str = "fourier",
-    fm_strategy: str = "parallel",
-) -> list[AbstractBlock]:
-    """Helper function to build a qadence QNN quantum circuit.
-
-    Args:
-        n_qubits (int): The number of qubits.
-        n_features (int): The number of input dimensions.
-        depth (int): The depth of the ansatz.
-        ansatz (Optional[AbstractBlock]):  An optional argument to pass a custom qadence ansatz.
-        fm_pauli (str): The type of Pauli gate for the feature map. Must be one of 'RX',
-            'RY', or 'RZ'.
-        spectrum (str): The desired spectrum of the feature map generator. The options simple,
-            tower and exponential produce a spectrum with linear, quadratic and exponential
-            eigenvalues with respect to the number of qubits.
-        basis (str): The encoding function. The options fourier and chebyshev correspond to Φ(x)=x
-            and arcos(x) respectively.
-        fm_strategy (str): The feature map encoding strategy. If "parallel", the features
-            are encoded in one block of rotation gates, with each feature given
-            an equal number of qubits. If "serial", the features are encoded
-            sequentially, with a HEA block between.
-
-    Returns:
-        A list of Abstract blocks to be used for constructing a quantum circuit
-    """
-
-    warnings.warn("Function build_qnn is deprecated and will be removed in v1.5.0.", FutureWarning)
-
-    depth = n_qubits if depth is None else depth
-
-    idx_fms = build_idx_fms(basis, fm_pauli, fm_strategy, n_features, n_qubits, spectrum)
-
-    if fm_strategy == "parallel":
-        _fm = kron(*idx_fms)
-        fm = tag(_fm, tag="FM")
-
-    elif fm_strategy == "serial":
-        fm_components: list[AbstractBlock] = []
-        for j, fm_idx in enumerate(idx_fms[:-1]):
-            fm_idx = tag(fm_idx, tag=f"FM{j}")  # type: ignore[assignment]
-            fm_component = (fm_idx, hea(n_qubits, 1, f"theta_{j}"))
-            fm_components.extend(fm_component)
-        fm_components.append(tag(idx_fms[-1], tag=f"FM{len(idx_fms) - 1}"))
-        fm = chain(*fm_components)  # type: ignore[assignment]
-
-    ansatz = hea(n_qubits, depth=depth) if ansatz is None else ansatz
-    return [fm, ansatz]

qadence/constructors/daqc/daqc.py

@@ -1,18 +1,19 @@
 from __future__ import annotations
 
+from logging import getLogger
+
 import torch
 
 from qadence.blocks import AbstractBlock, add, chain, kron
 from qadence.blocks.utils import block_is_qubit_hamiltonian
 from qadence.constructors.hamiltonians import hamiltonian_factory
-from qadence.logger import get_logger
 from qadence.operations import HamEvo, I, N, X
 from qadence.types import GenDAQC, Interaction, Strategy
 
 from .gen_parser import _check_compatibility, _parse_generator
 from .utils import _build_matrix_M, _ix_map
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def daqc_transform(

qadence/constructors/daqc/gen_parser.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
+from logging import getLogger
+
 import torch
 
 from qadence.blocks import AbstractBlock, KronBlock
 from qadence.blocks.utils import unroll_block_with_scaling
-from qadence.logger import get_logger
 from qadence.operations import N, Z
 from qadence.parameters import Parameter, evaluate
 from qadence.types import GenDAQC
 
 from .utils import _ix_map
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def _parse_generator(

qadence/constructors/daqc/utils.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-import torch
+from logging import getLogger
 
-from qadence.logger import get_logger
+import torch
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def _k_d(a: int, b: int) -> int:

qadence/constructors/feature_maps.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
-import warnings
 from collections.abc import Callable
+from logging import getLogger
 from math import isclose
 from typing import Union
 
 from sympy import Basic, acos
 
 from qadence.blocks import AbstractBlock, KronBlock, chain, kron, tag
-from qadence.logger import get_logger
 from qadence.operations import PHASE, RX, RY, RZ, H
 from qadence.parameters import FeatureParameter, Parameter, VariationalParameter
 from qadence.types import PI, BasisSet, ReuploadScaling, TParameter
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 ROTATIONS = [RX, RY, RZ, PHASE]
 RotationTypes = type[Union[RX, RY, RZ, PHASE]]
@@ -35,28 +34,6 @@ RS_FUNC_DICT = {
 }
 
 
-# FIXME: Remove in v1.5.0
-def backwards_compatibility(
-    fm_type: BasisSet | Callable | str,
-    reupload_scaling: ReuploadScaling | Callable | str,
-) -> tuple:
-    if fm_type in ("fourier", "chebyshev", "tower"):
-        logger.warning(
-            "Selecting `fm_type` as 'fourier', 'chebyshev' or 'tower' is deprecated. "
-            "Please use the respective enumerations: 'fm_type = BasisSet.FOURIER', "
-            "'fm_type = BasisSet.CHEBYSHEV' or 'reupload_scaling = ReuploadScaling.TOWER'."
-        )
-        if fm_type == "fourier":
-            fm_type = BasisSet.FOURIER
-        elif fm_type == "chebyshev":
-            fm_type = BasisSet.CHEBYSHEV
-        elif fm_type == "tower":
-            fm_type = BasisSet.CHEBYSHEV
-            reupload_scaling = ReuploadScaling.TOWER
-
-    return fm_type, reupload_scaling
-
-
 def fm_parameter_scaling(
     fm_type: BasisSet | Callable | str,
     param: Parameter | str = "phi",
@@ -195,9 +172,6 @@ def feature_map(
             f"Please provide one from {[rot.__name__ for rot in ROTATIONS]}."
         )
 
-    # Backwards compatibility
-    fm_type, reupload_scaling = backwards_compatibility(fm_type, reupload_scaling)
-
     scaled_fparam = fm_parameter_scaling(
         fm_type, param, feature_range=feature_range, target_range=target_range
     )
@@ -225,68 +199,6 @@ def feature_map(
     return fm
 
 
-# FIXME: Remove in v1.5.0
-def fourier_feature_map(
-    n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
-) -> AbstractBlock:
-    """Construct a Fourier feature map.
-
-    Args:
-        n_qubits: number of qubits across which the FM is created
-        param: The base name for the feature `Parameter`
-    """
-    warnings.warn(
-        "Function 'fourier_feature_map' is deprecated. Please use 'feature_map' directly.",
-        FutureWarning,
-    )
-    fm = feature_map(n_qubits, support=support, param=param, op=op, fm_type=BasisSet.FOURIER)
-    return fm
-
-
-# FIXME: Remove in v1.5.0
-def chebyshev_feature_map(
-    n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
-) -> AbstractBlock:
-    """Construct a Chebyshev feature map.
-
-    Args:
-        n_qubits: number of qubits across which the FM is created
-        support (Iterable[int]): The qubit support
-        param: The base name for the feature `Parameter`
-    """
-    warnings.warn(
-        "Function 'chebyshev_feature_map' is deprecated. Please use 'feature_map' directly.",
-        FutureWarning,
-    )
-    fm = feature_map(n_qubits, support=support, param=param, op=op, fm_type=BasisSet.CHEBYSHEV)
-    return fm
-
-
-# FIXME: Remove in v1.5.0
-def tower_feature_map(
-    n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
-) -> AbstractBlock:
-    """Construct a Chebyshev tower feature map.
-
-    Args:
-        n_qubits: number of qubits across which the FM is created
-        param: The base name for the feature `Parameter`
-    """
-    warnings.warn(
-        "Function 'tower_feature_map' is deprecated. Please use feature_map directly.",
-        FutureWarning,
-    )
-    fm = feature_map(
-        n_qubits,
-        support=support,
-        param=param,
-        op=op,
-        fm_type=BasisSet.CHEBYSHEV,
-        reupload_scaling=ReuploadScaling.TOWER,
-    )
-    return fm
-
-
 def exp_fourier_feature_map(
     n_qubits: int,
     support: tuple[int, ...] = None,

qadence/constructors/hamiltonians.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Callable, List, Type, Union
 
 import numpy as np
 from torch import Tensor, double, ones, rand
 
 from qadence.blocks import AbstractBlock, add, block_is_qubit_hamiltonian
-from qadence.logger import get_logger
 from qadence.operations import N, X, Y, Z
 from qadence.register import Register
 from qadence.types import Interaction, TArray
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def interaction_zz(i: int, j: int) -> AbstractBlock:
@@ -207,10 +207,6 @@ def total_magnetization(n_qubits: int, z_terms: np.ndarray | list | None = None)
     return hamiltonian_factory(n_qubits, detuning=Z, detuning_strength=z_terms)
 
 
-def single_z(qubit: int = 0, z_coefficient: float = 1.0) -> AbstractBlock:
-    return Z(qubit) * z_coefficient
-
-
 def zz_hamiltonian(
     n_qubits: int,
     z_terms: np.ndarray | None = None,

qadence/constructors/rydberg_feature_maps.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Callable
 
 import numpy as np
@@ -7,12 +8,11 @@ from sympy import Basic
 
 from qadence.blocks import AnalogBlock, KronBlock, kron
 from qadence.constructors.feature_maps import fm_parameter_func, fm_parameter_scaling
-from qadence.logger import get_logger
 from qadence.operations import AnalogRot, AnalogRX, AnalogRY, AnalogRZ
 from qadence.parameters import FeatureParameter, Parameter, VariationalParameter
 from qadence.types import PI, BasisSet, ReuploadScaling, TParameter
 
-logger = get_logger(__file__)
+logger = getLogger(__name__)
 
 AnalogRotationTypes = [AnalogRX, AnalogRY, AnalogRZ]
 

qadence/decompose.py

@@ -2,20 +2,20 @@ from __future__ import annotations
 
 import itertools
 from enum import Enum
+from logging import getLogger
 from typing import Any, List, Tuple, Union
 
 import sympy
 
 from qadence.blocks import AbstractBlock
 from qadence.blocks.utils import get_pauli_blocks, unroll_block_with_scaling
-from qadence.logger import get_logger
 from qadence.parameters import Parameter, evaluate
 
 # from qadence.types import TNumber, TParameter
 from qadence.types import PI
 from qadence.types import LTSOrder as Order
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 # flatten a doubly-nested list
 flatten = lambda a: list(itertools.chain(*a))  # noqa: E731

qadence/engines/torch/differentiable_expectation.py

@@ -45,6 +45,13 @@ class PSRExpectation(Function):
         expectation_values = expectation_fn(param_values=param_dict(param_keys, param_values))  # type: ignore[call-arg] # noqa: E501
         # Stack batches of expectations if so.
         if isinstance(expectation_values, list):
+            # Check for first element being a list in case of noisy simulations in Pulser.
+            if isinstance(expectation_values[0], list):
+                exp_vals: list = []
+                for expectation_value in expectation_values:
+                    res = list(map(lambda x: x.get_final_state().data.toarray(), expectation_value))
+                    exp_vals.append(torch.tensor(res))
+                expectation_values = exp_vals
             return torch.stack(expectation_values)
         else:
             return expectation_values

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/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/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:
@@ -59,8 +58,18 @@ def write_checkpoint(
     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
+    model_checkpoint_name: str = (
+        f"model_{type(model).__name__}_ckpt_" + f"{iteration:03n}" + f"_device_{device}" + ".pt"
+    )
+    opt_checkpoint_name: str = (
+        f"opt_{type(optimizer).__name__}_ckpt_" + f"{iteration:03n}" + f"_device_{device}" + ".pt"
+    )
     try:
         d = (
             model._to_dict(save_params=True)

qadence/ml_tools/train_grad.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Callable, Union
 
 from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn, TimeRemainingColumn
@@ -11,14 +12,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.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(
@@ -182,7 +182,7 @@ def train(
                         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

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(