qadence 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

qadence/backend.py

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

qadence/backends/braket/backend.py

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

qadence/backends/gpsr.py

@@ -10,14 +10,30 @@ from qadence.types import PI
 from qadence.utils import _round_complex
 
 
-def general_psr(spectrum: Tensor, shift_prefac: float = 0.5) -> Callable:
+def general_psr(spectrum: Tensor, n_eqs: int | None = None, shift_prefac: float = 0.5) -> Callable:
+    """Define whether single_gap_psr or multi_gap_psr is used.
+
+    Args:
+        spectrum (Tensor): Spectrum of the operation we apply PSR onto.
+        n_eqs (int | None, optional): Number of equations. Defaults to None.
+            If provided, we keep the n_eqs higher spectral gaps.
+        shift_prefac (float, optional): Shift prefactor. Defaults to 0.5.
+
+    Returns:
+        Callable: single_gap_psr or multi_gap_psr function for
+            concerned operation.
+    """
     diffs = _round_complex(spectrum - spectrum.reshape(-1, 1))
     sorted_unique_spectral_gaps = torch.unique(torch.abs(torch.tril(diffs)))
 
     # We have to filter out zeros
     sorted_unique_spectral_gaps = sorted_unique_spectral_gaps[sorted_unique_spectral_gaps > 0]
-    n_eqs = len(sorted_unique_spectral_gaps)
-    sorted_unique_spectral_gaps = torch.tensor(list(sorted_unique_spectral_gaps))
+    n_eqs = (
+        len(sorted_unique_spectral_gaps)
+        if n_eqs is None
+        else min(n_eqs, len(sorted_unique_spectral_gaps))
+    )
+    sorted_unique_spectral_gaps = torch.tensor(list(sorted_unique_spectral_gaps)[:n_eqs])
 
     if n_eqs == 1:
         return single_gap_psr

qadence/backends/horqrux/backend.py

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

qadence/backends/pulser/backend.py

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

qadence/backends/pyqtorch/backend.py

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

qadence/backends/pyqtorch/convert_ops.py

@@ -7,7 +7,6 @@ from typing import Any, Sequence, Tuple
 import pyqtorch as pyq
 import sympy
 import torch
-from pyqtorch.apply import apply_operator
 from pyqtorch.embed import Embedding
 from pyqtorch.matrices import _dagger
 from pyqtorch.time_dependent.sesolve import sesolve
@@ -15,6 +14,7 @@ from pyqtorch.utils import is_diag
 from torch import (
     Tensor,
     cdouble,
+    complex64,
     diag_embed,
     diagonal,
     exp,
@@ -45,7 +45,6 @@ from qadence.blocks import (
 )
 from qadence.blocks.block_to_tensor import (
     _block_to_tensor_embedded,
-    block_to_tensor,
 )
 from qadence.blocks.primitive import ProjectorBlock
 from qadence.blocks.utils import parameters
@@ -78,6 +77,27 @@ def is_single_qubit_chain(block: AbstractBlock) -> bool:
     )
 
 
