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)