Implements the structure of a general qiboml model

.github/workflows/deploy.yml

@@ -0,0 +1,24 @@
+# A single CI script with github workflow
+name: Build wheels and deploy
+
+on:
+  workflow_dispatch:
+  push:
+  merge_group:
+  release:
+    types:
+      - published
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: [ 3.9, '3.10', '3.11', '3.12']
+    uses: qiboteam/workflows/.github/workflows/deploy-pip-poetry.yml@v1
+    with:
+      os: ${{ matrix.os }}
+      python-version: ${{ matrix.python-version }}
+      publish: ${{ github.event_name == 'release' && github.event.action == 'published' && matrix.os == 'ubuntu-latest' && matrix.python-version == '3.10' }}
+      poetry-extras: "--with tests"
+    secrets: inherit

.github/workflows/tests.yml

@@ -4,17 +4,20 @@ on:
   workflow_dispatch:
   push:
   merge_group:
+  pull_request:
+    types: [labeled, opened] # opened is required to allow external contributors
 
 jobs:
   build:
+    if: contains(github.event.pull_request.labels.*.name, 'run-workflow') || github.event_name == 'push'
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python-version: [3.9, "3.10", "3.11"]
-    uses: qiboteam/workflows/.github/workflows/rules-poetry.yml@main
+        python-version: [3.9, "3.10", "3.11", "3.12"]
+    uses: qiboteam/workflows/.github/workflows/rules-poetry.yml@v1
     with:
       os: ${{ matrix.os }}
       python-version: ${{ matrix.python-version }}
       doctests: false
-      poetry-extras: --all-extras
+      poetry-extras: "--with tests"
     secrets: inherit

pyproject.toml

@@ -13,14 +13,14 @@ packages = [{ include = "qiboml", from = "src" }]
 [tool.poetry.dependencies]
 python = ">=3.9,<3.13"
 numpy = "^1.26.4"
-numba = "^0.59.0"
-tensorflow = { version = "^2.16.1", markers = "sys_platform == 'linux' or sys_platform == 'darwin'" }
+keras = { version = "^3.0.0", optional = true }
+tensorflow = { version = "^2.16.1", markers = "sys_platform == 'linux' or sys_platform == 'darwin'", optional = true }
 # TODO: the marker is a temporary solution due to the lack of the tensorflow-io 0.32.0's wheels for Windows, this package is one of
 # the tensorflow requirements
-torch = "^2.2.0"
+torch = { version = "^2.3.1", optional = true }
+qibo = {git="https://github.com/qiboteam/qibo", branch="qiboml_models_updates"}
 jax = "^0.4.25"
 jaxlib = "^0.4.25"
-qibo = "^0.2.8"
 
 [tool.poetry.group.dev]
 optional = true
@@ -29,11 +29,17 @@ optional = true
 ipython = "^7.34"
 pdbpp = "^0.10.3"
 
+[tool.poetry.group.tests]
+optional = true
+
+[tool.poetry.group.tests.dependencies]
+torch = "^2.3.1"
+tensorflow = { version = "^2.16.1", markers = "sys_platform == 'linux'" }
+pytest = "^7.2.1"
+pylint = "3.1.0"
+pytest-cov = "4.0.0"
+
 [tool.poetry.group.benchmark.dependencies]
-pytest = "^7.1.2"
-pylint = "^2.17"
-pytest-cov = "^3.0.0"
-pytest-env = "^0.8.1"
 pytest-benchmark = { version = "^4.0.0", extras = ["histogram"] }
 
 [tool.poe.tasks]

src/qiboml/__init__.py

@@ -1,5 +1,28 @@
 import importlib.metadata as im
+from typing import Union
+
+import numpy.typing as npt
 
 from qiboml.backends.__init__ import MetaBackend
 
 __version__ = im.version(__package__)
