qadence 1.11.2__tar.gz → 1.11.3__tar.gz

{qadence-1.11.2 → qadence-1.11.3}/.pre-commit-config.yaml

@@ -23,7 +23,7 @@ repos:
     rev: v1.14.1
     hooks:
       - id: mypy
-        args: [--install-types, --non-interactive]
+        args: [--install-types, --non-interactive, --explicit-package-bases]
         exclude: examples|docs
 
 -   repo: https://github.com/DanielNoord/pydocstringformatter

{qadence-1.11.2 → qadence-1.11.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.11.2
+Version: 1.11.3
 Summary: Pasqal interface for circuit-based quantum computing SDKs
-Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>, Pim Venderbosch <pim.venderbosch@pasqal.com>, Manu Lahariya <manu.lahariya@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>, Pim Venderbosch <pim.venderbosch@pasqal.com>, Manu Lahariya <manu.lahariya@pasqal.com>, Sungwoo Ahn <sungwoo.ahn@pasqal.com>
 License: PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)
 License-File: LICENSE
 Classifier: License :: Other/Proprietary License
@@ -24,7 +24,7 @@ Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
 Requires-Dist: pasqal-cloud
-Requires-Dist: pyqtorch==1.7.5
+Requires-Dist: pyqtorch==1.7.6
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -44,15 +44,25 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.8.0; extra == 'horqrux'
+Requires-Dist: horqrux==0.8.1; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
 Requires-Dist: sympy2jax; extra == 'horqrux'
+Provides-Extra: hub
+Requires-Dist: qadence-measurement; extra == 'hub'
+Requires-Dist: qadence-mitigation; extra == 'hub'
+Requires-Dist: qadence-model; extra == 'hub'
 Provides-Extra: libs
 Requires-Dist: qadence-libs; extra == 'libs'
+Provides-Extra: measurement
+Requires-Dist: qadence-measurement; extra == 'measurement'
+Provides-Extra: mitigation
+Requires-Dist: qadence-mitigation; extra == 'mitigation'
 Provides-Extra: mlflow
 Requires-Dist: mlflow; extra == 'mlflow'
+Provides-Extra: model
+Requires-Dist: qadence-model; extra == 'model'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser

{qadence-1.11.2 → qadence-1.11.3}/mkdocs.yml

@@ -48,6 +48,7 @@ nav:
       - Classification with QNN: tutorials/qml/classification.md
       - Solving MaxCut with QAOA: tutorials/qml/qaoa.md
       - Solving a 1D ODE: tutorials/qml/dqc_1d.md
+      - QCNN model: tutorials/qml/qcnn.md
 
     - ML Tools:
       - tutorials/qml/ml_tools/intro.md

{qadence-1.11.2 → qadence-1.11.3}/pyproject.toml

@@ -25,10 +25,11 @@ authors = [
     { name = "Daniele Cucurachi", email = "daniele.cucurachi@pasqal.com" },
     { name = "Pim Venderbosch", email = "pim.venderbosch@pasqal.com" },
     { name = "Manu Lahariya", email = "manu.lahariya@pasqal.com" },
+    { name = "Sungwoo Ahn", email = "sungwoo.ahn@pasqal.com" },
 ]
 requires-python = ">=3.9"
 license = { text = "PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)" }
