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

qadence/constructors/rydberg_feature_maps.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+from sympy import Basic, Function
+
+from qadence.blocks import AnalogBlock, KronBlock, kron
+from qadence.constructors.feature_maps import fm_parameter
+from qadence.logger import get_logger
+from qadence.operations import AnalogRot, AnalogRX, AnalogRY, AnalogRZ
+from qadence.parameters import FeatureParameter, Parameter, VariationalParameter
+from qadence.types import BasisSet, ReuploadScaling, TParameter
+
+logger = get_logger(__file__)
+
+AnalogRotationTypes = [AnalogRX, AnalogRY, AnalogRZ]
+
+
+def rydberg_feature_map(
+    n_qubits: int,
+    param: str = "phi",
+    max_abs_detuning: float = 2 * np.pi * 10,
+    weights: list[float] | None = None,
+) -> KronBlock:
+    """Feature map using semi-local addressing patterns.
+
+    If not weights are specified, variational parameters are created
+    for the pattern
+
+    Args:
+        n_qubits (int): number of qubits
+        param: the name of the feature parameter
+        max_abs_detuning: maximum value of absolute detuning for each qubit. Defaulted at 10 MHz.
+        weights: a list of wegiths to assign to each qubit parameter in the feature map
+
+    Returns:
+        The block representing the feature map
+    """
+
+    tower_coeffs: list[float | Parameter]
+    tower_coeffs = (
+        [VariationalParameter(f"w_{param}_{i}") for i in range(n_qubits)]
+        if weights is None
+        else weights
+    )
+    tower_detuning = max_abs_detuning / (sum(tower_coeffs[i] for i in range(n_qubits)))
+
+    param = FeatureParameter(param)
+    duration = 1000 * param / tower_detuning
+    return kron(
+        AnalogRot(
+            duration=duration,
+            delta=-tower_detuning * tower_coeffs[i],
+            phase=0.0,
+            qubit_support=(i,),
+        )
+        for i in range(n_qubits)
+    )
+
+
+def rydberg_tower_feature_map(
+    n_qubits: int, param: str = "phi", max_abs_detuning: float = 2 * np.pi * 10
+) -> KronBlock:
+    weights = list(np.arange(1, n_qubits + 1))
+    return rydberg_feature_map(
+        n_qubits, param=param, max_abs_detuning=max_abs_detuning, weights=weights
+    )
+
+
+def analog_feature_map(
+    param: str = "phi",
+    op: Callable[[Parameter | Basic], AnalogBlock] = AnalogRX,
+    fm_type: BasisSet | type[Function] | str = BasisSet.FOURIER,
+    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
+    feature_range: tuple[float, float] | None = None,
+    target_range: tuple[float, float] | None = None,
+    multiplier: Parameter | TParameter | None = None,
+) -> AnalogBlock:
+    """Generate a fully analog feature map.
+
+    Args:
+        param: Parameter of the feature map; you can pass a string or Parameter;
+            it will be set as non-trainable (FeatureParameter) regardless.
+        op: type of operation. Choose among AnalogRX, AnalogRY, AnalogRZ or a custom
+            callable function returning an AnalogBlock instance
+        fm_type: Basis set for data encoding; choose from `BasisSet.FOURIER` for Fourier
+            encoding, or `BasisSet.CHEBYSHEV` for Chebyshev polynomials of the first kind.
+        reupload_scaling: how the feature map scales the data that is re-uploaded. Given that
+            this feature map uses analog rotations, the reuploading works by simply
+            adding additional operations with different scaling factors in the parameter.
+            Choose from `ReuploadScaling` enumeration, currently only CONSTANT works,
+            or provide your own function with the first argument being the given
+            operation `op` and the second argument the feature parameter
+        feature_range: range of data that the input data is assumed to come from.
+        target_range: range of data the data encoder assumes as the natural range. For example,
+            in Chebyshev polynomials it is (-1, 1), while for Fourier it may be chosen as (0, 2*pi).
+        multiplier: overall multiplier; this is useful for reuploading the feature map serially with
+            different scalings; can be a number or parameter/expression.
+    """
+    transformed_feature = fm_parameter(
+        fm_type, param, feature_range=feature_range, target_range=target_range
+    )
+    multiplier = 1.0 if multiplier is None else Parameter(multiplier)
+
+    if callable(reupload_scaling):
+        return reupload_scaling(op, multiplier * transformed_feature)  # type: ignore[no-any-return]
+    elif reupload_scaling == ReuploadScaling.CONSTANT:
+        return op(multiplier * transformed_feature)
+    # TODO: implement tower scaling by reuploading multiple times
+    # using different analog rotations
+    else:
+        raise NotImplementedError(f"Reupload scaling {str(reupload_scaling)} not implemented!")