+
+ndarray = npt.NDArray
+
+try:
+    from tensorflow import Tensor as tf_tensor
+
+    from qiboml.models import keras
+
+    ndarray = Union[ndarray, tf_tensor]
+except ImportError:
+    pass
+
+try:
+    from torch import Tensor as pt_tensor
+
+    from qiboml.models import pytorch
+
+    ndarray = Union[ndarray, pt_tensor]
+except ImportError:
+    pass

src/qiboml/backends/__init__.py

@@ -1,9 +1,9 @@
 from typing import Union
 
+from qibo.backends.pytorch import PyTorchBackend  # qiboml pytorch is not updated
 from qibo.config import raise_error
 
 from qiboml.backends.jax import JaxBackend
-from qiboml.backends.pytorch import PyTorchBackend
 from qiboml.backends.tensorflow import TensorflowBackend
 
 PLATFORMS = ["tensorflow", "pytorch", "jax"]

src/qiboml/backends/jax.py

@@ -39,7 +39,7 @@ def cast(self, x, dtype=None, copy=False):
             dtype = self.dtype
         if isinstance(x, self.tensor_types):
             return x.astype(dtype)
-        elif self.issparse(x):
+        elif self.is_sparse(x):
             return x.astype(dtype)
         return self.np.array(x, dtype=dtype, copy=copy)
 

src/qiboml/backends/pytorch.py

@@ -100,7 +100,7 @@ def issparse(self, x):
         if isinstance(x, self.np.Tensor):
             return x.is_sparse
 
-        return super().issparse(x)
+        return super().is_sparse(x)
 
     def to_numpy(self, x):
         if isinstance(x, list):

src/qiboml/models/abstract.py

