qadence 1.10.2__tar.gz → 1.11.0__tar.gz

{qadence-1.10.2 → qadence-1.11.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.10.2
+Version: 1.11.0
 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>
+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>
 License: Apache 2.0
 License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
@@ -23,7 +23,7 @@ Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
 Requires-Dist: pasqal-cloud
-Requires-Dist: pyqtorch==1.7.0
+Requires-Dist: pyqtorch==1.7.1
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -43,7 +43,7 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.6.2; extra == 'horqrux'
+Requires-Dist: horqrux==0.7.0; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
@@ -55,9 +55,9 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.12.7; extra == 'pulser'
-Requires-Dist: pulser-core==1.2.1; extra == 'pulser'
-Requires-Dist: pulser-simulation==1.2.1; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.13.0; extra == 'pulser'
+Requires-Dist: pulser-core==1.3.0; extra == 'pulser'
+Requires-Dist: pulser-simulation==1.3.0; extra == 'pulser'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown
@@ -202,12 +202,15 @@ Users also report problems running Hatch on Windows, we suggest using WSL2.
 If you use Qadence for a publication, we kindly ask you to cite our work using the following BibTex entry:
 
 ```latex
-@article{qadence2024pasqal,
-  title = {Qadence: a differentiable interface for digital-analog programs.},
-  author={Dominik Seitz and Niklas Heim and João P. Moutinho and Roland Guichard and Vytautas Abramavicius and Aleksander Wennersteen and Gert-Jan Both and Anton Quelle and Caroline de Groot and Gergana V. Velikova and Vincent E. Elfving and Mario Dagrada},
-  journal={arXiv:2401.09915},
-  url = {https://github.com/pasqal-io/qadence},
-  year = {2024}
+@article{qadence2025,
+author = {Seitz, Dominik and Heim, Niklas and Moutinho, João and Guichard, Roland and Abramavicius, Vytautas and Wennersteen, Aleksander and Both, Gert-Jan and Quelle, Anton and Groot, Caroline and Velikova, Gergana and Elfving, Vincent and Dagrada, Mario},
+year = {2025},
+month = {01},
+pages = {1-14},
+title = {Qadence: a differentiable interface for digital and analog programs},
+volume = {PP},
+journal = {IEEE Software},
+doi = {10.1109/MS.2025.3536607}
 }
 ```
 

{qadence-1.10.2 → qadence-1.11.0}/README.md

@@ -138,12 +138,15 @@ Users also report problems running Hatch on Windows, we suggest using WSL2.
 If you use Qadence for a publication, we kindly ask you to cite our work using the following BibTex entry:
 
 ```latex
-@article{qadence2024pasqal,
-  title = {Qadence: a differentiable interface for digital-analog programs.},
-  author={Dominik Seitz and Niklas Heim and João P. Moutinho and Roland Guichard and Vytautas Abramavicius and Aleksander Wennersteen and Gert-Jan Both and Anton Quelle and Caroline de Groot and Gergana V. Velikova and Vincent E. Elfving and Mario Dagrada},
-  journal={arXiv:2401.09915},
-  url = {https://github.com/pasqal-io/qadence},
-  year = {2024}
+@article{qadence2025,
+author = {Seitz, Dominik and Heim, Niklas and Moutinho, João and Guichard, Roland and Abramavicius, Vytautas and Wennersteen, Aleksander and Both, Gert-Jan and Quelle, Anton and Groot, Caroline and Velikova, Gergana and Elfving, Vincent and Dagrada, Mario},
+year = {2025},
+month = {01},
+pages = {1-14},
+title = {Qadence: a differentiable interface for digital and analog programs},
+volume = {PP},
+journal = {IEEE Software},
+doi = {10.1109/MS.2025.3536607}
 }
 ```
 

{qadence-1.10.2 → qadence-1.11.0}/mkdocs.yml

@@ -19,6 +19,7 @@ nav:
     - Quantum models: content/quantummodels.md
     - Quantum registers: content/register.md
     - State initialization: content/state_init.md
+    - Noisy Simulation: content/noisy_simulation.md
     - Arbitrary Hamiltonians: content/hamiltonians.md
     - Time-dependent generators: content/time_dependent.md
     - QML Constructors: content/qml_constructors.md
@@ -42,14 +43,20 @@ nav:
 
     - Variational quantum algorithms:
       - tutorials/qml/index.md
-      - Training: tutorials/qml/ml_tools/trainer.md
-      - Training Callbacks: tutorials/qml/ml_tools/callbacks.md
-      - Data and Configurations: tutorials/qml/ml_tools/data_and_config.md
       - Configuring a QNN: tutorials/qml/config_qnn.md
       - Quantum circuit learning: tutorials/qml/qcl.md
       - Solving MaxCut with QAOA: tutorials/qml/qaoa.md
       - Solving a 1D ODE: tutorials/qml/dqc_1d.md
 
+    - ML Tools:
+      - tutorials/qml/ml_tools/intro.md
+      - Training: tutorials/qml/ml_tools/trainer.md
+      - Data and Configurations: tutorials/qml/ml_tools/data_and_config.md
+      - Training Callbacks: tutorials/qml/ml_tools/callbacks.md
+      - Accelerator: tutorials/qml/ml_tools/accelerator_doc.md
+      - CPU Training: tutorials/qml/ml_tools/CPU.md
+      - GPU Training: tutorials/qml/ml_tools/GPU.md
+
     - Advanced Tutorials:
       - tutorials/advanced_tutorials/index.md
       - Quantum circuits differentiation: tutorials/advanced_tutorials/differentiability.md

{qadence-1.10.2 → qadence-1.11.0}/pyproject.toml

@@ -23,11 +23,12 @@ authors = [
     { name = "Charles Moussa", email = "charles.moussa@pasqal.com" },
     { name = "Giorgio Tosti Balducci", email = "giorgio.tosti-balducci@pasqal.com" },
     { name = "Daniele Cucurachi", email = "daniele.cucurachi@pasqal.com" },
-    { name = "Pim Venderbosch", email = "pim.venderbosch@pasqal.com" }
+    { name = "Pim Venderbosch", email = "pim.venderbosch@pasqal.com" },
+    { name = "Manu Lahariya", email = "manu.lahariya@pasqal.com" },
 ]
 requires-python = ">=3.9"
 license = { text = "Apache 2.0" }
-version = "1.10.2"
+version = "1.11.0"
 classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -51,7 +52,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.7.0",
+    "pyqtorch==1.7.1",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -64,9 +65,9 @@ allow-ambiguous-features = true
 
 [project.optional-dependencies]
 pulser = [
-    "pulser-core==1.2.1",
-    "pulser-simulation==1.2.1",
-    "pasqal-cloud==0.12.7",
+    "pulser-core==1.3.0",
+    "pulser-simulation==1.3.0",
+    "pasqal-cloud==0.13.0",
 ]
 visualization = [
     "graphviz",
@@ -75,7 +76,7 @@ visualization = [
     # "scour",
 ]
 horqrux = [
-    "horqrux==0.6.2",
+    "horqrux==0.7.0",
     "jax",
     "flax",
     "optax",
@@ -136,7 +137,7 @@ filterwarnings = [
 [tool.hatch.envs.docs]
 dependencies = [
     "mkdocs",
-    "mkdocs_autorefs<1.3.1",
+    "mkdocs_autorefs",
     "mkdocs-material",
     "mkdocstrings",
     "mkdocstrings-python",

{qadence-1.10.2 → qadence-1.11.0}/qadence/backends/horqrux/convert_ops.py

@@ -245,7 +245,7 @@ class HorqHamiltonianEvolution(NativeHorqHEvo):
 
         self._time_evolution = lambda values: values[self.param_names[0]]
 
-    def unitary(self, values: dict[str, Array]) -> Array:
+    def _unitary(self, values: dict[str, Array]) -> Array:
         """The evolved operator given current parameter values for generator and time evolution."""
         return expm(self._hamiltonian(self, values) * (-1j * self._time_evolution(values)))
 

{qadence-1.10.2 → qadence-1.11.0}/qadence/blocks/block_to_tensor.py

@@ -79,20 +79,23 @@ def _fill_identities(
         torch.Tensor: augmented matrix with dimensions (2**nqubits, 2**nqubits)
         or a tensor (2**n_qubits) if diag_only
     """
+    full_qubit_support = tuple(sorted(full_qubit_support))
     qubit_support = tuple(sorted(qubit_support))
     block_mat = block_mat.to(device)
-    mat = IMAT.to(device) if qubit_support[0] != full_qubit_support[0] else block_mat
+    identity_mat = IMAT.to(device)
     if diag_only:
-        mat = torch.diag(mat.squeeze(0))
+        block_mat = torch.diag(block_mat.squeeze(0))
+        identity_mat = torch.diag(identity_mat.squeeze(0))
+    mat = identity_mat if qubit_support[0] != full_qubit_support[0] else block_mat
     for i in full_qubit_support[1:]:
         if i == qubit_support[0]:
-            other = torch.diag(block_mat.squeeze(0)) if diag_only else block_mat
+            other = block_mat
             if endianness == Endianness.LITTLE:
                 mat = torch.kron(other, mat)
             else:
                 mat = torch.kron(mat.contiguous(), other.contiguous())
         elif i not in qubit_support:
-            other = torch.diag(IMAT.squeeze(0).to(device)) if diag_only else IMAT.to(device)
+            other = identity_mat
             if endianness == Endianness.LITTLE:
                 mat = torch.kron(other.contiguous(), mat.contiguous())
             else:
@@ -263,13 +266,12 @@ def _gate_parameters(b: AbstractBlock, values: dict[str, torch.Tensor]) -> tuple
 
 def block_to_diagonal(
     block: AbstractBlock,
+    values: dict[str, TNumber | torch.Tensor] = dict(),
     qubit_support: tuple | list | None = None,
-    use_full_support: bool = True,
+    use_full_support: bool = False,
     endianness: Endianness = Endianness.BIG,
     device: torch.device = None,
 ) -> torch.Tensor:
-    if block.is_parametric:
-        raise TypeError("Sparse observables cant be parametric.")
     if not block._is_diag_pauli:
         raise TypeError("Sparse observables can only be used on paulis which are diagonal.")
     if qubit_support is None:
@@ -281,17 +283,16 @@ def block_to_diagonal(
     if isinstance(block, (ChainBlock, KronBlock)):
         v = torch.ones(2**nqubits, dtype=torch.cdouble)
         for b in block.blocks:
-            v *= block_to_diagonal(b, qubit_support)
+            v *= block_to_diagonal(b, values, qubit_support, device=device)
     if isinstance(block, AddBlock):
         t = torch.zeros(2**nqubits, dtype=torch.cdouble)
         for b in block.blocks:
-            t += block_to_diagonal(b, qubit_support)
+            t += block_to_diagonal(b, values, qubit_support, device=device)
         v = t
     elif isinstance(block, ScaleBlock):
-        _s = evaluate(block.scale, {}, as_torch=True)  # type: ignore[attr-defined]
-        _s = _s.detach()  # type: ignore[union-attr]
-        v = _s * block_to_diagonal(block.block, qubit_support)
-
+        _s = evaluate(block.scale, values, as_torch=True)  # type: ignore[attr-defined]
+        _s = _s.detach().squeeze(0)  # type: ignore[union-attr]
+        v = _s * block_to_diagonal(block.block, values, qubit_support, device=device)
     elif isinstance(block, PrimitiveBlock):
         v = _fill_identities(
             OPERATIONS_DICT[block.name],
@@ -299,6 +300,7 @@ def block_to_diagonal(
             qubit_support,  # type: ignore [arg-type]
             diag_only=True,
             endianness=endianness,
+            device=device,
         )
     return v
 
@@ -308,7 +310,7 @@ def block_to_tensor(
     block: AbstractBlock,
     values: dict[str, TNumber | torch.Tensor] = {},
     qubit_support: tuple | None = None,
-    use_full_support: bool = True,
+    use_full_support: bool = False,
     tensor_type: TensorType = TensorType.DENSE,
     endianness: Endianness = Endianness.BIG,
     device: torch.device = None,
@@ -338,18 +340,14 @@ def block_to_tensor(
     print(block_to_tensor(obs, tensor_type="SparseDiagonal"))
     ```
     """
+    from qadence.blocks import embedding
 
-    # FIXME: default use_full_support to False. In general, it would
-    # be more efficient to do that, and make sure that computations such
-    # as observables only do the matmul of the size of the qubit support.
-
+    (ps, embed) = embedding(block)
+    values = embed(ps, values)
     if tensor_type == TensorType.DENSE:
-        from qadence.blocks import embedding
-
-        (ps, embed) = embedding(block)
         return _block_to_tensor_embedded(
             block,
-            embed(ps, values),
+            values,
             qubit_support,
             use_full_support,
             endianness=endianness,
@@ -357,7 +355,7 @@ def block_to_tensor(
         )
 
     elif tensor_type == TensorType.SPARSEDIAGONAL:
-        t = block_to_diagonal(block, endianness=endianness)
+        t = block_to_diagonal(block, values, endianness=endianness)
         indices, values, size = torch.nonzero(t), t[t != 0], len(t)
         indices = torch.stack((indices.flatten(), indices.flatten()))
         return torch.sparse_coo_tensor(indices, values, (size, size))
@@ -368,7 +366,7 @@ def _block_to_tensor_embedded(
     block: AbstractBlock,
     values: dict[str, TNumber | torch.Tensor] = {},
     qubit_support: tuple | None = None,
-    use_full_support: bool = True,
+    use_full_support: bool = False,
     endianness: Endianness = Endianness.BIG,
     device: torch.device = None,
 ) -> torch.Tensor:
@@ -469,14 +467,13 @@ def _block_to_tensor_embedded(
         )
 
     elif isinstance(block, MatrixBlock):
-        mat = block.matrix.unsqueeze(0)
-        # FIXME: properly handle identity filling in matrix blocks
-        # mat = _fill_identities(
-        #    block.matrix.unsqueeze(0),
-        #    block.qubit_support,
-        #    qubit_support,
-        #    endianness=endianness,
-        # )
+        mat = _fill_identities(
+            block.matrix.unsqueeze(0),
+            block.qubit_support,
+            qubit_support,
+            endianness=endianness,
+            device=device,
+        )
 
     elif isinstance(block, SWAP):
         swap_block = _swap_block(block)

{qadence-1.10.2 → qadence-1.11.0}/qadence/blocks/matrix.py

@@ -7,6 +7,8 @@ import numpy as np
 import torch
 from torch.linalg import eigvals
 
+from math import log
+
 from qadence.blocks import PrimitiveBlock
 from qadence.noise import NoiseHandler
 
@@ -84,6 +86,8 @@ class MatrixBlock(PrimitiveBlock):
             if not self.is_unitary(matrix):
                 logger.warning("Provided matrix is not unitary.")
         self.matrix = matrix.clone()
+        if int(log(self.matrix.size(1), 2)) != len(qubit_support):
+            raise ValueError("Provided matrix does not match the qubit_support length.")
         super().__init__(qubit_support, noise)
 
     @cached_property

{qadence-1.10.2 → qadence-1.11.0}/qadence/constructors/__init__.py

@@ -17,6 +17,9 @@ from .hamiltonians import (
     ObservableConfig,
     total_magnetization,
     zz_hamiltonian,
+    total_magnetization_config,
+    zz_hamiltonian_config,
+    ising_hamiltonian_config,
 )
 
 from .rydberg_hea import rydberg_hea, rydberg_hea_layer
@@ -34,9 +37,12 @@ __all__ = [
     "iia",
     "hamiltonian_factory",
     "ising_hamiltonian",
-    "ObservableConfig",
     "total_magnetization",
     "zz_hamiltonian",
+    "ObservableConfig",
+    "total_magnetization_config",
+    "zz_hamiltonian_config",
+    "ising_hamiltonian_config",
     "qft",
     "daqc_transform",
     "rydberg_hea",

{qadence-1.10.2 → qadence-1.11.0}/qadence/constructors/hamiltonians.py

@@ -7,11 +7,12 @@ from typing import Callable, List, Type, Union
 import numpy as np
 from torch import Tensor, double, ones, rand
 from typing_extensions import Any
+from qadence.parameters import Parameter
 
 from qadence.blocks import AbstractBlock, add, block_is_qubit_hamiltonian
-from qadence.operations import N, X, Y, Z
+from qadence.operations import N, X, Y, Z, H
 from qadence.register import Register
-from qadence.types import Interaction, ObservableTransform, TArray, TParameter
+from qadence.types import Interaction, TArray, TParameter
 
 logger = getLogger(__name__)
 
@@ -239,7 +240,30 @@ def is_numeric(x: Any) -> bool:
 
 @dataclass
 class ObservableConfig:
-    detuning: TDetuning
+    """ObservableConfig is a configuration class for defining the parameters of an observable Hamiltonian."""
+
+    interaction: Interaction | Callable | None = None
+    """
+    The type of interaction.
+
+    Available options from the Interaction enum are:
+            - Interaction.ZZ
+            - Interaction.NN
+            - Interaction.XY
+            - Interaction.XYZ
+
+    Alternatively, a custom interaction function can be defined.
+            Example:
+
+                def custom_int(i: int, j: int):
+                    return X(i) @ X(j) + Y(i) @ Y(j)
+
+                n_qubits = 2
+
+                observable_config = ObservableConfig(interaction=custom_int, scale = 1.0, shift = 0.0)
+                observable = create_observable(register=4, config=observable_config)
+    """
+    detuning: TDetuning | None = None
     """
     Single qubit detuning of the observable Hamiltonian.
 
@@ -249,8 +273,6 @@ class ObservableConfig:
     """The scale by which to multiply the output of the observable."""
     shift: TParameter = 0.0
     """The shift to add to the output of the observable."""
-    transformation_type: ObservableTransform = ObservableTransform.NONE  # type: ignore[assignment]
-    """The type of transformation."""
     trainable_transform: bool | None = None
     """
     Whether to have a trainable transformation on the output of the observable.
@@ -261,8 +283,73 @@ class ObservableConfig:
     """
 
     def __post_init__(self) -> None:
+        if self.interaction is None and self.detuning is None:
+            raise ValueError(
+                "Please provide an interaction and/or detuning for the Observable Hamiltonian."
+            )
+
         if is_numeric(self.scale) and is_numeric(self.shift):
-            assert (
-                self.trainable_transform is None
-            ), f"If scale and shift are numbers, trainable_transform must be None. \
-            But got: {self.trainable_transform}"
+            assert self.trainable_transform is None, (
+                "If scale and shift are numbers, trainable_transform must be None."
+                f"But got: {self.trainable_transform}"
+            )
+
+        # trasform the scale and shift into parameters
+        if self.trainable_transform is not None:
+            self.shift = Parameter(name=self.shift, trainable=self.trainable_transform)
+            self.scale = Parameter(name=self.scale, trainable=self.trainable_transform)
+        else:
+            self.shift = Parameter(self.shift)
+            self.scale = Parameter(self.scale)
+
+
+def total_magnetization_config(
+    scale: TParameter = 1.0,
+    shift: TParameter = 0.0,
+    trainable_transform: bool | None = None,
+) -> ObservableConfig:
+    return ObservableConfig(
+        detuning=Z,
+        scale=scale,
+        shift=shift,
+        trainable_transform=trainable_transform,
+    )
+
+
+def zz_hamiltonian_config(
+    scale: TParameter = 1.0,
+    shift: TParameter = 0.0,
+    trainable_transform: bool | None = None,
+) -> ObservableConfig:
+    return ObservableConfig(
+        interaction=Interaction.ZZ,
+        detuning=Z,
+        scale=scale,
+        shift=shift,
+        trainable_transform=trainable_transform,
+    )
+
+
+def ising_hamiltonian_config(
+    scale: TParameter = 1.0,
+    shift: TParameter = 0.0,
+    trainable_transform: bool | None = None,
+) -> ObservableConfig:
+
+    def ZZ_Z_hamiltonian(i: int, j: int) -> AbstractBlock:
+        result = Z(i) @ Z(j)
+
+        if i == 0:
+            result += Z(j)
+        elif i == 1 and j == 2:
+            result += Z(0)
+
+        return result
+
+    return ObservableConfig(
+        interaction=ZZ_Z_hamiltonian,
+        detuning=Z,
+        scale=scale,
+        shift=shift,
+        trainable_transform=trainable_transform,
+    )

{qadence-1.10.2 → qadence-1.11.0}/qadence/mitigations/analog_zne.py

@@ -92,7 +92,9 @@ def pulse_experiment(
         )
     # Convert observable to Numpy types compatible with QuTip simulations.
     # Matrices are flipped to match QuTip conventions.
-    converted_observable = [np.flip(block_to_tensor(obs).numpy()) for obs in observable]
+    converted_observable = [
+        np.flip(block_to_tensor(obs, use_full_support=True).numpy()) for obs in observable
+    ]
     # Create ZNE datasets by looping over batches.
     for observable in converted_observable:
         # Get expectation values at the end of the time serie [0,t]
@@ -130,7 +132,9 @@ def noise_level_experiment(
     )
     # Convert observable to Numpy types compatible with QuTip simulations.
     # Matrices are flipped to match QuTip conventions.
-    converted_observable = [np.flip(block_to_tensor(obs).numpy()) for obs in observable]
+    converted_observable = [
+        np.flip(block_to_tensor(obs, use_full_support=True).numpy()) for obs in observable
+    ]
     # Create ZNE datasets by looping over batches.
     for observable in converted_observable:
         # Get expectation values at the end of the time serie [0,t]

{qadence-1.10.2 → qadence-1.11.0}/qadence/ml_tools/__init__.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 from .callbacks.saveload import load_checkpoint, load_model, write_checkpoint
 from .config import AnsatzConfig, FeatureMapConfig, TrainConfig
-from .constructors import create_ansatz, create_fm_blocks, observable_from_config
+from .constructors import create_ansatz, create_fm_blocks, create_observable
 from .data import DictDataLoader, InfiniteTensorDataset, OptimizeResult, to_dataloader
+from .information import InformationContent
 from .models import QNN
 from .optimize_step import optimize_step as default_optimize_step
 from .parameters import get_parameters, num_parameters, set_parameters
@@ -18,7 +19,7 @@ __all__ = [
     "DictDataLoader",
     "FeatureMapConfig",
     "load_checkpoint",
-    "observable_from_config",
+    "create_observable",
     "QNN",
     "TrainConfig",
     "OptimizeResult",