qadence/divergences.py

@@ -36,3 +36,15 @@ def js_divergence(counter_p: Counter, counter_q: Counter) -> float:
     entropy_p = shannon_entropy(counter_p)
     entropy_q = shannon_entropy(counter_q)
     return float(average_entropy - (entropy_p + entropy_q) / 2.0)
+
+
+def norm_difference(counter_p: Counter, counter_q: Counter) -> float:
+    # Normalise counters
+
+    counter_p = np.array([v for v in counter_p.values()])
+    counter_q = np.array([v for v in counter_q.values()])
+
+    prob_p = counter_p / np.sum(counter_p)
+    prob_q = counter_q / np.sum(counter_q)
+
+    return float(np.linalg.norm(prob_p - prob_q))

qadence/extensions.py

@@ -2,17 +2,12 @@ from __future__ import annotations
 
 import importlib
 from string import Template
-from typing import TypeVar
 
 from qadence.backend import Backend
-from qadence.blocks import (
-    AbstractBlock,
-)
+from qadence.blocks.abstract import TAbstractBlock
 from qadence.logger import get_logger
 from qadence.types import BackendName, DiffMode
 
-TAbstractBlock = TypeVar("TAbstractBlock", bound=AbstractBlock)
-
 backends_namespace = Template("qadence.backends.$name")
 
 logger = get_logger(__name__)

qadence/finitediff.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Callable
+
+import torch
+from torch import Tensor
+
+
+def finitediff(
+    f: Callable,
+    x: Tensor,
+    derivative_indices: tuple[int, ...],
+    eps: float = None,
+) -> Tensor:
+    """
+    Arguments:
+
+        f: Function to differentiate
+        x: Input of shape `(batch_size, input_size)`
+        derivative_indices: which *input* to differentiate (i.e. which variable x[:,i])
+        eps: finite difference spacing (uses `torch.finfo(x.dtype).eps ** (1 / (2 + order))` as a
+            default)
+    """
+
+    if eps is None:
+        order = len(derivative_indices)
+        eps = torch.finfo(x.dtype).eps ** (1 / (2 + order))
+
+    # compute derivative direction vector(s)
+    eps = torch.as_tensor(eps, dtype=x.dtype)
+    _eps = 1 / eps  # type: ignore[operator]
+    ev = torch.zeros_like(x)
+    i = derivative_indices[0]
+    ev[:, i] += eps
+
+    # recursive finite differencing for higher order than 3 / mixed derivatives
+    if len(derivative_indices) > 3 or len(set(derivative_indices)) > 1:
+        di = derivative_indices[1:]
+        return (finitediff(f, x + ev, di) - finitediff(f, x - ev, di)) * _eps / 2
+    elif len(derivative_indices) == 3:
+        return (f(x + 2 * ev) - 2 * f(x + ev) + 2 * f(x - ev) - f(x - 2 * ev)) * _eps**3 / 2
+    elif len(derivative_indices) == 2:
+        return (f(x + ev) + f(x - ev) - 2 * f(x)) * _eps**2
+    elif len(derivative_indices) == 1:
+        return (f(x + ev) - f(x - ev)) * _eps / 2
+    else:
+        raise ValueError("If you see this error there is a bug in the `finitediff` function.")

qadence/mitigations/readout.py

@@ -6,17 +6,50 @@ from functools import reduce
 import numpy as np
 import numpy.typing as npt
 import torch
+from numpy.linalg import inv, matrix_rank, pinv
 from scipy.linalg import norm
 from scipy.optimize import LinearConstraint, minimize
 
 from qadence.mitigations.protocols import Mitigations
 from qadence.noise.protocols import Noise
+from qadence.types import ReadOutOptimization
 
 
 def corrected_probas(p_corr: npt.NDArray, T: npt.NDArray, p_raw: npt.NDArray) -> np.double:
     return norm(T @ p_corr.T - p_raw.T, ord=2) ** 2
 
 
