qadence 1.8.0__tar.gz → 1.9.1__tar.gz

{qadence-1.8.0 → qadence-1.9.1}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.8.0
+Version: 1.9.1
 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>
 License: Apache 2.0
-License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -22,7 +21,7 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.5.1
+Requires-Dist: pyqtorch==1.6.0
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -54,7 +53,7 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.12.4; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.12.5; extra == 'pulser'
 Requires-Dist: pulser-core==1.1.1; extra == 'pulser'
 Requires-Dist: pulser-simulation==1.1.1; extra == 'pulser'
 Provides-Extra: visualization

{qadence-1.8.0 → qadence-1.9.1}/mkdocs.yml

@@ -16,11 +16,11 @@ nav:
   - Contents:
     - Block system: content/block_system.md
     - Parametric programs: content/parameters.md
-    - Time-dependent generators: content/time_dependent.md
     - Quantum models: content/quantummodels.md
     - Quantum registers: content/register.md
     - State initialization: content/state_init.md
     - Arbitrary Hamiltonians: content/hamiltonians.md
+    - Time-dependent generators: content/time_dependent.md
     - QML Constructors: content/qml_constructors.md
     - Wavefunction overlaps: content/overlap.md
     - Backends: content/backends.md
@@ -42,7 +42,9 @@ nav:
 
     - Variational quantum algorithms:
       - tutorials/qml/index.md
-      - Training tools: tutorials/qml/ml_tools.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

{qadence-1.8.0 → qadence-1.9.1}/pyproject.toml

@@ -26,7 +26,7 @@ authors = [
 ]
 requires-python = ">=3.9"
 license = { text = "Apache 2.0" }
-version = "1.8.0"
+version = "1.9.1"
 classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -50,7 +50,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.5.1",
