qadence 1.9.0__py3-none-any.whl → 1.9.2__py3-none-any.whl

qadence/analog/device.py

@@ -5,6 +5,8 @@ from dataclasses import dataclass, fields
 from qadence.analog import AddressingPattern
 from qadence.types import PI, DeviceType, Interaction
 
+from .constants import C6_DICT
+
 
 @dataclass(frozen=True, eq=True)
 class RydbergDevice:
@@ -41,6 +43,11 @@ class RydbergDevice:
     type: DeviceType = DeviceType.IDEALIZED
     """DeviceType.IDEALIZED or REALISTIC to convert to the Pulser backend."""
 
+    @property
+    def coeff_ising(self) -> float:
+        """Value of C_6."""
+        return C6_DICT[self.rydberg_level]
+
     def __post_init__(self) -> None:
         # FIXME: Currently not supporting custom interaction functions.
         if self.interaction not in [Interaction.NN, Interaction.XY]:

qadence/backends/pulser/backend.py

@@ -259,7 +259,7 @@ class Backend(BackendInterface):
             for i, param_values_el in enumerate(vals):
                 sequence = self.assign_parameters(circuit, param_values_el)
                 sim_result: CoherentResults = simulate_sequence(sequence, self.config, state)
-                final_state = sim_result.get_final_state().data.toarray()
+                final_state = sim_result.get_final_state().data.to_array()
                 batched_dm[i] = np.flip(final_state)
             return torch.from_numpy(batched_dm)
 

qadence/backends/pyqtorch/convert_ops.py

@@ -264,7 +264,7 @@ def convert_block(
                 duration=duration,
                 solver=config.ode_solver,
                 steps=config.n_steps_hevo,
-                noise_operators=noise_operators,
+                noise=noise_operators if len(noise_operators) > 0 else None,
             )
         ]
 
@@ -351,22 +351,22 @@ def convert_block(
         )
 
 
-def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.NoiseProtocol | None:
+def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.DigitalNoiseProtocol | None:
     """Convert the digital noise into pyqtorch NoiseProtocol.
 
     Args:
         noise (NoiseHandler): Noise to convert.
 
     Returns:
-        pyq.noise.NoiseProtocol | None: Pyqtorch native noise protocol
+        pyq.noise.DigitalNoiseProtocol | None: Pyqtorch native noise protocol
             if there are any digital noise protocols.
     """
     digital_part = noise.filter(NoiseProtocol.DIGITAL)
     if digital_part is None:
         return None
