qadence 1.6.3__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/pyqtorch/convert_ops.py

@@ -253,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:
@@ -280,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:

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

@@ -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/ml_tools/__init__.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
-from .config import TrainConfig
+from .config import AnsatzConfig, FeatureMapConfig, TrainConfig
+from .constructors import create_ansatz, create_fm_blocks, observable_from_config
 from .data import DictDataLoader, InfiniteTensorDataset, to_dataloader
+from .models import QNN
 from .optimize_step import optimize_step as default_optimize_step
 from .parameters import get_parameters, num_parameters, set_parameters
 from .printing import print_metrics, write_tensorboard
@@ -12,10 +14,16 @@ from .train_no_grad import train as train_gradient_free
 
 # Modules to be automatically added to the qadence namespace
 __all__ = [
-    "TrainConfig",
+    "AnsatzConfig",
+    "create_ansatz",
+    "create_fm_blocks",
     "DictDataLoader",
+    "FeatureMapConfig",
+    "load_checkpoint",
+    "observable_from_config",
+    "QNN",
+    "TrainConfig",
     "train_with_grad",
     "train_gradient_free",
-    "load_checkpoint",
     "write_checkpoint",
 ]

qadence/ml_tools/config.py

@@ -2,9 +2,20 @@ from __future__ import annotations
 
 import datetime
 import os
-from dataclasses import dataclass
+from dataclasses import dataclass, field, fields
+from logging import getLogger
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Callable, Optional, Type
+
+from sympy import Basic
+
+from qadence.blocks.analog import AnalogBlock
+from qadence.blocks.primitive import ParametricBlock
+from qadence.operations import RX, AnalogRX
+from qadence.parameters import Parameter
+from qadence.types import AnsatzType, BasisSet, MultivariateStrategy, ReuploadScaling, Strategy
+
+logger = getLogger(__file__)
 
 
 @dataclass
@@ -70,3 +81,267 @@ class TrainConfig:
             self.trainstop_criterion = lambda x: x <= self.max_iter
         if self.validation_criterion is None:
             self.validation_criterion = lambda *x: False