+def mle_solve(p_raw: npt.NDArray) -> npt.NDArray:
+    """
+    Compute the MLE probability vector.
+
+    Algorithmic details can be found in https://arxiv.org/pdf/1106.5458.pdf Page(3).
+    """
+    # Sort p_raw by values while keeping track of indices.
+    index_sort = p_raw.argsort()
+    p_sort = p_raw[index_sort]
+    neg_sum = 0
+    breakpoint = len(p_sort) - 1
+
+    for i in range(len(p_sort)):
+        ## if neg_sum cannot be distributed among other probabilities, continue to accumulate
+        if p_sort[i] + neg_sum / (len(p_sort) - i) < 0:
+            neg_sum += p_sort[i]
+            p_sort[i] = 0
+        # set breakpoint to current index
+        else:
+            breakpoint = i
+            break
+    ## number of entries to which i can distribute(includes breakpoint)
+    size = len(p_sort) - breakpoint
+    p_sort[breakpoint:] += neg_sum / size
+
+    re_index_sort = index_sort.argsort()
+    p_corr = p_sort[re_index_sort]
+
+    return p_corr
+
+
 def renormalize_counts(corrected_counts: npt.NDArray, n_shots: int) -> npt.NDArray:
     """Renormalize counts rounding discrepancies."""
     total_counts = sum(corrected_counts)
@@ -25,51 +58,85 @@ def renormalize_counts(corrected_counts: npt.NDArray, n_shots: int) -> npt.NDArr
         corrected_counts -= counts_diff
         corrected_counts = np.where(corrected_counts < 0, 0, corrected_counts)
         sum_corrected_counts = sum(corrected_counts)
-        if sum_corrected_counts < n_shots:
-            renormalization_factor = max(sum_corrected_counts, n_shots) / min(
-                sum_corrected_counts, n_shots
-            )
-        else:
-            renormalization_factor = min(sum_corrected_counts, n_shots) / max(
-                sum_corrected_counts, n_shots
-            )
+
+        renormalization_factor = n_shots / sum_corrected_counts
         corrected_counts = np.rint(corrected_counts * renormalization_factor).astype(int)
     return corrected_counts
 
 
+def matrix_inv(K: npt.NDArray) -> npt.NDArray:
+    return inv(K) if matrix_rank(K) == K.shape[0] else pinv(K)
+
+
 def mitigation_minimization(
-    noise: Noise, mitigation: Mitigations, samples: list[Counter]
+    noise: Noise,
+    mitigation: Mitigations,
+    samples: list[Counter],
 ) -> list[Counter]:
     """Minimize a correction matrix subjected to stochasticity constraints.
 
     See Equation (5) in https://arxiv.org/pdf/2001.09980.pdf.
+    See Page(3) in https://arxiv.org/pdf/1106.5458.pdf for MLE implementation
+
+    Args:
+        noise: Specifies confusion matrix and default error probability
+        mitigation: Selects additional mitigation options based on noise choice.
+        For readout we have the following mitigation options for optimization
+        1. constrained 2. mle. Default : mle
+        samples: List of samples to be mitigated
+
+    Returns:
+        Mitigated counts computed by the algorithm
     """
     noise_matrices = noise.options.get("noise_matrix", noise.options["confusion_matrices"])
+    optimization_type = mitigation.options.get("optimization_type", ReadOutOptimization.MLE)
     n_qubits = len(list(samples[0].keys())[0])
     n_shots = sum(samples[0].values())
-    # Build the whole T matrix.
-    T_matrix = reduce(torch.kron, noise_matrices).detach().numpy()
     corrected_counters: list[Counter] = []
+
+    if optimization_type == ReadOutOptimization.CONSTRAINED:
+        # Build the whole T matrix.
+        T_matrix = reduce(torch.kron, noise_matrices).detach().numpy()
+
+    if optimization_type == ReadOutOptimization.MLE:
+        # Check if matrix is singular and use appropriate inverse.
+        noise_matrices_inv = list(map(matrix_inv, noise_matrices.numpy()))
+        T_inv = reduce(np.kron, noise_matrices_inv)
+
     for sample in samples:
         bitstring_length = 2**n_qubits
         # List of bitstrings in lexicographical order.
         ordered_bitstrings = [f"{i:0{n_qubits}b}" for i in range(bitstring_length)]
         # Array of raw probabilites.
         p_raw = np.array([sample[bs] for bs in ordered_bitstrings]) / n_shots
