qadence 1.7.6__py3-none-any.whl → 1.7.8__py3-none-any.whl

qadence/backend.py

@@ -282,33 +282,6 @@ class Backend(ABC):
         """
         raise NotImplementedError
 
-    @abstractmethod
-    def run_dm(
-        self,
-        circuit: ConvertedCircuit,
-        noise: Noise,
-        param_values: dict[str, ArrayLike] = {},
-        state: Tensor | None = None,
-        endianness: Endianness = Endianness.BIG,
-    ) -> Tensor:
-        """Run a circuit and return the resulting the density matrix.
-
-        TODO: Temporary method for the purposes of noise model implementation.
-        To be removed in a later refactoring.
-
-        Arguments:
-            circuit: A converted circuit as returned by `backend.circuit`.
-            param_values: _**Already embedded**_ parameters of the circuit. See
-                [`embedding`][qadence.blocks.embedding.embedding] for more info.
-            state: Initial state.
-            endianness: Endianness of the resulting density matrix.
-
-        Returns:
-            A list of Counter objects where each key represents a bitstring
-            and its value the number of times it has been sampled from the given wave function.
-        """
-        raise NotImplementedError
-
     @abstractmethod
     def expectation(
         self,

qadence/backends/braket/backend.py

@@ -131,16 +131,6 @@ class Backend(BackendInterface):
             states = invert_endianness(states)
         return states
 
-    def run_dm(
-        self,
-        circuit: ConvertedCircuit,
-        noise: Noise,
-        param_values: dict[str, Tensor] = {},
-        state: Tensor | None = None,
-        endianness: Endianness = Endianness.BIG,
-    ) -> Tensor:
-        raise NotImplementedError
-
     def sample(
         self,
         circuit: ConvertedCircuit,

qadence/backends/horqrux/backend.py

@@ -107,16 +107,6 @@ class Backend(BackendInterface):
             state = unhorqify(state)
         return state
 
-    def run_dm(
-        self,
-        circuit: ConvertedCircuit,
-        noise: Noise,
-        param_values: ParamDictType = {},
-        state: ArrayLike | None = None,
-        endianness: Endianness = Endianness.BIG,
-    ) -> ArrayLike:
-        raise NotImplementedError
-
     def expectation(
         self,
         circuit: ConvertedCircuit,

qadence/backends/pulser/backend.py

@@ -187,6 +187,7 @@ class Backend(BackendInterface):
         param_values: dict[str, Tensor] = {},
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
+        noise: Noise | None = None,
     ) -> Tensor:
         vals = to_list_of_dicts(param_values)
 
@@ -197,37 +198,41 @@ class Backend(BackendInterface):
                 "specify any cloud credentials to use the .run() method"
             )
 
-        state = state if state is None else _convert_init_state(state)
-        batched_wf = np.zeros((len(vals), 2**circuit.abstract.n_qubits), dtype=np.complex128)
+        if noise is None:
+            state = state if state is None else _convert_init_state(state)
+            batched_wf = np.zeros((len(vals), 2**circuit.abstract.n_qubits), dtype=np.complex128)
 
-        for i, param_values_el in enumerate(vals):
-            sequence = self.assign_parameters(circuit, param_values_el)
-            pattern = circuit.original.register.device_specs.pattern
-            if pattern is not None:
-                add_addressing_pattern(sequence, pattern)
-            sequence.measure()
-            sim_result = simulate_sequence(sequence, self.config, state, n_shots=None)
-            wf = (
-                sim_result.get_final_state(  # type:ignore [union-attr]
-                    ignore_global_phase=False, normalize=True
+            for i, param_values_el in enumerate(vals):
+                sequence = self.assign_parameters(circuit, param_values_el)
+                pattern = circuit.original.register.device_specs.pattern
+                if pattern is not None:
+                    add_addressing_pattern(sequence, pattern)
+                sequence.measure()
+                sim_result = simulate_sequence(sequence, self.config, state, n_shots=None)
+                wf = (
+                    sim_result.get_final_state(  # type:ignore [union-attr]
+                        ignore_global_phase=False, normalize=True
+                    )
+                    .full()
+                    .flatten()
                 )
-                .full()
-                .flatten()
-            )
-            # We flip the wavefunction coming out of pulser,
-            # essentially changing logic 0 with logic 1 in the basis states.
-            batched_wf[i] = np.flip(wf)
+                # We flip the wavefunction coming out of pulser,
+                # essentially changing logic 0 with logic 1 in the basis states.
+                batched_wf[i] = np.flip(wf)
 
-        batched_wf_torch = torch.from_numpy(batched_wf)
+            batched_wf_torch = torch.from_numpy(batched_wf)
 
-        if endianness != self.native_endianness:
-            from qadence.transpile import invert_endianness
+            if endianness != self.native_endianness:
+                from qadence.transpile import invert_endianness
 
-            batched_wf_torch = invert_endianness(batched_wf_torch)
+                batched_wf_torch = invert_endianness(batched_wf_torch)
 
-        return batched_wf_torch
+            return batched_wf_torch
 
-    def run_dm(
+        else:
+            return self._run_noisy(circuit, noise, param_values, state, endianness)
+
+    def _run_noisy(
         self,
         circuit: ConvertedCircuit,
         noise: Noise,
@@ -342,12 +347,12 @@ class Backend(BackendInterface):
                 res = res if len(res.shape) > 0 else res.reshape(1)
                 return res.real
             elif noise is not None:
-                dms = self.run_dm(
+                dms = self.run(
                     circuit=circuit,
-                    noise=noise,
                     param_values=param_values,
                     state=state,
                     endianness=endianness,
+                    noise=noise,
                 )
                 support = sorted(list(circuit.abstract.register.support))
                 # TODO: There should be a better check for batched density matrices.

qadence/backends/pyqtorch/backend.py

@@ -106,16 +106,6 @@ class Backend(BackendInterface):
         state = invert_endianness(state) if endianness != self.native_endianness else state
         return state
 
-    def run_dm(
-        self,
-        circuit: ConvertedCircuit,
-        noise: Noise,
-        param_values: dict[str, Tensor] = {},
-        state: Tensor | None = None,
-        endianness: Endianness = Endianness.BIG,
-    ) -> Tensor:
-        raise NotImplementedError
-
     def _batched_expectation(
         self,
         circuit: ConvertedCircuit,

qadence/backends/pyqtorch/convert_ops.py

@@ -14,6 +14,7 @@ from pyqtorch.utils import is_diag
 from torch import (
     Tensor,
     cdouble,
+    complex64,
     diag_embed,
     diagonal,
     exp,
@@ -77,11 +78,24 @@ def is_single_qubit_chain(block: AbstractBlock) -> bool:
 
 
 def extract_parameter(block: ScaleBlock | ParametricBlock, config: Configuration) -> str | Tensor:
-    return (
-        tensor([block.parameters.parameter], dtype=float64)
-        if not block.is_parametric
-        else config.get_param_name(block)[0]
-    )
+    """Extract the parameter as string or its tensor value.
+
+    Args:
+        block (ScaleBlock | ParametricBlock): Block to extract parameter from.
+        config (Configuration): Configuration instance.
+
+    Returns:
+        str | Tensor: Parameter value or symbol.
+    """
+    if not block.is_parametric:
+        tensor_val = tensor([block.parameters.parameter], dtype=complex64)
+        return (
+            tensor([block.parameters.parameter], dtype=float64)
+            if torch.all(tensor_val.imag == 0)
+            else tensor_val
+        )
+
+    return config.get_param_name(block)[0]
 
 
 def convert_block(
@@ -122,17 +136,11 @@ def convert_block(
             else:
                 generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
             time_param = config.get_param_name(block)[0]
-            is_parametric = (
-                block.generator.is_parametric
-                if isinstance(block.generator, AbstractBlock)
-                else False
-            )
             return [
                 pyq.HamiltonianEvolution(
                     qubit_support=qubit_support,
                     generator=generator,
                     time=time_param,
-                    generator_parametric=is_parametric,  # type: ignore[union-attr]
                     cache_length=0,
                 )
             ]

qadence/mitigations/analog_zne.py

@@ -82,7 +82,7 @@ def pulse_experiment(
         conv_circuit = backend.circuit(stretched_circuit)
         noisy_density_matrices.append(
             # Contain a single experiment result for the stretch.
-            backend.run_dm(
+            backend.run(
                 conv_circuit,
                 param_values=param_values,
                 state=state,
@@ -124,7 +124,7 @@ def noise_level_experiment(
     zne_datasets: list = []
     # Get noisy density matrices.
     conv_circuit = backend.circuit(circuit)
-    noisy_density_matrices = backend.run_dm(
+    noisy_density_matrices = backend.run(
         conv_circuit, param_values=param_values, state=state, noise=noise, endianness=endianness
     )
     # Convert observable to Numpy types compatible with QuTip simulations.

qadence/ml_tools/__init__.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from .config import AnsatzConfig, Callback, FeatureMapConfig, TrainConfig
 from .constructors import create_ansatz, create_fm_blocks, observable_from_config
-from .data import DictDataLoader, InfiniteTensorDataset, to_dataloader
+from .data import DictDataLoader, InfiniteTensorDataset, OptimizeResult, 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
@@ -23,6 +23,7 @@ __all__ = [
     "observable_from_config",
     "QNN",
     "TrainConfig",
+    "OptimizeResult",
     "Callback",
     "train_with_grad",
     "train_gradient_free",

qadence/ml_tools/config.py

@@ -38,15 +38,22 @@ class Callback:
     Each callback function should take at least as first input
     an OptimizeResult instance.
 
+    Note: when setting call_after_opt to True, we skip
+    verifying iteration % called_every == 0.
+
     Attributes:
         callback (CallbackFunction): Callback function accepting an
             OptimizeResult as first argument.
         callback_condition (CallbackConditionFunction | None, optional): Function that
             conditions the call to callback. Defaults to None.
+        modify_optimize_result (CallbackFunction | dict[str, Any] | None, optional):
+            Function that modify the OptimizeResult before callback.
+            For instance, one can change the `extra` (dict) argument to be used in callback.
+            If a dict is provided, the `extra` field of OptimizeResult is updated with the dict.
         called_every (int, optional): Callback to be called each `called_every` epoch.
             Defaults to 1.
             If callback_condition is None, we set
-            callback_condition to returns True when iteration % every == 0.
+            callback_condition to returns True when iteration % called_every == 0.
         call_before_opt (bool, optional): If true, callback is applied before training.
             Defaults to False.
         call_end_epoch (bool, optional): If true, callback is applied during training,
@@ -61,6 +68,7 @@ class Callback:
         self,
         callback: CallbackFunction,
         callback_condition: CallbackConditionFunction | None = None,
+        modify_optimize_result: CallbackFunction | dict[str, Any] | None = None,
         called_every: int = 1,
         call_before_opt: bool = False,
         call_end_epoch: bool = True,
@@ -74,10 +82,13 @@ class Callback:
                 OptimizeResult as ifrst argument.
             callback_condition (CallbackConditionFunction | None, optional): Function that
                 conditions the call to callback. Defaults to None.
+            modify_optimize_result (CallbackFunction | dict[str, Any] | None , optional):
+                Function that modify the OptimizeResult before callback. If a dict
+                is provided, this updates the `extra` field of OptimizeResult.
             called_every (int, optional): Callback to be called each `called_every` epoch.
                 Defaults to 1.
                 If callback_condition is None, we set
-                callback_condition to returns True when iteration % every == 0.
+                callback_condition to returns True when iteration % called_every == 0.
             call_before_opt (bool, optional): If true, callback is applied before training.
                 Defaults to False.
             call_end_epoch (bool, optional): If true, callback is applied during training,
@@ -102,9 +113,56 @@ class Callback:
         else:
             self.callback_condition = callback_condition
 
-    def __call__(self, opt_result: OptimizeResult) -> Any:
+        if modify_optimize_result is None:
+            self.modify_optimize_result = lambda opt_result: opt_result
+        elif isinstance(modify_optimize_result, dict):
+
+            def update_extra(opt_result: OptimizeResult) -> OptimizeResult:
+                opt_result.extra.update(modify_optimize_result)
+                return opt_result
+
+            self.modify_optimize_result = update_extra
+        else:
+            self.modify_optimize_result = modify_optimize_result
+
+    def __call__(self, opt_result: OptimizeResult, is_last_iteration: bool = False) -> Any:
+        """Apply callback if conditions are met.
+
+        Note that the current result may be modified by specifying a function
+        `modify_optimize_result` for instance to add inputs to the `extra` argument
+        of the current OptimizeResult.
+
+        Args:
+            opt_result (OptimizeResult): Current result.
+            is_last_iteration (bool, optional): When True,
+                avoid verifying modulo. Defaults to False.
+                Useful when call_after_opt is True.
+
+        Returns:
+            Any: The result of the callback.
+        """
+        opt_result = self.modify_optimize_result(opt_result)
         if opt_result.iteration % self.called_every == 0 and self.callback_condition(opt_result):
             return self.callback(opt_result)
+        if is_last_iteration and self.callback_condition(opt_result):
+            return self.callback(opt_result)
+
+
+def run_callbacks(
+    callback_iterable: list[Callback], opt_res: OptimizeResult, is_last_iteration: bool = False
+) -> None:
+    """Run a list of Callback given the current OptimizeResult.
+
+    Used in train functions.
+
+    Args:
+        callback_iterable (list[Callback]): Iterable of Callbacks
+        opt_res (OptimizeResult): Current optimization result,
+        is_last_iteration (bool, optional): Whether we reached the last iteration or not.
+            Defaults to False.
+    """
+    for callback in callback_iterable:
+        callback(opt_res, is_last_iteration)
 
 
 @dataclass
@@ -389,6 +447,13 @@ class FeatureMapConfig:
     assign `t, x = xs[:,0], xs[:,1]`.
     """
 