+
+
+@dataclass
+class FeatureMapConfig:
+    num_features: int = 1
+    """Number of feature parameters to be encoded."""
+
+    basis_set: BasisSet | dict[str, BasisSet] = BasisSet.FOURIER
+    """
+    Basis set for feature encoding.
+
+    Takes qadence.BasisSet.
+    Give a single BasisSet to use the same for all features.
+    Give a dict of (str, BasisSet) where the key is the name of the variable and the
+    value is the BasisSet to use for encoding that feature.
+    BasisSet.FOURIER for Fourier encoding.
+    BasisSet.CHEBYSHEV for Chebyshev encoding.
+    """
+
+    reupload_scaling: ReuploadScaling | dict[str, ReuploadScaling] = ReuploadScaling.CONSTANT
+    """
+    Scaling for encoding the same feature on different qubits.
+
+    Scaling used to encode the same feature on different qubits in the
+    same layer of the feature maps. Takes qadence.ReuploadScaling.
+    Give a single ReuploadScaling to use the same for all features.
+    Give a dict of (str, ReuploadScaling) where the key is the name of the variable and the
+    value is the ReuploadScaling to use for encoding that feature.
+    ReuploadScaling.CONSTANT for constant scaling.
+    ReuploadScaling.TOWER for linearly increasing scaling.
+    ReuploadScaling.EXP for exponentially increasing scaling.
+    """
+
+    feature_range: tuple[float, float] | dict[str, tuple[float, float]] | None = None
+    """
+    Range of data that the input data is assumed to come from.
+
+    Give a single tuple to use the same range for all features.
+    Give a dict of (str, tuple) where the key is the name of the variable and the
+    value is the feature range to use for that feature.
+    """
+
+    target_range: tuple[float, float] | dict[str, tuple[float, float]] | None = None
+    """
+    Range of data the data encoder assumes as natural range.
+
+    Give a single tuple to use the same range for all features.
+    Give a dict of (str, tuple) where the key is the name of the variable and the
+    value is the target range to use for that feature.
+    """
+
+    multivariate_strategy: MultivariateStrategy = MultivariateStrategy.PARALLEL
+    """
+    The  encoding strategy in case of multi-variate function.
+
+    Takes qadence.MultivariateStrategy.
+    If PARALLEL, the features are encoded in one block of rotation gates
+    with each feature given an equal number of qubits.
+    If SERIES, the features are encoded sequentially, with an ansatz block
+    between. PARALLEL is allowed only for DIGITAL `feature_map_strategy`.
+    """
+
+    feature_map_strategy: Strategy = Strategy.DIGITAL
+    """
+    Strategy for feature map.
+
+    Accepts DIGITAL, ANALOG or RYDBERG. Defaults to DIGITAL.
+    If the strategy is incompatible with the `operation` chosen, then `operation`
+    gets preference and the given strategy is ignored.
+    """
+
+    param_prefix: str | None = None
+    """
+    String prefix to create trainable parameters in Feature Map.
+
+    A string prefix to create trainable parameters multiplying the feature parameter
+    inside the feature-encoding function. Note that currently this does not take into
+    account the domain of the feature-encoding function.
+    Defaults to `None` and thus, the feature map is not trainable.
+    Note that this is separate from the name of the parameter.
+    The user can provide a single prefix for all features, and they will be appended
+    by appropriate feature name automatically.
+    """
+
+    num_repeats: int | dict[str, int] = 0
+    """
+    Number of feature map layers repeated in the data reuploadig step.
+
+    If all are to be repeated the same number of times, then can give a single
+    `int`. For different number of repeatitions for each feature, provide a dict
+    of (str, int) where the key is the name of the variable and the value is the
+    number of repeatitions for that feature.
+    This amounts to the number of additional reuploads. So if `num_repeats` is N,
+    the data gets uploaded N+1 times. Defaults to no repeatition.
+    """
+
+    operation: Callable[[Parameter | Basic], AnalogBlock] | Type[RX] | None = None
+    """
+    Type of operation.
+
+    Choose among the analog or digital rotations or a custom
+    callable function returning an AnalogBlock instance. If the type of operation is
+    incompatible with the `strategy` chosen, then `operation` gets preference and
+    the given strategy is ignored.
+    """
+
+    inputs: list[Basic | str] | None = None
+    """
+    List that indicates the order of variables of the tensors that are passed.
+
+    Optional if a single feature is being encoded, required otherwise. Given input tensors
+    `xs = torch.rand(batch_size, input_size:=2)` a QNN with `inputs=["t", "x"]` will
+    assign `t, x = xs[:,0], xs[:,1]`.
+    """
+
+    def __post_init__(self) -> None:
+        if self.multivariate_strategy == MultivariateStrategy.PARALLEL and self.num_features > 1:
+            assert (
+                self.feature_map_strategy == Strategy.DIGITAL
+            ), "For `parallel` encoding of multiple features, the `feature_map_strategy` must be \
+                  of `digital` type."
+
+        if self.operation is None:
+            if self.feature_map_strategy == Strategy.DIGITAL:
+                self.operation = RX
+            elif self.feature_map_strategy == Strategy.ANALOG:
+                self.operation = AnalogRX  # type: ignore[assignment]
+
+        else:
+            if self.feature_map_strategy == Strategy.DIGITAL:
+                if isinstance(self.operation, AnalogBlock):
+                    logger.warning(
+                        "The `operation` is of type `AnalogBlock` but the `feature_map_strategy` is\
+                        `digital`. The `feature_map_strategy` will be modified and given operation\
+                        will be used."
+                    )
+
+                    self.feature_map_strategy = Strategy.ANALOG
+
+            elif self.feature_map_strategy == Strategy.ANALOG:
+                if isinstance(self.operation, ParametricBlock):
+                    logger.warning(
+                        "The `operation` is a digital gate but the `feature_map_strategy` is\
+                        `analog`. The `feature_map_strategy` will be modified and given operation\
+                        will be used."
+                    )
+
+                    self.feature_map_strategy = Strategy.DIGITAL
+
+        if self.inputs is not None:
+            assert (
+                len(self.inputs) == self.num_features
+            ), "Inputs list must be of same size as the number of features"
+        else:
+            if self.num_features == 1:
+                self.inputs = ["x"]
+            else:
+                raise ValueError(
+                    """
+                    Your QNN has more than one input. Please provide a list of inputs in the order
+                    of your tensor domain. For example, if you want to pass
+                    `xs = torch.rand(batch_size, input_size:=3)` to you QNN, where
+                    ```
+                    t = x[:,0]
+                    x = x[:,1]
+                    y = x[:,2]
+                    ```
+                    you have to specify
+                    ```
+                    inputs=["t", "x", "y"]
+                    ```
+                    You can also pass a list of sympy symbols.
+                """
+                )
+
+        property_list = [
+            "basis_set",
+            "reupload_scaling",
+            "feature_range",
+            "target_range",
+            "num_repeats",
+        ]
+
+        for target_field in fields(self):
+            if target_field.name in property_list:
+                prop = getattr(self, target_field.name)
+                if isinstance(prop, dict):
+                    assert set(prop.keys()) == set(
+                        self.inputs
+                    ), f"The keys in {target_field.name} must be the same as the inputs provided. \
+                    Alternatively, provide a single value of {target_field.name} to use the same\
+                    {target_field.name} for all features."
+                else:
+                    prop = {key: prop for key in self.inputs}
+                    setattr(self, target_field.name, prop)
+
+
+@dataclass
+class AnsatzConfig:
+    depth: int = 1
+    """Number of layers of the ansatz."""
+
+    ansatz_type: AnsatzType = AnsatzType.HEA
+    """What type of ansatz.
+
+    HEA for Hardware Efficient Ansatz.
+    IIA for Identity intialized Ansatz.
+    """
+
+    ansatz_strategy: Strategy = Strategy.DIGITAL
+    """Ansatz strategy.
+
+    DIGITAL for fully digital ansatz. Required if `ansatz_type` is `iia`.
+    SDAQC for analog entangling block.
+    RYDBERG for fully rydberg hea ansatz.
+    """
+
+    strategy_args: dict = field(default_factory=dict)
+    """
+    A dictionary containing keyword arguments to the function creating the ansatz.
+
+    Details about each below.
+
+    For DIGITAL strategy, accepts the following:
+        periodic (bool): if the qubits should be linked periodically.
+            periodic=False is not supported in emu-c.
+        operations (list): list of operations to cycle through in the
+            digital single-qubit rotations of each layer.
+            Defaults to  [RX, RY, RX] for hea and [RX, RY] for iia.
+        entangler (AbstractBlock): 2-qubit entangling operation.
+            Supports CNOT, CZ, CRX, CRY, CRZ, CPHASE. Controlld rotations
+            will have variational parameters on the rotation angles.
+            Defaults to CNOT
+
+    For SDAQC strategy, accepts the following:
+        operations (list): list of operations to cycle through in the
+            digital single-qubit rotations of each layer.
+            Defaults to  [RX, RY, RX] for hea and [RX, RY] for iia.
+        entangler (AbstractBlock): Hamiltonian generator for the
+            analog entangling layer. Time parameter is considered variational.
+            Defaults to NN interaction.
+
+    For RYDBERG strategy, accepts the following:
+        addressable_detuning: whether to turn on the trainable semi-local addressing pattern
+            on the detuning (n_i terms in the Hamiltonian).
+            Defaults to True.
+        addressable_drive: whether to turn on the trainable semi-local addressing pattern
+            on the drive (sigma_i^x terms in the Hamiltonian).
+            Defaults to False.
+        tunable_phase: whether to have a tunable phase to get both sigma^x and sigma^y rotations
+            in the drive term. If False, only a sigma^x term will be included in the drive part
+            of the Hamiltonian generator.
+            Defaults to False.
+    """
+    # The default for a dataclass can not be a mutable object without using this default_factory.
+
+    param_prefix: str = "theta"
+    """The base bame of the variational parameter."""
+
+    def __post_init__(self) -> None:
+        if self.ansatz_type == AnsatzType.IIA:
+            assert (
+                self.ansatz_strategy != Strategy.RYDBERG
+            ), "Rydberg strategy not allowed for Identity-initialized ansatz."