-    return pyq.noise.NoiseProtocol(
+    return pyq.noise.DigitalNoiseProtocol(
         [
-            pyq.noise.NoiseProtocol(proto, option.get("error_probability"))
+            pyq.noise.DigitalNoiseProtocol(proto, option.get("error_probability"))
             for proto, option in zip(digital_part.protocol, digital_part.options)
         ]
     )

qadence/backends/utils.py

@@ -110,9 +110,23 @@ def to_list_of_dicts(param_values: ParamDictType) -> list[ParamDictType]:
 
 
 def pyqify(state: Tensor, n_qubits: int = None) -> ArrayLike:
-    """Convert a state of shape (batch_size, 2**n_qubits) to [2] * n_qubits + [batch_size]."""
+    """Convert a state of shape (batch_size, 2**n_qubits) to [2] * n_qubits + [batch_size].
+
+    Or set the batch_size of a density matrix as the last dimension for PyQTorch.
+    """
     if n_qubits is None:
         n_qubits = int(log2(state.shape[1]))
+    if isinstance(state, DensityMatrix):
+        if (
+            len(state.shape) != 3
+            or (state.shape[1] != 2**n_qubits)
+            or (state.shape[1] != state.shape[2])
+        ):
+            raise ValueError(
+                "The initial state must be composed of tensors/arrays of size "
+                f"(batch_size, 2**n_qubits, 2**n_qubits). Found: {state.shape = }."
+            )
+        return torch.einsum("kij->ijk", state)
     if len(state.shape) != 2 or (state.shape[1] != 2**n_qubits):
         raise ValueError(
             "The initial state must be composed of tensors/arrays of size "

qadence/engines/torch/differentiable_expectation.py

@@ -49,7 +49,9 @@ class PSRExpectation(Function):
             if isinstance(expectation_values[0], list):
                 exp_vals: list = []
                 for expectation_value in expectation_values:
-                    res = list(map(lambda x: x.get_final_state().data.toarray(), expectation_value))
+                    res = list(
+                        map(lambda x: x.get_final_state().data.to_array(), expectation_value)
+                    )
                     exp_vals.append(torch.tensor(res))
                 expectation_values = exp_vals
             return torch.stack(expectation_values)

qadence/ml_tools/callbacks/__init__.py

@@ -2,9 +2,14 @@ from __future__ import annotations
 
 from .callback import (
     Callback,
+    EarlyStopping,
+    GradientMonitoring,
     LoadCheckpoint,
     LogHyperparameters,
     LogModelTracker,
+    LRSchedulerCosineAnnealing,
+    LRSchedulerCyclic,
+    LRSchedulerStepDecay,
     PlotMetrics,
     PrintMetrics,
     SaveBestCheckpoint,
@@ -26,5 +31,10 @@ __all__ = [
     "SaveBestCheckpoint",
     "SaveCheckpoint",
     "WriteMetrics",
+    "GradientMonitoring",
+    "LRSchedulerStepDecay",
+    "LRSchedulerCyclic",
+    "LRSchedulerCosineAnnealing",
+    "EarlyStopping",
     "get_writer",
 ]

qadence/ml_tools/callbacks/callback.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import math
+from logging import getLogger
 from typing import Any, Callable
 
 from qadence.ml_tools.callbacks.saveload import load_checkpoint, write_checkpoint
@@ -12,6 +14,8 @@ from qadence.ml_tools.stages import TrainingStage
 CallbackFunction = Callable[..., Any]
 CallbackConditionFunction = Callable[..., bool]
 
+logger = getLogger("ml_tools")
+
 
 class Callback:
     """Base class for defining various training callbacks.
@@ -258,7 +262,7 @@ class WriteMetrics(Callback):
             writer (BaseWriter ): The writer object for logging.
         """
         opt_result = trainer.opt_result
-        writer.write(opt_result)
+        writer.write(opt_result.iteration, opt_result.metrics)
 
 
 class PlotMetrics(Callback):
@@ -449,3 +453,323 @@ class LogModelTracker(Callback):
         writer.log_model(
             model, trainer.train_dataloader, trainer.val_dataloader, trainer.test_dataloader
         )
+
+
+class LRSchedulerStepDecay(Callback):
+    """
+    Reduces the learning rate by a factor at regular intervals.
+
+    This callback adjusts the learning rate by multiplying it with a decay factor
+    after a specified number of iterations. The learning rate is updated as:
+        lr = lr * gamma
+
+    Example Usage in `TrainConfig`:
+    To use `LRSchedulerStepDecay`, include it in the `callbacks` list when setting
+    up your `TrainConfig`:
+    ```python exec="on" source="material-block" result="json"
+    from qadence.ml_tools import TrainConfig
+    from qadence.ml_tools.callbacks import LRSchedulerStepDecay
+
+    # Create an instance of the LRSchedulerStepDecay callback
+    lr_step_decay = LRSchedulerStepDecay(on="train_epoch_end",
+                                         called_every=100,
+                                         gamma=0.5)
+
+    config = TrainConfig(
+        max_iter=10000,
+        # Print metrics every 1000 training epochs
+        print_every=1000,
+        # Add the custom callback
+        callbacks=[lr_step_decay]
+    )
+    ```
+    """
+
+    def __init__(self, on: str, called_every: int, gamma: float = 0.5):
+        """Initializes the LRSchedulerStepDecay callback.
+
+        Args:
+            on (str): The event to trigger the callback.
+            called_every (int): Frequency of callback calls in terms of iterations.
+            gamma (float, optional): The decay factor applied to the learning rate.
+                A value < 1 reduces the learning rate over time. Default is 0.5.
+        """
+        super().__init__(on=on, called_every=called_every)
+        self.gamma = gamma
+
+    def run_callback(self, trainer: Any, config: TrainConfig, writer: BaseWriter) -> None:
+        """
+        Runs the callback to apply step decay to the learning rate.
+
+        Args:
+            trainer (Any): The training object.
+            config (TrainConfig): The configuration object.
+            writer (BaseWriter): The writer object for logging.
+        """
+        for param_group in trainer.optimizer.param_groups:
+            param_group["lr"] *= self.gamma
+
+
+class LRSchedulerCyclic(Callback):
+    """
+    Applies a cyclic learning rate schedule during training.
+
+    This callback oscillates the learning rate between a minimum (base_lr)
+    and a maximum (max_lr) over a defined cycle length (step_size). The learning
+    rate follows a triangular wave pattern.
+
+    Example Usage in `TrainConfig`:
+    To use `LRSchedulerCyclic`, include it in the `callbacks` list when setting
+    up your `TrainConfig`:
+    ```python exec="on" source="material-block" result="json"
+    from qadence.ml_tools import TrainConfig
+    from qadence.ml_tools.callbacks import LRSchedulerCyclic
+
+    # Create an instance of the LRSchedulerCyclic callback
+    lr_cyclic = LRSchedulerCyclic(on="train_batch_end",
+                                  called_every=1,
+                                  base_lr=0.001,
+                                  max_lr=0.01,
+                                  step_size=2000)
+
+    config = TrainConfig(
+        max_iter=10000,
+        # Print metrics every 1000 training epochs
+        print_every=1000,
+        # Add the custom callback
+        callbacks=[lr_cyclic]
+    )
+    ```
+    """
+
+    def __init__(self, on: str, called_every: int, base_lr: float, max_lr: float, step_size: int):
+        """Initializes the LRSchedulerCyclic callback.
+
+        Args:
+            on (str): The event to trigger the callback.
+            called_every (int): Frequency of callback calls in terms of iterations.
+            base_lr (float): The minimum learning rate.
+            max_lr (float): The maximum learning rate.
+            step_size (int): Number of iterations for half a cycle.
+        """
+        super().__init__(on=on, called_every=called_every)
+        self.base_lr = base_lr
+        self.max_lr = max_lr
+        self.step_size = step_size
+
+    def run_callback(self, trainer: Any, config: TrainConfig, writer: BaseWriter) -> None:
+        """
+        Adjusts the learning rate cyclically.
+
+        Args:
+            trainer (Any): The training object.
+            config (TrainConfig): The configuration object.
+            writer (BaseWriter): The writer object for logging.
+        """
+        cycle = trainer.opt_result.iteration // (2 * self.step_size)
+        x = abs(trainer.opt_result.iteration / self.step_size - 2 * cycle - 1)
+        scale = max(0, (1 - x))
+        new_lr = self.base_lr + (self.max_lr - self.base_lr) * scale
+        for param_group in trainer.optimizer.param_groups:
+            param_group["lr"] = new_lr
+
+
+class LRSchedulerCosineAnnealing(Callback):
+    """
+    Applies cosine annealing to the learning rate during training.
+
+    This callback decreases the learning rate following a cosine curve,
+    starting from the initial learning rate and annealing to a minimum (min_lr).
+
+    Example Usage in `TrainConfig`:
+    To use `LRSchedulerCosineAnnealing`, include it in the `callbacks` list
+    when setting up your `TrainConfig`:
+    ```python exec="on" source="material-block" result="json"
+    from qadence.ml_tools import TrainConfig
+    from qadence.ml_tools.callbacks import LRSchedulerCosineAnnealing
+
+    # Create an instance of the LRSchedulerCosineAnnealing callback
+    lr_cosine = LRSchedulerCosineAnnealing(on="train_batch_end",
+                                           called_every=1,
+                                           t_max=5000,
+                                           min_lr=1e-6)
+
+    config = TrainConfig(
+        max_iter=10000,
+        # Print metrics every 1000 training epochs
+        print_every=1000,
+        # Add the custom callback
+        callbacks=[lr_cosine]
+    )
+    ```
+    """
+
+    def __init__(self, on: str, called_every: int, t_max: int, min_lr: float = 0.0):
+        """Initializes the LRSchedulerCosineAnnealing callback.
+
+        Args:
+            on (str): The event to trigger the callback.
+            called_every (int): Frequency of callback calls in terms of iterations.
+            t_max (int): The total number of iterations for one annealing cycle.
+            min_lr (float, optional): The minimum learning rate. Default is 0.0.
+        """
+        super().__init__(on=on, called_every=called_every)
+        self.t_max = t_max
+        self.min_lr = min_lr
+
+    def run_callback(self, trainer: Any, config: TrainConfig, writer: BaseWriter) -> None:
+        """
+        Adjusts the learning rate using cosine annealing.
+
+        Args:
+            trainer (Any): The training object.
+            config (TrainConfig): The configuration object.
+            writer (BaseWriter): The writer object for logging.
+        """
+        for param_group in trainer.optimizer.param_groups:
+            max_lr = param_group["lr"]
+            new_lr = (
+                self.min_lr
+                + (max_lr - self.min_lr)
+                * (1 + math.cos(math.pi * trainer.opt_result.iteration / self.t_max))
+                / 2
+            )
+            param_group["lr"] = new_lr
+
+
+class EarlyStopping(Callback):
+    """
+    Stops training when a monitored metric has not improved for a specified number of epochs.
+
+    This callback monitors a specified metric (e.g., validation loss or accuracy). If the metric
+    does not improve for a given patience period, training is stopped.
+
+    Example Usage in `TrainConfig`:
+    To use `EarlyStopping`, include it in the `callbacks` list when setting up your `TrainConfig`:
+    ```python exec="on" source="material-block" result="json"
+    from qadence.ml_tools import TrainConfig
+    from qadence.ml_tools.callbacks import EarlyStopping
+
+    # Create an instance of the EarlyStopping callback
+    early_stopping = EarlyStopping(on="val_epoch_end",
+                                   called_every=1,
+                                   monitor="val_loss",
+                                   patience=5,
+                                   mode="min")
+
+    config = TrainConfig(
+        max_iter=10000,
+        print_every=1000,
+        callbacks=[early_stopping]
+    )
+    ```
+    """
+
+    def __init__(
+        self, on: str, called_every: int, monitor: str, patience: int = 5, mode: str = "min"
+    ):
+        """Initializes the EarlyStopping callback.
+
+        Args:
+            on (str): The event to trigger the callback (e.g., "val_epoch_end").
+            called_every (int): Frequency of callback calls in terms of iterations.
+            monitor (str): The metric to monitor (e.g., "val_loss" or "train_loss").
+                All metrics returned by optimize step are available to monitor.
+                Please add "val_" and "train_" strings at the start of the metric name.
+            patience (int, optional): Number of iterations to wait for improvement. Default is 5.
+            mode (str, optional): Whether to minimize ("min") or maximize ("max") the metric.
+                Default is "min".
+        """
+        super().__init__(on=on, called_every=called_every)
+        self.monitor = monitor
+        self.patience = patience
+        self.mode = mode
+        self.best_value = float("inf") if mode == "min" else -float("inf")
+        self.counter = 0
+
+    def run_callback(self, trainer: Any, config: TrainConfig, writer: BaseWriter) -> None:
+        """
+        Monitors the metric and stops training if no improvement is observed.
+
+        Args:
+            trainer (Any): The training object.
+            config (TrainConfig): The configuration object.
+            writer (BaseWriter): The writer object for logging.
+        """
+        current_value = trainer.opt_result.metrics.get(self.monitor)
+        if current_value is None:
+            raise ValueError(f"Metric '{self.monitor}' is not available in the trainer's metrics.")
+
+        if (self.mode == "min" and current_value < self.best_value) or (
+            self.mode == "max" and current_value > self.best_value
+        ):
+            self.best_value = current_value
+            self.counter = 0
+        else:
+            self.counter += 1
+
+        if self.counter >= self.patience:
+            logger.info(
+                f"EarlyStopping: No improvement in '{self.monitor}' for {self.patience} epochs. "
+                "Stopping training."
+            )
+            trainer.stop_training = True
+
+
+class GradientMonitoring(Callback):
+    """
+    Logs gradient statistics (e.g., mean, standard deviation, max) during training.
+
+    This callback monitors and logs statistics about the gradients of the model parameters
+    to help debug or optimize the training process.
+
+    Example Usage in `TrainConfig`:
+    To use `GradientMonitoring`, include it in the `callbacks` list when
+    setting up your `TrainConfig`:
+    ```python exec="on" source="material-block" result="json"
+    from qadence.ml_tools import TrainConfig
+    from qadence.ml_tools.callbacks import GradientMonitoring
+
+    # Create an instance of the GradientMonitoring callback
+    gradient_monitoring = GradientMonitoring(on="train_batch_end", called_every=10)
+
+    config = TrainConfig(
+        max_iter=10000,
+        print_every=1000,
+        callbacks=[gradient_monitoring]
+    )
+    ```
+    """
+
+    def __init__(self, on: str, called_every: int = 1):
+        """Initializes the GradientMonitoring callback.
+
+        Args:
+            on (str): The event to trigger the callback (e.g., "train_batch_end").
+            called_every (int): Frequency of callback calls in terms of iterations.
+        """
+        super().__init__(on=on, called_every=called_every)
+
+    def run_callback(self, trainer: Any, config: TrainConfig, writer: BaseWriter) -> None:
+        """
+        Logs gradient statistics.
+
+        Args:
+            trainer (Any): The training object.
+            config (TrainConfig): The configuration object.
+            writer (BaseWriter): The writer object for logging.
+        """
+        gradient_stats = {}
+        for name, param in trainer.model.named_parameters():
+            if param.grad is not None:
+                grad = param.grad
+                gradient_stats.update(
+                    {
+                        name + "_mean": grad.mean().item(),
+                        name + "_std": grad.std().item(),
+                        name + "_max": grad.max().item(),
+                        name + "_min": grad.min().item(),
+                    }
+                )
+
+        writer.write(trainer.opt_result.iteration, gradient_stats)

qadence/ml_tools/callbacks/writer_registry.py

@@ -7,17 +7,14 @@ from types import ModuleType
 from typing import Any, Callable, Union
 from uuid import uuid4
 
-import mlflow
 from matplotlib.figure import Figure
-from mlflow.entities import Run
-from mlflow.models import infer_signature
 from torch import Tensor
 from torch.nn import Module
 from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 
 from qadence.ml_tools.config import TrainConfig
-from qadence.ml_tools.data import OptimizeResult
+from qadence.ml_tools.data import DictDataLoader, OptimizeResult
 from qadence.types import ExperimentTrackingTool
 
 logger = getLogger("ml_tools")
@@ -43,7 +40,7 @@ class BaseWriter(ABC):
         log_model(model, dataloader): Logs the model and any relevant information.
     """
 
-    run: Run  # [attr-defined]
+    run: Any  # [attr-defined]
 
     @abstractmethod
     def open(self, config: TrainConfig, iteration: int | None = None) -> Any:
@@ -63,12 +60,14 @@ class BaseWriter(ABC):
         raise NotImplementedError("Writers must implement a close method.")
 
     @abstractmethod
-    def write(self, result: OptimizeResult) -> None:
+    def write(self, iteration: int, metrics: dict) -> None:
         """
         Logs the results of the current iteration.
 
         Args:
-            result (OptimizeResult): The optimization results to log.
+            iteration (int): The current training iteration.
+            metrics (dict): A dictionary of metrics to log, where keys are metric names
+                            and values are the corresponding metric values.
         """
         raise NotImplementedError("Writers must implement a write method.")
 
@@ -104,18 +103,18 @@ class BaseWriter(ABC):
     def log_model(
         self,
         model: Module,
-        train_dataloader: DataLoader | None = None,
-        val_dataloader: DataLoader | None = None,
-        test_dataloader: DataLoader | None = None,
+        train_dataloader: DataLoader | DictDataLoader | None = None,
+        val_dataloader: DataLoader | DictDataLoader | None = None,
+        test_dataloader: DataLoader | DictDataLoader | None = None,
     ) -> None:
         """
         Logs the model and associated data.
 
         Args:
             model (Module): The model to log.
-            train_dataloader (DataLoader | None): DataLoader for training data.
-            val_dataloader (DataLoader | None): DataLoader for validation data.
-            test_dataloader (DataLoader | None): DataLoader for testing data.
+            train_dataloader (DataLoader | DictDataLoader |  None): DataLoader for training data.
+            val_dataloader (DataLoader | DictDataLoader |  None): DataLoader for validation data.
+            test_dataloader (DataLoader | DictDataLoader |  None): DataLoader for testing data.
         """
         raise NotImplementedError("Writers must implement a log_model method.")
 
@@ -169,23 +168,22 @@ class TensorBoardWriter(BaseWriter):
         if self.writer:
             self.writer.close()
 
-    def write(self, result: OptimizeResult) -> None:
+    def write(self, iteration: int, metrics: dict) -> None:
         """
         Logs the results of the current iteration to TensorBoard.
 
         Args:
-            result (OptimizeResult): The optimization results to log.
+            iteration (int): The current training iteration.
+            metrics (dict): A dictionary of metrics to log, where keys are metric names
+                            and values are the corresponding metric values.
         """
-        # Not writing loss as loss is available in the metrics
-        # if result.loss is not None:
-        #     self.writer.add_scalar("loss", float(result.loss), result.iteration)
         if self.writer:
-            for key, value in result.metrics.items():
-                self.writer.add_scalar(key, value, result.iteration)
+            for key, value in metrics.items():
+                self.writer.add_scalar(key, value, iteration)
         else:
             raise RuntimeError(
                 "The writer is not initialized."
-                "Please call the 'writer.open()' method before writing"
+                "Please call the 'writer.open()' method before writing."
             )
 
     def log_hyperparams(self, hyperparams: dict) -> None:
@@ -231,9 +229,9 @@ class TensorBoardWriter(BaseWriter):
     def log_model(
         self,
         model: Module,
-        train_dataloader: DataLoader | None = None,
-        val_dataloader: DataLoader | None = None,
-        test_dataloader: DataLoader | None = None,
+        train_dataloader: DataLoader | DictDataLoader | None = None,
+        val_dataloader: DataLoader | DictDataLoader | None = None,
+        test_dataloader: DataLoader | DictDataLoader | None = None,
     ) -> None:
         """
         Logs the model.
@@ -242,9 +240,9 @@ class TensorBoardWriter(BaseWriter):
 
         Args:
             model (Module): The model to log.
-            train_dataloader (DataLoader | None): DataLoader for training data.
-            val_dataloader (DataLoader | None): DataLoader for validation data.
-            test_dataloader (DataLoader | None): DataLoader for testing data.
+            train_dataloader (DataLoader | DictDataLoader |  None): DataLoader for training data.
+            val_dataloader (DataLoader | DictDataLoader |  None): DataLoader for validation data.
+            test_dataloader (DataLoader | DictDataLoader |  None): DataLoader for testing data.
         """
         logger.warning("Model logging is not supported by tensorboard. No model will be logged.")
 
@@ -259,6 +257,14 @@ class MLFlowWriter(BaseWriter):
     """
 
     def __init__(self) -> None:
+        try:
+            from mlflow.entities import Run
+        except ImportError:
+            raise ImportError(
+                "mlflow is not installed. Please install qadence with the mlflow feature: "
+                "`pip install qadence[mlflow]`."
+            )
+
         self.run: Run
         self.mlflow: ModuleType
 
@@ -274,6 +280,8 @@ class MLFlowWriter(BaseWriter):
         Returns:
             mlflow: The MLflow module instance.
         """
+        import mlflow
+
         self.mlflow = mlflow
         tracking_uri = os.getenv("MLFLOW_TRACKING_URI", "")
         experiment_name = os.getenv("MLFLOW_EXPERIMENT_NAME", str(uuid4()))
@@ -298,22 +306,21 @@ class MLFlowWriter(BaseWriter):
         if self.run:
             self.mlflow.end_run()
 
-    def write(self, result: OptimizeResult) -> None:
+    def write(self, iteration: int, metrics: dict) -> None:
         """
         Logs the results of the current iteration to MLflow.
 
         Args:
-            result (OptimizeResult): The optimization results to log.
+            iteration (int): The current training iteration.
+            metrics (dict): A dictionary of metrics to log, where keys are metric names
+                            and values are the corresponding metric values.
         """
-        # Not writing loss as loss is available in the metrics
-        # if result.loss is not None:
-        #     self.mlflow.log_metric("loss", float(result.loss), step=result.iteration)
         if self.mlflow:
-            self.mlflow.log_metrics(result.metrics, step=result.iteration)
+            self.mlflow.log_metrics(metrics, step=iteration)
         else:
             raise RuntimeError(
                 "The writer is not initialized."
-                "Please call the 'writer.open()' method before writing"
+                "Please call the 'writer.open()' method before writing."
             )
 
     def log_hyperparams(self, hyperparams: dict) -> None:
@@ -356,17 +363,21 @@ class MLFlowWriter(BaseWriter):
                 "Please call the 'writer.open()' method before writing"
             )
 
-    def get_signature_from_dataloader(self, model: Module, dataloader: DataLoader | None) -> Any:
+    def get_signature_from_dataloader(
+        self, model: Module, dataloader: DataLoader | DictDataLoader | None
+    ) -> Any:
         """
         Infers the signature of the model based on the input data from the dataloader.
 
         Args:
             model (Module): The model to use for inference.
-            dataloader (DataLoader | None): DataLoader for model inputs.
+            dataloader (DataLoader | DictDataLoader |  None): DataLoader for model inputs.
 
         Returns:
             Optional[Any]: The inferred signature, if available.
         """
+        from mlflow.models import infer_signature
+
         if dataloader is None:
             return None
 
@@ -384,18 +395,18 @@ class MLFlowWriter(BaseWriter):
     def log_model(
         self,
         model: Module,
-        train_dataloader: DataLoader | None = None,
-        val_dataloader: DataLoader | None = None,
-        test_dataloader: DataLoader | None = None,
+        train_dataloader: DataLoader | DictDataLoader | None = None,
+        val_dataloader: DataLoader | DictDataLoader | None = None,
+        test_dataloader: DataLoader | DictDataLoader | None = None,
     ) -> None:
         """
         Logs the model and its signature to MLflow using the provided data loaders.
 
         Args:
             model (Module): The model to log.
-            train_dataloader (DataLoader | None): DataLoader for training data.
-            val_dataloader (DataLoader | None): DataLoader for validation data.
-            test_dataloader (DataLoader | None): DataLoader for testing data.
+            train_dataloader (DataLoader | DictDataLoader |  None): DataLoader for training data.
+            val_dataloader (DataLoader | DictDataLoader |  None): DataLoader for validation data.
+            test_dataloader (DataLoader | DictDataLoader |  None): DataLoader for testing data.
         """
         if not self.mlflow:
             raise RuntimeError(

qadence/ml_tools/train_utils/base_trainer.py

@@ -8,11 +8,11 @@ import nevergrad as ng
 import torch
 from nevergrad.optimization.base import Optimizer as NGOptimizer
 from torch import nn, optim
-from torch.utils.data import DataLoader
+from torch.utils.data import DataLoader, TensorDataset
 
 from qadence.ml_tools.callbacks import CallbacksManager
 from qadence.ml_tools.config import TrainConfig
-from qadence.ml_tools.data import InfiniteTensorDataset
+from qadence.ml_tools.data import DictDataLoader
 from qadence.ml_tools.loss import get_loss_fn
 from qadence.ml_tools.optimize_step import optimize_step
 from qadence.ml_tools.parameters import get_parameters
@@ -42,9 +42,9 @@ class BaseTrainer:
         model (nn.Module): The neural network model.
         optimizer (optim.Optimizer | NGOptimizer | None): The optimizer for training.
         config (TrainConfig): The configuration settings for training.
-        train_dataloader (DataLoader | None): DataLoader for training data.
-        val_dataloader (DataLoader | None): DataLoader for validation data.
-        test_dataloader (DataLoader | None): DataLoader for testing data.
+        train_dataloader (Dataloader | DictDataLoader | None): DataLoader for training data.
+        val_dataloader (Dataloader | DictDataLoader | None): DataLoader for validation data.
+        test_dataloader (Dataloader | DictDataLoader | None): DataLoader for testing data.
 
         optimize_step (Callable): Function for performing an optimization step.
         loss_fn (Callable | str ]): loss function to use. Default loss function
@@ -69,9 +69,9 @@ class BaseTrainer:
         config: TrainConfig,
         loss_fn: str | Callable = "mse",
         optimize_step: Callable = optimize_step,
-        train_dataloader: DataLoader | None = None,
-        val_dataloader: DataLoader | None = None,
-        test_dataloader: DataLoader | None = None,
+        train_dataloader: DataLoader | DictDataLoader | None = None,
+        val_dataloader: DataLoader | DictDataLoader | None = None,
+        test_dataloader: DataLoader | DictDataLoader | None = None,
         max_batches: int | None = None,
     ):
         """
@@ -86,11 +86,11 @@ class BaseTrainer:
                 str input to be specified to use a default loss function.
                 currently supported loss functions: 'mse', 'cross_entropy'.
                 If not specified, default mse loss will be used.
-            train_dataloader (DataLoader | None): DataLoader for training data.
+            train_dataloader (Dataloader | DictDataLoader | None): DataLoader for training data.
                 If the model does not need data to evaluate loss, no dataset
                 should be provided.
-            val_dataloader (DataLoader | None): DataLoader for validation data.
-            test_dataloader (DataLoader | None): DataLoader for testing data.
+            val_dataloader (Dataloader | DictDataLoader | None): DataLoader for validation data.
+            test_dataloader (Dataloader | DictDataLoader | None): DataLoader for testing data.
             max_batches (int | None): Maximum number of batches to process per epoch.
                 This is only valid in case of finite TensorDataset dataloaders.
                 if max_batches is not None, the maximum number of batches used will
@@ -100,9 +100,9 @@ class BaseTrainer:
         self._model: nn.Module
         self._optimizer: optim.Optimizer | NGOptimizer | None
         self._config: TrainConfig
-        self._train_dataloader: DataLoader | None = None
-        self._val_dataloader: DataLoader | None = None
-        self._test_dataloader: DataLoader | None = None
+        self._train_dataloader: DataLoader | DictDataLoader | None = None
+        self._val_dataloader: DataLoader | DictDataLoader | None = None
+        self._test_dataloader: DataLoader | DictDataLoader | None = None
 
         self.config = config
         self.model = model
@@ -311,7 +311,7 @@ class BaseTrainer:
         self.callback_manager = CallbacksManager(value)
         self.config_manager = ConfigManager(value)
 
-    def _compute_num_batches(self, dataloader: DataLoader) -> int:
+    def _compute_num_batches(self, dataloader: DataLoader | DictDataLoader) -> int:
         """
         Computes the number of batches for the given DataLoader.
 
@@ -321,34 +321,41 @@ class BaseTrainer:
         """
         if dataloader is None:
             return 1
-        dataset = dataloader.dataset
-        if isinstance(dataset, InfiniteTensorDataset):
-            return 1
+        if isinstance(dataloader, DictDataLoader):
+            dataloader_name, dataloader_value = list(dataloader.dataloaders.items())[0]
+            dataset = dataloader_value.dataset
+            batch_size = dataloader_value.batch_size
         else:
-            n_batches = int(
-                (dataset.tensors[0].size(0) + dataloader.batch_size - 1) // dataloader.batch_size
-            )
+            dataset = dataloader.dataset
+            batch_size = dataloader.batch_size
+
+        if isinstance(dataset, TensorDataset):
+            n_batches = int((dataset.tensors[0].size(0) + batch_size - 1) // batch_size)
             return min(self.max_batches, n_batches) if self.max_batches is not None else n_batches
+        else:
+            return 1
 
-    def _validate_dataloader(self, dataloader: DataLoader, dataloader_type: str) -> None:
+    def _validate_dataloader(
+        self, dataloader: DataLoader | DictDataLoader, dataloader_type: str
+    ) -> None:
         """
         Validates the type of the DataLoader and raises errors for unsupported types.
 
         Args:
-            dataloader (DataLoader): The DataLoader to validate.
+            dataloader (DataLoader | DictDataLoader): The DataLoader to validate.
             dataloader_type (str): The type of DataLoader ("train", "val", or "test").
         """
         if dataloader is not None:
-            if not isinstance(dataloader, DataLoader):
+            if not isinstance(dataloader, (DataLoader, DictDataLoader)):
                 raise NotImplementedError(
                     f"Unsupported dataloader type: {type(dataloader)}."
                     "The dataloader must be an instance of DataLoader."
                 )
         if dataloader_type == "val" and self.config.val_every > 0:
-            if not isinstance(dataloader, DataLoader):
+            if not isinstance(dataloader, (DataLoader, DictDataLoader)):
                 raise ValueError(
                     "If `config.val_every` is provided as an integer > 0, validation_dataloader"
-                    "must be an instance of `DataLoader`."
+                    "must be an instance of `DataLoader` or `DictDataLoader`."
                 )
 
     @staticmethod

qadence/ml_tools/trainer.py

@@ -14,7 +14,7 @@ from torch import dtype as torch_dtype
 from torch.utils.data import DataLoader
 
 from qadence.ml_tools.config import TrainConfig
-from qadence.ml_tools.data import OptimizeResult
+from qadence.ml_tools.data import DictDataLoader, OptimizeResult
 from qadence.ml_tools.optimize_step import optimize_step, update_ng_parameters
 from qadence.ml_tools.stages import TrainingStage
 
@@ -49,9 +49,9 @@ class Trainer(BaseTrainer):
         model (nn.Module): The neural network model.
         optimizer (optim.Optimizer | NGOptimizer | None): The optimizer for training.
         config (TrainConfig): The configuration settings for training.
-        train_dataloader (DataLoader | None): DataLoader for training data.
-        val_dataloader (DataLoader | None): DataLoader for validation data.
-        test_dataloader (DataLoader | None): DataLoader for testing data.
+        train_dataloader (DataLoader | DictDataLoader |  None): DataLoader for training data.
+        val_dataloader (DataLoader | DictDataLoader |  None): DataLoader for validation data.
+        test_dataloader (DataLoader | DictDataLoader |  None): DataLoader for testing data.
 
         optimize_step (Callable): Function for performing an optimization step.
         loss_fn (Callable): loss function to use.
@@ -235,9 +235,9 @@ class Trainer(BaseTrainer):
         optimizer: optim.Optimizer | NGOptimizer | None,
         config: TrainConfig,
         loss_fn: str | Callable = "mse",
-        train_dataloader: DataLoader | None = None,
-        val_dataloader: DataLoader | None = None,
-        test_dataloader: DataLoader | None = None,
+        train_dataloader: DataLoader | DictDataLoader | None = None,
+        val_dataloader: DataLoader | DictDataLoader | None = None,
+        test_dataloader: DataLoader | DictDataLoader | None = None,
         optimize_step: Callable = optimize_step,
         device: torch_device | None = None,
         dtype: torch_dtype | None = None,
@@ -252,9 +252,9 @@ class Trainer(BaseTrainer):
             config (TrainConfig): Training configuration object.
             loss_fn (str | Callable ): Loss function used for training.
                 If not specified, default mse loss will be used.
-            train_dataloader (DataLoader | None): DataLoader for training data.
-            val_dataloader (DataLoader | None): DataLoader for validation data.
-            test_dataloader (DataLoader | None): DataLoader for test data.
+            train_dataloader (DataLoader | DictDataLoader |  None): DataLoader for training data.
+            val_dataloader (DataLoader | DictDataLoader |  None): DataLoader for validation data.
+            test_dataloader (DataLoader | DictDataLoader |  None): DataLoader for test data.
             optimize_step (Callable): Function to execute an optimization step.
             device (torch_device): Device to use for computation.
             dtype (torch_dtype): Data type for computation.
@@ -281,11 +281,14 @@ class Trainer(BaseTrainer):
         self.device: torch_device | None = device
         self.dtype: torch_dtype | None = dtype
         self.data_dtype: torch_dtype | None = None
+        self.stop_training: bool = False
         if self.dtype:
             self.data_dtype = float64 if (self.dtype == complex128) else float32
 
     def fit(
-        self, train_dataloader: DataLoader | None = None, val_dataloader: DataLoader | None = None
+        self,
+        train_dataloader: DataLoader | DictDataLoader | None = None,
+        val_dataloader: DataLoader | DictDataLoader | None = None,
     ) -> tuple[nn.Module, optim.Optimizer]:
         """
         Fits the model using the specified training configuration.
@@ -294,8 +297,8 @@ class Trainer(BaseTrainer):
         provided in the trainer will be used.
 
         Args:
-            train_dataloader (DataLoader | None): DataLoader for training data.
-            val_dataloader (DataLoader | None): DataLoader for validation data.
+            train_dataloader (DataLoader | DictDataLoader |  None): DataLoader for training data.
+            val_dataloader (DataLoader | DictDataLoader |  None): DataLoader for validation data.
 
         Returns:
             tuple[nn.Module, optim.Optimizer]: The trained model and optimizer.
@@ -319,6 +322,7 @@ class Trainer(BaseTrainer):
         The callback_manager.start_training takes care of loading checkpoint,
         and setting up the writer.
         """
+        self.stop_training = False
         self.config_manager.initialize_config()
         self.callback_manager.start_training(trainer=self)
 
@@ -336,10 +340,8 @@ class Trainer(BaseTrainer):
             TimeRemainingColumn(elapsed_when_finished=True),
         )
 
-        # Quick Fix for build_optimize_step
-        # Please review run_train_batch for more details
-        self.model_old = copy.deepcopy(self.model)
-        self.optimizer_old = copy.deepcopy(self.optimizer)
+        # Quick Fix for iteration 0
+        self._reset_model_and_opt()
 
         # Run validation at the start if specified in the configuration
         self.perform_val = self.config.val_every > 0
@@ -377,25 +379,26 @@ class Trainer(BaseTrainer):
             for epoch in range(
                 self.global_step, self.global_step + self.config_manager.config.max_iter + 1
             ):
-                try:
-                    self.current_epoch = epoch
-                    self.on_train_epoch_start()
-                    train_epoch_loss_metrics = self.run_training(self.train_dataloader)
-                    train_losses.append(train_epoch_loss_metrics)
-                    self.on_train_epoch_end(train_epoch_loss_metrics)
-
-                    # Run validation periodically if specified
-                    if self.perform_val and self.current_epoch % self.config.val_every == 0:
-                        self.on_val_epoch_start()
-                        val_epoch_loss_metrics = self.run_validation(self.val_dataloader)
-                        val_losses.append(val_epoch_loss_metrics)
-                        self.on_val_epoch_end(val_epoch_loss_metrics)
-                        self.progress.update(val_task, advance=1)
-
-                    self.progress.update(train_task, advance=1)
-                except KeyboardInterrupt:
-                    logger.info("Terminating training gracefully after the current iteration.")
-                    break
+                if not self.stop_training:
+                    try:
+                        self.current_epoch = epoch
+                        self.on_train_epoch_start()
+                        train_epoch_loss_metrics = self.run_training(self.train_dataloader)
+                        train_losses.append(train_epoch_loss_metrics)
+                        self.on_train_epoch_end(train_epoch_loss_metrics)
+
+                        # Run validation periodically if specified
+                        if self.perform_val and self.current_epoch % self.config.val_every == 0:
+                            self.on_val_epoch_start()
+                            val_epoch_loss_metrics = self.run_validation(self.val_dataloader)
+                            val_losses.append(val_epoch_loss_metrics)
+                            self.on_val_epoch_end(val_epoch_loss_metrics)
+                            self.progress.update(val_task, advance=1)
+
+                        self.progress.update(train_task, advance=1)
+                    except KeyboardInterrupt:
+                        logger.info("Terminating training gracefully after the current iteration.")
+                        break
 
         self.on_train_end(train_losses, val_losses)
         return train_losses
@@ -415,16 +418,10 @@ class Trainer(BaseTrainer):
         """
         self.model.train()
         train_epoch_loss_metrics = []
-        # Deep copy model and optimizer to maintain checkpoints
-        # We do this because optimize step provides loss, metrics
-        # before step of optimization
-        # To align them with model/optimizer correctly, we checkpoint
-        # the older copy of the model.
-        # TODO: review optimize_step to provide iteration aligned model and loss.
-        self.model_old = copy.deepcopy(self.model)
-        self.optimizer_old = copy.deepcopy(self.optimizer)
+        # Quick Fix for iteration 0
+        self._reset_model_and_opt()
 
-        for batch in self.batch_iter(dataloader, self.num_training_batches):
+        for batch in self._batch_iter(dataloader, self.num_training_batches):
             self.on_train_batch_start(batch)
             train_batch_loss_metrics = self.run_train_batch(batch)
             train_epoch_loss_metrics.append(train_batch_loss_metrics)
@@ -475,7 +472,7 @@ class Trainer(BaseTrainer):
             self.ng_params = ng_params
             loss_metrics = loss, metrics
 
-        return self.modify_batch_end_loss_metrics(loss_metrics)
+        return self._modify_batch_end_loss_metrics(loss_metrics)
 
     @BaseTrainer.callback("val_epoch")
     def run_validation(self, dataloader: DataLoader) -> list[tuple[torch.Tensor, dict[str, Any]]]:
@@ -493,7 +490,7 @@ class Trainer(BaseTrainer):
         self.model.eval()
         val_epoch_loss_metrics = []
 
-        for batch in self.batch_iter(dataloader, self.num_validation_batches):
+        for batch in self._batch_iter(dataloader, self.num_validation_batches):
             self.on_val_batch_start(batch)
             val_batch_loss_metrics = self.run_val_batch(batch)
             val_epoch_loss_metrics.append(val_batch_loss_metrics)
@@ -514,7 +511,7 @@ class Trainer(BaseTrainer):
         """
         with torch.no_grad():
             loss_metrics = self.loss_fn(self.model, batch)
-        return self.modify_batch_end_loss_metrics(loss_metrics)
+        return self._modify_batch_end_loss_metrics(loss_metrics)
 
     def test(self, test_dataloader: DataLoader = None) -> list[tuple[torch.Tensor, dict[str, Any]]]:
         """
@@ -537,7 +534,7 @@ class Trainer(BaseTrainer):
         self.model.eval()
         test_loss_metrics = []
 
-        for batch in self.batch_iter(test_dataloader, self.num_training_batches):
+        for batch in self._batch_iter(test_dataloader, self.num_training_batches):
             self.on_test_batch_start(batch)
             loss_metrics = self.run_test_batch(batch)
             test_loss_metrics.append(loss_metrics)
@@ -560,11 +557,11 @@ class Trainer(BaseTrainer):
         """
         with torch.no_grad():
             loss_metrics = self.loss_fn(self.model, batch)
-        return self.modify_batch_end_loss_metrics(loss_metrics)
+        return self._modify_batch_end_loss_metrics(loss_metrics)
 
-    def batch_iter(
+    def _batch_iter(
         self,
-        dataloader: DataLoader,
+        dataloader: DataLoader | DictDataLoader,
         num_batches: int,
     ) -> Iterable[tuple[torch.Tensor, ...] | None]:
         """
@@ -587,7 +584,7 @@ class Trainer(BaseTrainer):
                 # batch = data_to_device(batch, device=self.device, dtype=self.data_dtype)
                 yield batch
 
-    def modify_batch_end_loss_metrics(
+    def _modify_batch_end_loss_metrics(
         self, loss_metrics: tuple[torch.Tensor, dict[str, Any]]
     ) -> tuple[torch.Tensor, dict[str, Any]]:
         """
@@ -611,6 +608,28 @@ class Trainer(BaseTrainer):
                 return loss, updated_metrics
         return loss_metrics
 
+    def _reset_model_and_opt(self) -> None:
+        """
+        Save model_old and optimizer_old for epoch 0.
+
+        This allows us to create a copy of model
+        and optimizer before running the optimization.
+
+        We do this because optimize step provides loss, metrics
+        before step of optimization
+        To align them with model/optimizer correctly, we checkpoint
+        the older copy of the model.
+        """
+
+        # TODO: review optimize_step to provide iteration aligned model and loss.
+        try:
+            # Deep copy model and optimizer to maintain checkpoints
+            self.model_old = copy.deepcopy(self.model)
+            self.optimizer_old = copy.deepcopy(self.optimizer)
+        except Exception:
+            self.model_old = self.model
+            self.optimizer_old = self.optimizer
+
     def build_optimize_result(
         self,
         result: None

qadence/states.py

@@ -6,6 +6,7 @@ from typing import List
 
 import torch
 from numpy.typing import ArrayLike
+from pyqtorch.utils import DensityMatrix
 from torch import Tensor, concat
 from torch.distributions import Categorical, Distribution
 
@@ -37,6 +38,8 @@ __all__ = [
     "is_normalized",
     "rand_bitstring",
     "equivalent_state",
+    "DensityMatrix",
+    "density_mat",
 ]
 
 ATOL_64 = 1e-14  # 64 bit precision
@@ -319,6 +322,24 @@ def random_state(
     return state
 
 
+# DENSITY MATRIX
+
+
+def density_mat(state: Tensor) -> DensityMatrix:
+    """
+    Computes the density matrix from a pure state vector.
+
+    Arguments:
+        state: The pure state vector :math:`|\\psi\\rangle`.
+
+    Returns:
+        Tensor: The density matrix :math:`\\rho = |\psi \\rangle \\langle\\psi|`.
+    """
+    if isinstance(state, DensityMatrix):
+        return state
+    return DensityMatrix(torch.einsum("bi,bj->bij", (state, state.conj())))
+
+
 # BLOCKS
 
 

qadence/types.py

@@ -9,7 +9,7 @@ import numpy as np
 import sympy
 from matplotlib.figure import Figure
 from numpy.typing import ArrayLike
-from pyqtorch.noise import NoiseType as DigitalNoise
+from pyqtorch.noise import DigitalNoiseType as DigitalNoise
 from pyqtorch.noise.readout import WhiteNoise
 from pyqtorch.utils import DropoutMode, SolverType
 from torch import Tensor, pi

{qadence-1.9.0.dist-info → qadence-1.9.2.dist-info}/METADATA

@@ -1,9 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: qadence
-Version: 1.9.0
+Version: 1.9.2
 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
@@ -21,7 +22,7 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.6.0
+Requires-Dist: pyqtorch==1.7.0
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -53,9 +54,9 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-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'
+Requires-Dist: pasqal-cloud==0.12.6; extra == 'pulser'
+Requires-Dist: pulser-core==1.2.0; extra == 'pulser'
+Requires-Dist: pulser-simulation==1.2.0; extra == 'pulser'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown
@@ -80,6 +81,8 @@ programs** with tunable qubit interactions and arbitrary register topologies rea
 [![Documentation](https://github.com/pasqal-io/qadence/actions/workflows/build_docs.yml/badge.svg)](https://pasqal-io.github.io/qadence/latest)
 [![Pypi](https://badge.fury.io/py/qadence.svg)](https://pypi.org/project/qadence/)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+![Coverage](https://img.shields.io/codecov/c/github/pasqal-io/qadence?style=flat-square)
+
 
 ## Feature highlights
 

{qadence-1.9.0.dist-info → qadence-1.9.2.dist-info}/RECORD

@@ -17,26 +17,26 @@ qadence/qubit_support.py,sha256=Nkn1Q01RVViTcggSIom7EFKdWpAuM4TMGwBZ5feCUxA,2120
 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=NR1dnN4tKC3zL1KEzjs2p_IYVth7GctgXVbIJsuiUws,11992
+qadence/states.py,sha256=OMFuPAmPTLfZYwefXMv82P96xp5aBDJpanmCNgkRO-o,15379
+qadence/types.py,sha256=Jhd_qTI8X7R61LcueNfIsODLUFB7WfVHWiJpsQkrixs,11999
 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/device.py,sha256=t7oGjiZhk28IG2C-SVkc0RNSlV1L4SXV-tkLNiSYFNM,2570
 qadence/analog/hamiltonian_terms.py,sha256=9LKidqqEMJTTdXeaxkxP_otTmcv9i4yeJ-JKCLOCK3Y,3421
 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=HW5m6iHLq3hLHdJoU1q1i1laR0hBs7uCniXqrsFoNCI,5616
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
-qadence/backends/utils.py,sha256=SdeAf6BDayc-W9hPI271PKtJ_ROOzRry9Jw72wUGmm4,8565
+qadence/backends/utils.py,sha256=SSiMxZjaFS8e8sB6ZBLXPKuJNQGl93pRMy9hnI4oDrw,9104
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
 qadence/backends/horqrux/backend.py,sha256=KNFFGN9dsgB9QKtNXiP3LyMY9DQ-7W7ScyE6k29fHJY,8842
 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=kNo_AAvOPNevdiMbZnQlEUbWCO-NXcwUtFWQHJ6VR2Q,14845
+qadence/backends/pulser/backend.py,sha256=cI4IgijPpItNdDmLpKkJFas0X02wMiZd_XmVas41gEI,14846
 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
@@ -47,7 +47,7 @@ qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59o
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
 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/backends/pyqtorch/convert_ops.py,sha256=qG26-HmtUDaZO0KDnw2sbT3CRx_poS7eqJ3dn9wpWgc,13457
 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
@@ -86,7 +86,7 @@ qadence/engines/jax/differentiable_backend.py,sha256=FcSrzzjzb0zfXC0-4mUJ6UB-wGO
 qadence/engines/jax/differentiable_expectation.py,sha256=rn_l7IH-S4IvuAcyAIgyEuMZOIqswu5Nsfz0JffXjaE,3694
 qadence/engines/torch/__init__.py,sha256=iZFdD32ot0B0CVyC-f5dVViOBnqoalxa6M9Lj4WQuPE,160
 qadence/engines/torch/differentiable_backend.py,sha256=uQfyGg-25MAc0soK1FyvJ2FJakRuv5_5DOy7OPiZYg8,3567
-qadence/engines/torch/differentiable_expectation.py,sha256=AXb1nLG1WuJXUOH02OhRVKASXst12d1b8Y2eUMmPt5M,10304
+qadence/engines/torch/differentiable_expectation.py,sha256=kc4WTos7d65DDmao6YSrpTM0rCBnpqhGK4xLHm_K4yk,10351
 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
@@ -108,17 +108,17 @@ qadence/ml_tools/optimize_step.py,sha256=wUnxfWy0c9rEKe41-26On1bPFBwmSYBF4WCGn76
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/stages.py,sha256=qW2phMIvQBLM3tn2UoGN-ePiBnZoNq5k844eHVnnn8Y,1407
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/trainer.py,sha256=ic1UWu2lYJFSsg-FG-bcbge3pqDGocsZ2hH4Ln8uuLQ,26222
+qadence/ml_tools/trainer.py,sha256=phKCr3-hmHTsKMoZ89z0U5KTZ_h7kaUX7w4WX7A0YH8,26990
 qadence/ml_tools/utils.py,sha256=PW8FyoV0mG_DtN1U8njTDV5qxZ0EK4mnFwMAsLBArfk,1410
-qadence/ml_tools/callbacks/__init__.py,sha256=XaUKmyQZaqxI0jvKnWCpIBgnX5y4Kczcbn2FRiomFu4,655
-qadence/ml_tools/callbacks/callback.py,sha256=F9tbXBBv3ZKTFbm0fGBZIZtTRO63jLazMk_oeL77dyE,16289
+qadence/ml_tools/callbacks/__init__.py,sha256=pTdfjulDGNKca--9BgrdmMyvJSah_0spp929Th6RzC8,913
+qadence/ml_tools/callbacks/callback.py,sha256=XoqTS1uLOkbh4FtKpDSXbUA5_LzjOAoVMaa2jYcYB3w,28800
 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=Sl7OsBBzRCoOW5kQ1RMdAWS_y4TrIsGUI8XvA8JImJ4,14626
+qadence/ml_tools/callbacks/writer_registry.py,sha256=_lPb4VvDHiiRNh2EaEKxOSslnJgBAImGw5SoVReg-Rs,15351
 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=7XrIV2qEV8qetYSH9Pg-RKqQUxGw8u7Xlz42yeVjh3Y,19864
+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
@@ -137,7 +137,7 @@ qadence/transpile/flatten.py,sha256=EdhSG5WyF56nbnxINNLqrHgY84MRM1YFjT3fR4aph5Q,
 qadence/transpile/invert.py,sha256=KAefHTG2AWr39aengVhXrzCtJPhrZC-ZnL6vYvmbnY0,4867
 qadence/transpile/noise.py,sha256=LDcDJtQGkgUPkL2t69gg6AScTb-p3J3SxCDZbYOu1L8,1668
 qadence/transpile/transpile.py,sha256=6MRRkk1OS279L1fwUQjazA6qlfpbd-T_EJMKT8hAhOU,2721
-qadence-1.9.0.dist-info/METADATA,sha256=HbwOPe7bOi1evqjHaPIN8R7xiR_SRF2r4RqQyatKGPo,9842
-qadence-1.9.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-qadence-1.9.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.9.0.dist-info/RECORD,,
+qadence-1.9.2.dist-info/METADATA,sha256=JzJ9P6KRKQuAp8XeTW65OX5I6l9qc2aPMGGYNZczBpU,9954
+qadence-1.9.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qadence-1.9.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.9.2.dist-info/RECORD,,

{qadence-1.9.0.dist-info → qadence-1.9.2.dist-info}/WHEEL

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