qadence 1.6.3__py3-none-any.whl → 1.7.1__py3-none-any.whl

qadence/__init__.py

@@ -49,7 +49,7 @@ from .exceptions import *
 from .execution import *
 from .measurements import *
 from .ml_tools import *
-from .models import *
+from .model import *
 from .noise import *
 from .operations import *
 from .overlap import *
@@ -82,7 +82,7 @@ list_of_submodules = [
     ".execution",
     ".measurements",
     ".ml_tools",
-    ".models",
+    ".model",
     ".operations",
     ".overlap",
     ".parameters",

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(
@@ -253,7 +262,8 @@ class PyQHamiltonianEvolution(Module):
         """Approximate jacobian of the evolved operator with respect to time evolution."""
         return finitediff(
             lambda t: self._unitary(time_evolution=t, hamiltonian=self._hamiltonian(self, values)),
-            values[self.param_names[0]],
+            values[self.param_names[0]].reshape(-1, 1),
+            (0,),
         )
 
     def jacobian_generator(self, values: dict[str, Tensor]) -> Tensor:
@@ -280,25 +290,88 @@ class PyQHamiltonianEvolution(Module):
             lambda v: self._unitary(
                 time_evolution=self._time_evolution(values), hamiltonian=_generator(v)
             ),
-            values[self.param_names[1]],
+            values[self.param_names[1]].reshape(-1, 1),
+            (0,),
         )
 
     def dagger(self, values: dict[str, Tensor]) -> Tensor:
         """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

@@ -20,8 +20,8 @@ from torch import (
     rand,
 )
 
-from qadence.types import ParamDictType
-from qadence.utils import Endianness, int_to_basis, is_qadence_shape
+from qadence.types import Endianness, ParamDictType
+from qadence.utils import int_to_basis, is_qadence_shape
 
 FINITE_DIFF_EPS = 1e-06
 # Dict of NumPy dtype -> torch dtype (when the correspondence exists)
@@ -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,17 +144,71 @@ 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
 # native 'jacobian' methods.
 
 
-def finitediff(f: Callable, x: Tensor, eps: float = FINITE_DIFF_EPS) -> Tensor:
-    return (f(x + eps) - f(x - eps)) / (2 * eps)  # type: ignore
+def finitediff(
+    f: Callable,
+    x: Tensor,
+    derivative_indices: tuple[int, ...],
+    eps: float = None,
+) -> Tensor:
+    """
+    Compute the finite difference of a function at a point.
+
+    Args:
+        f: The function to differentiate.
+        x: Input of size `(batch_size, input_size)`.
+        derivative_indices: Which *input* to differentiate (i.e. which variable x[:,i])
+        eps: finite difference spacing (uses `torch.finfo(x.dtype).eps ** (1 / (2 + order))`
+            as default)
+
+    Returns:
+        (Tensor): The finite difference of the function at the point `x`.
+    """
+
+    if eps is None:
+        order = len(derivative_indices)
+        eps = torch.finfo(x.dtype).eps ** (1 / (2 + order))
+
+    # compute derivative direction vector(s)
+    eps = torch.as_tensor(eps, dtype=x.dtype)
+    _eps = 1 / eps  # type: ignore[operator]
+    ev = torch.zeros_like(x)
+    i = derivative_indices[0]
+    ev[:, i] += eps
+
+    # recursive finite differencing for higher order than 3 / mixed derivatives
+    if len(derivative_indices) > 3 or len(set(derivative_indices)) > 1:
+        di = derivative_indices[1:]
+        return (finitediff(f, x + ev, di) - finitediff(f, x - ev, di)) * _eps / 2
+    elif len(derivative_indices) == 3:
+        return (f(x + 2 * ev) - 2 * f(x + ev) + 2 * f(x - ev) - f(x - 2 * ev)) * _eps**3 / 2
+    elif len(derivative_indices) == 2:
+        return (f(x + ev) + f(x - ev) - 2 * f(x)) * _eps**2
+    elif len(derivative_indices) == 1:
+        return (f(x + ev) - f(x - ev)) * _eps / 2
+    else:
+        raise ValueError("If you see this error there is a bug in the `finitediff` function.")
 
 
 def finitediff_sampling(

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/blocks/matrix.py

@@ -27,7 +27,7 @@ class MatrixBlock(PrimitiveBlock):
     from qadence.circuit import QuantumCircuit
     from qadence.types import BackendName, DiffMode
     from qadence.blocks.matrix import MatrixBlock
-    from qadence.models import QuantumModel
+    from qadence.model import QuantumModel
     from qadence.operations import X, Z
     from qadence.states import random_state
 

qadence/blocks/primitive.py

@@ -27,7 +27,7 @@ class PrimitiveBlock(AbstractBlock):
     Primitive blocks represent elementary unitary operations.
 
     Examples are single/multi-qubit gates or Hamiltonian evolution.
-    See [`qadence.operations`](/qadence/operations.md) for a full list of
+    See [`qadence.operations`](operations.md) for a full list of
     primitive blocks.
     """
 

qadence/constructors/__init__.py

@@ -14,6 +14,7 @@ from .daqc import daqc_transform
 from .hamiltonians import (
     hamiltonian_factory,
     ising_hamiltonian,
+    ObservableConfig,
     total_magnetization,
     zz_hamiltonian,
 )
@@ -31,6 +32,7 @@ __all__ = [
     "identity_initialized_ansatz",
     "hamiltonian_factory",
     "ising_hamiltonian",
+    "ObservableConfig",
     "total_magnetization",
     "zz_hamiltonian",
     "qft",

qadence/constructors/hamiltonians.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from logging import getLogger
 from typing import Callable, List, Type, Union
 
 import numpy as np
 from torch import Tensor, double, ones, rand
+from typing_extensions import Any
 
 from qadence.blocks import AbstractBlock, add, block_is_qubit_hamiltonian
 from qadence.operations import N, X, Y, Z
 from qadence.register import Register
-from qadence.types import Interaction, TArray
+from qadence.types import Interaction, ObservableTransform, TArray, TParameter
 
 logger = getLogger(__name__)
 
@@ -229,3 +231,38 @@ def ising_hamiltonian(
     zz_ham = zz_hamiltonian(n_qubits, z_terms=z_terms, zz_terms=zz_terms)
     x_ham = hamiltonian_factory(n_qubits, detuning=X, detuning_strength=x_terms)
     return zz_ham + x_ham
+
+
+def is_numeric(x: Any) -> bool:
+    return type(x) in (int, float, complex, np.int64, np.float64)
+
+
+@dataclass
+class ObservableConfig:
+    detuning: TDetuning
+    """
+    Single qubit detuning of the observable Hamiltonian.
+
+    Accepts single-qubit operator N, X, Y, or Z.
+    """
+    scale: TParameter = 1.0
+    """The scale by which to multiply the output of the observable."""
+    shift: TParameter = 0.0
+    """The shift to add to the output of the observable."""
+    transformation_type: ObservableTransform = ObservableTransform.NONE  # type: ignore[assignment]
+    """The type of transformation."""
+    trainable_transform: bool | None = None
+    """
+    Whether to have a trainable transformation on the output of the observable.
+
+    If None, the scale and shift are numbers.
+    If True, the scale and shift are VariationalParameter.
+    If False, the scale and shift are FeatureParameter.
+    """
+
+    def __post_init__(self) -> None:
+        if is_numeric(self.scale) and is_numeric(self.shift):
+            assert (
+                self.trainable_transform is None
+            ), f"If scale and shift are numbers, trainable_transform must be None. \
+            But got: {self.trainable_transform}"

qadence/draw/utils.py

@@ -23,7 +23,7 @@ from qadence.blocks import (
 )
 from qadence.blocks.analog import ConstantAnalogRotation, InteractionBlock
 from qadence.circuit import QuantumCircuit
-from qadence.models import QuantumModel
+from qadence.model import QuantumModel
 from qadence.operations import RX, RY, RZ, SWAP, HamEvo, I
 from qadence.transpile.block import fill_identities
 from qadence.utils import format_parameter

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: