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

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
@@ -22,7 +23,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,
@@ -32,7 +32,7 @@ from qadence.parameters import (
 from qadence.types import LTSOrder, OpName, TGenerator, TParameter
 from qadence.utils import eigenvalues
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class HamEvo(TimeEvolutionBlock):

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):

qadence/parameters.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Any, ItemsView, KeysView, ValuesView, get_args
 from uuid import uuid4
 
@@ -12,13 +13,12 @@ from sympy.physics.quantum.dagger import Dagger
 from sympytorch import SymPyModule as torchSympyModule
 from torch import Tensor, heaviside, no_grad, rand, tensor
 
-from qadence.logger import get_logger
 from qadence.types import DifferentiableExpression, Engine, TNumber
 
 # Modules to be automatically added to the qadence namespace
 __all__ = ["FeatureParameter", "Parameter", "VariationalParameter"]
 
-logger = get_logger(__file__)
+logger = getLogger(__name__)
 
 dagger_expression = Dagger
 

qadence/serial_expr_grammar.peg

@@ -0,0 +1,11 @@
+Program = expr EOF
+expr = id '(' args ')'
+args = (value / expr) (',' (value / expr))*
+value = int / float_str / str / pair
+pair = param '=' (int / bool / str)
+param = r"[a-z][a-zA-Z]*"
+id = r"[a-zA-Z][a-zA-Z_0-9]*"
+bool = 'True' / 'False'
+int = r"-?(0|[1-9][0-9]*)"
+float_str = r"'-?(0|\d*(\.\d*))'"
+str = r"'[a-zA-Z0-9\_\.]+'"

qadence/serialization.py

@@ -2,21 +2,26 @@ from __future__ import annotations
 
 import json
 import os
+import sys
+from dataclasses import dataclass
+from dataclasses import field as dataclass_field
+from functools import lru_cache
+from logging import getLogger
 from pathlib import Path
-from typing import Any, get_args
+from typing import Any, Callable, get_args
 from typing import Union as TypingUnion
 
 import torch
+from arpeggio import NoMatch
+from arpeggio.cleanpeg import ParserPEG
 from sympy import *
-from sympy import Basic, Expr, srepr
+from sympy import core, srepr
 
-from qadence import QuantumCircuit, operations
+from qadence import QuantumCircuit, operations, parameters
 from qadence import blocks as qadenceblocks
 from qadence.blocks import AbstractBlock
 from qadence.blocks.utils import tag
-from qadence.logger import get_logger
-from qadence.ml_tools.models import TransformedModule
-from qadence.models import QNN, QuantumModel
+from qadence.models import QuantumModel
 from qadence.parameters import Parameter
 from qadence.register import Register
 from qadence.types import SerializationFormat
@@ -25,7 +30,7 @@ from qadence.types import SerializationFormat
 __all__ = ["deserialize", "load", "save", "serialize"]
 
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def file_extension(file: Path | str) -> str:
@@ -43,27 +48,172 @@ SUPPORTED_OBJECTS = [
     AbstractBlock,
     QuantumCircuit,
     QuantumModel,
-    QNN,
-    TransformedModule,
     Register,
-    Basic,
+    core.Basic,
     torch.nn.Module,
 ]
 SUPPORTED_TYPES = TypingUnion[
     AbstractBlock,
     QuantumCircuit,
     QuantumModel,
-    QNN,
-    TransformedModule,
     Register,
-    Basic,
+    core.Basic,
     torch.nn.Module,
 ]
 
-
 ALL_BLOCK_NAMES = [
     n for n in dir(qadenceblocks) if not (n.startswith("__") and n.endswith("__"))
 ] + [n for n in dir(operations) if not (n.startswith("__") and n.endswith("__"))]