+    "pyqtorch==1.6.0",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -64,7 +64,7 @@ allow-ambiguous-features = true
 pulser = [
     "pulser-core==1.1.1",
     "pulser-simulation==1.1.1",
-    "pasqal-cloud==0.12.4",
+    "pasqal-cloud==0.12.5",
 ]
 visualization = [
     "graphviz",

{qadence-1.8.0 → qadence-1.9.1}/qadence/__init__.py

@@ -34,7 +34,7 @@ logger.setLevel(LOG_LEVEL)
 [
     h.setLevel(LOG_LEVEL)  # type: ignore[func-returns-value]
     for h in logger.handlers
-    if h.get_name() == "console"
+    if h.get_name() == "console" or h.get_name() == "richconsole"
 ]
 logger.debug(f"Qadence logger successfully setup with log level {LOG_LEVEL}")
 

{qadence-1.8.0 → qadence-1.9.1}/qadence/analog/parse_analog.py

@@ -78,9 +78,8 @@ def _build_rot_ham_evo(
     if block.add_pattern and h_addr is not None:
         h_block += h_addr
     duration = block.parameters.duration
-    h_norm = block.parameters.h_norm
     h_block += h_drive
-    return HamEvo(h_block / h_norm, duration * h_norm / 1000)
+    return HamEvo(h_block, duration / 1000)
 
 
 def _analog_to_hevo(

{qadence-1.8.0 → qadence-1.9.1}/qadence/backends/gpsr.py

@@ -36,7 +36,11 @@ def general_psr(spectrum: Tensor, n_eqs: int | None = None, shift_prefac: float
     sorted_unique_spectral_gaps = torch.tensor(list(sorted_unique_spectral_gaps)[:n_eqs])
 
     if n_eqs == 1:
-        return single_gap_psr
+        return partial(
+            single_gap_psr,
+            spectral_gap=sorted_unique_spectral_gaps,
+            shift=shift_prefac * torch.tensor([PI / 2], dtype=torch.get_default_dtype()),
+        )
     else:
         return partial(
             multi_gap_psr,
@@ -110,7 +114,9 @@ def multi_gap_psr(
     batch_size = max(t.size(0) for t in param_dict.values())
 
     # get shift values
-    shifts = shift_prefac * torch.linspace(PI / 2 - PI / 5, PI / 2 + PI / 5, n_eqs)
+    shifts = shift_prefac * torch.linspace(
+        PI / 2 - PI / 4, PI / 2 + PI / 5, n_eqs
+    )  # breaking the symmetry of sampling range around PI/2
     device = torch.device("cpu")
     try:
         device = [v.device for v in param_dict.values()][0]

{qadence-1.8.0 → qadence-1.9.1}/qadence/backends/pulser/backend.py

@@ -25,7 +25,6 @@ from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.mitigations.protocols import apply_mitigation
 from qadence.noise import NoiseHandler
-from qadence.noise.protocols import apply_readout_noise
 from qadence.overlap import overlap_exact
 from qadence.register import Register
 from qadence.transpile import transpile
@@ -311,8 +310,6 @@ class Backend(BackendInterface):
             from qadence.transpile import invert_endianness
 
             samples = invert_endianness(samples)
-        if noise is not None:
-            samples = apply_readout_noise(noise=noise, samples=samples)
         if mitigation is not None:
             logger.warning(
                 "Mitigation protocol is deprecated. Use qadence-protocols instead.",
@@ -354,27 +351,14 @@ class Backend(BackendInterface):
                     noise=noise,
                 )
                 support = sorted(list(circuit.abstract.register.support))
-                # TODO: There should be a better check for batched density matrices.
-                if dms.size()[0] > 1:
-                    res_list = [
-                        [
-                            obs.native(
-                                dm.squeeze(), param_values, qubit_support=support, noise=noise
-                            )
-                            for dm in dms
-                        ]
-                        for obs in observable
-                    ]
-                    res = torch.stack(
-                        [torch.transpose(torch.stack(res), 0, -1) for res in res_list]
-                    )
-
-                else:
-                    res_list = [
-                        obs.native(dms, param_values, qubit_support=support) for obs in observable
+                res_list = [
+                    [
+                        obs.native(dm.squeeze(), param_values, qubit_support=support, noise=noise)
+                        for dm in dms
                     ]
-                    res = torch.transpose(torch.stack(res_list), 0, 1)
-                res = res if len(res.shape) > 0 else res.reshape(1)
+                    for obs in observable
+                ]
+                res = torch.stack([torch.transpose(torch.stack(res), 0, -1) for res in res_list])
                 return res.real
         elif mitigation is not None:
             logger.warning(

{qadence-1.8.0 → qadence-1.9.1}/qadence/backends/pyqtorch/backend.py

@@ -23,22 +23,62 @@ from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations.protocols import Mitigations, apply_mitigation
 from qadence.noise import NoiseHandler
-from qadence.noise.protocols import apply_readout_noise
 from qadence.transpile import (
     chain_single_qubit_ops,
     flatten,
     invert_endianness,
     scale_primitive_blocks_only,
+    set_noise,
     transpile,
 )
 from qadence.types import BackendName, Endianness, Engine
 
 from .config import Configuration, default_passes
-from .convert_ops import convert_block
+from .convert_ops import convert_block, convert_readout_noise
 
 logger = getLogger(__name__)
 
 
+def set_noise_abstract_to_native(circuit: ConvertedCircuit, config: Configuration) -> None:
+    """Set noise in native blocks from the abstract ones with noise.
+
+    Args:
+        circuit (ConvertedCircuit): Input converted circuit.
+    """
+    ops = convert_block(circuit.abstract.block, n_qubits=circuit.native.n_qubits, config=config)
+    circuit.native = pyq.QuantumCircuit(circuit.native.n_qubits, ops, circuit.native.readout_noise)
+
+
+def set_readout_noise(circuit: ConvertedCircuit, noise: NoiseHandler) -> None:
+    """Set readout noise in place in native.
+
+    Args:
+        circuit (ConvertedCircuit):  Input converted circuit.
+        noise (NoiseHandler | None): Noise.
+    """
+    readout = convert_readout_noise(circuit.abstract.n_qubits, noise)
+    if readout:
+        circuit.native.readout_noise = readout
+
+
+def set_block_and_readout_noises(
+    circuit: ConvertedCircuit, noise: NoiseHandler | None, config: Configuration
+) -> None:
+    """Add noise on blocks and readout on circuit.
+
+    We first start by adding noise to the abstract blocks. Then we do a conversion to their
+    native representation. Finally, we add readout.
+
+    Args:
+        circuit (ConvertedCircuit): Input circuit.
+        noise (NoiseHandler | None): Noise to add.
+    """
+    if noise:
+        set_noise(circuit, noise)
+        set_noise_abstract_to_native(circuit, config)
+        set_readout_noise(circuit, noise)
+
+
 @dataclass(frozen=True, eq=True)
 class Backend(BackendInterface):
     """PyQTorch backend."""
@@ -56,6 +96,17 @@ class Backend(BackendInterface):
     logger.debug("Initialised")
 
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
+        """Return the converted circuit.
+
+        Note that to get a representation with noise, noise
+        should be passed within the config.
+
+        Args:
+            circuit (QuantumCircuit): Original circuit
+
+        Returns:
+            ConvertedCircuit: ConvertedCircuit instance for backend.
+        """
         passes = self.config.transpilation_passes
         if passes is None:
             passes = default_passes(self.config)
@@ -63,9 +114,30 @@ class Backend(BackendInterface):
         original_circ = circuit
         if len(passes) > 0:
             circuit = transpile(*passes)(circuit)
+        # Setting noise in the circuit.
+        if self.config.noise:
+            set_noise(circuit, self.config.noise)
 
         ops = convert_block(circuit.block, n_qubits=circuit.n_qubits, config=self.config)
-        native = pyq.QuantumCircuit(circuit.n_qubits, ops)
+        readout_noise = (
+            convert_readout_noise(circuit.n_qubits, self.config.noise)
+            if self.config.noise
+            else None
+        )
+        if self.config.dropout_probability == 0:
+            native = pyq.QuantumCircuit(
+                circuit.n_qubits,
+                ops,
+                readout_noise,
+            )
+        else:
+            native = pyq.DropoutQuantumCircuit(
+                circuit.n_qubits,
+                ops,
+                readout_noise,
+                dropout_prob=self.config.dropout_probability,
+                dropout_mode=self.config.dropout_mode,
+            )
         return ConvertedCircuit(native=native, abstract=circuit, original=original_circ)
 
     def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
@@ -116,6 +188,7 @@ class Backend(BackendInterface):
         noise: NoiseHandler | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
+        set_block_and_readout_noises(circuit, noise, self.config)
         state = self.run(
             circuit,
             param_values=param_values,
@@ -152,6 +225,9 @@ class Backend(BackendInterface):
                 "Looping expectation does not make sense with batched initial state. "
                 "Define your initial state with `batch_size=1`"
             )
+
+        set_block_and_readout_noises(circuit, noise, self.config)
+
         list_expvals = []
         observables = observable if isinstance(observable, list) else [observable]
         for vals in to_list_of_dicts(param_values):
@@ -206,12 +282,11 @@ class Backend(BackendInterface):
         elif state is not None and pyqify_state:
             n_qubits = circuit.abstract.n_qubits
             state = pyqify(state, n_qubits) if pyqify_state else state
+        set_block_and_readout_noises(circuit, noise, self.config)
         samples: list[Counter] = circuit.native.sample(
             state=state, values=param_values, n_shots=n_shots
         )
         samples = invert_endianness(samples) if endianness != Endianness.BIG else samples
-        if noise is not None:
-            samples = apply_readout_noise(noise=noise, samples=samples)
         if mitigation is not None:
             logger.warning(
                 "Mitigation protocol is deprecated. Use qadence-protocols instead.",

{qadence-1.8.0 → qadence-1.9.1}/qadence/backends/pyqtorch/config.py

@@ -4,17 +4,16 @@ from dataclasses import dataclass
 from logging import getLogger
 from typing import Callable
 
-from pyqtorch.utils import SolverType
-
 from qadence.analog import add_background_hamiltonian
 from qadence.backend import BackendConfiguration
+from qadence.noise import NoiseHandler
 from qadence.transpile import (
     blockfn_to_circfn,
     chain_single_qubit_ops,
     flatten,
     scale_primitive_blocks_only,
 )
-from qadence.types import AlgoHEvo
+from qadence.types import AlgoHEvo, DropoutMode, SolverType
 
 logger = getLogger(__name__)
 
@@ -63,3 +62,11 @@ class Configuration(BackendConfiguration):
 
     Loop over the batch of parameters to only allocate a single wavefunction at any given time.
     """
+
+    noise: NoiseHandler | None = None
+    """NoiseHandler containing readout noise applied in backend."""
+
+    dropout_probability: float = 0.0
+    """Quantum dropout probability (0 means no dropout)."""
+    dropout_mode: DropoutMode = DropoutMode.ROTATIONAL
+    """Type of quantum dropout to perform."""

{qadence-1.8.0 → qadence-1.9.1}/qadence/backends/pyqtorch/convert_ops.py

@@ -175,8 +175,23 @@ def sympy_to_pyq(expr: sympy.Expr) -> ConcretizedCallable | Tensor:
 
 
 def convert_block(
-    block: AbstractBlock, n_qubits: int = None, config: Configuration = None
+    block: AbstractBlock,
+    n_qubits: int = None,
+    config: Configuration = None,
 ) -> Sequence[Module | Tensor | str | sympy.Expr]:
+    """Convert block to native Pyqtorch representation.
+
+    Args:
+        block (AbstractBlock): Block to convert.
+        n_qubits (int, optional): Number of qubits. Defaults to None.
+        config (Configuration, optional): Backend configuration instance. Defaults to None.
+
+    Raises:
+        NotImplementedError: For non supported blocks.
+
+    Returns:
+        Sequence[Module | Tensor | str | sympy.Expr]: List of native operations.
+    """
     if isinstance(block, (Tensor, str, sympy.Expr)):  # case for hamevo generators
         if isinstance(block, Tensor):
             block = block.permute(1, 2, 0)  # put batch size in the back
@@ -208,8 +223,10 @@ def convert_block(
         return [pyq.Scale(pyq.Sequence(scaled_ops), param)]
 
     elif isinstance(block, TimeEvolutionBlock):
+        duration = block.duration  # type: ignore [attr-defined]
         if getattr(block.generator, "is_time_dependent", False):
             config._use_gate_params = False
+            duration = config.get_param_name(block)[1]
             generator = convert_block(block.generator, config=config)[0]  # type: ignore [arg-type]
         elif isinstance(block.generator, sympy.Basic):
             generator = config.get_param_name(block)[1]
@@ -228,12 +245,26 @@ def convert_block(
             generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
         time_param = config.get_param_name(block)[0]
 
+        # convert noise operators here
+        noise_operators: list = [
+            convert_block(noise_block, config=config)[0] for noise_block in block.noise_operators
+        ]
+        if len(noise_operators) > 0:
+            # squeeze batch size for noise operators
+            noise_operators = [
+                pyq_op.tensor(full_support=qubit_support).squeeze(-1) for pyq_op in noise_operators
+            ]
+
         return [
             pyq.HamiltonianEvolution(
                 qubit_support=qubit_support,
                 generator=generator,
                 time=time_param,
                 cache_length=0,
+                duration=duration,
+                solver=config.ode_solver,
+                steps=config.n_steps_hevo,
+                noise_operators=noise_operators,
             )
         ]
 
@@ -320,7 +351,16 @@ def convert_block(
         )
 
 
-def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.NoiseProtocol:
+def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.NoiseProtocol | None:
+    """Convert the digital noise into pyqtorch NoiseProtocol.
+
+    Args:
+        noise (NoiseHandler): Noise to convert.
+
+    Returns:
+        pyq.noise.NoiseProtocol | None: Pyqtorch native noise protocol
+            if there are any digital noise protocols.
+    """
     digital_part = noise.filter(NoiseProtocol.DIGITAL)
     if digital_part is None:
         return None
@@ -330,3 +370,24 @@ def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.NoiseProtocol:
             for proto, option in zip(digital_part.protocol, digital_part.options)
         ]
     )
+
+
+def convert_readout_noise(n_qubits: int, noise: NoiseHandler) -> pyq.noise.ReadoutNoise | None:
+    """Convert the readout noise into pyqtorch ReadoutNoise.
+
+    Args:
+        n_qubits (int): Number of qubits
+        noise (NoiseHandler):  Noise to convert.
+
+    Returns:
+        pyq.noise.ReadoutNoise | None: Pyqtorch native ReadoutNoise instance
+            if readout is is noise.
+    """
+    readout_part = noise.filter(NoiseProtocol.READOUT)
+    if readout_part is None:
+        return None
+
+    if readout_part.protocol[0] == NoiseProtocol.READOUT.INDEPENDENT:
+        return pyq.noise.ReadoutNoise(n_qubits, **readout_part.options[0])
+    else:
+        return pyq.noise.CorrelatedReadoutNoise(**readout_part.options[0])

{qadence-1.8.0 → qadence-1.9.1}/qadence/blocks/primitive.py

@@ -356,6 +356,7 @@ class TimeEvolutionBlock(ParametricBlock):
     """
 
     name = "TimeEvolutionBlock"
+    noise_operators: list = list()
 
     @property
     def has_parametrized_generator(self) -> bool:

{qadence-1.8.0 → qadence-1.9.1}/qadence/execution.py

@@ -248,8 +248,6 @@ def _(
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> Tensor:
     observable = observable if isinstance(observable, list) else [observable]
-    if backend == BackendName.PYQTORCH:
-        diff_mode = DiffMode.AD
     bknd = backend_factory(backend, diff_mode=diff_mode, configuration=configuration)
     conv = bknd.convert(circuit, observable)
 

{qadence-1.8.0 → qadence-1.9.1}/qadence/log_config.yaml

@@ -4,11 +4,17 @@ formatters:
   base:
     format: "%(levelname) -5s %(asctime)s - %(name)s: %(message)s"
     datefmt: "%Y-%m-%d %H:%M:%S"
+  empty:
+    format: "%(message)s"  # Rich formatter for cleaner output
+    datefmt: "%Y-%m-%d %H:%M:%S"
 handlers:
   console:
     class: logging.StreamHandler
     formatter: base
     stream: ext://sys.stderr
+  richconsole:
+    class: rich.logging.RichHandler
+    formatter: empty
 loggers:
   qadence:
     level: INFO
@@ -22,3 +28,7 @@ loggers:
     level: INFO
     handlers: [console]
     propagate: yes
+  ml_tools:
+    level: INFO
+    handlers: [richconsole]
+    propagate: false