qadence 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

qadence/backends/api.py

@@ -2,10 +2,17 @@ from __future__ import annotations
 
 from qadence.backend import Backend, BackendConfiguration
 from qadence.engines.differentiable_backend import DifferentiableBackend
-from qadence.extensions import available_backends, available_engines, set_backend_config
-from qadence.types import BackendName, DiffMode, Engine
+from qadence.extensions import (
+    import_backend,
+    import_config,
+    import_engine,
+    set_backend_config,
+)
+from qadence.logger import get_logger
+from qadence.types import BackendName, DiffMode
 
 __all__ = ["backend_factory", "config_factory"]
+logger = get_logger(__name__)
 
 
 def backend_factory(
@@ -14,67 +21,47 @@ def backend_factory(
     configuration: BackendConfiguration | dict | None = None,
 ) -> Backend | DifferentiableBackend:
     backend_inst: Backend | DifferentiableBackend
-    backends = available_backends()
     try:
-        backend_name = BackendName(backend)
-    except ValueError:
-        raise NotImplementedError(f"The requested backend '{backend}' is not implemented.")
-    try:
-        BackendCls = backends[backend_name]
-    except Exception as e:
-        raise ImportError(
-            f"The requested backend '{backend_name}' is either not installed\
-              or could not be imported due to {e}."
-        )
-
-    default_config = BackendCls.default_configuration()
-    if configuration is None:
-        configuration = default_config
-    elif isinstance(configuration, dict):
-        configuration = config_factory(backend_name, configuration)
-    else:
-        # NOTE: types have to match exactly, hence we use `type`
-        if not isinstance(configuration, type(BackendCls.default_configuration())):
-            raise ValueError(
-                f"Given config class '{type(configuration)}' does not match the backend",
-                f" class: '{BackendCls}'. Expected: '{type(BackendCls.default_configuration())}.'",
-            )
-
-    # Create the backend
-    backend_inst = BackendCls(
-        config=configuration
-        if configuration is not None
-        else BackendCls.default_configuration()  # type: ignore[attr-defined]
-    )
+        BackendCls = import_backend(backend)
+        default_config = BackendCls.default_configuration()
+        if configuration is None:
+            configuration = default_config
+        elif isinstance(configuration, dict):
+            configuration = config_factory(backend, configuration)
+        else:
+            # NOTE: types have to match exactly, hence we use `type`
+            if not isinstance(configuration, type(BackendCls.default_configuration())):
+                expected_cfg = BackendCls.default_configuration()
+                raise ValueError(
+                    f"Given config class '{type(configuration)}' does not match the backend",
+                    f" class: '{BackendCls}'. Expected: '{type(expected_cfg)}.'",
+                )
 
+        # Instantiate the backend
+        backend_inst = BackendCls(  # type: ignore[operator]
+            config=configuration
+            if configuration is not None
+            else BackendCls.default_configuration()
+        )
+        set_backend_config(backend_inst, diff_mode)
+        # Wrap the quantum Backend in a DifferentiableBackend if a diff_mode is passed.
+        if diff_mode is not None:
+            diff_backend_cls = import_engine(backend_inst.engine)
+            backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode))  # type: ignore[operator]
+        return backend_inst
+    except Exception as e:
+        msg = f"The requested backend '{backend}' is either not installed\
+            or could not be imported due to {e}."
+        logger.error(msg)
+        raise Exception(msg)
     # Set backend configurations which depend on the differentiation mode
-    set_backend_config(backend_inst, diff_mode)
-    # Wrap the quantum Backend in a DifferentiableBackend if a diff_mode is passed.
-    if diff_mode is not None:
-        try:
-            engine_name = Engine(backend_inst.engine)
-        except ValueError:
-            raise NotImplementedError(
-                f"The requested engine '{backend_inst.engine}' is not implemented."
-            )
-        try:
-            diff_backend_cls = available_engines()[engine_name]
-            backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode))  # type: ignore[arg-type]
-        except Exception as e:
-            raise ImportError(
-                f"The requested engine '{engine_name}' is either not installed\
-                or could not be imported due to {e}."
-            )
-    return backend_inst
-
 
-def config_factory(name: BackendName | str, config: dict) -> BackendConfiguration:
-    backends = available_backends()
 
+def config_factory(backend_name: BackendName | str, config: dict) -> BackendConfiguration:
+    cfg: BackendConfiguration
     try:
