qml-essentials 0.1.13__tar.gz

qml_essentials-0.1.13/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024, Copyright Owner: Ostbayerische Technische Hochschule Regensburg (OTH Regensburg), Karlsruhe Institute of Technology (KIT). Author: Maja Franz (OTH), Melvin Strobl (KIT).  Contact: melvin.strobl@kit.edu, Scientific Computing Center (SCC)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

qml_essentials-0.1.13/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.1
+Name: qml-essentials
+Version: 0.1.13
+Summary: 
+Author: Melvin Strobl
+Author-email: lc3267@kit.edu
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pennylane (>=0.37.0,<0.38.0)
+Description-Content-Type: text/markdown
+
+# QML Essentials
+
+[![version](https://img.shields.io/badge/version-0.1.12-green.svg)](https://ea3a0fbb-599f-4d83-86f1-0e71abe27513.ka.bw-cloud-instance.org/lc3267/quantum/) [![Pipx Status](https://servers.stroblme.de/api/badge/3/uptime/72?color=%2331c754&labelColor=%233f4850)](https://servers.stroblme.de/status/open) [![Lint and Pytest](https://github.com/cirKITers/qml-essentials/actions/workflows/python-app.yml/badge.svg)](https://github.com/cirKITers/qml-essentials/actions/workflows/python-app.yml) [![Page Build](https://github.com/cirKITers/qml-essentials/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/cirKITers/qml-essentials/actions/workflows/pages/pages-build-deployment)
+
+## :scroll: About
+
+This repo contains some of the commonly used Ansaetze and coding stuff required for working with QML and Data-Reuploading models.
+There are also dedicated classes to calculate entanglement and expressiblity of a provided model as well as its Fourier coefficients.
+
+## :rocket: Getting Started
+
+You can find installation instructions and documentation on the corresponding [Github Page](https://cirkiters.github.io/qml-essentials/).
+
+## :construction: Contributing
+
+Contributions are very welcome! See [Contribution Guidelines](https://github.com/cirKITers/qml-essentials/blob/main/CONTRIBUTING.md).

qml_essentials-0.1.13/README.md

@@ -0,0 +1,16 @@
+# QML Essentials
+
+[![version](https://img.shields.io/badge/version-0.1.12-green.svg)](https://ea3a0fbb-599f-4d83-86f1-0e71abe27513.ka.bw-cloud-instance.org/lc3267/quantum/) [![Pipx Status](https://servers.stroblme.de/api/badge/3/uptime/72?color=%2331c754&labelColor=%233f4850)](https://servers.stroblme.de/status/open) [![Lint and Pytest](https://github.com/cirKITers/qml-essentials/actions/workflows/python-app.yml/badge.svg)](https://github.com/cirKITers/qml-essentials/actions/workflows/python-app.yml) [![Page Build](https://github.com/cirKITers/qml-essentials/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/cirKITers/qml-essentials/actions/workflows/pages/pages-build-deployment)
+
+## :scroll: About
+
+This repo contains some of the commonly used Ansaetze and coding stuff required for working with QML and Data-Reuploading models.
+There are also dedicated classes to calculate entanglement and expressiblity of a provided model as well as its Fourier coefficients.
+
+## :rocket: Getting Started
+
+You can find installation instructions and documentation on the corresponding [Github Page](https://cirkiters.github.io/qml-essentials/).
+
+## :construction: Contributing
+
+Contributions are very welcome! See [Contribution Guidelines](https://github.com/cirKITers/qml-essentials/blob/main/CONTRIBUTING.md).

qml_essentials-0.1.13/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "qml-essentials"
+version = "0.1.13"
+description = ""
+authors = ["Melvin Strobl <lc3267@kit.edu>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pennylane = "^0.37.0"
+
+
+[tool.poetry.group.dev.dependencies]
+devpi-client = "^7.0.3"
+black = "^24.4.2"
+pytest = "^8.2.2"
+flake8 = "^7.1.1"
+mkdocs = "^1.6.0"
+mkdocs-material = "^9.5.31"
+mkdocstrings-python = "^1.10.7"
+markdown-include = "^0.8.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

qml_essentials-0.1.13/qml_essentials/ansaetze.py

@@ -0,0 +1,485 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+import pennylane.numpy as np
+import pennylane as qml
+
+from typing import List
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class Circuit(ABC):
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def n_params_per_layer(n_qubits: int) -> int:
+        return
+
+    @abstractmethod
+    def get_control_indices(self, n_qubits: int) -> List[int]:
+        """
+        Returns the indices for the controlled rotation gates for one layer.
+        Indices should slice the list of all parameters for one layer as follows:
+        [indices[0]:indices[1]:indices[2]]
+
+        Parameters
+        ----------
+        n_qubits : int
+            Number of qubits in the circuit
+
+        Returns
+        -------
+        Optional[np.ndarray]
+            List of all controlled indices, or None if the circuit does not
+            contain controlled rotation gates.
+        """
+        return
+
+    def get_control_angles(self, w: np.ndarray, n_qubits: int) -> Optional[np.ndarray]:
+        """
+        Returns the angles for the controlled rotation gates from the list of
+        all parameters for one layer.
+
+        Parameters
+        ----------
+        w : np.ndarray
+            List of parameters for one layer
+        n_qubits : int
+            Number of qubits in the circuit
+
+        Returns
+        -------
+        Optional[np.ndarray]
+            List of all controlled parameters, or None if the circuit does not
+            contain controlled rotation gates.
+        """
+        indices = self.get_control_indices(n_qubits)
+        if indices is None:
+            return None
+
+        return w[indices[0] : indices[1] : indices[2]]
+
+    @abstractmethod
+    def build(self, n_qubits: int, n_layers: int):
+        return
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        self.build(*args, **kwds)
+
+
+class Ansaetze:
+    def get_available():
+        return [
+            Ansaetze.No_Ansatz,
+            Ansaetze.Circuit_1,
+            Ansaetze.Circuit_6,
+            Ansaetze.Circuit_9,
+            Ansaetze.Circuit_15,
+            Ansaetze.Circuit_18,
+            Ansaetze.Circuit_19,
+            Ansaetze.No_Entangling,
+            Ansaetze.Strongly_Entangling,
+            Ansaetze.Hardware_Efficient,
+            Ansaetze.Bansatz,
+        ]
+
+    class No_Ansatz(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return 0
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            pass
+
+    class Hardware_Efficient(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 3
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RY(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RY(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits // 2):
+                    qml.CZ(wires=[(2 * q), (2 * q + 1)])
+                for q in range((n_qubits - 1) // 2):
+                    qml.CZ(wires=[(2 * q + 1), (2 * q + 2)])
+
+    class Bansatz(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 3
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RY(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits // 2):
+                    qml.CRX(w[w_idx], wires=[(2 * q), (2 * q + 1)])
+                    w_idx += 1
+
+                for q in range((n_qubits - 1) // 2):
+                    qml.CRX(w[w_idx], wires=[(2 * q + 1), (2 * q + 2)])
+                    w_idx += 1
+
+    class Circuit_19(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CRX(
+                        w[w_idx],
+                        wires=[n_qubits - q - 1, (n_qubits - q) % n_qubits],
+                    )
+                    w_idx += 1
+
+    class Circuit_18(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit18 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CRZ(
+                        w[w_idx],
+                        wires=[n_qubits - q - 1, (n_qubits - q) % n_qubits],
+                    )
+                    w_idx += 1
+
+    class Circuit_15(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit15 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            raise NotImplementedError  # Did not figured out the entangling sequence yet
+
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CNOT(wires=[n_qubits - q - 1, (n_qubits - q) % n_qubits])
+
+            for q in range(n_qubits):
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Circuit_9(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return n_qubits
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.Hadamard(wires=q)
+
+            if n_qubits > 1:
+                for q in range(n_qubits - 1):
+                    qml.CZ(wires=[n_qubits - q - 2, n_qubits - q - 1])
+
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Circuit_6(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3 + n_qubits**2
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 4
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit1 ansatz.
+
+            Length of flattened vector must be n_qubits*2
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*2)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for ql in range(n_qubits):
+                    for q in range(n_qubits):
+                        if q == ql:
+                            continue
+                        qml.CRX(
+                            w[w_idx],
+                            wires=[n_qubits - ql - 1, (n_qubits - q - 1) % n_qubits],
+                        )
+                        w_idx += 1
+
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Circuit_1(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return n_qubits * 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit1 ansatz.
+
+            Length of flattened vector must be n_qubits*2
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*2)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Strongly_Entangling(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 6
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int) -> None:
+            """
+            Creates a StronglyEntanglingLayers ansatz.
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.Rot(w[w_idx], w[w_idx + 1], w[w_idx + 2], wires=q)
+                w_idx += 3
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CNOT(wires=[q, (q + 1) % n_qubits])
+
+            for q in range(n_qubits):
+                qml.Rot(w[w_idx], w[w_idx + 1], w[w_idx + 2], wires=q)
+                w_idx += 3
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CNOT(wires=[q, (q + n_qubits // 2) % n_qubits])
+
+    class No_Entangling(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return n_qubits * 3
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a circuit without entangling, but with U3 gates on all qubits
+
+            Length of flattened vector must be n_qubits*3
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.Rot(w[w_idx], w[w_idx + 1], w[w_idx + 2], wires=q)
+                w_idx += 3

qml_essentials-0.1.13/qml_essentials/coefficients.py

@@ -0,0 +1,37 @@
+from qml_essentials.model import Model
+from functools import partial
+from pennylane.fourier import coefficients
+import numpy as np
+
+
+class Coefficients:
+
+    @staticmethod
+    def sample_coefficients(model: Model, **kwargs) -> np.ndarray:
+        """
+        Sample the Fourier coefficients of a given model
+        using Pennylane fourier.coefficients function.
+
+        Note that the coefficients are complex numbers, but the imaginary part
+        of the coefficients should be very close to zero, since the expectation
+        values of the Pauli operators are real numbers.
+
+        Args:
+            model (Model): The model to sample.
+
+        Returns:
+            np.ndarray: The sampled Fourier coefficients.
+        """
+        kwargs.setdefault("force_mean", True)
+        kwargs.setdefault("execution_type", "expval")
+
+        partial_circuit = partial(model, model.params, **kwargs)
+        coeffs = coefficients(partial_circuit, 1, model.degree)
+
+        if not np.isclose(np.sum(coeffs).imag, 0.0, rtol=1.0e-5):
+            raise ValueError(
+                f"Spectrum is not real. Imaginary part of coefficients is:\
+                {np.sum(coeffs).imag}"
+            )
+
+        return coeffs