qadence 1.7.6__tar.gz → 1.7.8__tar.gz

{qadence-1.7.6 → qadence-1.7.8}/PKG-INFO

@@ -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 → qadence-1.7.8}/pyproject.toml

@@ -22,10 +22,11 @@ authors = [
     { name = "Ignacio Fernández Graña", email = "ignacio.fernandez-grana@pasqal.com" },
     { name = "Charles Moussa", email = "charles.moussa@pasqal.com" },
     { name = "Giorgio Tosti Balducci", email = "giorgio.tosti-balducci@pasqal.com" },
+    { name = "Daniele Cucurachi", email = "daniele.cucurachi@pasqal.com" },
 ]
 requires-python = ">=3.9"
 license = { text = "Apache 2.0" }
-version = "1.7.6"
+version = "1.7.8"
 classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -49,7 +50,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.4.4",
+    "pyqtorch==1.4.9",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -63,7 +64,7 @@ allow-ambiguous-features = true
 pulser = [
     "pulser-core==0.19.0",
     "pulser-simulation==0.19.0",
-    "pasqal-cloud==0.11.3",
+    "pasqal-cloud==0.12.2",
 ]
 braket = ["amazon-braket-sdk<1.71.2"]
 visualization = [

{qadence-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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-1.7.6 → qadence-1.7.8}/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: