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

qadence/analog/addressing.py

@@ -59,9 +59,13 @@ class AddressingPattern:
     ) -> dict:
         # augment weight dict if needed
         weights = {
-            i: Parameter(0.0)
-            if i not in weights
-            else (Parameter(weights[i]) if not isinstance(weights[i], Parameter) else weights[i])
+            i: (
+                Parameter(0.0)
+                if i not in weights
+                else (
+                    Parameter(weights[i]) if not isinstance(weights[i], Parameter) else weights[i]
+                )
+            )
             for i in range(self.n_qubits)
         }
 

qadence/backends/api.py

@@ -3,6 +3,9 @@ from __future__ import annotations
 from qadence.backend import Backend, BackendConfiguration
 from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.extensions import (
+    BackendNotFoundError,
+    ConfigNotFoundError,
+    EngineNotFoundError,
     import_backend,
     import_config,
     import_engine,
@@ -49,12 +52,9 @@ def backend_factory(
             diff_backend_cls = import_engine(backend_inst.engine)
             backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode))  # type: ignore[operator]
         return backend_inst
-    except Exception as e:
-        msg = f"The requested backend '{backend}' is either not installed\
-            or could not be imported due to {e}."
-        logger.error(msg)
-        raise Exception(msg)
-    # Set backend configurations which depend on the differentiation mode
+    except (BackendNotFoundError, EngineNotFoundError, ConfigNotFoundError) as e:
+        logger.error(e.msg)
+        raise e
 
 
 def config_factory(backend_name: BackendName | str, config: dict) -> BackendConfiguration:
@@ -62,6 +62,7 @@ def config_factory(backend_name: BackendName | str, config: dict) -> BackendConf
     try:
         BackendConfigCls = import_config(backend_name)
         cfg = BackendConfigCls(**config)  # type: ignore[operator]
-    except Exception as e:
-        logger.debug(f"Unable to import config for backend {backend_name} due to {e}.")
+    except ConfigNotFoundError as e:
+        logger.error(e.msg)
+        raise e
     return cfg

qadence/backends/gpsr.py

@@ -10,7 +10,7 @@ from qadence.types import PI
 from qadence.utils import _round_complex
 
 
-def general_psr(spectrum: Tensor, n_eqs: int | None = None, shift_prefac: float = 0.5) -> Callable:
+def general_psr(spectrum: Tensor, shift_prefac: float = 0.5) -> Callable:
     diffs = _round_complex(spectrum - spectrum.reshape(-1, 1))
     sorted_unique_spectral_gaps = torch.unique(torch.abs(torch.tril(diffs)))
 

qadence/backends/horqrux/convert_ops.py

@@ -7,11 +7,11 @@ from operator import add
 from typing import Any, Callable, Dict
 
 import jax.numpy as jnp
-from horqrux.abstract import Primitive as Gate
 from horqrux.analog import _HamiltonianEvolution as NativeHorqHEvo
 from horqrux.apply import apply_gate
 from horqrux.parametric import RX, RY, RZ
 from horqrux.primitive import NOT, SWAP, H, I, X, Y, Z
+from horqrux.primitive import Primitive as Gate
 from horqrux.utils import inner
 from jax import Array
 from jax.scipy.linalg import expm

qadence/backends/pyqtorch/backend.py

@@ -71,19 +71,16 @@ class Backend(BackendInterface):
     def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
         # make sure only leaves, i.e. primitive blocks are scaled
         transpilations = [
-            lambda block: chain_single_qubit_ops(block)
-            if self.config.use_single_qubit_composition
-            else flatten(block),
+            lambda block: (
+                chain_single_qubit_ops(block)
+                if self.config.use_single_qubit_composition
+                else flatten(block)
+            ),
             scale_primitive_blocks_only,
         ]
         block = transpile(*transpilations)(observable)  # type: ignore[call-overload]
         operations = convert_block(block, n_qubits, self.config)