+    tag: str | None = None
+    """
+    String to indicate the name tag of the feature map.
+
+    Defaults to None, in which case no tag will be applied.
+    """
+
     def __post_init__(self) -> None:
         if self.multivariate_strategy == MultivariateStrategy.PARALLEL and self.num_features > 1:
             assert (
@@ -548,6 +613,13 @@ class AnsatzConfig:
     param_prefix: str = "theta"
     """The base bame of the variational parameter."""
 
+    tag: str | None = None
+    """
+    String to indicate the name tag of the ansatz.
+
+    Defaults to None, in which case no tag will be applied.
+    """
+
     def __post_init__(self) -> None:
         if self.ansatz_type == AnsatzType.IIA:
             assert (

qadence/ml_tools/constructors.py

@@ -7,7 +7,7 @@ from qadence.backend import BackendConfiguration
 from qadence.blocks import chain, kron
 from qadence.blocks.abstract import AbstractBlock
 from qadence.blocks.composite import ChainBlock, KronBlock
-from qadence.blocks.utils import add
+from qadence.blocks.utils import add, tag
 from qadence.circuit import QuantumCircuit
 from qadence.constructors import (
     analog_feature_map,
@@ -774,10 +774,15 @@ def build_qnn_from_configs(
             fm_blocks=fm_blocks,
             ansatz_config=ansatz_config,
         )
+        if isinstance(fm_config.tag, str):
+            tag(full_fm, fm_config.tag)
         inputs = fm_config.inputs
         blocks.append(full_fm)
 
-    blocks.append(create_ansatz(register=register, config=ansatz_config))
+    ansatz = create_ansatz(register=register, config=ansatz_config)
+    if isinstance(ansatz_config.tag, str):
+        tag(ansatz, ansatz_config.tag)
+    blocks.append(ansatz)
 
     circ = QuantumCircuit(register, *blocks)
 

qadence/ml_tools/saveload.py

@@ -72,7 +72,11 @@ def write_checkpoint(
     device = None
     try:
         # We extract the device from the pyqtorch native circuit
-        device = model.device if isinstance(QuantumModel, QNN) else next(model.parameters()).device
+        device = (
+            model.device
+            if isinstance(model, (QNN, QuantumModel))
+            else next(model.parameters()).device
+        )
         device = str(device).split(":")[0]  # in case of using several CUDA devices
     except Exception as e:
         msg = (

qadence/ml_tools/train_grad.py

@@ -14,7 +14,7 @@ from torch.optim import Optimizer
 from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 
-from qadence.ml_tools.config import Callback, TrainConfig
+from qadence.ml_tools.config import Callback, TrainConfig, run_callbacks
 from qadence.ml_tools.data import DictDataLoader, OptimizeResult, data_to_device
 from qadence.ml_tools.optimize_step import optimize_step
 from qadence.ml_tools.printing import (
@@ -194,7 +194,6 @@ def train(
             Callback(
                 lambda opt_res: print_metrics(opt_res.loss, opt_res.metrics, opt_res.iteration - 1),
                 called_every=config.print_every,
-                call_after_opt=True,
             )
         ]
 
@@ -214,21 +213,48 @@ def train(
     ]
 
     # writing metrics
+    # we specify two writers,
+    # to write at evaluation time and before evaluation
     callbacks += [
         Callback(
             lambda opt_res: write_tracker(
                 writer,
                 opt_res.loss,
                 opt_res.metrics,
-                opt_res.iteration,
+                opt_res.iteration - 1,  # loss returned be optimized_step is at -1
                 tracking_tool=config.tracking_tool,
             ),
             called_every=config.write_every,
-            call_before_opt=False,
+            call_end_epoch=True,
+        ),
+        Callback(
+            lambda opt_res: write_tracker(
+                writer,
+                opt_res.loss,
+                opt_res.metrics,
+                opt_res.iteration,  # after_opt we match the right loss function
+                tracking_tool=config.tracking_tool,
+            ),
+            called_every=config.write_every,
+            call_end_epoch=False,
             call_after_opt=True,
-            call_during_eval=True,
-        )
+        ),
     ]
+    if perform_val:
+        callbacks += [
+            Callback(
+                lambda opt_res: write_tracker(
+                    writer,
+                    None,
+                    opt_res.metrics,
+                    opt_res.iteration,
+                    tracking_tool=config.tracking_tool,
+                ),
+                called_every=config.write_every,
+                call_before_opt=True,
+                call_during_eval=True,
+            )
+        ]
 
     # checkpointing
     if config.folder and config.checkpoint_every > 0 and not config.checkpoint_best_only:
@@ -262,10 +288,6 @@ def train(
             )
         ]
 
-    def run_callbacks(callback_iterable: list[Callback], opt_res: OptimizeResult) -> None:
-        for callback in callback_iterable:
-            callback(opt_res)
-
     callbacks_before_opt = [
         callback
         for callback in callbacks
@@ -337,19 +359,24 @@ def train(
                 logger.info("Terminating training gracefully after the current iteration.")
                 break
 
-        # Handling printing the last training loss
+        # For handling printing/writing the last training loss
         # as optimize_step does not give the loss value at the last iteration
         try:
             loss, metrics, *_ = next_loss_iter(dl_iter)
-            if iteration % config.print_every == 0 and config.verbose:
-                print_metrics(loss, metrics, iteration)
+            if isinstance(loss, Tensor):
+                loss = loss.item()
+            if perform_val:
+                # reputting val_loss as already evaluated before
+                metrics["val_loss"] = val_loss
+            print_metrics(loss, metrics, iteration)
 
         except KeyboardInterrupt:
             logger.info("Terminating training gracefully after the current iteration.")
 
     # Final callbacks, by default checkpointing and writing
+    opt_result = OptimizeResult(iteration, model, optimizer, loss, metrics)
     callbacks_after_opt = [callback for callback in callbacks if callback.call_after_opt]
-    run_callbacks(callbacks_after_opt, opt_result)
+    run_callbacks(callbacks_after_opt, opt_result, is_last_iteration=True)
 
     # writing hyperparameters
     if config.hyperparams:

qadence/ml_tools/train_no_grad.py

@@ -12,7 +12,7 @@ from torch.nn import Module
 from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 
-from qadence.ml_tools.config import Callback, TrainConfig
+from qadence.ml_tools.config import Callback, TrainConfig, run_callbacks
 from qadence.ml_tools.data import DictDataLoader, OptimizeResult
 from qadence.ml_tools.parameters import get_parameters, set_parameters
 from qadence.ml_tools.printing import (
@@ -160,10 +160,6 @@ def train(
             )
         ]
 
-    def run_callbacks(callback_iterable: list[Callback], opt_res: OptimizeResult) -> None:
-        for callback in callback_iterable:
-            callback(opt_res)
-
     callbacks_end_opt = [
         callback
         for callback in callbacks
@@ -192,7 +188,7 @@ def train(
 
     # Final callbacks
     callbacks_after_opt = [callback for callback in callbacks if callback.call_after_opt]
-    run_callbacks(callbacks_after_opt, opt_result)
+    run_callbacks(callbacks_after_opt, opt_result, is_last_iteration=True)
 
     # close tracker
     if config.tracking_tool == ExperimentTrackingTool.TENSORBOARD:

{qadence-1.7.6.dist-info → qadence-1.7.8.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.7.6
+Version: 1.7.8
 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>
+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
@@ -22,7 +22,7 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.4.4
+Requires-Dist: pyqtorch==1.4.9
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -57,7 +57,7 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.11.3; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.12.2; extra == 'pulser'
 Requires-Dist: pulser-core==0.19.0; extra == 'pulser'
 Requires-Dist: pulser-simulation==0.19.0; extra == 'pulser'
 Provides-Extra: visualization

{qadence-1.7.6.dist-info → qadence-1.7.8.dist-info}/RECORD

@@ -1,5 +1,5 @@
 qadence/__init__.py,sha256=0SFU1_XZ-3WlSU1rA4W1Y0edxpZLO_sNg-YnpjlD77w,2638
-qadence/backend.py,sha256=TTzWEHEyOg7EH02IBiDkhE-Uwtj0fSLNMvQ48qtAcOk,14401
+qadence/backend.py,sha256=N27CRrmjkgFGhwdTJvdRKn2hKjuTwGM5t0QFzGEgvJA,13351
 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
@@ -32,15 +32,15 @@ qadence/backends/gpsr.py,sha256=3lcOHgt0soCiDXAyZ8DVyS8dMgUypIPwkDADds2boSE,5371
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
 qadence/backends/utils.py,sha256=7gWiV_yJH3yyGFxwt-AQLEMLYkBX8aThvmFUlF0M2R0,8302
 qadence/backends/braket/__init__.py,sha256=eruyDZKMqkh1LE7eJ980vcrLJbia35uUX6krAP78clI,121
-qadence/backends/braket/backend.py,sha256=WX5FG4WsrtdnG0at2DvIY0n_AFm44t4g5OIJ1e8r6fQ,8752
+qadence/backends/braket/backend.py,sha256=HNqs4ASB1wgIaInBNifC83GDsXOfz8s6FIIvP4aY9IM,8481
 qadence/backends/braket/config.py,sha256=7cu22dmYdp48Fu760HPfxBHinaUnGmzx9MkE_EPhVN8,594
 qadence/backends/braket/convert_ops.py,sha256=DVXV7sT9sX_yGOgPKclD9KIGgmbBRuDy_e39i1Z8I1s,3417
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/horqrux/backend.py,sha256=W5sYvX9QP-xD3MMjwX-ZMcpHuncPVqBTyn80jgWViUM,9094
+qadence/backends/horqrux/backend.py,sha256=9BqJP_av_cyLtIw07ri8gwoOXLz3b2yCzm9CmP36ZWw,8821
 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=51lbX-KfK6wFxFW7t0QwsXXwAw06D6z2msvSZzM_vD8,15363
+qadence/backends/pulser/backend.py,sha256=bALJrLH4ZyJ24ehxilRat1LdFL7cwIpF7MSjHTXhPZQ,15621
 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
@@ -49,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=ITJ52hFAK0jfXo2-2QyIZ1Mt0NcxrwjJqVuT7dyR8hg,9178
+qadence/backends/pyqtorch/backend.py,sha256=NG83pZBuL2eevIFxqioiWWBrmCMVNvcvnEAAo-gju3A,8907
 qadence/backends/pyqtorch/config.py,sha256=jK-if0OF6L_inP-oZhWI4-b8wcrOiK8-EVv3NYDOfBM,2056
-qadence/backends/pyqtorch/convert_ops.py,sha256=gOETCypdCzecpvYy-5ROoCIML4HBy1Fq1NiqriD3tGc,14127
+qadence/backends/pyqtorch/convert_ops.py,sha256=PNn9TVXHWMGVyEpa8DqF1eJ4uSNAhZfuP9R_oT_fxOs,14314
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=QFwKPagbTrn3V4c2DHpBd-QL_mVIUXfbvyBLUdD6zw4,12023
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
@@ -100,21 +100,21 @@ qadence/measurements/shadow.py,sha256=lYZWbBCJJh7pFXPV5jSvsyN_0g22ao3jARpKnx1jeJ
 qadence/measurements/tomography.py,sha256=8fzXhYOu_DaMiUoZzLvpP03WhuwlZ3ldkWepLUHjWqM,2665
 qadence/measurements/utils.py,sha256=CJmnSobzdeR4T4FuEpad7d-BSJ9W-wTaU9hRbveB6kY,6534
 qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-bs,159
-qadence/mitigations/analog_zne.py,sha256=g0QkjSdF-N9Dv2N8Oza4sylnjUMid5ea-4NCT9Tcm3Y,7768
+qadence/mitigations/analog_zne.py,sha256=M43TRSlPy8HjM1PQJHZUgVPXTodkVMe5KkOYFWVDa-4,7762
 qadence/mitigations/protocols.py,sha256=Jq9MyLujfTyWmc7XVUGYVRUkJT1MmZw-GgmWpVjmX2Y,1608
 qadence/mitigations/readout.py,sha256=HPfYmdjRlieUdOBMZTghFK4DRWfveM4KkDkEI0bMI0E,6262
-qadence/ml_tools/__init__.py,sha256=VE5ma3QDdtemU7sfkoB4XL2MxAfGmFDJMlMWgWtOyJg,1080
-qadence/ml_tools/config.py,sha256=-9gnxolagg4g6_OwSRop162iG_7oBMYbH1Z5zeAtstY,22374
-qadence/ml_tools/constructors.py,sha256=VM7VdtvQ4-4b6SBzUdDpy6fbdDAeQPrj4t2HnUlvUas,27877
+qadence/ml_tools/__init__.py,sha256=nTXcVpfSnMBWwHjU18ASIbvqfht5TIY9Zt9Wu1DATUg,1118
+qadence/ml_tools/config.py,sha256=b6pFoluE0YxrjDLG-a2ZL8Z0fZKSHoUqpySTB2lkzvg,25316
+qadence/ml_tools/constructors.py,sha256=OOUHF4FkX1VsBB1FqATQQuPQTemMQ5tVYPMTXafSwDI,28067
 qadence/ml_tools/data.py,sha256=ubwtkNvoBf0ZTGQm2M2Lgaim2tBAiAsa9VoTRR_MWks,5175
 qadence/ml_tools/models.py,sha256=SjwAPbSl9zn9YqfmwqHc2lIXCkIpwG_ysz4jieRh7W0,16996
 qadence/ml_tools/optimize_step.py,sha256=L92-kNILrmwz20d_Xd_FIQw6SDGJYIEbFN3tSRz9eno,1835
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/printing.py,sha256=2xMhsn2j0nQdO2klLcLWY33GT_7r-Gi83Fv2M2rGQQE,4789
-qadence/ml_tools/saveload.py,sha256=r_AZstRiCwXfq44HxqammrH6yZGf7iAzp6Y0k6k_88M,5888
+qadence/ml_tools/saveload.py,sha256=B6709ZdqHkg6kCZJmlZhCoWaNJ4ZynJe_W2IoaexLTs,5945
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/train_grad.py,sha256=AaI6OHmElDdWHny1JAN2YzpICP3W2AR_GVCfMAAjtEU,13665
-qadence/ml_tools/train_no_grad.py,sha256=4SiIMVunTXCWLzoDudhs-eozDHOZ3t-Of2JXRJyKT20,7375
+qadence/ml_tools/train_grad.py,sha256=dJuNK8Gq1dLbK23TIeE6ynlYUoj0KQH9iPPDx7ZMNPU,14682
+qadence/ml_tools/train_no_grad.py,sha256=jUjnsxvWMrAa-7NV1bewpAo6mV9grF02gwBHy0SVTws,7249
 qadence/ml_tools/utils.py,sha256=PW8FyoV0mG_DtN1U8njTDV5qxZ0EK4mnFwMAsLBArfk,1410
 qadence/noise/__init__.py,sha256=r0nR8uEZeB1M9pI2UisjWq0bjw50fPFfVGzIMev923g,147
 qadence/noise/protocols.py,sha256=-aZ06JvMnpxCeT5v5lI_RNPOLbb9Ju1Pi1AB6uAXxVE,1653
@@ -133,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.7.6.dist-info/METADATA,sha256=Q0bt-7eH8L7b3QffCuD68-vjWa3F6kXBdZHarDsnC5c,9936
-qadence-1.7.6.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-qadence-1.7.6.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.7.6.dist-info/RECORD,,
+qadence-1.7.8.dist-info/METADATA,sha256=gEPDak8aSQfH-cItfLStkGpyqJnAfRHxxkeSns5_168,9986
+qadence-1.7.8.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+qadence-1.7.8.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.7.8.dist-info/RECORD,,