+SYMPY_EXPRS = [n for n in dir(core) if not (n.startswith("__") and n.endswith("__"))]
+QADENCE_PARAMETERS = [n for n in dir(parameters) if not (n.startswith("__") and n.endswith("__"))]
+
+
+THIS_PATH = Path(__file__).parent
+GRAMMAR_FILE = THIS_PATH / "serial_expr_grammar.peg"
+
+
+@lru_cache
+def _parser_fn() -> ParserPEG:
+    with open(GRAMMAR_FILE, "r") as f:
+        grammar = f.read()
+    return ParserPEG(grammar, "Program")
+
+
+_parsing_serialize_expr = _parser_fn()
+
+
+def parse_expr_fn(code: str) -> bool:
+    """
+    A parsing expressions function that checks whether a given code is valid on.
+
+    the parsing grammar. The grammar is defined to be compatible with `sympy`
+    expressions, such as `Float('-0.33261030434342942', precision=53)`, while
+    avoiding code injection such as `2*3` or `__import__('os').system('ls -la')`.
+
+    Args:
+        code (str): code to be parsed and checked.
+
+    Returns:
+        Boolean indicating whether the code matches the defined grammar or not.
+    """
+
+    parser = _parsing_serialize_expr
+    try:
+        parser.parse(code)
+    except NoMatch:
+        return False
+    else:
+        return True
+
+
+@dataclass
+class SerializationModel:
+    """
+    A serialization model class to serialize data from `QuantumModel`s,.
+
+    `torch.nn.Module` and similar structures. The data included in the
+    serialization logic includes: the `AbstractBlock` and its children
+    classes, `QuantumCircuit`, `Register`, and `sympy` expressions
+    (including `Parameter` class from `qadence.parameters`).
+
+    A children class must define the `value` attribute type and how to
+    handle it, since it is the main property for the class to be used
+    by the serialization process. For instance:
+
+    ```python
+    @dataclass
+    class QuantumCircuitSerialization(SerializationModel):
+        value: QuantumCircuit = dataclass_field(init=False)
+
+        def __post_init__(self) -> None:
+            self.value = (
+                QuantumCircuit._from_dict(self.d)
+                if isinstance(self.d, dict)
+                else self.d
+            )
+    ```
+    """
+
+    d: dict = dataclass_field(default_factory=dict)
+    value: Any = dataclass_field(init=False)
+
+
+@dataclass
+class BlockTypeSerialization(SerializationModel):
+    value: AbstractBlock = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        block = (
+            getattr(operations, self.d["type"])
+            if hasattr(operations, self.d["type"])
+            else getattr(qadenceblocks, self.d["type"])
+        )._from_dict(self.d)
+        if self.d["tag"] is not None:
+            block = tag(block, self.d["tag"])
+        self.value = block
+
+
+@dataclass
+class QuantumCircuitSerialization(SerializationModel):
+    value: QuantumCircuit = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        self.value = QuantumCircuit._from_dict(self.d) if isinstance(self.d, dict) else self.d
+
+
+@dataclass
+class RegisterSerialization(SerializationModel):
+    value: Register = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        self.value = Register._from_dict(self.d)
+
+
+@dataclass
+class ModelSerialization(SerializationModel):
+    as_torch: bool = False
+    value: torch.nn.Module = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        module_name = list(self.d.keys())[0]
+        obj = globals().get(module_name, None)
+        if obj is None:
+            obj = self._resolve_module(module_name)
+        if hasattr(obj, "_from_dict"):
+            self.value = obj._from_dict(self.d, self.as_torch)
+        elif hasattr(obj, "load_state_dict"):
+            self.value = obj.load_state_dict(self.d[module_name])
+        else:
+            msg = (
+                f"Unable to deserialize object '{module_name}'. "
+                f"Supported types are {SUPPORTED_OBJECTS}."
+            )
+            logger.error(TypeError(msg))
+            raise TypeError(msg)
+
+    @staticmethod
+    def _resolve_module(module: str) -> Any:
+        for loaded_module in sys.modules.keys():
+            if "qadence" in loaded_module:
+                obj = getattr(sys.modules[loaded_module], module, None)
+                if obj:
+                    return obj
+        raise ValueError(f"Couldn't resolve module '{module}'.")
+
+
+@dataclass
+class ExpressionSerialization(SerializationModel):
+    value: str | core.Expr | float = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        if parse_expr_fn(self.d["expression"]):
+            expr = eval(self.d["expression"])
+            if hasattr(expr, "free_symbols"):
+                for s in expr.free_symbols:
+                    s.value = float(self.d["symbols"][s.name]["value"])
+            self.value = expr
+        else:
+            raise ValueError(f"Invalid expression: {self.d['expression']}")
 
 
 def save_pt(d: dict, file_path: str | Path) -> None:
@@ -94,11 +244,11 @@ def serialize(obj: SUPPORTED_TYPES, save_params: bool = False) -> dict:
     """
     Supported Types:
 
-    AbstractBlock | QuantumCircuit | QuantumModel | TransformedModule | Register | Module
+    AbstractBlock | QuantumCircuit | QuantumModel | torch.nn.Module | Register | Module
     Serializes a qadence object to a dictionary.
 
     Arguments:
-        obj (AbstractBlock | QuantumCircuit | QuantumModel | Register | Module):
+        obj (AbstractBlock | QuantumCircuit | QuantumModel | Register | torch.nn.Module):
     Returns:
         A dict.
 
@@ -132,21 +282,28 @@ def serialize(obj: SUPPORTED_TYPES, save_params: bool = False) -> dict:
     """
     if not isinstance(obj, get_args(SUPPORTED_TYPES)):
         logger.error(TypeError(f"Serialization of object type {type(obj)} not supported."))
-    d: dict = {}
+
+    d: dict = dict()
     try:
-        if isinstance(obj, Expr):
-            symb_dict = {}
+        if isinstance(obj, core.Expr):
+            symb_dict = dict()
             expr_dict = {"name": str(obj), "expression": srepr(obj)}
-            symbs: set[Parameter | Basic] = obj.free_symbols
+            symbs: set[Parameter | core.Basic] = obj.free_symbols
             if symbs:
                 symb_dict = {"symbols": {str(s): s._to_dict() for s in symbs}}
             d = {**expr_dict, **symb_dict}
-        elif isinstance(obj, (QuantumModel, QNN, TransformedModule)):
-            d = obj._to_dict(save_params)
-        elif isinstance(obj, torch.nn.Module):
-            d = {type(obj).__name__: obj.state_dict()}
         else:
-            d = obj._to_dict()
+            if hasattr(obj, "_to_dict"):
+                model_to_dict: Callable = obj._to_dict
+                d = (
+                    model_to_dict(save_params)
+                    if isinstance(obj, torch.nn.Module)
+                    else model_to_dict()
+                )
+            elif hasattr(obj, "state_dict"):
+                d = {type(obj).__name__: obj.state_dict()}
+            else:
+                raise ValueError(f"Cannot serialize object {obj}.")
     except Exception as e:
         logger.error(f"Serialization of object {obj} failed due to {e}")
     return d
@@ -156,13 +313,14 @@ def deserialize(d: dict, as_torch: bool = False) -> SUPPORTED_TYPES:
     """
     Supported Types:
 
-    AbstractBlock | QuantumCircuit | QuantumModel | TransformedModule | Register | Module
+    AbstractBlock | QuantumCircuit | QuantumModel | Register | torch.nn.Module
     Deserializes a dict to one of the supported types.
 
     Arguments:
         d (dict): A dict containing a serialized object.
+        as_torch (bool): Whether to transform to torch for the deserialized object.
     Returns:
-        AbstractBlock, QuantumCircuit, QuantumModel, TransformedModule, Register, Module.
+        AbstractBlock, QuantumCircuit, QuantumModel, Register, torch.nn.Module.
 
     Examples:
     ```python exec="on" source="material-block" result="json"
@@ -192,51 +350,18 @@ def deserialize(d: dict, as_torch: bool = False) -> SUPPORTED_TYPES:
     assert torch.isclose(qm.expectation({}), qm_deserialized.expectation({}))
     ```
     """
-    obj: Any
+    obj: SerializationModel
     if d.get("expression"):
-        expr = eval(d["expression"])
-        if hasattr(expr, "free_symbols"):
-            for symb in expr.free_symbols:
-                symb.value = float(d["symbols"][symb.name]["value"])
-        obj = expr
-    elif d.get("QuantumModel"):
-        obj = QuantumModel._from_dict(d, as_torch)
-    elif d.get("QNN"):
-        obj = QNN._from_dict(d, as_torch)
-    elif d.get("TransformedModule"):
-        obj = TransformedModule._from_dict(d, as_torch)
+        obj = ExpressionSerialization(d)
     elif d.get("block") and d.get("register"):
-        obj = QuantumCircuit._from_dict(d)
+        obj = QuantumCircuitSerialization(d)
     elif d.get("graph"):
-        obj = Register._from_dict(d)
+        obj = RegisterSerialization(d)
     elif d.get("type"):
-        if d["type"] in ALL_BLOCK_NAMES:
-            block: AbstractBlock = (
-                getattr(operations, d["type"])._from_dict(d)
-                if hasattr(operations, d["type"])
-                else getattr(qadenceblocks, d["type"])._from_dict(d)
-            )
-            if d["tag"] is not None:
-                block = tag(block, d["tag"])
-            obj = block
+        obj = BlockTypeSerialization(d)
     else:
-        import warnings
-
-        msg = warnings.warn(
-            "In order to load a custom torch.nn.Module, make sure its imported in the namespace."
-        )
-        try:
-            module_name = list(d.keys())[0]
-            obj = getattr(globals(), module_name)
-            obj.load_state_dict(d[module_name])
-        except Exception as e:
-            logger.error(
-                TypeError(
-                    f"{msg}. Unable to deserialize object due to {e}.\
-                    Supported objects are: {SUPPORTED_OBJECTS}"
-                )
-            )
-    return obj
+        obj = ModelSerialization(d, as_torch=as_torch)
+    return obj.value
 
 
 def save(

qadence/transpile/block.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from copy import deepcopy
 from functools import singledispatch
+from logging import getLogger
 from typing import Callable, Iterable, Type
 
 import sympy
@@ -26,11 +27,10 @@ from qadence.blocks.utils import (
     _construct,
     parameters,
 )
-from qadence.logger import get_logger
 from qadence.operations import SWAP, I
 from qadence.parameters import Parameter
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def repeat(

qadence/types.py

@@ -9,8 +9,8 @@ import sympy
 from numpy.typing import ArrayLike
 from torch import Tensor, pi
 
-TNumber = Union[int, float, complex]
-"""Union of python number types."""
+TNumber = Union[int, float, complex, np.int64, np.float64]
+"""Union of python and numpy numeric types."""
 
 TDrawColor = Tuple[float, float, float, float]