-        obs_cls = (
-            pyq.DiagonalObservable
-            if block._is_diag_pauli and not block.is_parametric
-            else pyq.Observable
-        )
-        native = obs_cls(n_qubits=n_qubits, operations=operations)
+        native = pyq.Observable(operations=operations)
         return ConvertedObservable(native=native, abstract=block, original=observable)
 
     def run(
@@ -140,7 +137,7 @@ class Backend(BackendInterface):
         )
         observable = observable if isinstance(observable, list) else [observable]
         _expectation = torch.hstack(
-            [obs.native(state, param_values).reshape(-1, 1) for obs in observable]
+            [obs.native.expectation(state, param_values).reshape(-1, 1) for obs in observable]
         )
         return _expectation
 
@@ -169,7 +166,7 @@ class Backend(BackendInterface):
         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(wf, vals) for obs in observables], 0)
+            exs = torch.cat([obs.native.expectation(wf, vals) for obs in observables], 0)
             list_expvals.append(exs)
 
         batch_expvals = torch.vstack(list_expvals)

qadence/backends/pyqtorch/convert_ops.py

@@ -118,7 +118,7 @@ def convert_block(
         # ]
         return [PyQHamiltonianEvolution(qubit_support, n_qubits, block, config)]
     elif isinstance(block, MatrixBlock):
-        return [pyq.primitive.Primitive(block.matrix, block.qubit_support)]
+        return [pyq.primitives.Primitive(block.matrix, block.qubit_support)]
     elif isinstance(block, CompositeBlock):
         ops = list(flatten(*(convert_block(b, n_qubits, config) for b in block.blocks)))
         if isinstance(block, AddBlock):
@@ -374,8 +374,6 @@ class PyQHamiltonianEvolution(Module):
                 state,
                 self.unitary(values),
                 self.qubit_support,
-                self.n_qubits,
-                self.batch_size,
             )
 
         return result

qadence/backends/utils.py

@@ -9,7 +9,7 @@ import pyqtorch as pyq
 import torch
 from numpy.typing import ArrayLike
 from pyqtorch.apply import apply_operator
-from pyqtorch.parametric import Parametric as PyQParametric
+from pyqtorch.primitives import Parametric as PyQParametric
 from torch import (
     Tensor,
     cat,

qadence/blocks/composite.py

@@ -129,9 +129,11 @@ class CompositeBlock(AbstractBlock):
         from qadence.blocks.utils import _construct, tag
 
         blocks = [
-            getattr(operations, b["type"])._from_dict(b)
-            if hasattr(operations, b["type"])
-            else getattr(qadenceblocks, b["type"])._from_dict(b)
+            (
+                getattr(operations, b["type"])._from_dict(b)
+                if hasattr(operations, b["type"])
+                else getattr(qadenceblocks, b["type"])._from_dict(b)
+            )
             for b in d["blocks"]
         ]
         block = _construct(cls, blocks)  # type: ignore[arg-type]

qadence/blocks/utils.py

@@ -263,11 +263,29 @@ def expression_to_uuids(block: AbstractBlock) -> dict[Expr, list[str]]:
     return expr_to_uuid
 
 
-def uuid_to_eigen(block: AbstractBlock) -> dict[str, Tensor]:
+def uuid_to_eigen(
+    block: AbstractBlock, rescale_eigenvals_timeevo: bool = False
+) -> dict[str, Tensor]:
     """Creates a mapping between a parametric block's param_id and its' eigenvalues.
 
     This method is needed for constructing the PSR rules for a given block.
 
+    A PSR shift factor is also added in the mapping for dealing
+    with the time evolution case as it requires rescaling.
+
+    Args:
+        block (AbstractBlock): Block input
+        rescale_eigenvals_timeevo (bool, optional): If True, rescale
+        eigenvalues and shift factor
+        by 2 times spectral gap
+        for the TimeEvolutionBlock case to allow
+        differientiating with Hamevo.
+        Defaults to False.
+
+    Returns:
+        dict[str, Tensor]: Mapping between block's param_id, eigenvalues and
+        PSR shift.
+
     !!! warn
         Will ignore eigenvalues of AnalogBlocks that are not yet computed.
     """
@@ -276,7 +294,23 @@ def uuid_to_eigen(block: AbstractBlock) -> dict[str, Tensor]:
     for uuid, b in uuid_to_block(block).items():
         if b.eigenvalues_generator is not None:
             if b.eigenvalues_generator.numel() > 0:
-                result[uuid] = b.eigenvalues_generator
+                # 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,
+                        )
+                    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):

