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

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:
@@ -104,18 +101,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.")
 
@@ -231,9 +228,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 +239,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 +256,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 +279,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()))
@@ -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.
@@ -285,7 +285,9 @@ class Trainer(BaseTrainer):
             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 +296,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.
@@ -336,10 +338,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
@@ -415,16 +415,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 +469,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 +487,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 +508,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 +531,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 +554,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 +581,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 +605,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-1.9.0.dist-info → qadence-1.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.9.0
+Version: 1.9.1
 Summary: Pasqal interface for circuit-based quantum computing SDKs
 Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>
 License: Apache 2.0

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

@@ -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=u9Mxv9WwRlYScLozT1Qltf1tNYLAUgn3oiz2E8bLpx0,26803
 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/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=FVM13j1-mv1Qt-v2QgkRFSB_uQ1bmezr5v6UKfeh3as,15264
 qadence/ml_tools/loss/__init__.py,sha256=d_0FlisdmgLY0qL1PeaabbcWX1B42RBdm7220cfzSN4,247
 qadence/ml_tools/loss/loss.py,sha256=Bditg8nelMEpG4Yt0aopcAQz84xIc6O-AGUO2M0nqbM,2982
 qadence/ml_tools/train_utils/__init__.py,sha256=1A2FlFg7kn68R1fdRC73S8DzA9gkBW7whdNHjzH5UTA,235
-qadence/ml_tools/train_utils/base_trainer.py,sha256=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.1.dist-info/METADATA,sha256=LR5dgYAA874bZyIRlUpSxHmjPY3Ww-Yos7p_LLZtNT0,9842
+qadence-1.9.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+qadence-1.9.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.9.1.dist-info/RECORD,,