-        # Initial random guess in [0,1].
-        p_corr0 = np.random.rand(bitstring_length)
-        # Stochasticity constraints.
-        normality_constraint = LinearConstraint(
-            np.ones(bitstring_length).astype(int), lb=1.0, ub=1.0
-        )
-        positivity_constraint = LinearConstraint(
-            np.eye(bitstring_length).astype(int), lb=0.0, ub=1.0
-        )
-        constraints = [normality_constraint, positivity_constraint]
-        # Minimize the corrected probabilities.
-        res = minimize(corrected_probas, p_corr0, args=(T_matrix, p_raw), constraints=constraints)
-        # breakpoint()
-        corrected_counts = np.rint(res.x * n_shots).astype(int)
+
+        if optimization_type == ReadOutOptimization.CONSTRAINED:
+            # Initial random guess in [0,1].
+            p_corr0 = np.random.rand(bitstring_length)
+            # Stochasticity constraints.
+            normality_constraint = LinearConstraint(
+                np.ones(bitstring_length).astype(int), lb=1.0, ub=1.0
+            )
+            positivity_constraint = LinearConstraint(
+                np.eye(bitstring_length).astype(int), lb=0.0, ub=1.0
+            )
+            constraints = [normality_constraint, positivity_constraint]
+            # Minimize the corrected probabilities.
+            res = minimize(
+                corrected_probas, p_corr0, args=(T_matrix, p_raw), constraints=constraints
+            )
+            p_corr = res.x
+
+        elif optimization_type == ReadOutOptimization.MLE:
+            # Compute corrected inverse using matrix inversion and run MLE.
+            p_corr = mle_solve(T_inv @ p_raw)
+        else:
+            raise NotImplementedError(
+                f"Requested method {optimization_type} does not match supported protocols."
+            )
+
+        corrected_counts = np.rint(p_corr * n_shots).astype(int)
+
         # Renormalize if total counts differs from n_shots.
         corrected_counts = renormalize_counts(corrected_counts=corrected_counts, n_shots=n_shots)
         # At this point, the count should be off by at most 2, added or substracted to/from the

qadence/models/qnn.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
+from collections import Counter
 from typing import Callable
 
+import sympy
 from torch import Tensor
 
-from qadence.backend import BackendConfiguration
+from qadence.backend import BackendConfiguration, ConvertedObservable
 from qadence.blocks.abstract import AbstractBlock
 from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
+from qadence.mitigations import Mitigations
 from qadence.models.quantum_model import QuantumModel
 from qadence.noise import Noise
 from qadence.types import BackendName, DiffMode, Endianness
@@ -19,22 +22,25 @@ class QNN(QuantumModel):
     Examples:
     ```python exec="on" source="material-block" result="json"
     import torch
-    from qadence import QuantumCircuit, QNN
-    from qadence import hea, feature_map, hamiltonian_factory, Z
+    from qadence import QuantumCircuit, QNN, Z
+    from qadence import hea, feature_map, hamiltonian_factory, kron
 
     # create the circuit
     n_qubits, depth = 2, 4
-    fm = feature_map(n_qubits)
+    fm = kron(
+        feature_map(1, support=(0,), param="x"),
+        feature_map(1, support=(1,), param="y")
+    )
     ansatz = hea(n_qubits=n_qubits, depth=depth)
     circuit = QuantumCircuit(n_qubits, fm, ansatz)
-    obs_base = hamiltonian_factory(n_qubits, detuning = Z)
+    obs_base = hamiltonian_factory(n_qubits, detuning=Z)
 
     # the QNN will yield two outputs
     obs = [2.0 * obs_base, 4.0 * obs_base]
 
     # initialize and use the model
-    qnn = QNN(circuit, obs, diff_mode="ad", backend="pyqtorch")
-    y = qnn.expectation({"phi": torch.rand(3)})
+    qnn = QNN(circuit, obs, inputs=["x", "y"])
+    y = qnn(torch.rand(3, 2))
     print(str(y)) # markdown-exec: hide
     ```
     """
@@ -49,6 +55,7 @@ class QNN(QuantumModel):
         measurement: Measurements | None = None,
         noise: Noise | None = None,
         configuration: BackendConfiguration | dict | None = None,
+        inputs: list[sympy.Basic | str] | None = None,
     ):
         """Initialize the QNN.
 
@@ -59,6 +66,9 @@ class QNN(QuantumModel):
         Args:
             circuit: The quantum circuit to use for the QNN.
             transform: A transformation applied to the output of the QNN.
+            inputs: Tuple that indicates the order of variables of the tensors that are passed
+                to the model. Given input tensors `xs = torch.rand(batch_size, input_size:=2)` a QNN
+                with `inputs=("t", "x")` will assign `t, x = xs[:,0], xs[:,1]`.
             backend: The chosen quantum backend.
             diff_mode: The differentiation engine to use. Choices 'gpsr' or 'ad'.
             measurement: optional measurement protocol. If None,