qadence/constructors/utils.py

@@ -7,61 +7,59 @@ import sympy
 from qadence.blocks import KronBlock, kron
 from qadence.operations import RY
 from qadence.parameters import FeatureParameter, Parameter
-from qadence.types import PI
+from qadence.types import PI, BasisSet, MultivariateStrategy, ReuploadScaling
 
 
-def generator_prefactor(spectrum: str, qubit_index: int) -> float | int:
+def generator_prefactor(reupload_scaling: ReuploadScaling, qubit_index: int) -> float | int:
     """Converts a spectrum string, e.g. tower or exponential.
 
     The result is the correct generator prefactor.
     """
-    spectrum = spectrum.lower()
     conversion_dict: dict[str, float | int] = {
-        "simple": 1,
-        "tower": qubit_index + 1,
-        "exponential": 2 * PI / (2 ** (qubit_index + 1)),
+        ReuploadScaling.CONSTANT: 1,
+        ReuploadScaling.TOWER: qubit_index + 1,
+        ReuploadScaling.EXP: 2 * PI / (2 ** (qubit_index + 1)),
     }
-    return conversion_dict[spectrum]
+    return conversion_dict[reupload_scaling]
 
 
-def basis_func(basis: str, x: Parameter) -> Parameter | sympy.Expr:
-    basis = basis.lower()
+def basis_func(basis: BasisSet, x: Parameter) -> Parameter | sympy.Expr:
     conversion_dict: dict[str, Parameter | sympy.Expr] = {
-        "fourier": x,
-        "chebyshev": 2 * sympy.acos(x),
+        BasisSet.FOURIER: x,
+        BasisSet.CHEBYSHEV: 2 * sympy.acos(x),
     }
     return conversion_dict[basis]
 
 
 def build_idx_fms(
-    basis: str,
+    basis: BasisSet,
     fm_pauli: Type[RY],
-    fm_strategy: str,
+    multivariate_strategy: MultivariateStrategy,
     n_features: int,
     n_qubits: int,
-    spectrum: str,
+    reupload_scaling: ReuploadScaling,
 ) -> list[KronBlock]:
     """Builds the index feature maps based on the given parameters.
 
     Args:
-        basis (str): Type of basis chosen for the feature map.
+        basis (BasisSet): Type of basis chosen for the feature map.
         fm_pauli (PrimitiveBlock type): The chosen Pauli rotation type.
-        fm_strategy (str): The feature map strategy to be used. Possible values are
-            'parallel' or 'serial'.
+        multivariate_strategy (MultivariateStrategy): The strategy used for encoding
+            the multivariate feature map.
         n_features (int): The number of features.
         n_qubits (int): The number of qubits.
-        spectrum (str): The chosen spectrum.
+        reupload_scaling (ReuploadScaling): The chosen scaling for the reupload.
 
     Returns:
         List[KronBlock]: The list of index feature maps.
     """
     idx_fms = []
     for i in range(n_features):
-        target_qubits = get_fm_qubits(fm_strategy, i, n_qubits, n_features)
+        target_qubits = get_fm_qubits(multivariate_strategy, i, n_qubits, n_features)
         param = FeatureParameter(f"x{i}")
         block = kron(
             *[
-                fm_pauli(qubit, generator_prefactor(spectrum, j) * basis_func(basis, param))
+                fm_pauli(qubit, generator_prefactor(reupload_scaling, j) * basis_func(basis, param))
                 for j, qubit in enumerate(target_qubits)
             ]
         )
