qadence 1.11.1__py3-none-any.whl → 1.11.3__py3-none-any.whl

qadence/backends/pulser/backend.py

@@ -28,7 +28,7 @@ from qadence.noise import NoiseHandler
 from qadence.overlap import overlap_exact
 from qadence.register import Register
 from qadence.transpile import transpile
-from qadence.types import BackendName, DeviceType, Endianness, Engine, NoiseProtocol
+from qadence.types import BackendName, DeviceType, Endianness, Engine, NoiseProtocol, ParamDictType
 
 from .channels import GLOBAL_CHANNEL, LOCAL_CHANNEL
 from .cloud import get_client
@@ -183,7 +183,7 @@ class Backend(BackendInterface):
     def run(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
         noise: NoiseHandler | None = None,
@@ -235,7 +235,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         noise: NoiseHandler,
-        param_values: dict[str, Tensor] = dict(),
+        param_values: ParamDictType = dict(),
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
@@ -284,7 +284,7 @@ class Backend(BackendInterface):
     def sample(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         n_shots: int = 1,
         state: Tensor | None = None,
         noise: NoiseHandler | None = None,
@@ -322,7 +322,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
@@ -330,14 +330,19 @@ class Backend(BackendInterface):
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         observable = observable if isinstance(observable, list) else [observable]
+        param_circuit = param_values["circuit"] if "circuit" in param_values else param_values
+        param_observables = (
+            param_values["observables"] if "observables" in param_values else param_values
+        )
         if mitigation is None:
             if noise is None:
                 state = self.run(
-                    circuit, param_values=param_values, state=state, endianness=endianness
+                    circuit, param_values=param_circuit, state=state, endianness=endianness
                 )
                 support = sorted(list(circuit.abstract.register.support))
                 res_list = [
-                    obs.native(state, param_values, qubit_support=support) for obs in observable
+                    obs.native(state, param_observables, qubit_support=support)
+                    for obs in observable
                 ]
                 res = torch.transpose(torch.stack(res_list), 0, 1)
                 res = res if len(res.shape) > 0 else res.reshape(1)
@@ -345,7 +350,7 @@ class Backend(BackendInterface):
             elif noise is not None:
                 dms = self.run(
                     circuit=circuit,
-                    param_values=param_values,
+                    param_values=param_circuit,
                     state=state,
                     endianness=endianness,
                     noise=noise,
@@ -353,7 +358,9 @@ class Backend(BackendInterface):
                 support = sorted(list(circuit.abstract.register.support))
                 res_list = [
                     [
-                        obs.native(dm.squeeze(), param_values, qubit_support=support, noise=noise)
+                        obs.native(
+                            dm.squeeze(), param_observables, qubit_support=support, noise=noise
+                        )
                         for dm in dms
                     ]
                     for obs in observable

qadence/backends/pulser/config.py

@@ -66,6 +66,24 @@ class Configuration(BackendConfiguration):
     FIXME: To be deprecated.
     """
 
+    n_eqs: int | None = None
+    """Number of equations to use in aGPSR calculations."""
+
+    shift_prefac: float = 0.5
+    """Prefactor governing the magnitude of parameter shift values.
+
+    Select smaller value if spectral gaps are large.
+    """
+
+    gap_step: float = 1.0
+    """Step between generated pseudo-gaps when using aGPSR algorithm."""
+
+    lb: float | None = None
+    """Lower bound of optimal shift value search interval."""
+
+    ub: float | None = None
+    """Upper bound of optimal shift value search interval."""
+
     # configuration for cloud simulations
     cloud_configuration: Optional[CloudConfiguration] = None
 

qadence/backends/pyqtorch/backend.py

@@ -31,7 +31,7 @@ from qadence.transpile import (
     set_noise,
     transpile,
 )
-from qadence.types import BackendName, Endianness, Engine
+from qadence.types import BackendName, Endianness, Engine, ParamDictType
 
 from .config import Configuration, default_passes
 from .convert_ops import convert_block, convert_readout_noise
@@ -182,16 +182,21 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         set_block_and_readout_noises(circuit, noise, self.config)
+        param_circuit = param_values["circuit"] if "circuit" in param_values else param_values
+        param_observables = (
+            param_values["observables"] if "observables" in param_values else param_values
+        )
+
         state = self.run(
             circuit,
-            param_values=param_values,
+            param_values=param_circuit,
             state=state,
             endianness=endianness,
             pyqify_state=True,
@@ -200,7 +205,7 @@ class Backend(BackendInterface):
         )
         observable = observable if isinstance(observable, list) else [observable]
         _expectation = torch.hstack(
-            [obs.native.expectation(state, param_values).reshape(-1, 1) for obs in observable]
+            [obs.native.expectation(state, param_observables).reshape(-1, 1) for obs in observable]
         )
         return _expectation
 
@@ -208,7 +213,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
@@ -230,9 +235,18 @@ class Backend(BackendInterface):
 
         list_expvals = []
         observables = observable if isinstance(observable, list) else [observable]
-        for vals in to_list_of_dicts(param_values):
-            wf = self.run(circuit, vals, state, endianness, pyqify_state=True, unpyqify_state=False)
-            exs = torch.cat([obs.native.expectation(wf, vals) for obs in observables], 0)
+        param_circuits = param_values["circuit"] if "circuit" in param_values else param_values
+        param_observables = (
+            param_values["observables"] if "observables" in param_values else param_values
+        )
+
+        for vals_circ, vals_obs in zip(
+            to_list_of_dicts(param_circuits), to_list_of_dicts(param_observables)
+        ):
+            wf = self.run(
+                circuit, vals_circ, state, endianness, pyqify_state=True, unpyqify_state=False
+            )
+            exs = torch.cat([obs.native.expectation(wf, vals_obs) for obs in observables], 0)
             list_expvals.append(exs)
 
         batch_expvals = torch.vstack(list_expvals)
@@ -242,7 +256,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
@@ -269,7 +283,7 @@ class Backend(BackendInterface):
     def sample(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         n_shots: int = 1,
         state: Tensor | None = None,
         noise: NoiseHandler | None = None,
@@ -295,7 +309,7 @@ class Backend(BackendInterface):
             samples = apply_mitigation(noise=noise, mitigation=mitigation, samples=samples)
         return samples
 
-    def assign_parameters(self, circuit: ConvertedCircuit, param_values: dict[str, Tensor]) -> Any:
+    def assign_parameters(self, circuit: ConvertedCircuit, param_values: ParamDictType) -> Any:
         raise NotImplementedError
 
     @staticmethod

qadence/backends/pyqtorch/config.py

@@ -70,3 +70,21 @@ class Configuration(BackendConfiguration):
     """Quantum dropout probability (0 means no dropout)."""
     dropout_mode: DropoutMode = DropoutMode.ROTATIONAL
     """Type of quantum dropout to perform."""
+
+    n_eqs: int | None = None
+    """Number of equations to use in aGPSR calculations."""
+
+    shift_prefac: float = 0.5
+    """Prefactor governing the magnitude of parameter shift values.
+
+    Select smaller value if spectral gaps are large.
+    """
+
+    gap_step: float = 1.0
+    """Step between generated pseudo-gaps when using aGPSR algorithm."""
+
+    lb: float | None = None
+    """Lower bound of optimal shift value search interval."""
+
+    ub: float | None = None
+    """Upper bound of optimal shift value search interval."""

qadence/blocks/embedding.py

@@ -16,7 +16,14 @@ from qadence.blocks.utils import (
     uuid_to_expression,
 )
 from qadence.parameters import evaluate, make_differentiable, stringify
-from qadence.types import ArrayLike, DifferentiableExpression, Engine, ParamDictType, TNumber
+from qadence.types import (
+    ArrayLike,
+    DifferentiableExpression,
+    Engine,
+    ParamDictType,
+    TNumber,
+)
+from qadence.utils import merge_separate_params
 
 
 def _concretize_parameter(engine: Engine) -> Callable:
@@ -110,6 +117,8 @@ def embedding(
 
     def embedding_fn(params: ParamDictType, inputs: ParamDictType) -> ParamDictType:
         embedded_params: dict[sympy.Expr, ArrayLike] = {}
+        if "circuit" in inputs or "observables" in inputs:
+            inputs = merge_separate_params(inputs)
         for expr, fn in embeddings.items():
             angle: ArrayLike
             values = {}

qadence/blocks/primitive.py

@@ -187,9 +187,8 @@ class ParametricBlock(PrimitiveBlock):
         if not isinstance(other, AbstractBlock):
             raise TypeError(f"Cant compare {type(self)} to {type(other)}")
         if isinstance(other, type(self)):
-            return (
-                self.qubit_support == other.qubit_support
-                and self.parameters.parameter == other.parameters.parameter
+            return self.qubit_support == other.qubit_support and self.parameters.parameter.equals(
+                other.parameters.parameter
             )
         return False
 

qadence/blocks/utils.py

@@ -7,6 +7,7 @@ from logging import getLogger
 from typing import Generator, List, Type, TypeVar, Union, get_args
 
 from sympy import Array, Basic, Expr
+import torch
 from torch import Tensor
 
 from qadence.blocks import (
@@ -292,31 +293,39 @@ def uuid_to_eigen(
 
     result = {}
     for uuid, b in uuid_to_block(block).items():
-        if b.eigenvalues_generator is not None:
-            if b.eigenvalues_generator.numel() > 0:
-                # GPSR assumes a factor 0.5 for differentiation
-                # so need rescaling
-                if isinstance(b, TimeEvolutionBlock) and rescale_eigenvals_timeevo:
-                    if b.eigenvalues_generator.numel() > 1:
-                        result[uuid] = (
-                            b.eigenvalues_generator * 2.0,
-                            0.5,
-                        )
+        eigs_generator = None
+
+        # this is to handle the case for the N operator
+        try:
+            eigs_generator = b.eigenvalues_generator
+        except ValueError:
+            result[uuid] = (torch.zeros(2), 1.0)
+        else:
+            if eigs_generator is not None:
+                if eigs_generator.numel() > 0:
+                    # GPSR assumes a factor 0.5 for differentiation
+                    # so need rescaling
+                    if isinstance(b, TimeEvolutionBlock) and rescale_eigenvals_timeevo:
+                        if eigs_generator.numel() > 1:
+                            result[uuid] = (
+                                eigs_generator * 2.0,
+                                0.5,
+                            )
+                        else:
+                            result[uuid] = (
+                                eigs_generator * 2.0,
+                                (
+                                    1.0 / (eigs_generator.item() * 2.0)
+                                    if len(eigs_generator) == 1
+                                    else 1.0
+                                ),
+                            )
                     else:
-                        result[uuid] = (
-                            b.eigenvalues_generator * 2.0,
-                            (
-                                1.0 / (b.eigenvalues_generator.item() * 2.0)
-                                if len(b.eigenvalues_generator) == 1
-                                else 1.0
-                            ),
-                        )
-                else:
-                    result[uuid] = (b.eigenvalues_generator, 1.0)
-
-                # leave only angle parameter uuid with eigenvals for ConstantAnalogRotation block
-                if isinstance(block, ConstantAnalogRotation):
-                    break
+                        result[uuid] = (eigs_generator, 1.0)
+
+                    # leave only angle parameter uuid with eigenvals for ConstantAnalogRotation block
+                    if isinstance(block, ConstantAnalogRotation):
+                        break
 
     return result
 

qadence/engines/differentiable_backend.py

@@ -12,7 +12,13 @@ from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
-from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 
 @dataclass(frozen=True, eq=True)

qadence/engines/jax/differentiable_backend.py

@@ -8,7 +8,13 @@ from qadence.engines.jax.differentiable_expectation import DifferentiableExpecta
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
-from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 
 class DifferentiableBackend(DifferentiableBackendInterface):

qadence/engines/torch/differentiable_backend.py

@@ -8,11 +8,17 @@ from qadence.engines.differentiable_backend import (
     DifferentiableBackend as DifferentiableBackendInterface,
 )
 from qadence.engines.torch.differentiable_expectation import DifferentiableExpectation
-from qadence.extensions import get_gpsr_fns
+from qadence.backends.parameter_shift_rules import general_psr
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
-from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 
 class DifferentiableBackend(DifferentiableBackendInterface):
@@ -75,11 +81,8 @@ class DifferentiableBackend(DifferentiableBackendInterface):
             expectation = differentiable_expectation.ad
         elif self.diff_mode == DiffMode.ADJOINT:
             expectation = differentiable_expectation.adjoint
-        else:
-            try:
-                fns = get_gpsr_fns()
-                psr_fn = fns[self.diff_mode]
-            except KeyError:
-                raise ValueError(f"{self.diff_mode} differentiation mode is not supported")
-            expectation = partial(differentiable_expectation.psr, psr_fn=psr_fn, **self.psr_args)
+        elif self.diff_mode == DiffMode.GPSR:
+            expectation = partial(
+                differentiable_expectation.psr, psr_fn=general_psr, **self.psr_args
+            )
         return expectation()

qadence/engines/torch/differentiable_expectation.py

@@ -20,7 +20,7 @@ from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.ml_tools import promote_to_tensor
 from qadence.noise import NoiseHandler
-from qadence.types import Endianness
+from qadence.types import Endianness, ParamDictType
 
 
 class PSRExpectation(Function):
@@ -94,7 +94,7 @@ class DifferentiableExpectation:
     backend: QuantumBackend
     circuit: ConvertedCircuit
     observable: list[ConvertedObservable] | ConvertedObservable
-    param_values: dict[str, Tensor]
+    param_values: ParamDictType
     state: Tensor | None = None
     measurement: Measurements | None = None
     noise: NoiseHandler | None = None
@@ -135,8 +135,6 @@ class DifferentiableExpectation:
         self.observable = (
             self.observable if isinstance(self.observable, list) else [self.observable]
         )
-        if len(self.observable) > 1:
-            raise NotImplementedError("AdjointExpectation currently only supports one observable.")
 
         n_qubits = self.circuit.abstract.n_qubits
         values_batch_size = infer_batchsize(self.param_values)
@@ -150,18 +148,21 @@ class DifferentiableExpectation:
                 else self.state
             )
         batch_size = max(values_batch_size, self.state.size(-1))
-        return (
-            AdjointExpectation.apply(
+
+        def expectation_fn(i: int) -> Tensor:
+            return AdjointExpectation.apply(
                 self.circuit.native,
                 self.state,
-                self.observable[0].native,  # Currently, adjoint only supports a single observable.
+                self.observable[i].native,  # Currently, adjoint only supports a single observable.
                 None,
                 self.param_values.keys(),
                 *self.param_values.values(),
-            )
-            .unsqueeze(1)
-            .reshape(batch_size, 1)
-        )  # we expect (batch_size, n_observables) shape
+            ).reshape(
+                batch_size, 1
+            )  # we expect (batch_size, n_observables) shape
+
+        expectation_list = [expectation_fn(i) for i in range(len(self.observable))]
+        return torch.vstack(expectation_list)
 
     def psr(self, psr_fn: Callable, **psr_args: int | float | None) -> Tensor:
         # wrapper which unpacks the parameters

qadence/extensions.py

@@ -108,14 +108,6 @@ def _supported_gates(backend_name: str) -> list[TAbstractBlock]:
     return [getattr(operations, gate) for gate in _supported_gates]
 
 
-def _gpsr_fns() -> dict:
-    """Fallback function for native Qadence GPSR functions if extensions is not present."""
-    # avoid circular import
-    from qadence.backends.gpsr import general_psr
-
-    return {DiffMode.GPSR: general_psr}
-
-
 def _validate_diff_mode(backend: Backend, diff_mode: DiffMode) -> None:
     """Fallback function for native Qadence diff_mode if extensions is not present."""
     if not backend.supports_ad and diff_mode == DiffMode.AD:
@@ -152,11 +144,9 @@ try:
     available_backends = getattr(module, "available_backends")
     available_engines = getattr(module, "available_engines")
     supported_gates = getattr(module, "supported_gates")
-    get_gpsr_fns = getattr(module, "gpsr_fns")
     set_backend_config = getattr(module, "set_backend_config")
 except ModuleNotFoundError:
     available_backends = _available_backends
     available_engines = _available_engines
     supported_gates = _supported_gates
-    get_gpsr_fns = _gpsr_fns
     set_backend_config = _set_backend_config

qadence/ml_tools/__init__.py

@@ -10,6 +10,7 @@ from .optimize_step import optimize_step as default_optimize_step
 from .parameters import get_parameters, num_parameters, set_parameters
 from .tensors import numpy_to_tensor, promote_to, promote_to_tensor
 from .trainer import Trainer
+from .qcnn_model import QCNN
 
 # Modules to be automatically added to the qadence namespace
 __all__ = [
@@ -25,4 +26,5 @@ __all__ = [
     "OptimizeResult",
     "Trainer",
     "write_checkpoint",
+    "QCNN",
 ]

qadence/ml_tools/callbacks/callbackmanager.py

@@ -115,8 +115,10 @@ class CallbacksManager:
             self.add_callback("PlotMetrics", "train_end")
         # only save the last checkpoint if not checkpoint_best_only
         if not self.config.checkpoint_best_only:
-            self.add_callback("SaveCheckpoint", "train_end")
-        self.add_callback("WriteMetrics", "train_end")
+            if self.config.checkpoint_every != 0:
+                self.add_callback("SaveCheckpoint", "train_end")
+        if self.config.write_every != 0:
+            self.add_callback("WriteMetrics", "train_end")
 
     def add_callback(
         self, callback: str | Callback, on: str | TrainingStage, called_every: int = 1