qadence 1.6.2__py3-none-any.whl → 1.7.0__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/gpsr.py

@@ -48,7 +48,13 @@ def single_gap_psr(
     Returns:
         Tensor: tensor containing derivative values
     """
-
+    device = torch.device("cpu")
+    try:
+        device = [v.device for v in param_dict.values()][0]
+    except Exception:
+        pass
+    spectral_gap = spectral_gap.to(device=device)
+    shift = shift.to(device=device)
     # + pi/2 shift
     shifted_params = param_dict.copy()
     shifted_params[param_name] = shifted_params[param_name] + shift
@@ -89,11 +95,17 @@ def multi_gap_psr(
 
     # get shift values
     shifts = shift_prefac * torch.linspace(PI / 2 - PI / 5, PI / 2 + PI / 5, n_eqs)
-
+    device = torch.device("cpu")
+    try:
+        device = [v.device for v in param_dict.values()][0]
+    except Exception:
+        pass
+    spectral_gaps = spectral_gaps.to(device=device)
+    shifts = shifts.to(device=device)
     # calculate F vector and M matrix
     # (see: https://arxiv.org/pdf/2108.01218.pdf on p. 4 for definitions)
     F = []
-    M = torch.empty((n_eqs, n_eqs))
+    M = torch.empty((n_eqs, n_eqs)).to(device=device)
     n_obs = 1
     for i in range(n_eqs):
         # + shift

qadence/backends/pyqtorch/backend.py

@@ -31,10 +31,10 @@ from qadence.transpile import (
     transpile,
 )
 from qadence.types import BackendName, Endianness, Engine
-from qadence.utils import infer_batchsize, int_to_basis
+from qadence.utils import infer_batchsize
 
 from .config import Configuration, default_passes
-from .convert_ops import convert_block, convert_observable
+from .convert_ops import convert_block
 
 logger = getLogger(__name__)
 
@@ -77,8 +77,13 @@ class Backend(BackendInterface):
             scale_primitive_blocks_only,
         ]
         block = transpile(*transpilations)(observable)  # type: ignore[call-overload]
-
-        (native,) = convert_observable(block, n_qubits=n_qubits, config=self.config)
+        operations = convert_block(block, n_qubits, self.config)
+        obs_cls = (
+            pyq.DiagonalObservable
+            if block._is_diag_pauli and not block.is_parametric
+            else pyq.Observable
+        )
+        native = obs_cls(n_qubits=n_qubits, operations=operations)
         return ConvertedObservable(native=native, abstract=block, original=observable)
 
     def run(
@@ -99,7 +104,7 @@ class Backend(BackendInterface):
             validate_state(state, n_qubits)
             # pyqtorch expects input shape [2] * n_qubits + [batch_size]
             state = pyqify(state, n_qubits) if pyqify_state else state
-        state = circuit.native.run(state, param_values)
+        state = circuit.native.run(state=state, values=param_values)
         state = unpyqify(state) if unpyqify_state else state
         state = invert_endianness(state) if endianness != self.native_endianness else state
         return state
@@ -208,46 +213,26 @@ class Backend(BackendInterface):
         noise: Noise | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
+        pyqify_state: bool = True,
     ) -> list[Counter]:
-        if n_shots < 1:
-            raise ValueError("You can only call sample with n_shots>0.")
-
-        def _sample(_probs: Tensor, n_shots: int, endianness: Endianness, n_qubits: int) -> Counter:
-            return Counter(
-                {
-                    int_to_basis(k=k, n_qubits=n_qubits, endianness=endianness): count.item()
-                    for k, count in enumerate(
-                        torch.bincount(
-                            torch.multinomial(input=_probs, num_samples=n_shots, replacement=True)
-                        )
-                    )
-                    if count > 0
-                }
-            )
-
-        with torch.no_grad():
-            wf = self.run(circuit=circuit, param_values=param_values, state=state)
-            probs = torch.abs(torch.pow(wf, 2))
-            samples = list(
-                map(
-                    lambda _probs: _sample(
-                        _probs=_probs,
-                        n_shots=n_shots,
-                        endianness=endianness,
-                        n_qubits=circuit.abstract.n_qubits,
-                    ),
-                    probs,
-                )
+        if state is None:
+            state = circuit.native.init_state(batch_size=infer_batchsize(param_values))
+        elif state is not None and pyqify_state:
+            n_qubits = circuit.abstract.n_qubits
+            state = pyqify(state, n_qubits) if pyqify_state else state
+        samples: list[Counter] = circuit.native.sample(
+            state=state, values=param_values, n_shots=n_shots
+        )
+        samples = invert_endianness(samples) if endianness != Endianness.BIG else samples
+        if noise is not None:
+            samples = apply_noise(noise=noise, samples=samples)
+        if mitigation is not None:
+            logger.warning(
+                "Mitigation protocol is deprecated. Use qadence-protocols instead.",
             )
-            if noise is not None:
-                samples = apply_noise(noise=noise, samples=samples)
-            if mitigation is not None:
-                logger.warning(
-                    "Mitigation protocol is deprecated. Use qadence-protocols instead.",
-                )
-                assert noise
-                samples = apply_mitigation(noise=noise, mitigation=mitigation, samples=samples)
-            return samples
+            assert noise
+            samples = apply_mitigation(noise=noise, mitigation=mitigation, samples=samples)
+        return samples
 
     def assign_parameters(self, circuit: ConvertedCircuit, param_values: dict[str, Tensor]) -> Any:
         raise NotImplementedError

qadence/backends/pyqtorch/convert_ops.py

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-from functools import reduce
 from itertools import chain as flatten
 from math import prod
-from operator import add
-from typing import Any, Iterable, Sequence, Tuple
+from typing import Any, Sequence, Tuple
 
 import pyqtorch as pyq
 import sympy
@@ -13,15 +11,12 @@ from pyqtorch.matrices import _dagger
 from pyqtorch.utils import is_diag
 from torch import (
     Tensor,
-    argsort,
-    bmm,
     cdouble,
     diag_embed,
     diagonal,
     exp,
+    float64,
     linalg,
-    ones_like,
-    permute,
     tensor,
     transpose,
 )
@@ -31,8 +26,6 @@ from torch.nn import Module
 
 from qadence.backends.utils import (
     finitediff,
-    pyqify,
-    unpyqify,
 )
 from qadence.blocks import (
     AbstractBlock,
@@ -45,11 +38,7 @@ from qadence.blocks import (
     ScaleBlock,
     TimeEvolutionBlock,
 )
-from qadence.blocks.block_to_tensor import (
-    _block_to_tensor_embedded,
-    block_to_diagonal,
-    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.operations import (
     U,
@@ -60,7 +49,6 @@ from qadence.operations import (
     two_qubit_gateset,
 )
 from qadence.types import OpName
-from qadence.utils import infer_batchsize
 
 from .config import Configuration
 
@@ -81,15 +69,13 @@ def is_single_qubit_chain(block: AbstractBlock) -> bool:
     )
 
 
-def convert_observable(
-    block: AbstractBlock, n_qubits: int, config: Configuration = None
-) -> Sequence[Module]:
-    return [PyQObservable(block, n_qubits, config)]
-
-
 def convert_block(
     block: AbstractBlock, n_qubits: int = None, config: Configuration = None
-) -> Sequence[Module]:
+) -> Sequence[Module | Tensor | str | sympy.Expr]:
+    if isinstance(block, (Tensor, str, sympy.Expr)):  # case for hamevo generators
+        if isinstance(block, Tensor):
+            block = block.permute(1, 2, 0)  # put batch size in the back
+        return [block]
     qubit_support = block.qubit_support
     if n_qubits is None:
         n_qubits = max(qubit_support) + 1
@@ -98,37 +84,40 @@ def convert_block(
         config = Configuration()
 
     if isinstance(block, ScaleBlock):
-        return [ScalePyQOperation(n_qubits, block, config)]
-
-    elif isinstance(block, AddBlock):
-        ops = list(flatten(*(convert_block(b, n_qubits, config) for b in block.blocks)))
-        return [AddPyQOperation(n_qubits, ops)]
+        scaled_ops = convert_block(block.block, n_qubits, config)
+        scale = (
+            tensor([block.parameters.parameter], dtype=float64)
+            if not block.is_parametric
+            else config.get_param_name(block)[0]
+        )
+        return [pyq.Scale(pyq.Sequence(scaled_ops), scale)]
 
     elif isinstance(block, TimeEvolutionBlock):
-        return [
-            PyQHamiltonianEvolution(
-                qubit_support=qubit_support,
-                n_qubits=n_qubits,
-                block=block,
-                config=config,
-            )
-        ]
+        # TODO add native pyq hamevo
+        # generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
+        # time_param = config.get_param_name(block)[0]
+        # is_parametric = (
+        #     block.generator.is_parametric if isinstance(block.generator, AbstractBlock) else False
+        # )
+        # return [
+        #     pyq.HamiltonianEvolution(
+        #         qubit_support=qubit_support,
+        #         generator=generator,
+        #         time=time_param,
+        #         generator_parametric=is_parametric,  # type: ignore[union-attr]
+        #     )
+        # ]
+        return [PyQHamiltonianEvolution(qubit_support, n_qubits, block, config)]
     elif isinstance(block, MatrixBlock):
-        return [PyQMatrixBlock(block, n_qubits, config)]
+        return [pyq.primitive.Primitive(block.matrix, block.qubit_support)]
     elif isinstance(block, CompositeBlock):
         ops = list(flatten(*(convert_block(b, n_qubits, config) for b in block.blocks)))
-        if is_single_qubit_chain(block) and config.use_single_qubit_composition:
-            return [PyQComposedBlock(ops, qubit_support, n_qubits, config)]
+        if isinstance(block, AddBlock):
+            return [pyq.Add(ops)]  # add
+        elif is_single_qubit_chain(block) and config.use_single_qubit_composition:
+            return [pyq.Merge(ops)]  # for chains of single qubit ops on the same qubit
         else:
-            # NOTE: without wrapping in a pyq.QuantumCircuit here the kron/chain
-            # blocks won't be properly nested which leads to incorrect results from
-            # the `AddBlock`s. For example:
-            # add(chain(Z(0), Z(1))) has to result in the following (pseudo-code)
-            # AddPyQOperation(pyq.QuantumCircuit(Z, Z))
-            # as opposed to
-            # AddPyQOperation(Z, Z)
-            # which would be wrong.
-            return [pyq.QuantumCircuit(n_qubits, ops)]
+            return [pyq.Sequence(ops)]  # for kron and chain
     elif isinstance(block, tuple(non_unitary_gateset)):
         if isinstance(block, ProjectorBlock):
             projector = getattr(pyq, block.name)
@@ -161,7 +150,10 @@ def convert_block(
         if isinstance(block, ParametricBlock):
             op = pyq_cls(qubit_support[:-1], qubit_support[-1], config.get_param_name(block)[0])
         else:
-            op = pyq_cls(qubit_support[:-1], qubit_support[-1])
+            if "CSWAP" in block_name:
+                op = pyq_cls(qubit_support[:-2], qubit_support[-2:])
+            else:
+                op = pyq_cls(qubit_support[:-1], qubit_support[-1])
         return [op]
     else:
         raise NotImplementedError(
@@ -171,147 +163,6 @@ def convert_block(
         )
 
 
-class PyQMatrixBlock(Module):
-    def __init__(self, block: MatrixBlock, n_qubits: int, config: Configuration = None):
-        super().__init__()
-        self.n_qubits = n_qubits
-        self.qubits = block.qubit_support
-        self.register_buffer("mat", block.matrix.unsqueeze(2))
-        self.mat: Tensor
-        self._device: torch_device = self.mat.device
-        self._dtype: torch_dtype = self.mat.dtype
-
-    def forward(self, state: Tensor, _: dict[str, Tensor] = None) -> Tensor:
-        return apply_operator(state, self.mat, self.qubits, self.n_qubits)
-
-    @property
-    def device(self) -> torch_device:
-        return self._device
-
-    def to(self, *args: Any, **kwargs: Any) -> PyQMatrixBlock:
-        self.mat = self.mat.to(*args, **kwargs)
-        self._device = self.mat.device
-        self._dtype = self.mat.dtype
-        return self
-
-
-class PyQComposedBlock(pyq.QuantumCircuit):
-    def __init__(
-        self,
-        ops: list[Module],
-        qubits: Tuple[int, ...],
-        n_qubits: int,
-        config: Configuration = None,
-    ):
-        """
-        Merge operations that are adjacent and have identical qubit_support.
-
-        It results in fewer call of apply_operator
-        """
-        super().__init__(n_qubits, ops)
-        self.qubits = qubits
-        self.merged_qubits_support = [
-            grouped_op[-1].qubit_support for grouped_op in self.grouped_operations()
-        ]
-
-    def grouped_operations(self) -> list[list[Module]]:
-        # takes a list of operations and group adjacent operations into sublist
-        # if those operations have the same control qubits
-        def _sublist_grouper(x: Iterable[list[Module]], y: Module) -> list[list[Module]]:
-            # Appends the element y with the last sublist in the list x
-            # if they have the same qubit_support.
-            # Appends the element y as a new sublist to x if it has different qubit_domain
-            x = list(x)
-            if y.qubit_support == x[-1][-1].qubit_support:
-                x[-1].append(y)
-                return x
-            else:
-                x.append([y])
-                return x
-
-        return list(reduce(_sublist_grouper, iter(self.operations[1:]), [[self.operations[0]]]))
-
-    def merged_unitary(self, values: dict[str, Tensor] | None, batch_size: int) -> list[Tensor]:
-        # compute the tensor multiplication of each group of operations
-        batch_first_perm = (2, 0, 1)
-        undo_perm = tuple(argsort(tensor(batch_first_perm)))
-
-        def _expand(m: Tensor) -> Tensor:
-            if len(m.size()) == 2:
-                m = m.unsqueeze(2).repeat(
-                    1, 1, batch_size
-                )  # Primitive gates are 2D, so we expand them.
-            elif m.shape != (2, 2, batch_size) and m.shape != (4, 4, batch_size):
-                m = m.repeat(1, 1, batch_size)  # In case a tensor is 3D doesnt have batch_size.
-            return m
-
-        def _batch_first(m: Tensor) -> Tensor:
-            return permute(m, batch_first_perm)  # This returns shape (batch_size, 2, 2)
-
-        def _batch_last(m: Tensor) -> Tensor:
-            return permute(
-                m, undo_perm
-            )  # We need to undo the permute since PyQ expects (2, 2, batch_size).
-
-        def _list_wise_bmm(ops: list[Module]) -> Tensor:
-            # Takes a list of operations and apply torch.bmm to all the unitaries of the list
-            return _batch_last(
-                reduce(bmm, [_batch_first(_expand(op.unitary(values))) for op in reversed(ops)])
-            )  # We reverse the list of tensors here since matmul is not commutative.
-
-        return list(map(_list_wise_bmm, reversed(self.grouped_operations())))[::-1]
-
-    def forward(self, state: Tensor, values: dict[str, Tensor] | None = None) -> Tensor:
-        # compute evolution of the state by the list of operations
-        batch_size = infer_batchsize(values)
-        return reduce(
-            lambda y, x: apply_operator(state=y, operator=x[0], qubits=x[1]),
-            zip(self.merged_unitary(values, batch_size), self.merged_qubits_support),
-            state,
-        )
-
-
-class PyQObservable(Module):
-    def __init__(self, block: AbstractBlock, n_qubits: int, config: Configuration = None):
-        super().__init__()
-        if config is None:
-            config = Configuration()
-        self.n_qubits = n_qubits
-        if block._is_diag_pauli and not block.is_parametric:
-            self.register_buffer("operation", block_to_diagonal(block, tuple(range(n_qubits))))
-            self._forward = lambda self, state, values: pyqify(
-                self.operation * unpyqify(state), n_qubits=self.n_qubits
-            )
-        else:
-            self.operation = pyq.QuantumCircuit(
-                n_qubits,
-                convert_block(block, n_qubits, config),
-            )
-            self._forward = lambda self, state, values: self.operation(state, values)
-        self._device = self.operation.device
-        self._dtype = self.operation.dtype
-
-    def run(self, state: Tensor, values: dict[str, Tensor]) -> Tensor:
-        return self._forward(self, state, values)
-
-    def forward(self, state: Tensor, values: dict[str, Tensor]) -> Tensor:
-        return pyq.inner_prod(state, self.run(state, values)).real
-
-    @property
-    def device(self) -> torch_device:
-        return self._device
-
-    @property
-    def dtype(self) -> torch_dtype:
-        return self._dtype
-
-    def to(self, *args: Any, **kwargs: Any) -> PyQObservable:
-        self.operation = self.operation.to(*args, **kwargs)
-        self._device = self.operation.device
-        self._dtype = self.operation.dtype
-        return self
-
-
 class PyQHamiltonianEvolution(Module):
     def __init__(
         self,
@@ -402,7 +253,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:
@@ -429,7 +281,8 @@ 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:
@@ -463,39 +316,3 @@ class PyQHamiltonianEvolution(Module):
             self._device = self.hmat.device
             self._dtype = self.hmat.dtype
         return self
-
-
-class AddPyQOperation(pyq.QuantumCircuit):
-    def __init__(self, n_qubits: int, operations: list[Module]):
-        super().__init__(n_qubits=n_qubits, operations=operations)
-
-    def forward(self, state: Tensor, values: dict[str, Tensor]) -> Tensor:
-        return reduce(add, (op(state, values) for op in self.operations))
-
-
-class ScalePyQOperation(pyq.QuantumCircuit):
-    def __init__(self, n_qubits: int, block: ScaleBlock, config: Configuration):
-        if not isinstance(block.block, PrimitiveBlock):
-            raise NotImplementedError(
-                "The pyqtorch backend can currently only scale `PrimitiveBlock` types.\
-                Please use the following transpile function on your circuit first:\
-                from qadence.transpile import scale_primitive_blocks_only"
-            )
-        ops = convert_block(block.block, n_qubits, config)
-        assert len(ops) == 1
-        super().__init__(n_qubits, ops)
-        (self.param_name,) = config.get_param_name(block)
-        self.qubit_support = self.operations[0].qubit_support
-
-    def forward(self, state: Tensor, values: dict[str, Tensor]) -> Tensor:
-        return apply_operator(state, self.unitary(values), self.qubit_support, self.n_qubits)
-
-    def unitary(self, values: dict[str, Tensor]) -> Tensor:
-        thetas = values[self.param_name]
-        return thetas * self.operations[0].unitary(values)
-
-    def dagger(self, values: dict[str, Tensor]) -> Tensor:
-        return _dagger(self.unitary(values))
-
-    def jacobian(self, values: dict[str, Tensor]) -> Tensor:
-        return values[self.param_name] * ones_like(self.unitary(values))

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)
@@ -152,8 +152,49 @@ def infer_batchsize(param_values: ParamDictType = None) -> int:
 # 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/matrix.py

@@ -22,12 +22,12 @@ class MatrixBlock(PrimitiveBlock):
 
     Examples:
     ```python exec="on" source="material-block" result="json"
-        import torch
+    import torch
 
     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}"