qadence 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

qadence/backends/__init__.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 from .api import backend_factory, config_factory
-from .pytorch_wrapper import DifferentiableBackend
 
 # Modules to be automatically added to the qadence namespace
-__all__ = ["backend_factory", "config_factory", "DifferentiableBackend"]
+__all__ = ["backend_factory", "config_factory"]

qadence/backends/api.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from qadence.backend import Backend, BackendConfiguration
-from qadence.backends.pytorch_wrapper import DifferentiableBackend
-from qadence.extensions import available_backends, set_backend_config
-from qadence.types import BackendName, DiffMode
+from qadence.engines.differentiable_backend import DifferentiableBackend
+from qadence.extensions import available_backends, available_engines, set_backend_config
+from qadence.types import BackendName, DiffMode, Engine
 
 __all__ = ["backend_factory", "config_factory"]
 
@@ -14,13 +14,18 @@ def backend_factory(
     configuration: BackendConfiguration | dict | None = None,
 ) -> Backend | DifferentiableBackend:
     backend_inst: Backend | DifferentiableBackend
-    backend_name = BackendName(backend)
     backends = available_backends()
-
+    try:
+        backend_name = BackendName(backend)
+    except ValueError:
+        raise NotImplementedError(f"The requested backend '{backend}' is not implemented.")
     try:
         BackendCls = backends[backend_name]
-    except (KeyError, ValueError):
-        raise NotImplementedError(f"The requested backend '{backend_name}' is not implemented.")
+    except Exception as e:
+        raise ImportError(
+            f"The requested backend '{backend_name}' is either not installed\
+              or could not be imported due to {e}."
+        )
 
     default_config = BackendCls.default_configuration()
     if configuration is None:
@@ -44,9 +49,22 @@ def backend_factory(
 
     # Set backend configurations which depend on the differentiation mode
     set_backend_config(backend_inst, diff_mode)
-
+    # Wrap the quantum Backend in a DifferentiableBackend if a diff_mode is passed.
     if diff_mode is not None:
-        backend_inst = DifferentiableBackend(backend_inst, DiffMode(diff_mode))
+        try:
+            engine_name = Engine(backend_inst.engine)
+        except ValueError:
+            raise NotImplementedError(
+                f"The requested engine '{backend_inst.engine}' is not implemented."
+            )
+        try:
+            diff_backend_cls = available_engines()[engine_name]
+            backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode))  # type: ignore[arg-type]
+        except Exception as e:
+            raise ImportError(
+                f"The requested engine '{engine_name}' is either not installed\
+                or could not be imported due to {e}."
+            )
     return backend_inst
 
 

qadence/backends/braket/backend.py

@@ -23,7 +23,7 @@ from qadence.noise import Noise
 from qadence.noise.protocols import apply_noise
 from qadence.overlap import overlap_exact
 from qadence.transpile import transpile
-from qadence.types import BackendName
+from qadence.types import BackendName, Engine
 from qadence.utils import Endianness
 
 from .config import Configuration, default_passes
@@ -55,6 +55,7 @@ class Backend(BackendInterface):
     with_noise: bool = False
     native_endianness: Endianness = Endianness.BIG
     config: Configuration = field(default_factory=Configuration)
+    engine: Engine = Engine.TORCH
 
     # braket specifics
     # TODO: include it in the configuration?
@@ -87,7 +88,7 @@ class Backend(BackendInterface):
         ).squeeze(0)
         return ConvertedObservable(native=native, abstract=obs, original=obs)
 
