qadence 1.8.0__py3-none-any.whl → 1.9.1__py3-none-any.whl

qadence/model.py

@@ -514,7 +514,7 @@ class QuantumModel(nn.Module):
         if isinstance(file_path, str):
             file_path = Path(file_path)
         if os.path.isdir(file_path):
-            from qadence.ml_tools.saveload import get_latest_checkpoint_name
+            from qadence.ml_tools.callbacks.saveload import get_latest_checkpoint_name
 
             file_path = file_path / get_latest_checkpoint_name(file_path, "model")
 

qadence/noise/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from .protocols import NoiseHandler, apply_readout_noise
+from .protocols import NoiseHandler
 
 # Modules to be automatically added to the qadence namespace
-__all__ = ["NoiseHandler", "apply_readout_noise"]
+__all__ = ["NoiseHandler"]

qadence/noise/protocols.py

@@ -1,15 +1,10 @@
 from __future__ import annotations
 
-import importlib
 from itertools import compress
-from typing import Any, Callable, Counter, cast
+from typing import Any
 
 from qadence.types import NoiseEnum, NoiseProtocol
 
-PROTOCOL_TO_MODULE = {
-    "Readout": "qadence.noise.readout",
-}
-
 
 class NoiseHandler:
     """A container for multiple sources of noise.
@@ -58,7 +53,7 @@ class NoiseHandler:
         self.verify_all_protocols()
 
     def _verify_single_protocol(self, protocol: NoiseEnum, option: dict) -> None:
-        if protocol != NoiseProtocol.READOUT:
+        if not isinstance(protocol, NoiseProtocol.READOUT):  # type: ignore[arg-type]
             name_mandatory_option = (
                 "noise_probs" if isinstance(protocol, NoiseProtocol.ANALOG) else "error_probability"
             )
@@ -91,10 +86,10 @@ class NoiseHandler:
             if types.count(NoiseProtocol.ANALOG) > 1:
                 raise ValueError("Multiple Analog Noises are not supported yet.")
 
-        if NoiseProtocol.READOUT in self.protocol:
+        if NoiseProtocol.READOUT in unique_types:
             if (
-                self.protocol[-1] != NoiseProtocol.READOUT
-                or self.protocol.count(NoiseProtocol.READOUT) > 1
+                not isinstance(self.protocol[-1], NoiseProtocol.READOUT)
+                or types.count(NoiseProtocol.READOUT) > 1
             ):
                 raise ValueError("Only define a NoiseHandler with one READOUT as the last Noise.")
 
@@ -106,16 +101,6 @@ class NoiseHandler:
             ]
         )
 
-    def get_noise_fn(self, index_protocol: int) -> Callable:
-        try:
-            module = importlib.import_module(PROTOCOL_TO_MODULE[self.protocol[index_protocol]])
-        except KeyError:
-            ImportError(
-                f"The module for the protocol {self.protocol[index_protocol]} is not found."
-            )
-        fn = getattr(module, "add_noise")
-        return cast(Callable, fn)
-
     def append(self, other: NoiseHandler | list[NoiseHandler]) -> None:
         """Append noises.
 
@@ -164,15 +149,15 @@ class NoiseHandler:
         return list(filter(lambda el: not el.startswith("__"), dir(cls)))
 
     def filter(self, protocol: NoiseEnum) -> NoiseHandler | None:
-        is_protocol: list = [isinstance(p, protocol) for p in self.protocol]  # type: ignore[arg-type]
-        return (
-            NoiseHandler(
-                list(compress(self.protocol, is_protocol)),
-                list(compress(self.options, is_protocol)),
+        protocol_matches: list = [isinstance(p, protocol) for p in self.protocol]  # type: ignore[arg-type]
+
+        # if we have at least a match
+        if True in protocol_matches:
+            return NoiseHandler(
+                list(compress(self.protocol, protocol_matches)),
+                list(compress(self.options, protocol_matches)),
             )
-            if len(is_protocol) > 0
-            else None
-        )
+        return None
 
     def bitflip(self, *args: Any, **kwargs: Any) -> NoiseHandler:
         self.append(NoiseHandler(NoiseProtocol.DIGITAL.BITFLIP, *args, **kwargs))
@@ -212,30 +197,10 @@ class NoiseHandler:
         self.append(NoiseHandler(NoiseProtocol.ANALOG.DEPHASING, *args, **kwargs))
         return self
 
-    def readout(self, *args: Any, **kwargs: Any) -> NoiseHandler:
-        self.append(NoiseHandler(NoiseProtocol.READOUT, *args, **kwargs))
+    def readout_independent(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.READOUT.INDEPENDENT, *args, **kwargs))
         return self
 
-
-def apply_readout_noise(noise: NoiseHandler, samples: list[Counter]) -> list[Counter]:
-    """Apply readout noise to samples if provided.
-
-    Args:
-        noise (NoiseHandler): Noise to apply.
-        samples (list[Counter]): Samples to alter
-
-    Returns:
-        list[Counter]: Altered samples.
-    """
-    if noise.protocol[-1] == NoiseProtocol.READOUT:
-        error_fn = noise.get_noise_fn(-1)
-        # Get the number of qubits from the sample keys.
-        n_qubits = len(list(samples[0].keys())[0])
-        # Get the number of shots from the sample values.
-        n_shots = sum(samples[0].values())
-        noisy_samples: list = error_fn(
-            counters=samples, n_qubits=n_qubits, options=noise.options[-1], n_shots=n_shots
-        )
-        return noisy_samples
-    else:
-        return samples
+    def readout_correlated(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.READOUT.CORRELATED, *args, **kwargs))
+        return self

qadence/operations/ham_evo.py

@@ -33,29 +33,59 @@ logger = getLogger(__name__)
 
 class HamEvo(TimeEvolutionBlock):
     """
-    A block implementing the Hamiltonian evolution operation H where:
+    The Hamiltonian evolution operator U(t).
 
-        H = exp(-iG, t)
-    where G represents a square generator and t represents the time parameter
-    which can be parametrized.
+    For time-independent Hamiltonians the solution is exact:
+
+        U(t) = exp(-iGt)
+
+    where G represents an Hermitian generator, or Hamiltonian and t represents the
+    time parameter. For time-dependent Hamiltonians, the solution is obtained by
+    numerical integration of the Schrodinger equation.
 
     Arguments:
-        generator: Either a AbstractBlock, torch.Tensor or numpy.ndarray.
-        parameter: A scalar or vector of numeric or torch.Tensor type.
-        qubit_support: The qubits on which the evolution will be performed on.
-        duration: duration of evolution in case of time-dependent generator
+        generator: Hamiltonian generator, either symbolic as an AbstractBlock,
+            or as a torch.Tensor or numpy.ndarray.
+        parameter: The time parameter for evolution operator. For the time-independent
+            case, it represents the actual value for which the evolution will be
+            evaluated. For the time-dependent case, it should be an instance of
+            TimeParameter to signal the solver the variable that will be integrated over.
+        qubit_support: The qubits on which the evolution will be performed on. Only
+            required for generators that are not a composition of blocks.
+        duration: (optional) duration of the evolution in case of time-dependent
+            generator. By default, a FeatureParameter with tag "duration" will
+            be initialized, and the value will then be required in the values dict.
+        noise_operators: (optional) the list of jump operators to use when using
+            a shrodinger solver, allowing to perform noisy simulations.
 
     Examples:
 
     ```python exec="on" source="material-block" result="json"
-    from qadence import RX, HamEvo, run, PI
+    from qadence import X, HamEvo, PI, add, run
+    from qadence import FeatureParameter, TimeParameter
     import torch
-    hevo = HamEvo(generator=RX(0, PI), parameter=torch.rand(2))
-    print(run(hevo))
-    # Now lets use a torch.Tensor as a generator, Now we have to pass the support
-    gen = torch.rand(2,2, dtype=torch.complex128)
-    hevo = HamEvo(generator=gen, parameter=torch.rand(2), qubit_support=(0,))
-    print(run(hevo))
+
+    n_qubits = 3
+
+    # Hamiltonian as a block composition
+    hamiltonian = add(X(i) for i in range(n_qubits))
+    hevo = HamEvo(hamiltonian, parameter=torch.rand(2))
+    state = run(hevo)
+
+    # Hamiltonian as a random matrix
+    hamiltonian = torch.rand(2, 2, dtype=torch.complex128)
+    hevo = HamEvo(hamiltonian, parameter=torch.rand(2), qubit_support=(0,))
+    state = run(hevo)
+
+    # Time-dependent Hamiltonian
+    t = TimeParameter("t")
+    hamiltonian = t * add(X(i) for i in range(n_qubits))
+    hevo = HamEvo(hamiltonian, parameter=t)
+    state = run(hevo, values = {"duration": torch.tensor(1.0)})
+
+    # Adding noise operators
+    noise_ops = [X(0)]
+    hevo = HamEvo(hamiltonian, parameter=t, noise_operators=noise_ops)
     ```
     """
 
@@ -67,21 +97,31 @@ class HamEvo(TimeEvolutionBlock):
         generator: Union[TGenerator, AbstractBlock],
         parameter: TParameter,
         qubit_support: tuple[int, ...] = None,
-        duration: float | None = None,
+        duration: TParameter | None = None,
+        noise_operators: list[AbstractBlock] = list(),
     ):
-        gen_exprs = {}
+        params = {}
         if qubit_support is None and not isinstance(generator, AbstractBlock):
             raise ValueError("You have to supply a qubit support for non-block generators.")
         super().__init__(qubit_support if qubit_support else generator.qubit_support)
         if isinstance(generator, AbstractBlock):
             qubit_support = generator.qubit_support
             if generator.is_parametric:
-                gen_exprs = {str(e): e for e in expressions(generator)}
-
-                if generator.is_time_dependent and duration is None:
-                    raise ValueError("For time-dependent generators, a duration must be specified.")
-
+                params = {str(e): e for e in expressions(generator)}
+            if generator.is_time_dependent:
+                if isinstance(duration, str):
+                    duration = Parameter(duration, trainable=False)
+                elif duration is None:
+                    duration = Parameter("duration", trainable=False)
+            if not generator.is_time_dependent and duration is not None:
+                raise TypeError(
+                    "Duration argument is only supported for time-dependent generators."
+                )
         elif isinstance(generator, torch.Tensor):
+            if duration is not None:
+                raise TypeError(
+                    "Duration argument is only supported for time-dependent generators."
+                )
             msg = "Please provide a square generator."
             if len(generator.shape) == 2:
                 assert generator.shape[0] == generator.shape[1], msg
@@ -94,20 +134,41 @@ class HamEvo(TimeEvolutionBlock):
                                 In case of a 3D generator, the batch dim\
                                 is expected to be at dim 0."
                 )
-            gen_exprs = {str(generator.__hash__()): generator}
+            params = {str(generator.__hash__()): generator}
         elif isinstance(generator, (sympy.Basic, sympy.Array)):
-            gen_exprs = {str(generator): generator}
+            if duration is not None:
+                raise TypeError(
+                    "Duration argument is only supported for time-dependent generators."
+                )
+            params = {str(generator): generator}
         else:
             raise TypeError(
                 f"Generator of type {type(generator)} not supported.\
                             If you're using a numpy.ndarray, please cast it to a torch tensor."
             )
-        ps = {"parameter": Parameter(parameter), **gen_exprs}
-        self.parameters = ParamMap(**ps)
+        if duration is not None:
+            params = {"duration": Parameter(duration), **params}
+        params = {"parameter": Parameter(parameter), **params}
+        self.parameters = ParamMap(**params)
         self.time_param = parameter
         self.generator = generator
         self.duration = duration
 
+        if len(noise_operators) > 0:
+            if not all(
+                [
+                    len(set(op.qubit_support + self.qubit_support) - set(self.qubit_support)) == 0
+                    for op in noise_operators
+                ]
+            ):
+                raise ValueError(
+                    "Noise operators should be defined"
+                    " over the same or a subset of the qubit support"
+                )
+            if True in [op.is_parametric for op in noise_operators]:
+                raise ValueError("Parametric operators are not supported")
+        self.noise_operators = noise_operators
+
     @classmethod
     def num_parameters(cls) -> int:
         return 2

qadence/transpile/noise.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from qadence.backend import ConvertedCircuit
 from qadence.blocks.abstract import AbstractBlock
 from qadence.circuit import QuantumCircuit
 from qadence.noise.protocols import NoiseHandler
