qadence 1.6.3__tar.gz → 1.7.1__tar.gz

{qadence-1.6.3 → qadence-1.7.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.6.3
+Version: 1.7.1
 Summary: Pasqal interface for circuit-based quantum computing SDKs
-Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>
+Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>
 License: Apache 2.0
 License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
@@ -22,10 +22,11 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.2.1
+Requires-Dist: pyqtorch==1.2.5
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
+Requires-Dist: sympy<1.13
 Requires-Dist: sympytorch>=0.1.2
 Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
@@ -53,9 +54,9 @@ Requires-Dist: qadence-libs; extra == 'libs'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.10.1; extra == 'pulser'
-Requires-Dist: pulser-core==0.18.1; extra == 'pulser'
-Requires-Dist: pulser-simulation==0.18.1; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.11.1; extra == 'pulser'
+Requires-Dist: pulser-core==0.19.0; extra == 'pulser'
+Requires-Dist: pulser-simulation==0.19.0; extra == 'pulser'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown

{qadence-1.6.3 → qadence-1.7.1}/mkdocs.yml

@@ -16,6 +16,7 @@ nav:
   - Contents:
     - Block system: content/block_system.md
     - Parametric programs: content/parameters.md
+    - Time-dependent generators: content/time_dependent.md
     - Quantum models: content/quantummodels.md
     - Quantum registers: content/register.md
     - State initialization: content/state_init.md
@@ -32,15 +33,17 @@ nav:
     - Digital-analog quantum computing:
       - tutorials/digital_analog_qc/index.md
       - Basic operations on neutral-atoms: tutorials/digital_analog_qc/analog-basics.md
-      - Fitting a simple function: tutorials/digital_analog_qc/analog-qcl.md
+      - Fitting a function with analog blocks: tutorials/digital_analog_qc/analog-blocks-qcl.md
       - Restricted local addressability: tutorials/digital_analog_qc/semi-local-addressing.md
       - Pulse-level programming with Pulser: tutorials/digital_analog_qc/pulser-basic.md
+      - Fitting a function with a Hamiltonian ansatz: tutorials/digital_analog_qc/digital-analog-qcl.md
       - Solve a QUBO problem: tutorials/digital_analog_qc/analog-qubo.md
       - CNOT with interacting qubits: tutorials/digital_analog_qc/daqc-cnot.md
 
     - Variational quantum algorithms:
       - tutorials/qml/index.md
       - Training tools: tutorials/qml/ml_tools.md
+      - Configuring a QNN: tutorials/qml/config_qnn.md
       - Quantum circuit learning: tutorials/qml/qcl.md
       - Solving MaxCut with QAOA: tutorials/qml/qaoa.md
       - Solving a 1D ODE: tutorials/qml/dqc_1d.md

{qadence-1.6.3 → qadence-1.7.1}/pyproject.toml

@@ -14,15 +14,18 @@ authors = [
     { name = "Vincent Elfving", email = "vincent.elfving@pasqal.com" },
     { name = "Dominik Seitz", email = "dominik.seitz@pasqal.com" },
     { name = "Roland Guichard", email = "roland.guichard@pasqal.com" },
-    { name = "Joao P. Moutinho", email = "joao.moutinho@pasqal.com"},
+    { name = "Joao P. Moutinho", email = "joao.moutinho@pasqal.com" },
     { name = "Vytautas Abramavicius", email = "vytautas.abramavicius@pasqal.com" },
     { name = "Gergana Velikova", email = "gergana.velikova@pasqal.com" },
     { name = "Eduardo Maschio", email = "eduardo.maschio@pasqal.com" },
+    { name = "Smit Chaudhary", email = "smit.chaudhary@pasqal.com" },
+    { name = "Ignacio Fernández Graña", email = "ignacio.fernandez-grana@pasqal.com" },
+    { name = "Charles Moussa", email = "charles.moussa@pasqal.com" },
 ]
 requires-python = ">=3.9"
-license = {text = "Apache 2.0"}
-version = "1.6.3"
-classifiers=[
+license = { text = "Apache 2.0" }
+version = "1.7.1"
+classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
@@ -37,6 +40,7 @@ dependencies = [
     "numpy",
     "torch",
     "openfermion",
+    "sympy<1.13",
     "sympytorch>=0.1.2",
     "rich",
     "tensorboard>=2.12.0",
@@ -44,7 +48,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.2.1",
+    "pyqtorch==1.2.5",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -55,13 +59,17 @@ allow-direct-references = true
 allow-ambiguous-features = true
 
 [project.optional-dependencies]
-pulser = ["pulser-core==0.18.1", "pulser-simulation==0.18.1","pasqal-cloud==0.10.1"]
+pulser = [
+    "pulser-core==0.19.0",
+    "pulser-simulation==0.19.0",
+    "pasqal-cloud==0.11.1",
+]
 braket = ["amazon-braket-sdk<1.71.2"]
 visualization = [
-  "graphviz",
-  # FIXME: will be needed once we support latex labels
-  # "latex2svg @ git+https://github.com/Moonbase59/latex2svg.git#egg=latex2svg",
-  # "scour",
+    "graphviz",
+    # FIXME: will be needed once we support latex labels
+    # "latex2svg @ git+https://github.com/Moonbase59/latex2svg.git#egg=latex2svg",
+    # "scour",
 ]
 horqrux = [
     "horqrux==0.6.0",
@@ -70,35 +78,31 @@ horqrux = [
     "optax",
     "jaxopt",
     "einops",
-    "sympy2jax"]
+    "sympy2jax",
+]
 protocols = ["qadence-protocols"]
 libs = ["qadence-libs"]
 dlprof = ["nvidia-pyindex", "nvidia-dlprof[pytorch]"]
-all = [
-  "pulser",
-  "braket",
-  "visualization",
-  "protocols",
-  "libs",
-]
+all = ["pulser", "braket", "visualization", "protocols", "libs"]
+
 
 [tool.hatch.envs.default]
 dependencies = [
-  "flaky",
-  "hypothesis",
-  "pytest",
-  "pytest-cov",
-  "pytest-mypy",
-  "pytest-xdist",
-  "types-PyYAML",
-  "ipykernel",
-  "pre-commit",
-  "black",
-  "isort",
-  "ruff",
-  "pydocstringformatter",
+    "flaky",
+    "hypothesis",
+    "pytest",
+    "pytest-cov",
+    "pytest-mypy",
+    "pytest-xdist",
+    "types-PyYAML",
+    "ipykernel",
+    "pre-commit",
+    "black",
+    "isort",
+    "ruff",
+    "pydocstringformatter",
 ]
-features = ["pulser", "braket","visualization", "horqrux"]
+features = ["pulser", "braket", "visualization", "horqrux"]
 
 [tool.hatch.envs.default.scripts]
 test = "pytest -n auto --cov-report lcov --cov-config=pyproject.toml --cov=qadence --cov=tests --ignore=./tests/test_examples.py {args}"
@@ -108,34 +112,32 @@ test-docs = "mkdocs build --clean --strict"
 test-all = "pytest -n auto {args}  && mkdocs build --clean --strict"
 
 [tool.pytest.ini_options]
-markers = [
-  "slow: marks tests as slow (deselect with '-m \"not slow\"')",
-]
+markers = ["slow: marks tests as slow (deselect with '-m \"not slow\"')"]
 testpaths = ["tests"]
 addopts = """-vvv"""
 xfail_strict = true
 filterwarnings = [
-  "ignore:Call to deprecated create function FieldDescriptor",
-  "ignore:Call to deprecated create function Descriptor",
-  "ignore:Call to deprecated create function EnumDescriptor",
-  "ignore:Call to deprecated create function EnumValueDescriptor",
-  "ignore:Call to deprecated create function FileDescriptor",
-  "ignore:Call to deprecated create function OneofDescriptor",
-  "ignore:distutils Version classes are deprecated.",
-  "ignore::DeprecationWarning"
+    "ignore:Call to deprecated create function FieldDescriptor",
+    "ignore:Call to deprecated create function Descriptor",
+    "ignore:Call to deprecated create function EnumDescriptor",
+    "ignore:Call to deprecated create function EnumValueDescriptor",
+    "ignore:Call to deprecated create function FileDescriptor",
+    "ignore:Call to deprecated create function OneofDescriptor",
+    "ignore:distutils Version classes are deprecated.",
+    "ignore::DeprecationWarning",
 ]
 
 
 [tool.hatch.envs.docs]
 dependencies = [
-  "mkdocs",
-  "mkdocs-material",
-  "mkdocstrings",
-  "mkdocstrings-python",
-  "mkdocs-section-index",
-  "mkdocs-exclude",
-  "markdown-exec",
-  "mike",
+    "mkdocs",
+    "mkdocs-material",
+    "mkdocstrings",
+    "mkdocstrings-python",
+    "mkdocs-section-index",
+    "mkdocs-exclude",
+    "markdown-exec",
+    "mike",
 ]
 features = ["pulser", "braket", "horqrux", "visualization"]
 
@@ -151,12 +153,12 @@ features = ["all"]
 
 [tool.hatch.build.targets.sdist]
 exclude = [
-  "/.gitignore",
-  "/.gitlab-ci-yml",
-  "/.pre-commit-config.yml",
-  "/tests",
-  "/docs",
-  "/examples",
+    "/.gitignore",
+    "/.gitlab-ci-yml",
+    "/.pre-commit-config.yml",
+    "/tests",
+    "/docs",
+    "/examples",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -167,15 +169,11 @@ branch = true
 parallel = true
 
 [tool.coverage.report]
-exclude_lines = [
-  "no cov",
-  "if __name__ == .__main__.:",
-  "if TYPE_CHECKING:",
-]
+exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
 
 [tool.ruff]
 select = ["E", "F", "I", "Q"]
-extend-ignore = ["F841","F403"]
+extend-ignore = ["F841", "F403"]
 line-length = 100
 
 [tool.ruff.isort]
@@ -183,8 +181,12 @@ required-imports = ["from __future__ import annotations"]
 
 [tool.ruff.per-file-ignores]
 "__init__.py" = ["F401", "E402"]
-"qadence/operations/primitive.py" = ["E742"]  # Avoid ambiguous class name warning for identity.
-"qadence/backends/horqrux/convert_ops.py" = ["E741"]  # Avoid ambiguous class name warning for 0.
+"qadence/operations/primitive.py" = [
+    "E742",
+] # Avoid ambiguous class name warning for identity.
+"qadence/backends/horqrux/convert_ops.py" = [
+    "E741",
+] # Avoid ambiguous class name warning for 0.
 "examples/*" = ["E402"] # Allow torch seed to be set before qadence imports
 
 [tool.ruff.mccabe]

{qadence-1.6.3 → qadence-1.7.1}/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-1.7.1/qadence/backends/api.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from qadence.backend import Backend, BackendConfiguration
+from qadence.engines.differentiable_backend import DifferentiableBackend
+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(
+    backend: BackendName | str,
+    diff_mode: DiffMode | str | None = None,
+    configuration: BackendConfiguration | dict | None = None,
+) -> Backend | DifferentiableBackend:
+    backend_inst: Backend | DifferentiableBackend
+    try:
+        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
+
+
+def config_factory(backend_name: BackendName | str, config: dict) -> BackendConfiguration:
+    cfg: BackendConfiguration
+    try:
+        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-1.6.3 → qadence-1.7.1}/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-1.6.3 → qadence-1.7.1}/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-1.6.3 → qadence-1.7.1}/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-1.6.3 → qadence-1.7.1}/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-1.6.3 → qadence-1.7.1}/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(