@@ -0,0 +1,45 @@
+"""Defines the general structure of a qiboml module"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from qibo import Circuit
+from qibo.backends import Backend
+from qibo.config import raise_error
+from qibo.gates import abstract
+
+from qiboml import ndarray
+from qiboml.backends import JaxBackend
+
+
+@dataclass
+class QuantumCircuitLayer(ABC):
+
+    nqubits: int
+    qubits: list[int] = None
+    _circuit: Circuit = None
+    backend: Backend = JaxBackend()
+
+    def __post_init__(self) -> None:
+        if self.qubits is None:
+            self.qubits = list(range(self.nqubits))
+        self._circuit = Circuit(self.nqubits)
+
+    @abstractmethod
+    def forward(self, x):  # pragma: no cover
+        pass
+
+    def __call__(self, x):
+        return self.forward(x)
+
+    @property
+    def parameters(self) -> ndarray:
+        return self.backend.cast(self.circuit.get_parameters())
+
+    @parameters.setter
+    def parameters(self, params: ndarray):
+        self._circuit.set_parameters(self.backend.cast(params.ravel()))
+
+    @property
+    def circuit(self) -> Circuit:
+        return self._circuit

src/qiboml/models/ansatze.py

@@ -1,14 +1,22 @@
+from dataclasses import dataclass
+
+import numpy as np
 from qibo import Circuit, gates
 
+from qiboml.models.abstract import QuantumCircuitLayer
+
+
+@dataclass
+class ReuploadingLayer(QuantumCircuitLayer):
+
+    def __post_init__(self):
+        super().__post_init__()
+        for q in self.qubits:
+            self.circuit.add(gates.RY(q, theta=0.0))
+            self.circuit.add(gates.RZ(q, theta=0.0))
+        for i, q in enumerate(self.qubits[:-2]):
+            self.circuit.add(gates.CNOT(q0=q, q1=self.qubits[i + 1]))
+        self.circuit.add(gates.CNOT(q0=self.qubits[-1], q1=self.qubits[0]))
 
-def reuploading_circuit(nqubits, nlayers):
-    c = Circuit(nqubits)
-    for _ in range(nlayers):
-        for q in range(nqubits):
-            c.add(gates.RY(q, 0))
-            c.add(gates.RZ(q, 0))
-        for q in range(0, nqubits - 1, 1):
-            c.add(gates.CNOT(q0=q, q1=q + 1))
-        c.add(gates.CNOT(q0=nqubits - 1, q1=0))
-    c.add(gates.M(*range(nqubits)))
-    return c
+    def forward(self, x: Circuit) -> Circuit:
+        return x + self.circuit

src/qiboml/models/encoding_decoding.py

@@ -0,0 +1,128 @@
+"""Some standard encoding and decoding layers"""
+
+from dataclasses import dataclass
+from typing import Union
+
+import numpy as np
+from qibo import Circuit, gates
+from qibo.config import raise_error
+from qibo.hamiltonians import Hamiltonian
+
+from qiboml import ndarray
+from qiboml.models.abstract import QuantumCircuitLayer
+
+
+@dataclass
+class QuantumEncodingLayer(QuantumCircuitLayer):
+    pass
+
+
+@dataclass
+class BinaryEncodingLayer(QuantumEncodingLayer):
+
+    def forward(self, x: ndarray) -> Circuit:
+        if x.shape[-1] != len(self.qubits):
+            raise_error(
+                RuntimeError,
+                f"Invalid input dimension {x.shape[-1]}, but the allocated qubits are {self.qubits}.",
+            )
+        circuit = self.circuit.copy()
+        ones = np.flatnonzero(x.ravel() == 1)
+        for bit in ones:
+            circuit.add(gates.X(self.qubits[bit]))
+        return circuit
+
+
+@dataclass
+class PhaseEncodingLayer(QuantumEncodingLayer):
+
+    def __post_init__(self):
+        super().__post_init__()
+        for q in self.qubits:
+            self.circuit.add(gates.RZ(q, theta=0.0))
+
+    def forward(self, x: ndarray) -> Circuit:
+        self.parameters = x
+        return self.circuit
+
+
+@dataclass
+class QuantumDecodingLayer(QuantumCircuitLayer):
+
+    nshots: int = 1000
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.circuit.add(gates.M(*self.qubits))
+
+    def forward(self, x: Circuit) -> "CircuitResult":
+        return self.backend.execute_circuit(x + self.circuit, nshots=self.nshots)
+
+
+class ProbabilitiesLayer(QuantumDecodingLayer):
+
+    def __post_init__(self):
+        super().__post_init__()
+
+    def forward(self, x: Circuit) -> ndarray:
+        return super().forward(x).probabilities(self.qubits).reshape(1, -1)
+
+    @property
+    def output_shape(self):
+        return (1, 2 ** len(self.qubits))
+
+
+class SamplesLayer(QuantumDecodingLayer):
+
+    def forward(self, x: Circuit) -> ndarray:
+        return self.backend.cast(super().forward(x).samples(), dtype=np.float64)
+
+    @property
+    def output_shape(self):
+        return (self.nshots, len(self.qubits))
+
+
+class StateLayer(QuantumDecodingLayer):
+
+    def forward(self, x: Circuit) -> ndarray:
+        state = super().forward(x).state()
+        return self.backend.np.vstack(
+            (self.backend.np.real(state), self.backend.np.imag(state))
+        )
+
+    @property
+    def output_shape(self):
+        return (2, 2**self.nqubits)
+
+
+@dataclass
+class ExpectationLayer(QuantumDecodingLayer):
+
+    observable: Union[ndarray, Hamiltonian] = None
+    analytic: bool = False
+
+    def __post_init__(self):
+        if self.observable is None:
+            raise_error(
+                RuntimeError,
+                "Please provide an observable for expectation value calculation.",
+            )
+        super().__post_init__()
+
+    def forward(self, x: Circuit) -> ndarray:
+        if self.analytic:
+            return self.observable.expectation(
+                super().forward(x).state(),
+            ).reshape(1, 1)
+        else:
+            return self.backend.cast(
+                self.observable.expectation_from_samples(
+                    super().forward(x).frequencies(),
+                    qubit_map=self.qubits,
+                ).reshape(1, 1),
+                dtype=np.float64,
+            )
+
+    @property
+    def output_shape(self):
+        return (1, 1)