@@ -70,12 +68,14 @@ def build_idx_fms(
     return idx_fms
 
 
-def get_fm_qubits(fm_strategy: str, i: int, n_qubits: int, n_features: int) -> Iterable:
+def get_fm_qubits(
+    multivariate_strategy: MultivariateStrategy, i: int, n_qubits: int, n_features: int
+) -> Iterable:
     """Returns the list of target qubits for the given feature map strategy and feature index.
 
     Args:
-        fm_strategy (str): The feature map strategy to be used. Possible values
-            are 'parallel' or 'serial'.
+        multivariate_strategy (MultivariateStrategy): The strategy used for encoding
+            the multivariate feature map.
         i (int): The feature index.
         n_qubits (int): The number of qubits.
         n_features (int): The number of features.
@@ -86,11 +86,11 @@ def get_fm_qubits(fm_strategy: str, i: int, n_qubits: int, n_features: int) -> I
     Raises:
         ValueError: If the feature map strategy is not implemented.
     """
-    if fm_strategy == "parallel":
+    if multivariate_strategy == MultivariateStrategy.PARALLEL:
         n_qubits_per_feature = int(n_qubits / n_features)
         target_qubits = range(i * n_qubits_per_feature, (i + 1) * n_qubits_per_feature)
-    elif fm_strategy == "serial":
+    elif multivariate_strategy == MultivariateStrategy.SERIES:
         target_qubits = range(0, n_qubits)
     else:
-        raise ValueError(f"Feature map strategy {fm_strategy} not implemented.")
+        raise ValueError(f"Multivariate strategy {multivariate_strategy} not implemented.")
     return target_qubits

qadence/engines/jax/differentiable_expectation.py

@@ -52,7 +52,7 @@ class DifferentiableExpectation:
             return expectation_fn(state, values, psr_params)
 
         uuid_to_eigs = {
-            k: tensor_to_jnp(v) for k, v in uuid_to_eigen(self.circuit.abstract.block).items()
+            k: tensor_to_jnp(v[0]) for k, v in uuid_to_eigen(self.circuit.abstract.block).items()
         }
         self.psr_params = {
             k: self.param_values[k] for k in uuid_to_eigs.keys()

qadence/engines/torch/differentiable_expectation.py

@@ -6,7 +6,7 @@ from functools import partial
 from typing import Any, Callable, Sequence
 
 import torch
-from pyqtorch.adjoint import AdjointExpectation
+from pyqtorch.differentiation import AdjointExpectation
 from torch import Tensor
 from torch.autograd import Function
 
@@ -211,24 +211,28 @@ class DifferentiableExpectation:
         circuit: QuantumCircuit,
         observable: list[AbstractBlock],
         psr_fn: Callable,
-        **psr_args: int | float | None,
+        **psr_args: float | None,
     ) -> dict[str, Callable]:
         """Create a mapping between parameters and PSR functions."""
 
-        uuid_to_eigs = uuid_to_eigen(circuit.block)
+        uuid_to_eigs = uuid_to_eigen(circuit.block, rescale_eigenvals_timeevo=True)
         # We currently rely on implicit ordering to match the PSR to the parameter,
         # because we want to cache PSRs.
 
         param_to_psr = OrderedDict()
-        for param_id, eigenvalues in uuid_to_eigs.items():
+        for param_id, eigenvalues_shift_factor in uuid_to_eigs.items():
+            eigenvalues, shift_factor = eigenvalues_shift_factor
             if eigenvalues is None:
                 raise ValueError(
                     f"Eigenvalues are not defined for param_id {param_id}\n"
                     # f"of type {type(block)}.\n"
                     "PSR cannot be defined in that case."
                 )
-
-            param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args)
+            if shift_factor == 1:
+                param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args)
+            else:
+                psr_args_factor = {k: v * shift_factor for k, v in psr_args.items()}
+                param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args)
         for obs in observable:
             for param_id, _ in uuid_to_eigen(obs).items():
                 # We need the embedded fixed params of the observable in the param_values dict

qadence/extensions.py

@@ -15,6 +15,22 @@ EngineClsType = TypeVar("EngineClsType", bound=DifferentiableBackend)
 logger = getLogger(__name__)
 
 