-version = "1.11.2"
+version = "1.11.3"
 classifiers = [
     "License :: Other/Proprietary License",
     "Programming Language :: Python",
@@ -53,7 +54,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.7.5",
+    "pyqtorch==1.7.6",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -77,7 +78,7 @@ visualization = [
     # "scour",
 ]
 horqrux = [
-    "horqrux==0.8.0",
+    "horqrux==0.8.1",
     "jax",
     "flax",
     "optax",
@@ -90,7 +91,14 @@ libs = ["qadence-libs"]
 dlprof = ["nvidia-pyindex", "nvidia-dlprof[pytorch]"]
 mlflow = ["mlflow"]
 all = ["pulser", "visualization", "protocols", "libs", "mlflow"]
-
+hub = [
+    "qadence-mitigation",
+    "qadence-measurement",
+    "qadence-model",
+]
+mitigation = ["qadence-mitigation"]
+measurement = ["qadence-measurement"]
+model = ["qadence-model"]
 
 [tool.hatch.envs.default]
 dependencies = [

{qadence-1.11.2 → qadence-1.11.3}/qadence/backend.py

@@ -25,7 +25,14 @@ from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
 from qadence.parameters import stringify
-from qadence.types import ArrayLike, BackendName, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    BackendName,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 logger = getLogger(__name__)
 
@@ -215,7 +222,7 @@ class Backend(ABC):
         if observable is not None:
             observable = observable if isinstance(observable, list) else [observable]
             conv_obs = []
-            obs_embedding_fn_list = []
+            obs_embedding_fns = []
 
             for obs in observable:
                 obs = check_observable(obs)
@@ -224,13 +231,18 @@ class Backend(ABC):
                     c_obs.abstract, self.config._use_gate_params, self.engine
                 )
                 params.update(obs_params)
-                obs_embedding_fn_list.append(obs_embedding_fn)
+                obs_embedding_fns.append(obs_embedding_fn)
                 conv_obs.append(c_obs)
 
             def embedding_fn_dict(a: dict, b: dict) -> dict:
-                embedding_dict = circ_embedding_fn(a, b)
-                for o in obs_embedding_fn_list:
-                    embedding_dict.update(o(a, b))
+                if "circuit" in b or "observables" in b:
+                    embedding_dict = {"circuit": circ_embedding_fn(a, b), "observables": dict()}
+                    for obs_embedding_fn in obs_embedding_fns:
+                        embedding_dict["observables"].update(obs_embedding_fn(a, b))
+                else:
+                    embedding_dict = circ_embedding_fn(a, b)
+                    for obs_embedding_fn in obs_embedding_fns:
+                        embedding_dict.update(obs_embedding_fn(a, b))
                 return embedding_dict
 
             return Converted(conv_circ, conv_obs, embedding_fn_dict, params)
@@ -316,7 +328,11 @@ class Backend(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def assign_parameters(self, circuit: ConvertedCircuit, param_values: dict[str, Tensor]) -> Any:
+    def assign_parameters(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: dict[str, Tensor] | dict[str, dict[str, Tensor]],
+    ) -> Any:
         raise NotImplementedError
 
     @staticmethod

{qadence-1.11.2 → qadence-1.11.3}/qadence/backends/horqrux/backend.py

@@ -134,19 +134,32 @@ class Backend(BackendInterface):
         Returns:
             A jax.Array of shape (batch_size, n_observables)
         """
-        observable = observable if isinstance(observable, list) else [observable]
-        batch_size = max([arr.size for arr in param_values.values()])
+        observables = observable if isinstance(observable, list) else [observable]
+        if "observables" in param_values or "circuit" in param_values:
+            raise NotImplementedError("The Horqrux backend does not support separated parameters.")
+        else:
+            merged_params = param_values
+            batch_size = max([arr.size for arr in param_values.values()])  # type: ignore[union-attr]
         n_obs = len(observable)
 
         def _expectation(params: ParamDictType) -> ArrayLike:
+            param_circuits = params["circuit"] if "circuit" in params else params
+            param_observables = params["observables"] if "observables" in params else params
             out_state = self.run(
-                circuit, params, state, endianness, horqify_state=True, unhorqify_state=False
+                circuit,
+                param_circuits,
+                state,
+                endianness,
+                horqify_state=True,
+                unhorqify_state=False,
+            )
+            return jnp.array(
+                [observable.native(out_state, param_observables) for observable in observables]
             )
-            return jnp.array([o.native(out_state, params) for o in observable])
 
         if batch_size > 1:  # We vmap for batch_size > 1
-            expvals = jax.vmap(_expectation, in_axes=({k: 0 for k in param_values.keys()},))(
-                uniform_batchsize(param_values)
+            expvals = jax.vmap(_expectation, in_axes=({k: 0 for k in merged_params.keys()},))(
+                uniform_batchsize(merged_params)
             )
         else:
             expvals = _expectation(param_values)

{qadence-1.11.2 → qadence-1.11.3}/qadence/backends/jax_utils.py

@@ -19,6 +19,7 @@ from qadence.blocks import (
 )
 from qadence.blocks.block_to_tensor import _gate_parameters
 from qadence.types import Endianness, ParamDictType
+from qadence.utils import merge_separate_params
 
 
 def jarr_to_tensor(arr: Array, dtype: Any = cdouble) -> Tensor:
@@ -52,9 +53,11 @@ def horqify(state: Array) -> Array:
 
 
 def uniform_batchsize(param_values: ParamDictType) -> ParamDictType:
-    max_batch_size = max(p.size for p in param_values.values())
+    if "observables" in param_values or "circuit" in param_values:
+        param_values = merge_separate_params(param_values)
+    max_batch_size = max(p.size for p in param_values.values())  # type: ignore[union-attr]
     batched_values = {
-        k: (v if v.size == max_batch_size else v.repeat(max_batch_size))
+        k: (v if v.size == max_batch_size else v.repeat(max_batch_size))  # type: ignore[union-attr]
         for k, v in param_values.items()
     }
     return batched_values

{qadence-1.11.2 → qadence-1.11.3}/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-1.11.2 → qadence-1.11.3}/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-1.11.2 → qadence-1.11.3}/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-1.11.2 → qadence-1.11.3}/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-1.11.2 → qadence-1.11.3}/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-1.11.2 → qadence-1.11.3}/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-1.11.2 → qadence-1.11.3}/qadence/engines/torch/differentiable_backend.py

@@ -12,7 +12,13 @@ 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):

{qadence-1.11.2 → qadence-1.11.3}/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-1.11.2 → qadence-1.11.3}/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",
 ]