@@ -23,13 +24,15 @@ def _set_noise(
 
 
 def set_noise(
-    circuit: QuantumCircuit | AbstractBlock,
+    circuit: QuantumCircuit | AbstractBlock | ConvertedCircuit,
     noise: NoiseHandler | None,
     target_class: AbstractBlock | None = None,
 ) -> QuantumCircuit | AbstractBlock:
     """
     Parses a `QuantumCircuit` or `CompositeBlock` to add noise to specific gates.
 
+    If `circuit` is a `ConvertedCircuit`, this is done within `circuit.abstract`.
+
     Changes the input in place.
 
     Arguments:
@@ -37,10 +40,14 @@ def set_noise(
         noise: the NoiseHandler protocol to change to, or `None` to remove the noise.
         target_class: optional class to selectively add noise to.
     """
-    is_circuit_input = isinstance(circuit, QuantumCircuit)
-
-    input_block: AbstractBlock = circuit.block if is_circuit_input else circuit  # type: ignore
+    input_block: AbstractBlock
+    if isinstance(circuit, ConvertedCircuit):
+        input_block = circuit.abstract.block
+    elif isinstance(circuit, QuantumCircuit):
+        input_block = circuit.block
+    else:
+        input_block = circuit
 
-    output_block = apply_fn_to_blocks(input_block, _set_noise, noise, target_class)
+    apply_fn_to_blocks(input_block, _set_noise, noise, target_class)
 
     return circuit

qadence/types.py

@@ -10,7 +10,8 @@ import sympy
 from matplotlib.figure import Figure
 from numpy.typing import ArrayLike
 from pyqtorch.noise import NoiseType as DigitalNoise
-from pyqtorch.utils import SolverType
+from pyqtorch.noise.readout import WhiteNoise
+from pyqtorch.utils import DropoutMode, SolverType
 from torch import Tensor, pi
 from torch.nn import Module
 
@@ -54,7 +55,9 @@ __all__ = [
     "SerializationFormat",
     "PI",
     "SolverType",
+    "DropoutMode",
     "NoiseProtocol",
+    "WhiteNoise",
 ]  # type: ignore
 
 
@@ -468,16 +471,25 @@ class AnalogNoise(StrEnum):
     DEPHASING = "Dephasing"
 
 
+class ReadoutNoise(StrEnum):
+    """Type of readout protocol."""
+
+    INDEPENDENT = "Independent Readout"
+    """Simple readout protocols where each qubit is corrupted independently."""
+    CORRELATED = "Correlated Readout"
+    """Using a confusion matrix (2**n, 2**n) for corrupting bitstrings values."""
+
+
 @dataclass
 class NoiseProtocol:
     """Type of noise protocol."""
 
     ANALOG = AnalogNoise
     """Noise applied in analog blocks."""
-    READOUT = "Readout"
+    READOUT = ReadoutNoise
     """Noise applied on outputs of quantum programs."""
     DIGITAL = DigitalNoise
     """Noise applied to digital blocks."""
 
 
-NoiseEnum = Union[DigitalNoise, AnalogNoise, str]
+NoiseEnum = Union[DigitalNoise, AnalogNoise, ReadoutNoise]

{qadence-1.8.0.dist-info → qadence-1.9.1.dist-info}/METADATA

@@ -1,10 +1,9 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.8.0
+Version: 1.9.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>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>
 License: Apache 2.0
-License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -22,7 +21,7 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.5.1
+Requires-Dist: pyqtorch==1.6.0
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -54,7 +53,7 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.12.4; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.12.5; extra == 'pulser'
 Requires-Dist: pulser-core==1.1.1; extra == 'pulser'
 Requires-Dist: pulser-simulation==1.1.1; extra == 'pulser'
 Provides-Extra: visualization

{qadence-1.8.0.dist-info → qadence-1.9.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
-qadence/__init__.py,sha256=0SFU1_XZ-3WlSU1rA4W1Y0edxpZLO_sNg-YnpjlD77w,2638
+qadence/__init__.py,sha256=c3y-Tbq_P4cbWKi7b45Z6zUFlnqgd8Q68OOpL2O2GOI,2671
 qadence/backend.py,sha256=MigWAAroh_STGLg2qoQED9tDHmTo15uBbvFNz_oHy7A,13372
 qadence/circuit.py,sha256=r8QvzLWHvavqLOlNstq8aHg6UpKmPClEDoZVBkk-tzY,6970
 qadence/decompose.py,sha256=C4LYia_GcC9Rx3QO0ZLWTI9dN63a8WTEAXO0ZVQWuiE,5221
 qadence/divergences.py,sha256=JhpELhWSnuDvQxa9hJp_DE3EQg2Ban-Ta0mHZ_fVrHg,1832
-qadence/execution.py,sha256=rYOKNQyOL6xM5qkqe9rYU823U7OYBnTnCWNdwteGAw8,9742
+qadence/execution.py,sha256=SoB5n8mRQ6mxY9JqnqrrU5hY-M72WQOpnZC25PBM_dA,9670
 qadence/extensions.py,sha256=Fyj8WweDNbtZc6snZ2y7zLL-jBOvi7InMYElbC2gNmQ,6084
 qadence/libs.py,sha256=HetkKO8TCTlVCViQdVQJvxwBekrhd-y_iMox4UJMY1M,410
-qadence/log_config.yaml,sha256=WwSpxqMSXgPJ7wO_wh46UnFzXdgX9NVA4MbN3TcJFyE,485
+qadence/log_config.yaml,sha256=QiwoB1bnRdk9NpxnvfgWX2PjN7EDfYlrc3GVD38rtdI,739
 qadence/logger.py,sha256=Hb76pK3VyQjVjJb4_NqFlOJgjYJVa8t7DHJFlzOM86M,407
-qadence/model.py,sha256=qmB_IFnjNjcl_p_EaECXDTwnyQSy1LY9HiB8DzUnqPg,21613
+qadence/model.py,sha256=OH61_Ij_c7PRywiXf16tJ5mnK9iYNbBTdRiHeG8PZ54,21623
 qadence/overlap.py,sha256=ekaUnIcQWdF4hSFuUWpRjaxo43JyDGFOayP7vMXCZpw,16821
 qadence/parameters.py,sha256=RDYklyW5EQZTjsAazEXa4lLGDOdmUUU53hLj385uSaI,12687
 qadence/protocols.py,sha256=bcYTxSjgMPV-a-D6yv90jCpnGik8myzaNpFv9z1gzJ0,442
@@ -18,17 +18,17 @@ qadence/register.py,sha256=mwmvS6PcTY0F9cIhTUXG3NT73FIagfMCwVqYa4DrQrk,13001
 qadence/serial_expr_grammar.peg,sha256=z5ytL7do9kO8o4h-V5GrsDuLdso0KsRcMuIYURFfmAY,328
 qadence/serialization.py,sha256=qEET6Gu9u2aSibPve3bJrqDzK2_gO3RPDJjt4ZY8GbE,15596
 qadence/states.py,sha256=5QIOBBYs8e2uLFiMa8iMYZ-MvWIFEqkZAjNYx0SyYPI,14843
-qadence/types.py,sha256=dYcn3hlFkzqFs29xaF2f17mg-NfBNN6dyzfpaqZ8GoA,11576
+qadence/types.py,sha256=NR1dnN4tKC3zL1KEzjs2p_IYVth7GctgXVbIJsuiUws,11992
 qadence/utils.py,sha256=zb2j7wURfy8kazaS84r4t35vAeDpo4Tpm4HbmPH-kFA,9865
 qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
 qadence/analog/addressing.py,sha256=GSt4heEmRkBmoQIgdgkTclEFxZY-jjuAd77_SsZtGdI,6513
 qadence/analog/constants.py,sha256=B2phQoN1ASL8CwM-Dsa1rbraYwGwwPSeiB3HbVe-MPA,1243
 qadence/analog/device.py,sha256=LK8rQYBiK_PWHezLfTL0Ig83yc5wQPmZ3rBZF-gWgYw,2416
 qadence/analog/hamiltonian_terms.py,sha256=9LKidqqEMJTTdXeaxkxP_otTmcv9i4yeJ-JKCLOCK3Y,3421
-qadence/analog/parse_analog.py,sha256=ppvMZtsKXOIkIehCgjbdmG9n232DIycSanyuyVth5Wg,4223
+qadence/analog/parse_analog.py,sha256=9Y_LMdw4wCHH6YSkvHhs6PUNwzT14HS7cUGheNSmDQg,4168
 qadence/backends/__init__.py,sha256=ibm7wmZxuIoMYAQxgAx0MsfLYWOVHNWgLwyS1HjMuuI,215
 qadence/backends/api.py,sha256=NPrvtZQ4klUBabUWJ5hbTUCVoaoW9-sHVbiXxAnTt3A,2643
-qadence/backends/gpsr.py,sha256=3lcOHgt0soCiDXAyZ8DVyS8dMgUypIPwkDADds2boSE,5371
+qadence/backends/gpsr.py,sha256=HW5m6iHLq3hLHdJoU1q1i1laR0hBs7uCniXqrsFoNCI,5616
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
 qadence/backends/utils.py,sha256=SdeAf6BDayc-W9hPI271PKtJ_ROOzRry9Jw72wUGmm4,8565
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
@@ -36,7 +36,7 @@ qadence/backends/horqrux/backend.py,sha256=KNFFGN9dsgB9QKtNXiP3LyMY9DQ-7W7ScyE6k
 qadence/backends/horqrux/config.py,sha256=xz7JlUcwW_4JAbvProbSI9hA1SXZRRAN0Hr2bvmLzfg,892
 qadence/backends/horqrux/convert_ops.py,sha256=3uG3yLq5wjfrWzFHDs0HEnd8kER91ZHVX3HCpYjOdjk,8565
 qadence/backends/pulser/__init__.py,sha256=capQ-eHqwtOeLf4mWsI0BIseAHhiLGie5cFD4-iVhUo,116
-qadence/backends/pulser/backend.py,sha256=U2VcHUMtMXpCe470OfrGCzOjJ28SA6rx40LhkIkZqC4,15582
+qadence/backends/pulser/backend.py,sha256=kNo_AAvOPNevdiMbZnQlEUbWCO-NXcwUtFWQHJ6VR2Q,14845
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
 qadence/backends/pulser/cloud.py,sha256=0uUluvbFV9sOuCPraE-9uiVtC3Q8QaDY1IJMDi8grDM,2057
 qadence/backends/pulser/config.py,sha256=aoHDmtgq5i0Zryxenw_p3uARY0B1w-UaYvfqDmrWHM0,2175
@@ -45,9 +45,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=Cn-hXzEz-iqrOC87m_xI7MIapRielQH26nAjhCFbWas,8958
-qadence/backends/pyqtorch/config.py,sha256=jK-if0OF6L_inP-oZhWI4-b8wcrOiK8-EVv3NYDOfBM,2056
-qadence/backends/pyqtorch/convert_ops.py,sha256=y17_ECCXFke2HCFzBwYDtuFC_RXwMEKyZRplpFhFsyU,11231
+qadence/backends/pyqtorch/backend.py,sha256=Sjuof9b332w4gk9o8Rso2rgSHxskexfkIazRfxRD0Ng,11458
+qadence/backends/pyqtorch/config.py,sha256=sAxWVSkWvj6Lu0em1KJCDb6nfjqe8Dsxi7pyh6qYJpA,2387
+qadence/backends/pyqtorch/convert_ops.py,sha256=QVlXAqqBPtBt2NuFU9mvEm5i7FWXg3gWqoeizlH-1_s,13401
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=DSQUE71rMyRBwAP--4Tx1WQC_LCXaNlftjd7goGyrpQ,12027
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
@@ -56,7 +56,7 @@ qadence/blocks/composite.py,sha256=f9D8L3u5Ktu_-xDBWsWiPlY8I-YW5YFgU18BtqwFHK0,8
 qadence/blocks/embedding.py,sha256=MA3vRt659A828ZnH-6q7SpFdzS8Cf0oTtA2DJIDHmx4,7043
 qadence/blocks/manipulate.py,sha256=kPmzej7mnWFoqTJA2CkGulT7hcPha0GGPARC8rjZltg,2387
 qadence/blocks/matrix.py,sha256=unE8mVWBTTcmSLX4le2fHqHFu4fbGeMTK8MrGoPsVRY,4036
-qadence/blocks/primitive.py,sha256=ezIx3GdO9Yc_cFjnKZSdHOL5C9BvO3K_pDJdOqfDlq0,17622
+qadence/blocks/primitive.py,sha256=GLruKpiFBStWVd_M9mzLr3MqDNPbyaMUzEVB6xV3cPQ,17657
 qadence/blocks/utils.py,sha256=_ggOmIesfmTtIeldUyiZrKyS5HT5i_R3ZS8ihBCw73E,17700
 qadence/constructors/__init__.py,sha256=HTVulUFol_RxdCI3Gn2CBKjJ6ue0ALOB6GUuibP0ONE,1000
 qadence/constructors/ansatze.py,sha256=a7ZTYhfOat7fme_w_NFEUbZrMLSDMrkpu5RrablkeUU,14856
@@ -92,33 +92,40 @@ qadence/exceptions/exceptions.py,sha256=4j_VJpx2sZ2Mir5BJUWu4nwb131FY1ygO4q8-Xly
 qadence/measurements/__init__.py,sha256=RIjG9tVJMqhNzyj7maZI250Um0KgHl2PizDcKJag-JU,161
 qadence/measurements/protocols.py,sha256=mD50R9yPs5bIYH7Efd0BsR0503apiyrsZydi_Q6BJag,1161
 qadence/measurements/samples.py,sha256=AVvszDwgfKnZ_ooATyTA3270vGeg1V3WO94jsfrTk-8,1200
-qadence/measurements/shadow.py,sha256=uV0qHflf2jV_X2Rk-0v4sqH64O5RFjJic6tHHpbUnI0,12290
+qadence/measurements/shadow.py,sha256=ahyGl-krBqyzm1teMlWes9o1vqSjp4pX-QIYQ_AzNPc,11499
 qadence/measurements/tomography.py,sha256=Xz_sw-Vo1LOAHFgTiUsEmIn77j__4uuJNwWZz3KmTgE,2679
-qadence/measurements/utils.py,sha256=pdEs7pvLvGmMeaevNp3saKebCivCcrXSL1D-cYqPR7Y,6548
+qadence/measurements/utils.py,sha256=rGFU2ZoTWdhYrUmVHiSSobzhQri8VTCPC-CW23-Dv5E,6548
 qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-bs,159
 qadence/mitigations/analog_zne.py,sha256=5n1ffjGM1I5sd9TATsB90pKdDh32UTFJ-ZyOHKdM5z0,7821
 qadence/mitigations/protocols.py,sha256=0TeHvlGTN8_88XNEwrjA97C5BUlrh34wYmx0w6-5Tyw,1622
-qadence/mitigations/readout.py,sha256=Lj7D-1J4W8Y8xKy9ieo7AOl9R-uebpxDzJ8UMD1iBig,6472
-qadence/ml_tools/__init__.py,sha256=nTXcVpfSnMBWwHjU18ASIbvqfht5TIY9Zt9Wu1DATUg,1118
-qadence/ml_tools/config.py,sha256=b6pFoluE0YxrjDLG-a2ZL8Z0fZKSHoUqpySTB2lkzvg,25316
+qadence/mitigations/readout.py,sha256=nI-voV5N0R7630Cn8t8x9EdV9iB76P0LDkRosy1s0Ec,6631
+qadence/ml_tools/__init__.py,sha256=a52dLBtUh5rTJ0ks_LREv-txtQ8pQZZhnQaIg28fSOw,936
+qadence/ml_tools/config.py,sha256=KcwvfyUb1XT-8NkP1ULjaGRNZqJm6dmWnuY9Bl4KZl0,19406
 qadence/ml_tools/constructors.py,sha256=gPfU-ICudfsByilYK-rFjax3HeTjtf_CqnR8axDy0F0,28081
-qadence/ml_tools/data.py,sha256=ubwtkNvoBf0ZTGQm2M2Lgaim2tBAiAsa9VoTRR_MWks,5175
+qadence/ml_tools/data.py,sha256=5sAqG9rUtGZPzFlzEDhMjSeOXF8Z0BmszJ_FRzYAy2A,5311
 qadence/ml_tools/models.py,sha256=DKSVFNC-Iq0-AmBrCZ1kqUpTBHQh_pX_1MqYT8eCG08,17045
-qadence/ml_tools/optimize_step.py,sha256=L92-kNILrmwz20d_Xd_FIQw6SDGJYIEbFN3tSRz9eno,1835
+qadence/ml_tools/optimize_step.py,sha256=wUnxfWy0c9rEKe41-26On1bPFBwmSYBF4WCGn76oyq8,3376
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
-qadence/ml_tools/printing.py,sha256=MpKU9PJYo_nPWdOeHuZToKohPZ7SJDcszhBLugkGZ60,4830
-qadence/ml_tools/saveload.py,sha256=B6709ZdqHkg6kCZJmlZhCoWaNJ4ZynJe_W2IoaexLTs,5945
+qadence/ml_tools/stages.py,sha256=qW2phMIvQBLM3tn2UoGN-ePiBnZoNq5k844eHVnnn8Y,1407
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/train_grad.py,sha256=dJuNK8Gq1dLbK23TIeE6ynlYUoj0KQH9iPPDx7ZMNPU,14682
-qadence/ml_tools/train_no_grad.py,sha256=jUjnsxvWMrAa-7NV1bewpAo6mV9grF02gwBHy0SVTws,7249
+qadence/ml_tools/trainer.py,sha256=u9Mxv9WwRlYScLozT1Qltf1tNYLAUgn3oiz2E8bLpx0,26803
 qadence/ml_tools/utils.py,sha256=PW8FyoV0mG_DtN1U8njTDV5qxZ0EK4mnFwMAsLBArfk,1410
-qadence/noise/__init__.py,sha256=_24vp6Busn4LGby_aGzriPpagV8yImOiB95GXuANF1w,205
-qadence/noise/protocols.py,sha256=BZUDjQI76-aej2f7t0XPBmwph74VifzHIkTPgA1pmgU,9629
-qadence/noise/readout.py,sha256=UpUdxaGu09SmqKXn0O7RYfF7b7UcRZiNMfDlpY0weV0,6726
+qadence/ml_tools/callbacks/__init__.py,sha256=XaUKmyQZaqxI0jvKnWCpIBgnX5y4Kczcbn2FRiomFu4,655
+qadence/ml_tools/callbacks/callback.py,sha256=F9tbXBBv3ZKTFbm0fGBZIZtTRO63jLazMk_oeL77dyE,16289
+qadence/ml_tools/callbacks/callbackmanager.py,sha256=HwxgbqJi1GWYg2lgUqEyw9Y6a71YG_m5DmhpaeB6kLs,8007
+qadence/ml_tools/callbacks/saveload.py,sha256=2z8v1A3qIIPZuusEcSNqgYTnKGKkDj71KvY_atJvKnM,6015
+qadence/ml_tools/callbacks/writer_registry.py,sha256=FVM13j1-mv1Qt-v2QgkRFSB_uQ1bmezr5v6UKfeh3as,15264
+qadence/ml_tools/loss/__init__.py,sha256=d_0FlisdmgLY0qL1PeaabbcWX1B42RBdm7220cfzSN4,247
+qadence/ml_tools/loss/loss.py,sha256=Bditg8nelMEpG4Yt0aopcAQz84xIc6O-AGUO2M0nqbM,2982
+qadence/ml_tools/train_utils/__init__.py,sha256=1A2FlFg7kn68R1fdRC73S8DzA9gkBW7whdNHjzH5UTA,235
+qadence/ml_tools/train_utils/base_trainer.py,sha256=giOcBRMjgbq9sLjqck6MCWH8V1MCVBHarWuFrS-ahbw,20442
+qadence/ml_tools/train_utils/config_manager.py,sha256=dps94qfiwjhoY_aQp5RvQPd9zW_MIN2knw1UaDaYrKs,6896
+qadence/noise/__init__.py,sha256=tnChHv7FzOaV8C7O0P2l_gfjrpmHg8JaNhZprL33CP4,161
+qadence/noise/protocols.py,sha256=SPHJi5AiIOcz6U_iXY3ddVHk3cl9UHSDKk49eMTX2QM,8586
 qadence/operations/__init__.py,sha256=HAAo9VZUTq2H7kcEarChTgTWCIq7LT25-xBxkwE0F9c,1922
 qadence/operations/analog.py,sha256=v11DSrg-XUbwIAWAWM43y3VQbYKsx2ynx-HimUoC-x0,7435
 qadence/operations/control_ops.py,sha256=2ABP8fuf2mpJqRooDiBd2p-J-AL1yx3NDRF2TZf3K-c,10253
-qadence/operations/ham_evo.py,sha256=tomOxTX6htgk23tvSno07_by3WThwBSyaNfnVbR6lA8,7850
+qadence/operations/ham_evo.py,sha256=brJ11tlwj6UPYkUcnId-BKlzNStsZd0vp9FKHCFTjlM,10642
 qadence/operations/parametric.py,sha256=kV5d-diaQAoRlqKqoo0CGCbPej6eAxHQXniqfFKff3g,5394
 qadence/operations/primitive.py,sha256=hDuwWndfPWqchM_98mOMf40qpkuPuwh39DIwHAbzGRo,9944
 qadence/transpile/__init__.py,sha256=JrrQ4Osc4nNRWWjRGmVn57fWc8WwF92MokhKLRZ1vVA,499
@@ -128,9 +135,9 @@ qadence/transpile/circuit.py,sha256=KTh6Gv1czZddFuA1JhNNszheZbwViVixiGh4rGvIgTM,
 qadence/transpile/digitalize.py,sha256=iWRwYAYQsD2INHj0HNbGJriv_3fRCuBW1nDBrwtKSuI,1523
 qadence/transpile/flatten.py,sha256=EdhSG5WyF56nbnxINNLqrHgY84MRM1YFjT3fR4aph5Q,3427
 qadence/transpile/invert.py,sha256=KAefHTG2AWr39aengVhXrzCtJPhrZC-ZnL6vYvmbnY0,4867
-qadence/transpile/noise.py,sha256=-gb72Ko-w5nhm3FmJAh73XlUe0Q9ckYIme6sBXwxYF0,1448
+qadence/transpile/noise.py,sha256=LDcDJtQGkgUPkL2t69gg6AScTb-p3J3SxCDZbYOu1L8,1668
 qadence/transpile/transpile.py,sha256=6MRRkk1OS279L1fwUQjazA6qlfpbd-T_EJMKT8hAhOU,2721
-qadence-1.8.0.dist-info/METADATA,sha256=BQNMO785SPR2sZNiYPrXEOZHvO6eaCHDFUMh2-ZhF2g,9864
-qadence-1.8.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-qadence-1.8.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.8.0.dist-info/RECORD,,
+qadence-1.9.1.dist-info/METADATA,sha256=LR5dgYAA874bZyIRlUpSxHmjPY3Ww-Yos7p_LLZtNT0,9842
+qadence-1.9.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+qadence-1.9.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.9.1.dist-info/RECORD,,

{qadence-1.8.0.dist-info → qadence-1.9.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any