@@ -67,7 +77,7 @@ class QNN(QuantumModel):
             configuration: optional configuration for the backend
         """
         super().__init__(
-            circuit=circuit,
+            circuit,
             observable=observable,
             backend=backend,
             diff_mode=diff_mode,
@@ -75,12 +85,33 @@ class QNN(QuantumModel):
             configuration=configuration,
             noise=noise,
         )
-
         if self.out_features is None:
             raise ValueError("You need to provide at least one observable in the QNN constructor")
-
         self.transform = transform if transform else lambda x: x
 
+        if (inputs is not None) and (len(self.inputs) == len(inputs)):
+            self.inputs = [sympy.symbols(x) if isinstance(x, str) else x for x in inputs]  # type: ignore[union-attr]
+        elif (inputs is None) and len(self.inputs) <= 1:
+            self.inputs = [sympy.symbols(x) if isinstance(x, str) else x for x in self.inputs]  # type: ignore[union-attr]
+        else:
+            raise ValueError(
+                """
+                Your QNN has more than one input. Please provide a list of inputs in the order of
+                your tensor domain. For example, if you want to pass
+                `xs = torch.rand(batch_size, input_size:=3)` to you QNN, where
+                ```
+                t = x[:,0]
+                x = x[:,1]
+                y = x[:,2]
+                ```
+                you have to specify
+                ```
+                QNN(circuit, observable, inputs=["t", "x", "y"])
+                ```
+                You can also pass a list of sympy symbols.
+            """
+            )
+
     def forward(
         self,
         values: dict[str, Tensor] | Tensor = None,
@@ -103,7 +134,7 @@ class QNN(QuantumModel):
         is instead `n_batches x n_observables`
 
         Args:
-            values (dict[str, Tensor] | Tensor): the values of the feature parameters
+            values: the values of the feature parameters
             state: Initial state.
             measurement: optional measurement protocol. If None,
                 use exact expectation value with a statevector simulator
@@ -114,18 +145,55 @@ class QNN(QuantumModel):
             Tensor: a tensor with the expectation value of the observables passed
                 in the constructor of the model
         """
+        return self.expectation(
+            values, state=state, measurement=measurement, noise=noise, endianness=endianness
+        )
+
+    def run(
+        self,
+        values: Tensor | dict[str, Tensor] = None,
+        state: Tensor | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> Tensor:
+        return super().run(values=self._format_to_dict(values), state=state, endianness=endianness)
+
+    def sample(
+        self,
+        values: Tensor | dict[str, Tensor] = {},
+        n_shots: int = 1000,
+        state: Tensor | None = None,
+        noise: Noise | None = None,
+        mitigation: Mitigations | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> list[Counter]:
+        return super().sample(
+            values=self._format_to_dict(values),
+            n_shots=n_shots,
+            state=state,
+            noise=noise,
+            mitigation=mitigation,
+            endianness=endianness,
+        )
+
+    def expectation(
+        self,
+        values: Tensor | dict[str, Tensor] = {},
+        observable: list[ConvertedObservable] | ConvertedObservable | None = None,
+        state: Tensor | None = None,
+        measurement: Measurements | None = None,
+        noise: Noise | None = None,
+        mitigation: Mitigations | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> Tensor:
         if values is None:
             values = {}
-        if not isinstance(values, dict):
-            values = self._format_to_dict(values)
         if measurement is None:
             measurement = self._measurement
         if noise is None:
             noise = self._noise
-
         return self.transform(
-            self.expectation(
-                values=values,
+            super().expectation(
+                values=self._format_to_dict(values),
                 state=state,
                 measurement=measurement,
                 endianness=endianness,
@@ -139,6 +207,9 @@ class QNN(QuantumModel):
         The tensor is assumed to have dimensions: n_batches x in_features where in_features
         corresponds to the number of input features of the QNN
         """
+        # for backwards compat...
+        if isinstance(values, dict):
+            return values
 
         if len(values.size()) == 1:
             values = values.reshape(-1, 1)
@@ -146,10 +217,4 @@ class QNN(QuantumModel):
         assert len(values.size()) == 2, msg
         assert values.size()[1] == self.in_features, msg
 
-        names = [p.name for p in self.inputs]
-        res = {}
-        for i, name in enumerate(names):
-            res[name] = values[:, i]
-        return res
-
-    # TODO: Implement derivatives w.r.t. to inputs
+        return {var.name: values[:, self.inputs.index(var)] for var in self.inputs}