+class ConfigNotFoundError(ModuleNotFoundError):
+    ...
+
+
+class BackendNotFoundError(ModuleNotFoundError):
+    ...
+
+
+class EngineNotFoundError(ModuleNotFoundError):
+    ...
+
+
+class SupportedGatesNotFoundError(ModuleNotFoundError):
+    ...
+
+
 def import_config(backend_name: str | BackendName) -> BackendConfiguration:
     module_path = f"qadence.backends.{backend_name}.config"
     cfg: BackendConfiguration
@@ -22,7 +38,8 @@ def import_config(backend_name: str | BackendName) -> BackendConfiguration:
         module = importlib.import_module(module_path)
         cfg = getattr(module, "Configuration")
     except (ModuleNotFoundError, ImportError) as e:
-        raise type(e)(f"Failed to import backend config of {backend_name} due to {e}.") from e
+        msg = f"Failed to import backend config for '{backend_name}' due to: '{e.msg}'."
+        raise ConfigNotFoundError(msg)
     return cfg
 
 
@@ -37,7 +54,8 @@ def import_backend(backend_name: str | BackendName) -> Backend:
         try:
             module = importlib.import_module(module_path)
         except (ModuleNotFoundError, ImportError) as e:
-            raise type(e)
+            msg = f"Failed to import backend '{backend_name}' due to: '{e.msg}'."
+            raise BackendNotFoundError(msg)
     backend = getattr(module, "Backend")
     return backend
 
@@ -48,8 +66,8 @@ def _available_backends() -> dict[BackendName, Backend]:
     for backend in BackendName.list():
         try:
             res[backend] = import_backend(backend)
-        except (ModuleNotFoundError, ImportError) as e:
-            raise type(e)(f"Failed to import backend {backend} due to {e}.") from e
+        except BackendNotFoundError as e:
+            raise e
     logger.debug(f"Found backends: {res.keys()}")
     return res
 
@@ -61,7 +79,8 @@ def import_engine(engine_name: str | Engine) -> DifferentiableBackend:
         module = importlib.import_module(module_path)
         engine = getattr(module, "DifferentiableBackend")
     except (ModuleNotFoundError, ImportError) as e:
-        raise type(e)
+        msg = f"Failed to import engine '{engine_name}' due to: '{e.msg}'."
+        raise EngineNotFoundError(msg)
     return engine
 
 
@@ -71,8 +90,8 @@ def _available_engines() -> dict[Engine, DifferentiableBackend]:
     for engine in Engine.list():
         try:
             res[engine] = import_engine(engine)
-        except (ModuleNotFoundError, ImportError) as e:
-            raise type(e)(f"Failed to import engine {engine} due to {e}.") from e
+        except EngineNotFoundError as e:
+            raise e
     logger.debug(f"Found engines: {res.keys()}")
     return res
 
@@ -87,7 +106,8 @@ def _supported_gates(backend_name: str) -> list[TAbstractBlock]:
     try:
         module = importlib.import_module(module_path)
     except (ModuleNotFoundError, ImportError) as e:
-        raise type(e)(f"Failed to import backend module for {backend_name} due to {e}.") from e
+        msg = f"Failed to import supported gates for '{backend_name}' due to: '{e.msg}'."
+        raise SupportedGatesNotFoundError(msg)
     _supported_gates = getattr(module, "supported_gates")
     return [getattr(operations, gate) for gate in _supported_gates]
 

qadence/ml_tools/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from .config import AnsatzConfig, FeatureMapConfig, TrainConfig
+from .config import AnsatzConfig, Callback, FeatureMapConfig, TrainConfig
 from .constructors import create_ansatz, create_fm_blocks, observable_from_config
 from .data import DictDataLoader, InfiniteTensorDataset, to_dataloader
 from .models import QNN
@@ -23,6 +23,7 @@ __all__ = [
     "observable_from_config",
     "QNN",
     "TrainConfig",
+    "Callback",
     "train_with_grad",
     "train_gradient_free",
     "write_checkpoint",