+def extract_parameter(block: ScaleBlock | ParametricBlock, config: Configuration) -> str | Tensor:
+    """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(
     block: AbstractBlock, n_qubits: int = None, config: Configuration = None
 ) -> Sequence[Module | Tensor | str | sympy.Expr]:
@@ -94,29 +114,37 @@ def convert_block(
 
     if isinstance(block, ScaleBlock):
         scaled_ops = convert_block(block.block, n_qubits, config)
-        scale = (
-            tensor([block.parameters.parameter], dtype=float64)
-            if not block.is_parametric
-            else config.get_param_name(block)[0]
-        )
+        scale = extract_parameter(block, config)
         return [pyq.Scale(pyq.Sequence(scaled_ops), scale)]
 
     elif isinstance(block, TimeEvolutionBlock):
-        # TODO add native pyq hamevo
-        # 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]
-        #     )
-        # ]
-        return [PyQHamiltonianEvolution(qubit_support, n_qubits, block, config)]
+        if getattr(block.generator, "is_time_dependent", False):
+            return [PyQTimeDependentEvolution(qubit_support, n_qubits, block, config)]
+        else:
+            if isinstance(block.generator, sympy.Basic):
+                generator = config.get_param_name(block)[1]
+            elif isinstance(block.generator, Tensor):
+                m = block.generator.to(dtype=cdouble)
+                generator = convert_block(
+                    MatrixBlock(
+                        m,
+                        qubit_support=qubit_support,
+                        check_unitary=False,
+                        check_hermitian=True,
+                    )
+                )[0]
+            else:
+                generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
+            time_param = config.get_param_name(block)[0]
+            return [
+                pyq.HamiltonianEvolution(
+                    qubit_support=qubit_support,
+                    generator=generator,
+                    time=time_param,
+                    cache_length=0,
+                )
+            ]
+
     elif isinstance(block, MatrixBlock):
         return [pyq.primitives.Primitive(block.matrix, block.qubit_support)]
     elif isinstance(block, CompositeBlock):
@@ -142,14 +170,14 @@ def convert_block(
             if isinstance(block, U):
                 op = pyq_cls(qubit_support[0], *config.get_param_name(block))
             else:
-                op = pyq_cls(qubit_support[0], config.get_param_name(block)[0])
+                op = pyq_cls(qubit_support[0], extract_parameter(block, config))
         else:
             op = pyq_cls(qubit_support[0])
         return [op]
     elif isinstance(block, tuple(two_qubit_gateset)):
         pyq_cls = getattr(pyq, block.name)
         if isinstance(block, ParametricBlock):
-            op = pyq_cls(qubit_support[0], qubit_support[1], config.get_param_name(block)[0])
+            op = pyq_cls(qubit_support[0], qubit_support[1], extract_parameter(block, config))
         else:
             op = pyq_cls(qubit_support[0], qubit_support[1])
         return [op]
@@ -157,7 +185,7 @@ def convert_block(
         block_name = block.name[1:] if block.name.startswith("M") else block.name
         pyq_cls = getattr(pyq, block_name)
         if isinstance(block, ParametricBlock):
-            op = pyq_cls(qubit_support[:-1], qubit_support[-1], config.get_param_name(block)[0])
+            op = pyq_cls(qubit_support[:-1], qubit_support[-1], extract_parameter(block, config))
         else:
             if "CSWAP" in block_name:
                 op = pyq_cls(qubit_support[:-2], qubit_support[-2:])
@@ -172,7 +200,7 @@ def convert_block(
         )
 
 
-class PyQHamiltonianEvolution(Module):
+class PyQTimeDependentEvolution(Module):
     def __init__(
         self,
         qubit_support: Tuple[int, ...],
@@ -188,50 +216,17 @@ class PyQHamiltonianEvolution(Module):
         self.hmat: Tensor
         self.config = config
 
-        if isinstance(block.generator, AbstractBlock) and not block.generator.is_parametric:
-            hmat = block_to_tensor(
-                block.generator,
-                qubit_support=self.qubit_support,
-                use_full_support=False,
-            )
-            hmat = hmat.permute(1, 2, 0)
-            self.register_buffer("hmat", hmat)
-            self._hamiltonian = lambda self, values: self.hmat
-
-        elif isinstance(block.generator, Tensor):
-            m = block.generator.to(dtype=cdouble)
-            hmat = block_to_tensor(
-                MatrixBlock(
-                    m,
-                    qubit_support=block.qubit_support,
-                    check_unitary=False,
-                    check_hermitian=True,
-                ),
+        def _hamiltonian(self: PyQTimeDependentEvolution, values: dict[str, Tensor]) -> Tensor:
+            hmat = _block_to_tensor_embedded(
+                block.generator,  # type: ignore[arg-type]
+                values=values,
                 qubit_support=self.qubit_support,
                 use_full_support=False,
+                device=self.device,
             )
-            hmat = hmat.permute(1, 2, 0)
-            self.register_buffer("hmat", hmat)
-            self._hamiltonian = lambda self, values: self.hmat
-
-        elif isinstance(block.generator, sympy.Basic):
-            self._hamiltonian = (
-                lambda self, values: values[self.param_names[1]].squeeze(3).permute(1, 2, 0)
-            )
-            # FIXME Why are we squeezing
-        else:
-
-            def _hamiltonian(self: PyQHamiltonianEvolution, values: dict[str, Tensor]) -> Tensor:
-                hmat = _block_to_tensor_embedded(
-                    block.generator,  # type: ignore[arg-type]
-                    values=values,
-                    qubit_support=self.qubit_support,
-                    use_full_support=False,
-                    device=self.device,
-                )
-                return hmat.permute(1, 2, 0)
+            return hmat.permute(1, 2, 0)
 
-            self._hamiltonian = _hamiltonian
+        self._hamiltonian = _hamiltonian
 
         self._time_evolution = lambda values: values[self.param_names[0]]
         self._device: torch_device = (
@@ -322,59 +317,51 @@ class PyQHamiltonianEvolution(Module):
         values: dict[str, Tensor] | ParameterDict = dict(),
         embedding: Embedding | None = None,
     ) -> Tensor:
-        if getattr(self.block.generator, "is_time_dependent", False):  # type: ignore [union-attr]
-
-            def Ht(t: Tensor | float) -> Tensor:
-                # values dict has to change with new value of t
-                # initial value of a feature parameter inside generator block
-                # has to be inferred here
-                new_vals = dict()
-                for str_expr, val in values.items():
-                    expr = sympy.sympify(str_expr)
-                    t_symb = sympy.Symbol(self._get_time_parameter())
-                    free_symbols = expr.free_symbols
-                    if t_symb in free_symbols:
-                        # create substitution list for time and feature params
-                        subs_list = [(t_symb, t)]
-
-                        if len(free_symbols) > 1:
-                            # get feature param symbols
-                            feat_symbols = free_symbols.difference(set([t_symb]))
-
-                            # get feature param values
-                            feat_vals = values["orig_param_values"]
-
-                            # update substitution list with feature param values
-                            for fs in feat_symbols:
-                                subs_list.append((fs, feat_vals[str(fs)]))
-
-                        # evaluate expression with new time param value
-                        new_vals[str_expr] = torch.tensor(float(expr.subs(subs_list)))
-                    else:
-                        # expression doesn't contain time parameter - copy it as is
-                        new_vals[str_expr] = val
-
-                # get matrix form of generator
-                hmat = _block_to_tensor_embedded(
-                    self.block.generator,  # type: ignore[arg-type]
-                    values=new_vals,
-                    qubit_support=self.qubit_support,
-                    use_full_support=False,
-                    device=self.device,
-                ).squeeze(0)
-
-                return hmat
-
-            tsave = torch.linspace(0, self.block.duration, self.config.n_steps_hevo)  # type: ignore [attr-defined]
-            result = pyqify(
-                sesolve(Ht, unpyqify(state).T[:, 0:1], tsave, self.config.ode_solver).states[-1].T
-            )
-        else:
-            result = apply_operator(
-                state,
-                self.unitary(values),
-                self.qubit_support,
-            )
+        def Ht(t: Tensor | float) -> Tensor:
+            # values dict has to change with new value of t
+            # initial value of a feature parameter inside generator block
+            # has to be inferred here
+            new_vals = dict()
+            for str_expr, val in values.items():
+                expr = sympy.sympify(str_expr)
+                t_symb = sympy.Symbol(self._get_time_parameter())
+                free_symbols = expr.free_symbols
+                if t_symb in free_symbols:
+                    # create substitution list for time and feature params
+                    subs_list = [(t_symb, t)]
+
+                    if len(free_symbols) > 1:
+                        # get feature param symbols
+                        feat_symbols = free_symbols.difference(set([t_symb]))
+
+                        # get feature param values
+                        feat_vals = values["orig_param_values"]
+
+                        # update substitution list with feature param values
+                        for fs in feat_symbols:
+                            subs_list.append((fs, feat_vals[str(fs)]))
+
+                    # evaluate expression with new time param value
+                    new_vals[str_expr] = torch.tensor(float(expr.subs(subs_list)))
+                else:
+                    # expression doesn't contain time parameter - copy it as is
+                    new_vals[str_expr] = val
+
+            # get matrix form of generator
+            hmat = _block_to_tensor_embedded(
+                self.block.generator,  # type: ignore[arg-type]
+                values=new_vals,
+                qubit_support=self.qubit_support,
+                use_full_support=False,
+                device=self.device,
+            ).squeeze(0)
+
+            return hmat
+
+        tsave = torch.linspace(0, self.block.duration, self.config.n_steps_hevo)  # type: ignore [attr-defined]
+        result = pyqify(
+            sesolve(Ht, unpyqify(state).T[:, 0:1], tsave, self.config.ode_solver).states[-1].T
+        )
 
         return result
 
@@ -386,7 +373,7 @@ class PyQHamiltonianEvolution(Module):
     def dtype(self) -> torch_dtype:
         return self._dtype
 
-    def to(self, *args: Any, **kwargs: Any) -> PyQHamiltonianEvolution:
+    def to(self, *args: Any, **kwargs: Any) -> PyQTimeDependentEvolution:
         if hasattr(self, "hmat"):
             self.hmat = self.hmat.to(*args, **kwargs)
             self._device = self.hmat.device

qadence/engines/torch/differentiable_expectation.py

@@ -231,8 +231,15 @@ class DifferentiableExpectation:
             if shift_factor == 1:
                 param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args)
             else:
-                psr_args_factor = {k: v * shift_factor for k, v in psr_args.items()}
-                param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args)
+                psr_args_factor = psr_args.copy()
+                if "shift_prefac" in psr_args_factor:
+                    if psr_args_factor["shift_prefac"] is not None:
+                        psr_args_factor["shift_prefac"] = (
+                            shift_factor * psr_args_factor["shift_prefac"]
+                        )
+                else:
+                    psr_args_factor["shift_prefac"] = shift_factor
+                param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args_factor)
         for obs in observable:
             for param_id, _ in uuid_to_eigen(obs).items():
                 # We need the embedded fixed params of the observable in the param_values dict

qadence/mitigations/analog_zne.py

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

qadence/ml_tools/__init__.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from .config import AnsatzConfig, Callback, FeatureMapConfig, TrainConfig
 from .constructors import create_ansatz, create_fm_blocks, observable_from_config
-from .data import DictDataLoader, InfiniteTensorDataset, to_dataloader
+from .data import DictDataLoader, InfiniteTensorDataset, OptimizeResult, to_dataloader
 from .models import QNN
 from .optimize_step import optimize_step as default_optimize_step
 from .parameters import get_parameters, num_parameters, set_parameters
@@ -23,6 +23,7 @@ __all__ = [
     "observable_from_config",
     "QNN",
     "TrainConfig",
+    "OptimizeResult",
     "Callback",
     "train_with_grad",
     "train_gradient_free",

qadence/ml_tools/config.py

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

qadence/ml_tools/saveload.py

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

qadence/ml_tools/train_grad.py

@@ -14,7 +14,7 @@ from torch.optim import Optimizer
 from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 
-from qadence.ml_tools.config import Callback, TrainConfig
+from qadence.ml_tools.config import Callback, TrainConfig, run_callbacks
 from qadence.ml_tools.data import DictDataLoader, OptimizeResult, data_to_device
 from qadence.ml_tools.optimize_step import optimize_step
 from qadence.ml_tools.printing import (
@@ -194,7 +194,6 @@ def train(
             Callback(
                 lambda opt_res: print_metrics(opt_res.loss, opt_res.metrics, opt_res.iteration - 1),
                 called_every=config.print_every,
-                call_after_opt=True,
             )
         ]
 
@@ -262,10 +261,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
@@ -349,7 +344,7 @@ def train(
 
     # Final callbacks, by default checkpointing and writing
     callbacks_after_opt = [callback for callback in callbacks if callback.call_after_opt]
-    run_callbacks(callbacks_after_opt, opt_result)
+    run_callbacks(callbacks_after_opt, opt_result, is_last_iteration=True)
 
     # writing hyperparameters
     if config.hyperparams:

qadence/ml_tools/train_no_grad.py

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

{qadence-1.7.5.dist-info → qadence-1.7.7.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.7.5
+Version: 1.7.7
 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.3
+Requires-Dist: pyqtorch==1.4.7
 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.11.4; 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.5.dist-info → qadence-1.7.7.dist-info}/RECORD

@@ -1,5 +1,5 @@
 qadence/__init__.py,sha256=0SFU1_XZ-3WlSU1rA4W1Y0edxpZLO_sNg-YnpjlD77w,2638
-qadence/backend.py,sha256=TTzWEHEyOg7EH02IBiDkhE-Uwtj0fSLNMvQ48qtAcOk,14401
+qadence/backend.py,sha256=N27CRrmjkgFGhwdTJvdRKn2hKjuTwGM5t0QFzGEgvJA,13351
 qadence/circuit.py,sha256=3lQdjj_srxgk6f5M3eh3kE-Qdov4FA9TZxZZb0E1_mI,6966
 qadence/decompose.py,sha256=C4LYia_GcC9Rx3QO0ZLWTI9dN63a8WTEAXO0ZVQWuiE,5221
 qadence/divergences.py,sha256=JhpELhWSnuDvQxa9hJp_DE3EQg2Ban-Ta0mHZ_fVrHg,1832
@@ -28,19 +28,19 @@ qadence/analog/hamiltonian_terms.py,sha256=9LKidqqEMJTTdXeaxkxP_otTmcv9i4yeJ-JKC
 qadence/analog/parse_analog.py,sha256=ppvMZtsKXOIkIehCgjbdmG9n232DIycSanyuyVth5Wg,4223
 qadence/backends/__init__.py,sha256=ibm7wmZxuIoMYAQxgAx0MsfLYWOVHNWgLwyS1HjMuuI,215
 qadence/backends/api.py,sha256=NPrvtZQ4klUBabUWJ5hbTUCVoaoW9-sHVbiXxAnTt3A,2643
-qadence/backends/gpsr.py,sha256=dTmXcOKm_kJywl2EPJbUIjkylRh3J7hfWQyhLDLXYZQ,4758
+qadence/backends/gpsr.py,sha256=3lcOHgt0soCiDXAyZ8DVyS8dMgUypIPwkDADds2boSE,5371
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
 qadence/backends/utils.py,sha256=7gWiV_yJH3yyGFxwt-AQLEMLYkBX8aThvmFUlF0M2R0,8302
 qadence/backends/braket/__init__.py,sha256=eruyDZKMqkh1LE7eJ980vcrLJbia35uUX6krAP78clI,121
-qadence/backends/braket/backend.py,sha256=WX5FG4WsrtdnG0at2DvIY0n_AFm44t4g5OIJ1e8r6fQ,8752
+qadence/backends/braket/backend.py,sha256=HNqs4ASB1wgIaInBNifC83GDsXOfz8s6FIIvP4aY9IM,8481
 qadence/backends/braket/config.py,sha256=7cu22dmYdp48Fu760HPfxBHinaUnGmzx9MkE_EPhVN8,594
 qadence/backends/braket/convert_ops.py,sha256=DVXV7sT9sX_yGOgPKclD9KIGgmbBRuDy_e39i1Z8I1s,3417
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/horqrux/backend.py,sha256=W5sYvX9QP-xD3MMjwX-ZMcpHuncPVqBTyn80jgWViUM,9094
+qadence/backends/horqrux/backend.py,sha256=9BqJP_av_cyLtIw07ri8gwoOXLz3b2yCzm9CmP36ZWw,8821
 qadence/backends/horqrux/config.py,sha256=xz7JlUcwW_4JAbvProbSI9hA1SXZRRAN0Hr2bvmLzfg,892
 qadence/backends/horqrux/convert_ops.py,sha256=3uG3yLq5wjfrWzFHDs0HEnd8kER91ZHVX3HCpYjOdjk,8565
 qadence/backends/pulser/__init__.py,sha256=capQ-eHqwtOeLf4mWsI0BIseAHhiLGie5cFD4-iVhUo,116
-qadence/backends/pulser/backend.py,sha256=51lbX-KfK6wFxFW7t0QwsXXwAw06D6z2msvSZzM_vD8,15363
+qadence/backends/pulser/backend.py,sha256=bALJrLH4ZyJ24ehxilRat1LdFL7cwIpF7MSjHTXhPZQ,15621
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
 qadence/backends/pulser/cloud.py,sha256=0uUluvbFV9sOuCPraE-9uiVtC3Q8QaDY1IJMDi8grDM,2057
 qadence/backends/pulser/config.py,sha256=aoHDmtgq5i0Zryxenw_p3uARY0B1w-UaYvfqDmrWHM0,2175
@@ -49,9 +49,9 @@ qadence/backends/pulser/devices.py,sha256=DermLZNfmCB3SqteKVW4uhg4jp6ya1G6ptnXbB
 qadence/backends/pulser/pulses.py,sha256=F4fExIRAhLPMtVg1bhNtDihUYHxu5RExGjovk8-CQIo,11884
 qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59ozwsRCzg,2227
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/pyqtorch/backend.py,sha256=ITJ52hFAK0jfXo2-2QyIZ1Mt0NcxrwjJqVuT7dyR8hg,9178
+qadence/backends/pyqtorch/backend.py,sha256=NG83pZBuL2eevIFxqioiWWBrmCMVNvcvnEAAo-gju3A,8907
 qadence/backends/pyqtorch/config.py,sha256=jK-if0OF6L_inP-oZhWI4-b8wcrOiK8-EVv3NYDOfBM,2056
-qadence/backends/pyqtorch/convert_ops.py,sha256=zDV9lj72K59YsJyky0Q7Je3NweZHrk5IO0uyMggLyKI,15097
+qadence/backends/pyqtorch/convert_ops.py,sha256=PNn9TVXHWMGVyEpa8DqF1eJ4uSNAhZfuP9R_oT_fxOs,14314
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=QFwKPagbTrn3V4c2DHpBd-QL_mVIUXfbvyBLUdD6zw4,12023
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
@@ -90,7 +90,7 @@ qadence/engines/jax/differentiable_backend.py,sha256=W5rDA8wb-ECnFWoLj4dVugF9v1l
 qadence/engines/jax/differentiable_expectation.py,sha256=poI--yV3srG3wndTcg6hk1lV63RYPJEQjypiWGzwqsk,3680
 qadence/engines/torch/__init__.py,sha256=iZFdD32ot0B0CVyC-f5dVViOBnqoalxa6M9Lj4WQuPE,160
 qadence/engines/torch/differentiable_backend.py,sha256=AWthwvKE8pCOih4dZ3tXxQX4W1ps9mBcvo7n4V9V24Y,3553
-qadence/engines/torch/differentiable_expectation.py,sha256=sN21wa5AbdlXTDRNK5FonYbmfXWbLDQ-ESHrn17Ruso,9946
+qadence/engines/torch/differentiable_expectation.py,sha256=iaWpd4Y3e_rGKt-S0TNXqqSFg5z6I_5_ZIJxjQxd7Ow,10290
 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
@@ -100,21 +100,21 @@ qadence/measurements/shadow.py,sha256=lYZWbBCJJh7pFXPV5jSvsyN_0g22ao3jARpKnx1jeJ
 qadence/measurements/tomography.py,sha256=8fzXhYOu_DaMiUoZzLvpP03WhuwlZ3ldkWepLUHjWqM,2665
 qadence/measurements/utils.py,sha256=CJmnSobzdeR4T4FuEpad7d-BSJ9W-wTaU9hRbveB6kY,6534
 qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-bs,159
-qadence/mitigations/analog_zne.py,sha256=g0QkjSdF-N9Dv2N8Oza4sylnjUMid5ea-4NCT9Tcm3Y,7768
+qadence/mitigations/analog_zne.py,sha256=M43TRSlPy8HjM1PQJHZUgVPXTodkVMe5KkOYFWVDa-4,7762
 qadence/mitigations/protocols.py,sha256=Jq9MyLujfTyWmc7XVUGYVRUkJT1MmZw-GgmWpVjmX2Y,1608
 qadence/mitigations/readout.py,sha256=HPfYmdjRlieUdOBMZTghFK4DRWfveM4KkDkEI0bMI0E,6262
-qadence/ml_tools/__init__.py,sha256=VE5ma3QDdtemU7sfkoB4XL2MxAfGmFDJMlMWgWtOyJg,1080
-qadence/ml_tools/config.py,sha256=-9gnxolagg4g6_OwSRop162iG_7oBMYbH1Z5zeAtstY,22374
+qadence/ml_tools/__init__.py,sha256=nTXcVpfSnMBWwHjU18ASIbvqfht5TIY9Zt9Wu1DATUg,1118
+qadence/ml_tools/config.py,sha256=3vXodiN_1t17vO9uZnss3qvMS9saGqTa_tAClDKQMbs,24999
 qadence/ml_tools/constructors.py,sha256=VM7VdtvQ4-4b6SBzUdDpy6fbdDAeQPrj4t2HnUlvUas,27877
 qadence/ml_tools/data.py,sha256=ubwtkNvoBf0ZTGQm2M2Lgaim2tBAiAsa9VoTRR_MWks,5175
 qadence/ml_tools/models.py,sha256=SjwAPbSl9zn9YqfmwqHc2lIXCkIpwG_ysz4jieRh7W0,16996
 qadence/ml_tools/optimize_step.py,sha256=L92-kNILrmwz20d_Xd_FIQw6SDGJYIEbFN3tSRz9eno,1835
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/printing.py,sha256=2xMhsn2j0nQdO2klLcLWY33GT_7r-Gi83Fv2M2rGQQE,4789
-qadence/ml_tools/saveload.py,sha256=r_AZstRiCwXfq44HxqammrH6yZGf7iAzp6Y0k6k_88M,5888
+qadence/ml_tools/saveload.py,sha256=B6709ZdqHkg6kCZJmlZhCoWaNJ4ZynJe_W2IoaexLTs,5945
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/train_grad.py,sha256=AaI6OHmElDdWHny1JAN2YzpICP3W2AR_GVCfMAAjtEU,13665
-qadence/ml_tools/train_no_grad.py,sha256=4SiIMVunTXCWLzoDudhs-eozDHOZ3t-Of2JXRJyKT20,7375
+qadence/ml_tools/train_grad.py,sha256=sOQkx6aDxXrQ4HmFB1X7VKqKcOlaFthGD-5lx6gS0Jw,13502
+qadence/ml_tools/train_no_grad.py,sha256=jUjnsxvWMrAa-7NV1bewpAo6mV9grF02gwBHy0SVTws,7249
 qadence/ml_tools/utils.py,sha256=PW8FyoV0mG_DtN1U8njTDV5qxZ0EK4mnFwMAsLBArfk,1410
 qadence/noise/__init__.py,sha256=r0nR8uEZeB1M9pI2UisjWq0bjw50fPFfVGzIMev923g,147
 qadence/noise/protocols.py,sha256=-aZ06JvMnpxCeT5v5lI_RNPOLbb9Ju1Pi1AB6uAXxVE,1653
@@ -133,7 +133,7 @@ qadence/transpile/digitalize.py,sha256=iWRwYAYQsD2INHj0HNbGJriv_3fRCuBW1nDBrwtKS
 qadence/transpile/flatten.py,sha256=EdhSG5WyF56nbnxINNLqrHgY84MRM1YFjT3fR4aph5Q,3427
 qadence/transpile/invert.py,sha256=KAefHTG2AWr39aengVhXrzCtJPhrZC-ZnL6vYvmbnY0,4867
 qadence/transpile/transpile.py,sha256=6MRRkk1OS279L1fwUQjazA6qlfpbd-T_EJMKT8hAhOU,2721
-qadence-1.7.5.dist-info/METADATA,sha256=fh8IjATKiYFEPkpPXOzirL9PCYnXk-YaLARmUmxoQP0,9936
-qadence-1.7.5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-qadence-1.7.5.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.7.5.dist-info/RECORD,,
+qadence-1.7.7.dist-info/METADATA,sha256=hkypZEbHl7IP8RyJRdlViMHC2hBVSXre2XAnpp1Q2JM,9986
+qadence-1.7.7.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+qadence-1.7.7.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.7.7.dist-info/RECORD,,