-        BackendCls = backends[BackendName(name)]
-    except KeyError:
-        raise NotImplementedError(f"The requested backend '{name}' is not implemented!")
-
-    BackendConfigCls = type(BackendCls.default_configuration())
-    return BackendConfigCls(**config)  # type: ignore[no-any-return]
+        BackendConfigCls = import_config(backend_name)
+        cfg = BackendConfigCls(**config)  # type: ignore[operator]
+    except Exception as e:
+        logger.debug(f"Unable to import config for backend {backend_name} due to {e}.")
+    return cfg

qadence/backends/gpsr.py

@@ -126,6 +126,7 @@ def multi_gap_psr(
 
     # get number of observables from expectation value tensor
     if f_plus.numel() > 1:
+        batch_size = F[0].shape[0]
         n_obs = F[0].shape[1]
 
     # reshape F vector

qadence/backends/pyqtorch/backend.py

@@ -12,6 +12,7 @@ from torch import Tensor
 from qadence.backend import Backend as BackendInterface
 from qadence.backend import ConvertedCircuit, ConvertedObservable
 from qadence.backends.utils import (
+    infer_batchsize,
     pyqify,
     to_list_of_dicts,
     unpyqify,
@@ -31,7 +32,6 @@ from qadence.transpile import (
     transpile,
 )
 from qadence.types import BackendName, Endianness, Engine
-from qadence.utils import infer_batchsize
 
 from .config import Configuration, default_passes
 from .convert_ops import convert_block
@@ -165,7 +165,6 @@ class Backend(BackendInterface):
                 "Looping expectation does not make sense with batched initial state. "
                 "Define your initial state with `batch_size=1`"
             )
-
         list_expvals = []
         observables = observable if isinstance(observable, list) else [observable]
         for vals in to_list_of_dicts(param_values):

qadence/backends/pyqtorch/config.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from logging import getLogger
 from typing import Callable
 
+from pyqtorch.utils import SolverType
+
 from qadence.analog import add_background_hamiltonian
 from qadence.backend import BackendConfiguration
 from qadence.transpile import (
@@ -41,6 +43,9 @@ class Configuration(BackendConfiguration):
     algo_hevo: AlgoHEvo = AlgoHEvo.EXP
     """Determine which kind of Hamiltonian evolution algorithm to use."""
 
+    ode_solver: SolverType = SolverType.DP5_SE
+    """Determine which ODE solver to use for time-dependent blocks."""
+
     n_steps_hevo: int = 100
     """Default number of steps for the Hamiltonian evolution."""
 

qadence/backends/pyqtorch/convert_ops.py

@@ -6,8 +6,10 @@ from typing import Any, Sequence, Tuple
 
 import pyqtorch as pyq
 import sympy
+import torch
 from pyqtorch.apply import apply_operator
 from pyqtorch.matrices import _dagger
+from pyqtorch.time_dependent.sesolve import sesolve
 from pyqtorch.utils import is_diag
 from torch import (
     Tensor,
@@ -26,6 +28,8 @@ from torch.nn import Module
 
 from qadence.backends.utils import (
     finitediff,
+    pyqify,
+    unpyqify,
 )
 from qadence.blocks import (
     AbstractBlock,
@@ -38,8 +42,12 @@ from qadence.blocks import (
     ScaleBlock,
     TimeEvolutionBlock,
 )
-from qadence.blocks.block_to_tensor import _block_to_tensor_embedded, block_to_tensor
+from qadence.blocks.block_to_tensor import (
+    _block_to_tensor_embedded,
+    block_to_tensor,
+)
 from qadence.blocks.primitive import ProjectorBlock
+from qadence.blocks.utils import parameters
 from qadence.operations import (
     U,
     multi_qubit_gateset,
@@ -177,6 +185,7 @@ class PyQHamiltonianEvolution(Module):
         self.param_names = config.get_param_name(block)
         self.block = block
         self.hmat: Tensor
+        self.config = config
 
         if isinstance(block.generator, AbstractBlock) and not block.generator.is_parametric:
             hmat = block_to_tensor(
@@ -289,18 +298,80 @@ class PyQHamiltonianEvolution(Module):
         """Dagger of the evolved operator given the current parameter values."""
         return _dagger(self.unitary(values))
 
+    def _get_time_parameter(self) -> str:
+        # get unique time parameters
+        unique_time_params = set()
+        for p in parameters(self.block.generator):  # type: ignore [arg-type]
+            if getattr(p, "is_time", False):
+                unique_time_params.add(str(p))
+
+        if len(unique_time_params) > 1:
+            raise Exception("Only a single time parameter is supported.")
+
+        return unique_time_params.pop()
+
     def forward(
         self,
         state: Tensor,
         values: dict[str, Tensor],
     ) -> Tensor:
-        return apply_operator(
-            state,
-            self.unitary(values),
-            self.qubit_support,
-            self.n_qubits,
-            self.batch_size,
-        )
+        if getattr(self.block.generator, "is_time_dependent", False):  # type: ignore [union-attr]
+
+            def Ht(t: Tensor | float) -> Tensor:
+                # values dict has to change with new value of t
+                # initial value of a feature parameter inside generator block
+                # has to be inferred here
+                new_vals = dict()
+                for str_expr, val in values.items():
+                    expr = sympy.sympify(str_expr)
+                    t_symb = sympy.Symbol(self._get_time_parameter())
+                    free_symbols = expr.free_symbols
+                    if t_symb in free_symbols:
+                        # create substitution list for time and feature params
+                        subs_list = [(t_symb, t)]
+
+                        if len(free_symbols) > 1:
+                            # get feature param symbols
+                            feat_symbols = free_symbols.difference(set([t_symb]))
+
+                            # get feature param values
+                            feat_vals = values["orig_param_values"]
+
+                            # update substitution list with feature param values
+                            for fs in feat_symbols:
+                                subs_list.append((fs, feat_vals[str(fs)]))
+
+                        # evaluate expression with new time param value
+                        new_vals[str_expr] = torch.tensor(float(expr.subs(subs_list)))
+                    else:
+                        # expression doesn't contain time parameter - copy it as is
+                        new_vals[str_expr] = val
+
+                # get matrix form of generator
+                hmat = _block_to_tensor_embedded(
+                    self.block.generator,  # type: ignore[arg-type]
+                    values=new_vals,
+                    qubit_support=self.qubit_support,
+                    use_full_support=False,
+                    device=self.device,
+                ).squeeze(0)
+
+                return hmat
+
+            tsave = torch.linspace(0, self.block.duration, self.config.n_steps_hevo)  # type: ignore [attr-defined]
+            result = pyqify(
+                sesolve(Ht, unpyqify(state).T[:, 0:1], tsave, self.config.ode_solver).states[-1].T
+            )
+        else:
+            result = apply_operator(
+                state,
+                self.unitary(values),
+                self.qubit_support,
+                self.n_qubits,
+                self.batch_size,
+            )
+
+        return result
 
     @property
     def device(self) -> torch_device:

qadence/backends/utils.py

@@ -98,10 +98,11 @@ def to_list_of_dicts(param_values: ParamDictType) -> list[ParamDictType]:
     if not param_values:
         return [param_values]
 
-    max_batch_size = max(p.size()[0] for p in param_values.values())
+    max_batch_size = max(p.size()[0] for p in param_values.values() if isinstance(p, Tensor))
     batched_values = {
         k: (v if v.size()[0] == max_batch_size else v.repeat(max_batch_size, 1))
         for k, v in param_values.items()
+        if isinstance(v, Tensor)
     }
 
     return [{k: v[i] for k, v in batched_values.items()} for i in range(max_batch_size)]
@@ -143,9 +144,22 @@ def validate_state(state: Tensor, n_qubits: int) -> None:
         )
 
 
-def infer_batchsize(param_values: ParamDictType = None) -> int:
+def infer_batchsize(param_values: dict[str, Tensor] = None) -> int:
     """Infer the batch_size through the length of the parameter tensors."""
-    return max([len(tensor) for tensor in param_values.values()]) if param_values else 1
+    try:
+        return (
+            max(
+                [
+                    len(tensor_or_dict)
+                    for tensor_or_dict in param_values.values()
+                    if isinstance(tensor_or_dict, Tensor)
+                ]
+            )
+            if param_values
+            else 1
+        )
+    except Exception:
+        return 1
 
 
 # The following functions can be used to compute potentially higher order gradients using pyqtorch's

qadence/blocks/abstract.py

@@ -300,6 +300,13 @@ class AbstractBlock(ABC):
         params: list[sympy.Basic] = parameters(self)
         return any(isinstance(p, Parameter) for p in params)
 
+    @property
+    def is_time_dependent(self) -> bool:
+        from qadence.blocks.utils import parameters
+
+        params: list[sympy.Basic] = parameters(self)
+        return any(getattr(p, "is_time", False) for p in params)
+
     def tensor(self, values: dict[str, TNumber | torch.Tensor] = {}) -> torch.Tensor:
         from .block_to_tensor import block_to_tensor
 

qadence/blocks/embedding.py

@@ -111,18 +111,21 @@ def embedding(
             angle: ArrayLike
             values = {}
             for symbol in expr.free_symbols:
-                if symbol.name in inputs:
-                    value = inputs[symbol.name]
-                elif symbol.name in params:
-                    value = params[symbol.name]
+                if not symbol.is_time:
+                    if symbol.name in inputs:
+                        value = inputs[symbol.name]
+                    elif symbol.name in params:
+                        value = params[symbol.name]
+                    else:
+                        msg_trainable = "Trainable" if symbol.trainable else "Non-trainable"
+                        raise KeyError(
+                            f"{msg_trainable} parameter '{symbol.name}' not found in the "
+                            f"inputs list: {list(inputs.keys())} nor the "
+                            f"params list: {list(params.keys())}."
+                        )
+                    values[symbol.name] = value
                 else:
-                    msg_trainable = "Trainable" if symbol.trainable else "Non-trainable"
-                    raise KeyError(
-                        f"{msg_trainable} parameter '{symbol.name}' not found in the "
-                        f"inputs list: {list(inputs.keys())} nor the "
-                        f"params list: {list(params.keys())}."
-                    )
-                values[symbol.name] = value
+                    values[symbol.name] = tensor(1.0)
             angle = fn(**values)
             # do not reshape parameters which are multi-dimensional
             # tensors, such as for example generator matrices
@@ -139,7 +142,9 @@ def embedding(
                 gate_lvl_params[uuid] = embedded_params[e]
             return gate_lvl_params
         else:
-            return {stringify(k): v for k, v in embedded_params.items()}
+            out = {stringify(k): v for k, v in embedded_params.items()}
+            out.update({"orig_param_values": inputs})
+            return out
 
     params: ParamDictType
     params = {

qadence/execution.py

@@ -71,7 +71,10 @@ def _(
     endianness: Endianness = Endianness.BIG,
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> Tensor:
-    bknd = backend_factory(backend, configuration=configuration)
+    diff_mode = None
+    if backend == BackendName.PYQTORCH:
+        diff_mode = DiffMode.AD
+    bknd = backend_factory(backend, diff_mode=diff_mode, configuration=configuration)
     conv = bknd.convert(circuit)
     with no_grad():
         return bknd.run(
@@ -147,7 +150,10 @@ def _(
     endianness: Endianness = Endianness.BIG,
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> list[Counter]:
-    bknd = backend_factory(backend, configuration=configuration)
+    diff_mode = None
+    if backend == BackendName.PYQTORCH:
+        diff_mode = DiffMode.AD
+    bknd = backend_factory(backend, diff_mode=diff_mode, configuration=configuration)
     conv = bknd.convert(circuit)
     return bknd.sample(
         circuit=conv.circuit,
@@ -242,7 +248,9 @@ def _(
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> Tensor:
     observable = observable if isinstance(observable, list) else [observable]
-    bknd = backend_factory(backend, configuration=configuration, diff_mode=diff_mode)
+    if backend == BackendName.PYQTORCH:
+        diff_mode = DiffMode.AD
+    bknd = backend_factory(backend, diff_mode=diff_mode, configuration=configuration)
     conv = bknd.convert(circuit, observable)
 
     def _expectation() -> Tensor:

qadence/extensions.py

@@ -2,62 +2,93 @@ from __future__ import annotations
 
 import importlib
 from logging import getLogger
-from string import Template
+from typing import TypeVar
 
-from qadence.backend import Backend
+from qadence.backend import Backend, BackendConfiguration
 from qadence.blocks.abstract import TAbstractBlock
+from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.types import BackendName, DiffMode, Engine
 
-backends_namespace = Template("qadence.backends.$name")
+BackendClsType = TypeVar("BackendClsType", bound=Backend)
+EngineClsType = TypeVar("EngineClsType", bound=DifferentiableBackend)
 
 logger = getLogger(__name__)
 
 
-def _available_engines() -> dict:
-    """Returns a dictionary of currently installed, native qadence engines."""
-    res = {}
-    for engine in Engine.list():
-        module_path = f"qadence.engines.{engine}.differentiable_backend"
+def import_config(backend_name: str | BackendName) -> BackendConfiguration:
+    module_path = f"qadence.backends.{backend_name}.config"
+    cfg: BackendConfiguration
+    try:
+        module = importlib.import_module(module_path)
+        cfg = getattr(module, "Configuration")
+    except (ModuleNotFoundError, ImportError) as e:
+        raise type(e)(f"Failed to import backend config of {backend_name} due to {e}.") from e
+    return cfg
+
+
+def import_backend(backend_name: str | BackendName) -> Backend:
+    module_path = f"qadence.backends.{backend_name}.backend"
+    backend: Backend
+    try:
+        module = importlib.import_module(module_path)
+    except (ModuleNotFoundError, ImportError) as e:
+        # If backend is not in Qadence, search in extensions.
+        module_path = f"qadence_extensions.backends.{backend_name}.backend"
         try:
             module = importlib.import_module(module_path)
-            DifferentiableBackendCls = getattr(module, "DifferentiableBackend")
-            res[engine] = DifferentiableBackendCls
-        except (ImportError, ModuleNotFoundError):
-            pass
-    logger.debug(f"Found engines: {res.keys()}")
-    return res
+        except (ModuleNotFoundError, ImportError) as e:
+            raise type(e)
+    backend = getattr(module, "Backend")
+    return backend
 
 
-def _available_backends() -> dict:
-    """Returns a dictionary of currently installed, native qadence backends."""
-    res = {}
+def _available_backends() -> dict[BackendName, Backend]:
+    """Return a dictionary of currently installed, native qadence backends."""
+    res: dict[BackendName, Backend] = dict()
     for backend in BackendName.list():
-        module_path = f"qadence.backends.{backend}.backend"
         try:
-            module = importlib.import_module(module_path)
-            BackendCls = getattr(module, "Backend")
-            res[backend] = BackendCls
-        except (ImportError, ModuleNotFoundError):
-            pass
+            res[backend] = import_backend(backend)
+        except (ModuleNotFoundError, ImportError) as e:
+            raise type(e)(f"Failed to import backend {backend} due to {e}.") from e
     logger.debug(f"Found backends: {res.keys()}")
     return res
 
 
-def _supported_gates(name: BackendName | str) -> list[TAbstractBlock]:
-    """Returns a list of supported gates for the queried backend 'name'."""
+def import_engine(engine_name: str | Engine) -> DifferentiableBackend:
+    module_path = f"qadence.engines.{engine_name}.differentiable_backend"
+    engine: DifferentiableBackend
+    try:
+        module = importlib.import_module(module_path)
+        engine = getattr(module, "DifferentiableBackend")
+    except (ModuleNotFoundError, ImportError) as e:
+        raise type(e)
+    return engine
+
+
+def _available_engines() -> dict[Engine, DifferentiableBackend]:
+    """Return a dictionary of currently installed, native qadence engines."""
+    res: dict[Engine, DifferentiableBackend] = dict()
+    for engine in Engine.list():
+        try:
+            res[engine] = import_engine(engine)
+        except (ModuleNotFoundError, ImportError) as e:
+            raise type(e)(f"Failed to import engine {engine} due to {e}.") from e
+    logger.debug(f"Found engines: {res.keys()}")
+    return res
+
+
+def _supported_gates(backend_name: str) -> list[TAbstractBlock]:
+    """Return a list of supported gates for the queried backend 'name'."""
     from qadence import operations
 
-    name = str(BackendName(name).name.lower())
+    backend_name = BackendName(backend_name)  # Validate backend name.
+    module_path = f"qadence.backends.{backend_name}"
 
     try:
-        backend_namespace = backends_namespace.substitute(name=name)
-        module = importlib.import_module(backend_namespace)
-    except KeyError:
-        pass
-    _supported_gates = getattr(module, "supported_gates", None)
-    assert (
-        _supported_gates is not None
-    ), f"{name} backend should define a 'supported_gates' variable"
+        module = importlib.import_module(module_path)
+    except (ModuleNotFoundError, ImportError) as e:
+        raise type(e)(f"Failed to import backend module for {backend_name} due to {e}.") from e
+    _supported_gates = getattr(module, "supported_gates")
     return [getattr(operations, gate) for gate in _supported_gates]
 
 

qadence/ml_tools/config.py

@@ -85,8 +85,12 @@ class TrainConfig:
 
 @dataclass
 class FeatureMapConfig:
-    num_features: int = 1
-    """Number of feature parameters to be encoded."""
+    num_features: int = 0
+    """
+    Number of feature parameters to be encoded.
+
+    Defaults to 0. Thus, no feature parameters are encoded.
+    """
 
     basis_set: BasisSet | dict[str, BasisSet] = BasisSet.FOURIER
     """
@@ -235,7 +239,9 @@ class FeatureMapConfig:
                 len(self.inputs) == self.num_features
             ), "Inputs list must be of same size as the number of features"
         else:
-            if self.num_features == 1:
+            if self.num_features == 0:
+                self.inputs = []
+            elif self.num_features == 1:
                 self.inputs = ["x"]
             else:
                 raise ValueError(