-    def run(
+    def _run(
         self,
         circuit: ConvertedCircuit,
         param_values: dict[str, Tensor] = {},

qadence/backends/horqrux/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .backend import Backend
+from .config import Configuration
+from .convert_ops import supported_gates

qadence/backends/horqrux/backend.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+from horqrux.utils import prepare_state
+from jax.typing import ArrayLike
+
+from qadence.backend import Backend as BackendInterface
+from qadence.backend import ConvertedCircuit, ConvertedObservable
+from qadence.backends.jax_utils import (
+    tensor_to_jnp,
+    unhorqify,
+    uniform_batchsize,
+)
+from qadence.backends.utils import pyqify
+from qadence.blocks import AbstractBlock
+from qadence.circuit import QuantumCircuit
+from qadence.measurements import Measurements
+from qadence.mitigations import Mitigations
+from qadence.noise import Noise
+from qadence.transpile import flatten, scale_primitive_blocks_only, transpile
+from qadence.types import BackendName, Endianness, Engine, ParamDictType
+from qadence.utils import int_to_basis
+
+from .config import Configuration, default_passes
+from .convert_ops import HorqruxCircuit, convert_block, convert_observable
+
+
+@dataclass(frozen=True, eq=True)
+class Backend(BackendInterface):
+    # set standard interface parameters
+    name: BackendName = BackendName.HORQRUX  # type: ignore[assignment]
+    supports_ad: bool = True
+    supports_adjoint: bool = False
+    support_bp: bool = True
+    supports_native_psr: bool = False
+    is_remote: bool = False
+    with_measurements: bool = True
+    with_noise: bool = False
+    native_endianness: Endianness = Endianness.BIG
+    config: Configuration = field(default_factory=Configuration)
+    engine: Engine = Engine.JAX
+
+    def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
+        passes = self.config.transpilation_passes
+        if passes is None:
+            passes = default_passes(self.config)
+
+        original_circ = circuit
+        if len(passes) > 0:
+            circuit = transpile(*passes)(circuit)
+        ops = convert_block(circuit.block, n_qubits=circuit.n_qubits, config=self.config)
+        return ConvertedCircuit(
+            native=HorqruxCircuit(ops), abstract=circuit, original=original_circ
+        )
+
+    def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
+        transpilations = [
+            flatten,
+            scale_primitive_blocks_only,
+        ]
+        block = transpile(*transpilations)(observable)  # type: ignore[call-overload]
+        hq_obs = convert_observable(block, n_qubits=n_qubits, config=self.config)
+        return ConvertedObservable(native=hq_obs, abstract=block, original=observable)
+
+    def _run(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
+        endianness: Endianness = Endianness.BIG,
+        horqify_state: bool = True,
+        unhorqify_state: bool = True,
+    ) -> ArrayLike:
+        n_qubits = circuit.abstract.n_qubits
+        if state is None:
+            state = prepare_state(n_qubits, "0" * n_qubits)
+        else:
+            state = tensor_to_jnp(pyqify(state)) if horqify_state else state
+        state = circuit.native.forward(state, param_values)
+        if endianness != self.native_endianness:
+            state = jnp.reshape(state, (1, 2**n_qubits))  # batch_size is always 1
+            ls = list(range(2**n_qubits))
+            permute_ind = jnp.array([int(f"{num:0{n_qubits}b}"[::-1], 2) for num in ls])
+            state = state[:, permute_ind]
+        if unhorqify_state:
+            state = unhorqify(state)
+        return state
+
+    def run_dm(
+        self,
+        circuit: ConvertedCircuit,
+        noise: Noise,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> ArrayLike:
+        raise NotImplementedError
+
+    def expectation(
+        self,
+        circuit: ConvertedCircuit,
+        observable: list[ConvertedObservable] | ConvertedObservable,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
+        measurement: Measurements | None = None,
+        noise: Noise | None = None,
+        mitigation: Mitigations | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> ArrayLike:
+        observable = observable if isinstance(observable, list) else [observable]
+        batch_size = max([arr.size for arr in param_values.values()])
+        n_obs = len(observable)
+
+        def _expectation(params: ParamDictType) -> ArrayLike:
+            out_state = self.run(
+                circuit, params, state, endianness, horqify_state=True, unhorqify_state=False
+            )
+            return jnp.array([o.native.forward(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)
+            )
+        else:
+            expvals = _expectation(param_values)
+        if expvals.size > 1:
+            expvals = jnp.reshape(expvals, (batch_size, n_obs))
+        else:
+            expvals = jnp.squeeze(
+                expvals, 0
+            )  # For the case of batch_size == n_obs == 1, we remove the dims
+        return expvals
+
+    def sample(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: ParamDictType = {},
+        n_shots: int = 1,
+        state: ArrayLike | None = None,
+        noise: Noise | None = None,
+        mitigation: Mitigations | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> list[Counter]:
+        """Samples from a batch of discrete probability distributions.
+
+        Args:
+            circuit: A ConvertedCircuit object holding the native PyQ Circuit.
+            param_values: A dict holding the embedded parameters which the native ciruit expects.
+            n_shots: The number of samples to generate per distribution.
+            state: The input state.
+            endianness (Endianness): The target endianness of the resulting samples.
+
+        Returns:
+            A list of Counter objects where each key represents a bitstring
+            and its value the number of times it has been sampled from the given wave function.
+        """
+        if n_shots < 1:
+            raise ValueError("You can only call sample with n_shots>0.")
+
+        def _sample(
+            _probs: ArrayLike, n_shots: int, endianness: Endianness, n_qubits: int
+        ) -> Counter:
+            _logits = jax.vmap(lambda _p: jnp.log(_p / (1 - _p)))(_probs)
+
+            def _smple(accumulator: ArrayLike, i: int) -> tuple[ArrayLike, None]:
+                accumulator = accumulator.at[i].set(
+                    jax.random.categorical(jax.random.PRNGKey(i), _logits)
+                )
+                return accumulator, None
+
+            samples = jax.lax.scan(
+                _smple, jnp.empty_like(jnp.arange(n_shots)), jnp.arange(n_shots)
+            )[0]
+            return Counter(
+                {
+                    int_to_basis(k=k, n_qubits=n_qubits, endianness=endianness): count.item()
+                    for k, count in enumerate(jnp.bincount(samples))
+                    if count > 0
+                }
+            )
+
+        wf = self.run(
+            circuit=circuit,
+            param_values=param_values,
+            state=state,
+            horqify_state=True,
+            unhorqify_state=False,
+        )
+        probs = jnp.abs(jnp.float_power(wf, 2.0)).ravel()
+        samples = [
+            _sample(
+                _probs=probs,
+                n_shots=n_shots,
+                endianness=endianness,
+                n_qubits=circuit.abstract.n_qubits,
+            ),
+        ]
+
+        return samples
+
+    def assign_parameters(self, circuit: ConvertedCircuit, param_values: ParamDictType) -> Any:
+        raise NotImplementedError
+
+    @staticmethod
+    def _overlap(bras: ArrayLike, kets: ArrayLike) -> ArrayLike:
+        # TODO
+        raise NotImplementedError
+
+    @staticmethod
+    def default_configuration() -> Configuration:
+        return Configuration()

qadence/backends/horqrux/config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from qadence.backend import BackendConfiguration
+from qadence.logger import get_logger
+from qadence.transpile import (
+    blockfn_to_circfn,
+    flatten,
+    scale_primitive_blocks_only,
+)
+
+logger = get_logger(__name__)
+
+
+def default_passes(config: Configuration) -> list[Callable]:
+    return [
+        flatten,
+        blockfn_to_circfn(scale_primitive_blocks_only),
+    ]
+
+
+@dataclass
+class Configuration(BackendConfiguration):
+    pass

qadence/backends/horqrux/convert_ops.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from functools import reduce
+from itertools import chain as flatten
+from operator import add
+from typing import Any, Callable, Dict
+
+import jax.numpy as jnp
+from horqrux.gates import NOT, H, I, Rx, Ry, Rz, X, Y, Z
+from horqrux.ops import apply_gate
+from horqrux.types import Gate
+from horqrux.utils import overlap
+from jax import Array
+from jax.tree_util import register_pytree_node_class
+
+from qadence.blocks import (
+    AbstractBlock,
+    AddBlock,
+    ChainBlock,
+    CompositeBlock,
+    KronBlock,
+    ParametricBlock,
+    PrimitiveBlock,
+    ScaleBlock,
+)
+from qadence.operations import CNOT, CRX, CRY, CRZ
+from qadence.types import OpName, ParamDictType
+
+from .config import Configuration
+
+ops_map: Dict[str, Callable] = {
+    OpName.X: X,
+    OpName.Y: Y,
+    OpName.Z: Z,
+    OpName.H: H,
+    OpName.RX: Rx,
+    OpName.RY: Ry,
+    OpName.RZ: Rz,
+    OpName.CRX: Rx,
+    OpName.CRY: Ry,
+    OpName.CRZ: Rz,
+    OpName.CNOT: NOT,
+    OpName.I: I,
+}
+
+supported_gates = list(set(list(ops_map.keys())))
+
+
+@register_pytree_node_class
+@dataclass
+class HorqruxCircuit:
+    operators: list[Gate] = field(default_factory=list)
+
+    def tree_flatten(self) -> tuple[tuple[list[Any]], tuple[()]]:
+        children = (self.operators,)
+        aux_data = ()
+        return (children, aux_data)
+
+    @classmethod
+    def tree_unflatten(cls, aux_data: Any, children: Any) -> Any:
+        return cls(*children, *aux_data)
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        for op in self.operators:
+            state = op.forward(state, values)
+        return state
+
+
+@dataclass
+class HorqruxObservable(HorqruxCircuit):
+    def __init__(self, operators: list[Gate]):
+        super().__init__(operators=operators)
+
+    def _forward(self, state: Array, values: ParamDictType) -> Array:
+        for op in self.operators:
+            state = op.forward(state, values)
+        return state
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        return overlap(state, self._forward(state, values))
+
+
+def convert_observable(
+    block: AbstractBlock, n_qubits: int, config: Configuration
+) -> HorqruxObservable:
+    _ops = convert_block(block, n_qubits, config)
+    return HorqruxObservable(_ops)
+
+
+def convert_block(
+    block: AbstractBlock, n_qubits: int = None, config: Configuration = Configuration()
+) -> list:
+    if n_qubits is None:
+        n_qubits = max(block.qubit_support) + 1
+    ops = []
+    if isinstance(block, CompositeBlock):
+        ops = list(flatten(*(convert_block(b, n_qubits, config) for b in block.blocks)))
+        if isinstance(block, AddBlock):
+            ops = [HorqAddGate(ops)]
+        elif isinstance(block, ChainBlock):
+            ops = [HorqruxCircuit(ops)]
+        elif isinstance(block, KronBlock):
+            if all(
+                [
+                    isinstance(b, ParametricBlock) and not isinstance(b, ScaleBlock)
+                    for b in block.blocks
+                ]
+            ):
+                param_names = [config.get_param_name(b)[0] for b in block.blocks if b.is_parametric]
+                ops = [
+                    HorqKronParametric(
+                        gates=[ops_map[b.name] for b in block.blocks],
+                        target=[b.qubit_support[0] for b in block.blocks],
+                        param_names=param_names,
+                    )
+                ]
+
+            elif all([b.name == "CNOT" for b in block.blocks]):
+                ops = [
+                    HorqKronCNOT(
+                        gates=[ops_map[b.name] for b in block.blocks],
+                        target=[b.qubit_support[1] for b in block.blocks],
+                        control=[b.qubit_support[0] for b in block.blocks],
+                    )
+                ]
+            else:
+                ops = [HorqruxCircuit(ops)]
+
+    elif isinstance(block, CNOT):
+        native_op = ops_map[block.name]
+        ops = [
+            HorqCNOTGate(native_op, block.qubit_support[0], block.qubit_support[1])
+        ]  # in horqrux target and control are swapped
+
+    elif isinstance(block, (CRX, CRY, CRZ)):
+        native_op = ops_map[block.name]
+        param_name = config.get_param_name(block)[0]
+
+        ops = [
+            HorqParametricGate(
+                gate=native_op,
+                qubit=block.qubit_support[1],
+                parameter_name=param_name,
+                control=block.qubit_support[0],
+                name=block.name,
+            )
+        ]
+    elif isinstance(block, ScaleBlock):
+        op = convert_block(block.block, n_qubits, config=config)[0]
+        param_name = config.get_param_name(block)[0]
+        ops = [HorqScaleGate(op, param_name)]
+
+    elif isinstance(block, ParametricBlock):
+        native_op = ops_map[block.name]
+        if len(block.parameters._uuid_dict) > 1:
+            raise NotImplementedError("Only single-parameter operations are supported.")
+        param_name = config.get_param_name(block)[0]
+
+        ops = [
+            HorqParametricGate(
+                gate=native_op,
+                qubit=block.qubit_support[0],
+                parameter_name=param_name,
+            )
+        ]
+
+    elif isinstance(block, PrimitiveBlock):
+        native_op = ops_map[block.name]
+        qubit = block.qubit_support[0]
+        ops = [HorqPrimitiveGate(gate=native_op, qubit=qubit, name=block.name)]
+
+    else:
+        raise NotImplementedError(f"Non-supported operation of type {type(block)}.")
+
+    return ops
+
+
+class HorqPrimitiveGate:
+    def __init__(self, gate: Gate, qubit: int, name: str):
+        self.gates: Gate = gate
+        self.target = qubit
+        self.name = name
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        return apply_gate(state, self.gates(self.target))
+
+    def __repr__(self) -> str:
+        return self.name + f"(target={self.target})"
+
+
+class HorqCNOTGate:
+    def __init__(self, gate: Gate, control: int, target: int):
+        self.gates: Callable = gate
+        self.control: int = control
+        self.target: int = target
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        return apply_gate(state, self.gates(self.target, self.control))
+
+
+class HorqKronParametric:
+    def __init__(self, gates: list[Gate], param_names: list[str], target: list[int]):
+        self.operators: list[Gate] = gates
+        self.target: list[int] = target
+        self.param_names: list[str] = param_names
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        return apply_gate(
+            state,
+            tuple(
+                gate(values[param_name], target)
+                for gate, target, param_name in zip(self.operators, self.target, self.param_names)
+            ),
+        )
+
+
+class HorqKronCNOT(HorqruxCircuit):
+    def __init__(self, gates: list[Gate], target: list[int], control: list[int]):
+        self.operators: list[Gate] = gates
+        self.target: list[int] = target
+        self.control: list[int] = control
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        return apply_gate(
+            state,
+            tuple(
+                gate(target, control)
+                for gate, target, control in zip(self.operators, self.target, self.control)
+            ),
+        )
+
+
+class HorqParametricGate:
+    def __init__(
+        self, gate: Gate, qubit: int, parameter_name: str, control: int = None, name: str = ""
+    ):
+        self.gates: Callable = gate
+        self.target: int = qubit
+        self.parameter: str = parameter_name
+        self.control: int | None = control
+        self.name = name
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        val = jnp.array(values[self.parameter])
+        return apply_gate(state, self.gates(val, self.target, self.control))
+
+    def __repr__(self) -> str:
+        return (
+            self.name
+            + f"(target={self.target}, parameter={self.parameter}, control={self.control})"
+        )
+
+
+class HorqAddGate(HorqruxCircuit):
+    def __init__(self, operations: list[Gate]):
+        self.operators = operations
+        self.name = "Add"
+
+    def forward(self, state: Array, values: ParamDictType = {}) -> Array:
+        return reduce(add, (op.forward(state, values) for op in self.operators))
+
+    def __repr__(self) -> str:
+        return self.name + f"({self.operators})"
+
+
+class HorqScaleGate:
+    def __init__(self, op: Gate, parameter_name: str):
+        self.op = op
+        self.parameter: str = parameter_name
+
+    def forward(self, state: Array, values: ParamDictType) -> Array:
+        return jnp.array(values[self.parameter]) * self.op.forward(state, values)

qadence/backends/jax_utils.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any
+
+import jax.numpy as jnp
+from jax import Array, device_get
+from sympy import Expr
+from sympy2jax import SymbolicModule as JaxSympyModule
+from torch import Tensor, cdouble, from_numpy
+
+from qadence.types import ParamDictType
+
+
+def jarr_to_tensor(arr: Array, dtype: Any = cdouble) -> Tensor:
+    return from_numpy(device_get(arr)).to(dtype=dtype)
+
+
+def tensor_to_jnp(tensor: Tensor, dtype: Any = jnp.complex128) -> Array:
+    return (
+        jnp.array(tensor.numpy(), dtype=dtype)
+        if not tensor.requires_grad
+        else jnp.array(tensor.detach().numpy(), dtype=dtype)
+    )
+
+
+def values_to_jax(param_values: dict[str, Tensor]) -> dict[str, Array]:
+    return {key: jnp.array(value.detach().numpy()) for key, value in param_values.items()}
+
+
+def jaxify(expr: Expr) -> JaxSympyModule:
+    return JaxSympyModule(expr)
+
+
+def unhorqify(state: Array) -> Array:
+    """Convert a state of shape [2] * n_qubits + [batch_size] to (batch_size, 2**n_qubits)."""
+    return jnp.ravel(state)
+
+
+def uniform_batchsize(param_values: ParamDictType) -> ParamDictType:
+    max_batch_size = max(p.size for p in param_values.values())
+    batched_values = {
+        k: (v if v.size == max_batch_size else v.repeat(max_batch_size))
+        for k, v in param_values.items()
+    }
+    return batched_values

qadence/backends/pulser/__init__.py

@@ -1,5 +1,4 @@
 from __future__ import annotations
 
 from .backend import Backend, Configuration
-from .devices import Device
 from .pulses import supported_gates