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

qadence/ml_tools/saveload.py

@@ -55,8 +55,9 @@ def load_checkpoint(
 def write_checkpoint(
     folder: Path, model: Module, optimizer: Optimizer | NGOptimizer, iteration: int | str
 ) -> None:
-    from qadence.ml_tools.models import TransformedModule
-    from qadence.models import QNN, QuantumModel
+    from qadence import QuantumModel
+
+    from .models import QNN
 
     device = None
     try:
@@ -81,7 +82,7 @@ def write_checkpoint(
     try:
         d = (
             model._to_dict(save_params=True)
-            if isinstance(model, (QNN, QuantumModel)) or isinstance(model, TransformedModule)
+            if isinstance(model, (QNN, QuantumModel))
             else model.state_dict()
         )
         torch.save((iteration, d), folder / model_checkpoint_name)
@@ -103,8 +104,7 @@ def write_checkpoint(
 def load_model(
     folder: Path, model: Module, model_ckpt_name: str | Path = "", *args: Any, **kwargs: Any
 ) -> tuple[Module, int]:
-    from qadence.ml_tools.models import TransformedModule
-    from qadence.models import QNN, QuantumModel
+    from qadence import QNN, QuantumModel
 
     iteration = 0
     if model_ckpt_name == "":
@@ -112,7 +112,7 @@ def load_model(
 
     try:
         iteration, model_dict = torch.load(folder / model_ckpt_name, *args, **kwargs)
-        if isinstance(model, (QuantumModel, QNN, TransformedModule)):
+        if isinstance(model, (QuantumModel, QNN)):
             model._from_dict(model_dict, as_torch=True)
         elif isinstance(model, Module):
             model.load_state_dict(model_dict, strict=True)

qadence/ml_tools/train_grad.py

@@ -52,16 +52,12 @@ def train(
         device: String defining device to train on, pass 'cuda' for GPU.
         optimize_step: Customizable optimization callback which is called at every iteration.=
             The function must have the signature `optimize_step(model,
-            optimizer, loss_fn, xs, device="cpu")` (see the example below).
-            Apart from the default we already supply three other optimization
-            functions `optimize_step_evo`, `optimize_step_grad_norm`, and
-            `optimize_step_inv_dirichlet`. Learn more about how to use this in
-            the [Advancded features](../../tutorials/advanced) tutorial of the
-            documentation.
+            optimizer, loss_fn, xs, device="cpu")`.
         write_tensorboard: Customizable tensorboard logging callback which is
             called every `config.write_every` iterations. The function must have
             the signature `write_tensorboard(writer, loss, metrics, iteration)`
             (see the example below).
+        dtype: The dtype to use for the data.
 
     Example:
     ```python exec="on" source="material-block"
@@ -70,7 +66,7 @@ def train(
     from itertools import count
     from qadence import Parameter, QuantumCircuit, Z
     from qadence import hamiltonian_factory, hea, feature_map, chain
-    from qadence.models import QNN
+    from qadence import QNN
     from qadence.ml_tools import TrainConfig, train_with_grad, to_dataloader
 
     n_qubits = 2

qadence/ml_tools/utils.py

@@ -5,16 +5,15 @@ from typing import Any
 
 from torch import Tensor, rand
 
+from qadence import QNN, QuantumModel
 from qadence.blocks import AbstractBlock, parameters
 from qadence.circuit import QuantumCircuit
-from qadence.ml_tools.models import TransformedModule
-from qadence.models import QNN, QuantumModel
 from qadence.parameters import Parameter, stringify
 
 
 @singledispatch
 def rand_featureparameters(
-    x: QuantumCircuit | AbstractBlock | QuantumModel | QNN | TransformedModule, *args: Any
+    x: QuantumCircuit | AbstractBlock | QuantumModel | QNN, *args: Any
 ) -> dict[str, Tensor]:
     raise NotImplementedError(f"Unable to generate random featureparameters for object {type(x)}.")
 
@@ -39,8 +38,3 @@ def _(qm: QuantumModel, batch_size: int = 1) -> dict[str, Tensor]:
 @rand_featureparameters.register
 def _(qnn: QNN, batch_size: int = 1) -> dict[str, Tensor]:
     return rand_featureparameters(qnn._circuit.abstract, batch_size)
-
-
-@rand_featureparameters.register
-def _(tm: TransformedModule, batch_size: int = 1) -> dict[str, Tensor]:
-    return rand_featureparameters(tm.model, batch_size)

qadence/{models/quantum_model.py → model.py}

@@ -36,7 +36,7 @@ class QuantumModel(nn.Module):
 
     This class should be used as base class for any new quantum model supported in the qadence
     framework for information on the implementation of custom models see
-    [here](/advanced_tutorials/custom-models.md).
+    [here](../tutorials/advanced_tutorials/custom-models.md).
     """
 
     backend: Backend | DifferentiableBackend
@@ -258,10 +258,10 @@ class QuantumModel(nn.Module):
                 "observable": abs_obs,
                 "backend": self._backend_name,
                 "diff_mode": self._diff_mode,
-                "measurement": self._measurement._to_dict()
-                if self._measurement is not None
-                else {},
-                "noise": self._noise._to_dict() if self._noise is not None else {},
+                "measurement": (
+                    self._measurement._to_dict() if self._measurement is not None else dict()
+                ),
+                "noise": self._noise._to_dict() if self._noise is not None else dict(),
                 "backend_configuration": asdict(self.backend.backend.config),  # type: ignore
             }
             param_dict_conv = {}
@@ -354,9 +354,11 @@ class QuantumModel(nn.Module):
                             obs.native = obs.native.to(*args, **kwargs)
                 self._params = self._params.to(
                     device=self._circuit.native.device,
-                    dtype=torch.float64
-                    if self._circuit.native.dtype == torch.cdouble
-                    else torch.float32,
+                    dtype=(
+                        torch.float64
+                        if self._circuit.native.dtype == torch.cdouble
+                        else torch.float32
+                    ),
                 )
                 logger.debug(f"Moved {self} to {args}, {kwargs}.")
             else:
@@ -372,3 +374,7 @@ class QuantumModel(nn.Module):
             if self.backend.backend.name == "pyqtorch"  # type: ignore[union-attr]
             else torch.device("cpu")
         )
+
+
+# Modules to be automatically added to the qadence namespace
+__all__ = ["QuantumModel"]  # type: ignore

qadence/overlap.py

@@ -13,7 +13,7 @@ from qadence.blocks.utils import chain, kron, tag
 from qadence.circuit import QuantumCircuit
 from qadence.divergences import js_divergence
 from qadence.measurements import Measurements
-from qadence.models.quantum_model import QuantumModel
+from qadence.model import QuantumModel
 from qadence.operations import SWAP, H, I, S
 from qadence.transpile import reassign
 from qadence.types import BackendName, DiffMode, OverlapMethod

qadence/serialization.py

@@ -17,11 +17,10 @@ from arpeggio.cleanpeg import ParserPEG
 from sympy import *
 from sympy import core, srepr
 
-from qadence import QuantumCircuit, operations, parameters
+from qadence import QNN, QuantumCircuit, QuantumModel, operations, parameters
 from qadence import blocks as qadenceblocks
 from qadence.blocks import AbstractBlock
 from qadence.blocks.utils import tag
-from qadence.models import QuantumModel
 from qadence.parameters import Parameter
 from qadence.register import Register
 from qadence.types import SerializationFormat
@@ -48,6 +47,7 @@ SUPPORTED_OBJECTS = [
     AbstractBlock,
     QuantumCircuit,
     QuantumModel,
+    QNN,
     Register,
     core.Basic,
     torch.nn.Module,
@@ -374,12 +374,12 @@ def save(
     Same as serialize/deserialize but for storing/loading files.
 
     Supported types:
-    AbstractBlock | QuantumCircuit | QuantumModel | TransformedModule | Register | torch.nn.Module
+    AbstractBlock | QuantumCircuit | QuantumModel | Register | torch.nn.Module
     Saves a qadence object to a json/.pt.
 
     Arguments:
         obj (AbstractBlock | QuantumCircuit | QuantumModel | Register):
-                Either AbstractBlock, QuantumCircuit, QuantumModel, TransformedModule, Register.
+                Either AbstractBlock, QuantumCircuit, QuantumModel, Register.
         file_name (str): The name of the file.
         format (str): The type of file to save.
     Returns:
@@ -431,14 +431,14 @@ def load(file_path: str | Path, map_location: str = "cpu") -> SUPPORTED_TYPES:
     """
     Same as serialize/deserialize but for storing/loading files.
 
-    Supported types: AbstractBlock | QuantumCircuit | QuantumModel | TransformedModule | Register
+    Supported types: AbstractBlock | QuantumCircuit | QuantumModel | Register
     Loads a .json or .pt file to one of the supported types.
 
     Arguments:
         file_path (str): The name of the file.
         map_location (str): In case of a .pt file, on which device to load the object (cpu,cuda).
     Returns:
-        A object of type AbstractBlock, QuantumCircuit, QuantumModel, TransformedModule, Register.
+        A object of type AbstractBlock, QuantumCircuit, QuantumModel, Register.
 
     Examples:
     ```python exec="on" source="material-block" result="json"

qadence/types.py

@@ -27,6 +27,7 @@ PI = pi
 
 # Modules to be automatically added to the qadence namespace
 __all__ = [
+    "AnsatzType",
     "Endianness",
     "Strategy",
     "ResultType",
@@ -34,6 +35,7 @@ __all__ = [
     "BackendName",
     "StateGeneratorType",
     "LTSOrder",
+    "MultivariateStrategy",
     "ReuploadScaling",
     "BasisSet",
     "TensorType",
@@ -70,6 +72,8 @@ class Strategy(StrEnum):
     """Use the step-wise digital-analog QC paradigm."""
     BDAQC = "bDAQC"
     """Use the banged digital-analog QC paradigm."""
+    RYDBERG = "Rydberg"
+    """Use the Rydberg QC paradigm."""
 
 
 class Endianness(StrEnum):
@@ -145,6 +149,24 @@ class ReuploadScaling(StrEnum):
     """Exponentially increasing scaling."""
 
 
+class MultivariateStrategy(StrEnum):
+    """Multivariate strategy for feature maps."""
+
+    PARALLEL = "parallel"
+    """Parallel strategy."""
+    SERIES = "SERIES"
+    """Serial strategy."""
+
+
+class AnsatzType(StrEnum):
+    """Ansatz types for variational circuits."""
+
+    HEA = "hea"
+    """Hardware-efficient ansatz."""
+    IIA = "iia"
+    """Identity-Initialised Ansatz."""
+
+
 class _DiffMode(StrEnum):
     """Differentiation modes to choose from."""
 
@@ -401,3 +423,23 @@ class ReadOutOptimization(StrEnum):
 
 ParamDictType = dict[str, ArrayLike]
 DifferentiableExpression = Callable[..., ArrayLike]
+
+
+class InputDiffMode(StrEnum):
+    """Derivative modes w.r.t inputs of UFAs."""
+
+    AD = "ad"
+    """Reverse automatic differentiation."""
+    FD = "fd"
+    """Central finite differencing."""
+
+
+class ObservableTransform:
+    """Observable transformation type."""
+
+    SCALE = "scale"
+    """Use the given values as scale and shift."""
+    RANGE = "range"
+    """Use the given values as min and max."""
+    NONE = "none"
+    """No transformation."""

{qadence-1.6.2.dist-info → qadence-1.7.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.6.2
+Version: 1.7.0
 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>
 License: Apache 2.0
 License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
@@ -22,7 +22,7 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.1.2
+Requires-Dist: pyqtorch==1.2.1
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -149,6 +149,15 @@ brew install graphviz
 conda install python-graphviz
 ```
 
+On Windows Linux Subsystem (WSL2) it has been reported that in some cases "wslutilities" must be installed.
+Please follow instructions [here](https://wslutiliti.es/wslu/install.html) for your flavour.
+For example on Ubuntu 22.04 LTS and later you must run:
+```
+sudo add-apt-repository ppa:wslutilities/wslu
+sudo apt update
+sudo apt install wslu
+```
+
 ## Contributing
 
 Before making a contribution, please review our [code of conduct](docs/getting_started/CODE_OF_CONDUCT.md).
@@ -179,6 +188,8 @@ install it from source using `pip`:
 python -m pip install -e .
 ```
 
+Users also report problems running Hatch on Windows, we suggest using WSL2.
+
 ## Citation
 
 If you use Qadence for a publication, we kindly ask you to cite our work using the following BibTex entry:

{qadence-1.6.2.dist-info → qadence-1.7.0.dist-info}/RECORD

@@ -1,24 +1,24 @@
-qadence/__init__.py,sha256=LY5QUBt19J4PNAXsDa8w-ClsAXyoAUi1lqzDgsGjemY,2640
+qadence/__init__.py,sha256=0SFU1_XZ-3WlSU1rA4W1Y0edxpZLO_sNg-YnpjlD77w,2638
 qadence/backend.py,sha256=TTzWEHEyOg7EH02IBiDkhE-Uwtj0fSLNMvQ48qtAcOk,14401
 qadence/circuit.py,sha256=3lQdjj_srxgk6f5M3eh3kE-Qdov4FA9TZxZZb0E1_mI,6966
 qadence/decompose.py,sha256=C4LYia_GcC9Rx3QO0ZLWTI9dN63a8WTEAXO0ZVQWuiE,5221
 qadence/divergences.py,sha256=JhpELhWSnuDvQxa9hJp_DE3EQg2Ban-Ta0mHZ_fVrHg,1832
 qadence/execution.py,sha256=5_P5OSatiwEAu7aAkCLau5VcmtIZiC3VFIj5YYdwAbY,9287
 qadence/extensions.py,sha256=qly8STovIr_tB9yJSlIjkaYfKFY-1VLto-Zqq0RdLAw,4247
-qadence/finitediff.py,sha256=TijuaWUbX9VlbLyMYco6HkK9eCoRTVnKug4Ekd6mlTI,1592
 qadence/libs.py,sha256=HetkKO8TCTlVCViQdVQJvxwBekrhd-y_iMox4UJMY1M,410
 qadence/log_config.yaml,sha256=WwSpxqMSXgPJ7wO_wh46UnFzXdgX9NVA4MbN3TcJFyE,485
 qadence/logger.py,sha256=Hb76pK3VyQjVjJb4_NqFlOJgjYJVa8t7DHJFlzOM86M,407
-qadence/overlap.py,sha256=VHEXfsqcn7aax1-f_iJ8Fe5Eoz4AcceQbwgqipifgzY,17104
+qadence/model.py,sha256=4ajqTcj1JNbVaaC_P59nRJ_XjHHatYNK25iioEL4UX8,14607
+qadence/overlap.py,sha256=v3XP3g7BaMoTjR0GVTqg7IDtAfq_Njo1ZNTeyo8uYNA,17089
 qadence/parameters.py,sha256=WdHCcLJ8tyRfBdaLAo89GwJboj6wLdfhdHdqPDLLAhM,12337
 qadence/protocols.py,sha256=bcYTxSjgMPV-a-D6yv90jCpnGik8myzaNpFv9z1gzJ0,442
 qadence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qadence/qubit_support.py,sha256=Nkn1Q01RVViTcggSIom7EFKdWpAuM4TMGwBZ5feCUxA,2120
 qadence/register.py,sha256=cBMzwZ7GWZ5ieuFt0bpproEI6a2ncNwfjj7ic379zyg,10276
 qadence/serial_expr_grammar.peg,sha256=z5ytL7do9kO8o4h-V5GrsDuLdso0KsRcMuIYURFfmAY,328
-qadence/serialization.py,sha256=0UdcDQP2tJOtygVQI258G3MgnDiZJmBY4o15w0G-O0Y,15686
+qadence/serialization.py,sha256=qEET6Gu9u2aSibPve3bJrqDzK2_gO3RPDJjt4ZY8GbE,15596
 qadence/states.py,sha256=5QIOBBYs8e2uLFiMa8iMYZ-MvWIFEqkZAjNYx0SyYPI,14843
-qadence/types.py,sha256=wsxZNik5d8xdw46Dp1xRHpVS1-mSM-kMl2J_W64UhgA,9732
+qadence/types.py,sha256=n9vkVejthNlsJQABX9i2FmjWMHsvneVjs4UVxSJz99Q,10673
 qadence/utils.py,sha256=mTDI54uXsFXrKKFshmXFzDdoaeLMLlqA1MR2G061TSc,10092
 qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
 qadence/analog/addressing.py,sha256=fu5-xW9lquEbagApNp23S_ET1kl0iDtZUrIYSVNmw9s,6435
@@ -27,11 +27,10 @@ qadence/analog/device.py,sha256=RmPXWxq77pJXzvV6CIVSUVxxy-oKd6SqoSnQESNLIqg,2412
 qadence/analog/hamiltonian_terms.py,sha256=9LKidqqEMJTTdXeaxkxP_otTmcv9i4yeJ-JKCLOCK3Y,3421
 qadence/analog/parse_analog.py,sha256=ppvMZtsKXOIkIehCgjbdmG9n232DIycSanyuyVth5Wg,4223
 qadence/backends/__init__.py,sha256=ibm7wmZxuIoMYAQxgAx0MsfLYWOVHNWgLwyS1HjMuuI,215
-qadence/backends/adjoint.py,sha256=0NF7dFwjYWF-p3IwVdKjm7GaX9TO2CvfJiWiVzwSqNI,6946
 qadence/backends/api.py,sha256=6PoK4ydhi2tj9w0ePMQl1G4kEFROoWe3lrkrtQwWxkc,3224
-qadence/backends/gpsr.py,sha256=MapXSAw-9JwJbVaGRlCvw2ltUNLtbOtmLBxxw0-kr-E,4283
+qadence/backends/gpsr.py,sha256=GxK3hkdE-uUwZJokPalzLDaF8sO9MLTN9oRBZ2uKrEM,4749
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
-qadence/backends/utils.py,sha256=hnV9AXztMvAPcO8mv9UhdGMbS9albiMQBxlYPgLrD68,6490
+qadence/backends/utils.py,sha256=vPEBkjyS_xtc3OtzdqA_qcEQwkNhTl0JsBoUAHrpZ4s,7978
 qadence/backends/braket/__init__.py,sha256=eruyDZKMqkh1LE7eJ980vcrLJbia35uUX6krAP78clI,121
 qadence/backends/braket/backend.py,sha256=WX5FG4WsrtdnG0at2DvIY0n_AFm44t4g5OIJ1e8r6fQ,8752
 qadence/backends/braket/config.py,sha256=7cu22dmYdp48Fu760HPfxBHinaUnGmzx9MkE_EPhVN8,594
@@ -50,9 +49,9 @@ qadence/backends/pulser/devices.py,sha256=DermLZNfmCB3SqteKVW4uhg4jp6ya1G6ptnXbB
 qadence/backends/pulser/pulses.py,sha256=F4fExIRAhLPMtVg1bhNtDihUYHxu5RExGjovk8-CQIo,11884
 qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59ozwsRCzg,2227
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/pyqtorch/backend.py,sha256=7CkXccCHwK3pijNDmIB_-hdRGa79yhZ3_3A2p7wOSB0,9785
+qadence/backends/pyqtorch/backend.py,sha256=xAPJT--Lu_OW8GVeXc1weBFB5iEwJ6hihFGo8PRJXnk,9309
 qadence/backends/pyqtorch/config.py,sha256=hhea1dDAeee7uDE1fiCh4lJRS0EMSc3mmbXn92HBdyA,1898
-qadence/backends/pyqtorch/convert_ops.py,sha256=0CLIncSmOSOZh4o7kjdOSc9a60srtegGul-dj_Q8Ufc,18935
+qadence/backends/pyqtorch/convert_ops.py,sha256=R7FNJ5UgO7_SsUOMY6tSXeOfIpq3-eqFZwXakLvUiHU,11943
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=35RcVlNvD1BmBoJ8bbYJ3LrdU72wixt9ZmTbCtEwNus,11796
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
@@ -60,13 +59,13 @@ qadence/blocks/block_to_tensor.py,sha256=Sg7YGKUoPUUHKvyB8Khztrk7UYnV5SD451_3I00
 qadence/blocks/composite.py,sha256=z_lXRBVnh-DdvfZdv6T0ZEmVhlU76zBt72P_FGGa-PQ,8897
 qadence/blocks/embedding.py,sha256=TQt620UIVaNYHP34tpK9slv-PFiLvTQRYw5Ez9RuImE,6513
 qadence/blocks/manipulate.py,sha256=kPmzej7mnWFoqTJA2CkGulT7hcPha0GGPARC8rjZltg,2387
-qadence/blocks/matrix.py,sha256=WTByjt_0yf3OiK-OcJNEfSGO8Hyq_tIBlklSO_BtOb0,3776
-qadence/blocks/primitive.py,sha256=NWxgpG77cjBy-APg-kAGOX2kOR-OuH8hzml8U_Zfv1A,16640
+qadence/blocks/matrix.py,sha256=k6CC3zN2i6nd7_9S9u4fJAxy9wfkM287945GpArwOhY,3771
+qadence/blocks/primitive.py,sha256=RoEA9_VCI_8o4yg_pMe5T38z3LD6IFz9qlCiF3iHmOo,16631
 qadence/blocks/utils.py,sha256=iCJDi6HTYYaQQCoP3cdIKeCDuy8KQCxctrHN5QWXV-M,16349
-qadence/constructors/__init__.py,sha256=PWfSKcEJmo5azIkcRuRWsmch3FOeXl055iPsboNzryQ,938
+qadence/constructors/__init__.py,sha256=oEGuILUB8qEbSeaKV9Q-Tk-DAVx-U0wqn8VoSztVueg,984
 qadence/constructors/ansatze.py,sha256=bTrcF2RsyA_Btmkk80tWxP1dn9fK_SXAQFueIuWkT-c,9660
 qadence/constructors/feature_maps.py,sha256=BaAxFi6fSKwjsfFjqZ8T7lyZfjotcgH2OW3b0j67YVk,8644
-qadence/constructors/hamiltonians.py,sha256=QMYHKLWadj-jVTYGkojGAsy-06A8or6OyQrwE7xXa8M,8738
+qadence/constructors/hamiltonians.py,sha256=u9feuuLmgQ7tX0TcP8tsbCefvBSVjkY7k4fMT5vp12Q,10054
 qadence/constructors/iia.py,sha256=z-4AA9Oj-j2oZ0QDkLYNk4duS3UHY_98Qwt9VO_ZDDU,7001
 qadence/constructors/qft.py,sha256=2LpgQ-z1HUxB3rqHzYsbjqpdU63gyuuaUVCbNEFbjo8,7688
 qadence/constructors/rydberg_feature_maps.py,sha256=RuXtuAhjpong78jpKUjZHdh4fOdHBnuht1ffoAMWdEE,4839
@@ -78,7 +77,7 @@ qadence/constructors/daqc/gen_parser.py,sha256=taZMJ9BNp672qXqsNSQ8RY71tN2gMV4Rb
 qadence/constructors/daqc/utils.py,sha256=1T83veISoOXhJYUWXhfocbISpfIgsrKrdDHCMbskGoQ,1067
 qadence/draw/__init__.py,sha256=A2lU7_CfCjwZCnMRojG5CsoWm-7aWKpUYGyaJ9qBZIQ,2319
 qadence/draw/themes.py,sha256=VV4YtC8X3UI63AuJO2D0fLMTLbdDUjIyXQcKuDuIVmI,5533
-qadence/draw/utils.py,sha256=xsSogG76DYRLLetR0u7bDR66UTbDDPFok4YplFXYcso,12108
+qadence/draw/utils.py,sha256=4Hk-vwGz6ZRLKYnV26r1g3zBvOONvlFiN4Kh6toUsI0,12107
 qadence/draw/vizbackend.py,sha256=BKq1fjW7zgEhaIhrmi-i6XV9ZWY7NmlmdDo9-tfP0Hk,14997
 qadence/draw/assets/dark/measurement.png,sha256=hSMhZZCFKHNO2tCpYTTSYIF-nsAfNalRunRUIyhygC0,502
 qadence/draw/assets/dark/measurement.svg,sha256=6ALGjaCX3xZ1NqB6RW6yzOchzZV-j8ukW4aGhEWe4Lk,7282
@@ -91,7 +90,7 @@ qadence/engines/jax/differentiable_backend.py,sha256=W5rDA8wb-ECnFWoLj4dVugF9v1l
 qadence/engines/jax/differentiable_expectation.py,sha256=XBYHT1XKRuZfKxTcNy8KJpSDPt-2PR4ZCanImCPI9OI,3677
 qadence/engines/torch/__init__.py,sha256=iZFdD32ot0B0CVyC-f5dVViOBnqoalxa6M9Lj4WQuPE,160
 qadence/engines/torch/differentiable_backend.py,sha256=AWthwvKE8pCOih4dZ3tXxQX4W1ps9mBcvo7n4V9V24Y,3553
-qadence/engines/torch/differentiable_expectation.py,sha256=fgWRxozb8OL1yRmHSZeltViYAwFq6DogarnUinV6jbQ,9607
+qadence/engines/torch/differentiable_expectation.py,sha256=kAYl23Xq9MwkLm0MzmiIES-qUXc2zQsl9TuIF_c-qTE,9599
 qadence/exceptions/__init__.py,sha256=BU6vWrI9mshzr1aTPm1Ticr_o_42GjTrWI4OZXhThsI,203
 qadence/exceptions/exceptions.py,sha256=4j_VJpx2sZ2Mir5BJUWu4nwb131FY1ygO4q8-XlyfRc,190
 qadence/measurements/__init__.py,sha256=RIjG9tVJMqhNzyj7maZI250Um0KgHl2PizDcKJag-JU,161
@@ -104,21 +103,19 @@ qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-
 qadence/mitigations/analog_zne.py,sha256=g0QkjSdF-N9Dv2N8Oza4sylnjUMid5ea-4NCT9Tcm3Y,7768
 qadence/mitigations/protocols.py,sha256=Jq9MyLujfTyWmc7XVUGYVRUkJT1MmZw-GgmWpVjmX2Y,1608
 qadence/mitigations/readout.py,sha256=HPfYmdjRlieUdOBMZTghFK4DRWfveM4KkDkEI0bMI0E,6262
-qadence/ml_tools/__init__.py,sha256=_H5A_BWZRZVGoJszb9s8XRJnLnJxUNfYjuT9HT2yASo,786
-qadence/ml_tools/config.py,sha256=bA_9TYeuy0DPdhFg0_3PFctd6bx4hKugg4LmlUB2jyw,2647
+qadence/ml_tools/__init__.py,sha256=HP4xjldkUZ9_WbZEDgpl31qoP9st5SBbC-DjI5pkx3k,1054
+qadence/ml_tools/config.py,sha256=XIL_V3zmHaBWIRoUmaHjN2a3tjZV-o0ya2gTRzugVzg,14007
+qadence/ml_tools/constructors.py,sha256=bEQuE4h3njZiXo8GHviu8krQ4sG9x2dNlBvspE8XtZc,26364
 qadence/ml_tools/data.py,sha256=8ZUFjhQSp94w7icX7RzM2J39Yo7P_T-AgjcThBc8miI,4283
-qadence/ml_tools/models.py,sha256=lELcq__wfGsurUm2UOgYkOzdBDwu66Nik9ySoAjDKnY,12673
+qadence/ml_tools/models.py,sha256=UutQ_pd2mHmZ1DUncxEtw7asdFuhW3syDyH86xp4S5E,15298
 qadence/ml_tools/optimize_step.py,sha256=ATXWmAqybJVK3QmAaDqVXB5mxjTo2MIi_e0a5WSPFpc,1800
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/printing.py,sha256=YK2zc9SOc5wiLnMxm3Q1gSwPAVW9Vy2Pcnjg9gP0aKU,694
-qadence/ml_tools/saveload.py,sha256=_5ni1sUohbtpGAcCRynh4j1dXkMXDpvgoDN-Jby2miQ,5041
+qadence/ml_tools/saveload.py,sha256=SAhXVN4dI13JUdr_xuD_4MRcSBw_oSnTPZml2Mqims4,4876
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/train_grad.py,sha256=6ZFFd7wGKFFqz3wpVkSD_xFjQPJ4IgIpA0IjYanohcs,9507
+qadence/ml_tools/train_grad.py,sha256=Bp2bJYDE_ojlu0lm79RNLKS8JLlBLzCyfH_wUtEo_lU,9185
 qadence/ml_tools/train_no_grad.py,sha256=PrOfPwu6C-YqfFxnRkbeyOQzqSyjRrx4AZZd6C-1xRw,4705
-qadence/ml_tools/utils.py,sha256=_GZSN5Flk1nRFutkXih397Q3cWKdX0UP8c9CRXpUL7c,1654
-qadence/models/__init__.py,sha256=0nZzAC2TGr8Yuf40-R7m2cSsr_BlNq_GsMOwaOYZLqM,193
-qadence/models/qnn.py,sha256=gc_iC1GG6WJbeLaln9jy4yYp9fY0p8fkpKkKJpXJ3ck,10397
-qadence/models/quantum_model.py,sha256=RcKdkWX0dQaYuJiZbJ1WUYpLKmlJLiUglWV0Gv0-DIo,14417
+qadence/ml_tools/utils.py,sha256=PW8FyoV0mG_DtN1U8njTDV5qxZ0EK4mnFwMAsLBArfk,1410
 qadence/noise/__init__.py,sha256=r0nR8uEZeB1M9pI2UisjWq0bjw50fPFfVGzIMev923g,147
 qadence/noise/protocols.py,sha256=-aZ06JvMnpxCeT5v5lI_RNPOLbb9Ju1Pi1AB6uAXxVE,1653
 qadence/noise/readout.py,sha256=UpUdxaGu09SmqKXn0O7RYfF7b7UcRZiNMfDlpY0weV0,6726
@@ -136,7 +133,7 @@ qadence/transpile/digitalize.py,sha256=iWRwYAYQsD2INHj0HNbGJriv_3fRCuBW1nDBrwtKS
 qadence/transpile/flatten.py,sha256=EdhSG5WyF56nbnxINNLqrHgY84MRM1YFjT3fR4aph5Q,3427
 qadence/transpile/invert.py,sha256=KAefHTG2AWr39aengVhXrzCtJPhrZC-ZnL6vYvmbnY0,4867
 qadence/transpile/transpile.py,sha256=6MRRkk1OS279L1fwUQjazA6qlfpbd-T_EJMKT8hAhOU,2721
-qadence-1.6.2.dist-info/METADATA,sha256=8vr_cvIxfMOFrYUEiQpTUDRyA3CeOJQ3_YpV1kCFatA,9169
-qadence-1.6.2.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-qadence-1.6.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.6.2.dist-info/RECORD,,
+qadence-1.7.0.dist-info/METADATA,sha256=8c2Am0vveGaO_sjoun3ProUrJmWzGmI75V-_bRMo_18,9640
+qadence-1.7.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+qadence-1.7.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.7.0.dist-info/RECORD,,

qadence/backends/adjoint.py

@@ -1,163 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from pyqtorch.apply import apply_operator
-from pyqtorch.circuit import QuantumCircuit as PyQCircuit
-from pyqtorch.parametric import Parametric as PyQParametric
-from pyqtorch.primitive import Primitive as PyQPrimitive
-from pyqtorch.utils import inner_prod, param_dict
-from torch import Tensor, no_grad, zeros
-from torch.autograd import Function
-from torch.nn import Module
-
-from qadence.backends.pyqtorch.convert_ops import PyQHamiltonianEvolution, ScalePyQOperation
-from qadence.blocks.abstract import AbstractBlock
-
-
-class AdjointExpectation(Function):
-    """
-    The adjoint differentiation method (https://arxiv.org/pdf/2009.02823.pdf).
-
-    is able to perform a backward pass in O(P) time and maintaining
-    atmost 3 states where P is the number of parameters in a variational circuit.
-
-    Pseudo-code of the algorithm:
-
-    c: a variational circuit
-    c.gates = gate0,gate1,..gateN, where N denotes the last gate in c
-    o: a observable
-    state: an initial state
-
-    1. Forward pass.
-    for gate in c.gates: # We apply gate0, gate1 to gateN.
-        state = gate(state)
-
-    projected_state = o(state)  # Apply the observable to the state.
-    expval = overlap(state, projected_state)  # Compute the expected value.
-
-    2. Backward pass:
-    grads = []
-    for gate in reversed(c.gates): # Iterate through c.gates in "reverse", so gateN, gateN-1 etc.
-        state = dagger(gate)(state)  # 'Undo' the gate by applying its dagger.
-        if gate is Parametric:
-            mu = jacobian(gate)(state) # Compute the jacobian of the gate w.r.t its parameter.
-            grads.append(2 * overlap(mu, projected_state) # Compute the gradient.
-        projected_state = dagger(gate)(projected_state)  # 'Undo' the gate from the projected_state.
-
-    Current Limitations:
-
-    (1) The adjoint method is only available in the pyqtorch backend.
-    (2) Parametric observables are not supported.
-    (3) Multiple observables are not supported.
-    (4) Higher order derivatives are not natively supported.
-    (5) Only expectation values can be differentiated, not wave functions.
-    """
-
-    @staticmethod
-    @no_grad()
-    def forward(
-        ctx: Any,
-        circuit: PyQCircuit,
-        observable: PyQCircuit,
-        state: Tensor,
-        param_names: list[str],
-        *param_values: Tensor,
-    ) -> Tensor:
-        for param in param_values:
-            param = param.detach()
-        ctx.circuit = circuit
-        ctx.observable = observable
-        ctx.param_names = param_names
-        values = param_dict(param_names, param_values)
-        ctx.out_state = circuit.run(state, values)
-        ctx.projected_state = observable.run(ctx.out_state, values)
-        ctx.save_for_backward(*param_values)
-        return inner_prod(ctx.out_state, ctx.projected_state).real
-
-    @staticmethod
-    @no_grad()
-    def backward(ctx: Any, grad_out: Tensor) -> tuple:
-        param_values = ctx.saved_tensors
-        values = param_dict(ctx.param_names, param_values)
-
-        def _apply_adjoint(ctx: Any, op: Module) -> list:
-            grads: list = []
-            if isinstance(op, PyQHamiltonianEvolution):
-                generator = op.block.generator
-                time_param = values[op.param_names[0]]
-                ctx.out_state = apply_operator(ctx.out_state, op.dagger(values), op.qubit_support)
-                # A HamEvo can have a parametrized (1) time evolution and/or (2) generator.
-                if (
-                    isinstance(generator, AbstractBlock)
-                    and generator.is_parametric
-                    and values[op.param_names[1]].requires_grad
-                ):
-                    # If the generator contains a trainable parameter, we compute its gradient.
-                    mu = apply_operator(
-                        ctx.out_state, op.jacobian_generator(values), op.qubit_support
-                    )
-                    grads.append(2 * inner_prod(ctx.projected_state, mu).real)
-                if time_param.requires_grad:
-                    # If the time evolution is trainable, we compute its gradient.
-                    mu = apply_operator(ctx.out_state, op.jacobian_time(values), op.qubit_support)
-                    grads.append(2 * inner_prod(ctx.projected_state, mu).real)
-                ctx.projected_state = apply_operator(
-                    ctx.projected_state, op.dagger(values), op.qubit_support
-                )
-            elif isinstance(op, ScalePyQOperation):
-                ctx.out_state = apply_operator(ctx.out_state, op.dagger(values), op.qubit_support)
-                scaled_pyq_op = op.operations[0]
-                if (
-                    isinstance(scaled_pyq_op, PyQParametric)
-                    and values[scaled_pyq_op.param_name].requires_grad
-                ):
-                    mu = apply_operator(
-                        ctx.out_state,
-                        scaled_pyq_op.jacobian(values),
-                        scaled_pyq_op.qubit_support,
-                    )
-                    grads.append(2 * inner_prod(ctx.projected_state, mu).real)
-
-                if values[op.param_name].requires_grad:
-                    grads.append(2 * -values[op.param_name])
-                ctx.projected_state = apply_operator(
-                    ctx.projected_state, op.dagger(values), op.qubit_support
-                )
-            elif isinstance(op, PyQCircuit):
-                grads = [g for sub_op in op.operations[::-1] for g in _apply_adjoint(ctx, sub_op)]
-            elif isinstance(op, PyQPrimitive):
-                ctx.out_state = apply_operator(ctx.out_state, op.dagger(values), op.qubit_support)
-                if isinstance(op, PyQParametric) and values[op.param_name].requires_grad:
-                    mu = apply_operator(
-                        ctx.out_state,
-                        op.jacobian(values),
-                        op.qubit_support,
-                    )
-                    grads.append(2 * inner_prod(ctx.projected_state, mu).real)
-                ctx.projected_state = apply_operator(
-                    ctx.projected_state, op.dagger(values), op.qubit_support
-                )
-            else:
-                raise TypeError(
-                    f"AdjointExpectation does not support a backward pass for type {type(op)}."
-                )
-
-            return grads
-
-        grads = list(
-            reversed(
-                [
-                    grad_out * g
-                    for op in ctx.circuit.operations[::-1]
-                    for g in _apply_adjoint(ctx, op)
-                ]
-            )
-        )
-        num_grads = len(grads)
-        num_params = len(ctx.saved_tensors)
-        diff = num_params - num_grads
-        grads = grads + [zeros(1, device=ctx.circuit.device) for _ in range(diff)]
-        # Set observable grads to 0
-        ctx.save_for_backward(*grads)
-        return (None, None, None, None, *grads)