qxmt 0.0.0__py3-none-any.whl

qxmt/__init__.py

@@ -0,0 +1,45 @@
+from qxmt.configs import (
+    DatasetConfig,
+    DeviceConfig,
+    EvaluationConfig,
+    ExperimentConfig,
+    FeatureMapConfig,
+    KernelConfig,
+    ModelConfig,
+    PathConfig,
+)
+from qxmt.exceptions import (
+    ExperimentNotInitializedError,
+    ExperimentRunSettingError,
+    InputShapeError,
+    InvalidFileExtensionError,
+    InvalidModelNameError,
+    InvalidPlatformError,
+    InvalidQunatumDeviceError,
+    JsonEncodingError,
+    ModelSettingError,
+    ReproductionError,
+)
+from qxmt.experiment.experiment import Experiment
+
+__all__ = [
+    "ExperimentNotInitializedError",
+    "ExperimentRunSettingError",
+    "InputShapeError",
+    "InvalidFileExtensionError",
+    "InvalidModelNameError",
+    "InvalidPlatformError",
+    "InvalidQunatumDeviceError",
+    "JsonEncodingError",
+    "ModelSettingError",
+    "ReproductionError",
+    "Experiment",
+    "ExperimentConfig",
+    "DatasetConfig",
+    "DeviceConfig",
+    "EvaluationConfig",
+    "FeatureMapConfig",
+    "KernelConfig",
+    "ModelConfig",
+    "PathConfig",
+]

qxmt/configs.py

@@ -0,0 +1,70 @@
+from pathlib import Path
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+from qxmt.constants import MODULE_HOME
+
+
+class PathConfig(BaseModel):
+    data: Path | str
+    label: Path | str
+
+    def model_post_init(self, __context: dict[str, Any]) -> None:
+        if not Path(self.data).is_absolute():
+            self.data = MODULE_HOME / self.data
+
+        if not Path(self.label).is_absolute():
+            self.label = MODULE_HOME / self.label
+
+
+class DatasetConfig(BaseModel):
+    type: Literal["file", "generate"]
+    path: PathConfig
+    random_seed: int
+    test_size: float = Field(ge=0.0, le=1.0)
+    features: Optional[list[str]] = None
+    raw_preprocess_logic: Optional[dict[str, Any]] = None
+    transform_logic: Optional[dict[str, Any]] = None
+
+
+class DeviceConfig(BaseModel):
+    platform: str
+    name: str
+    n_qubits: int
+    shots: Optional[int] = None
+
+
+class FeatureMapConfig(BaseModel):
+    module_name: str
+    implement_name: str
+    params: Optional[dict[str, Any]] = None
+
+
+class KernelConfig(BaseModel):
+    module_name: str
+    implement_name: str
+    params: Optional[dict[str, Any]] = None
+
+
+class ModelConfig(BaseModel):
+    name: str
+    file_name: str
+    params: dict[str, Any]
+    feature_map: Optional[FeatureMapConfig] = None
+    kernel: Optional[KernelConfig] = None
+
+
+class EvaluationConfig(BaseModel):
+    default_metrics: list[str]
+
+
+class ExperimentConfig(BaseModel):
+    path: Path | str = ""
+    description: str = ""
+    dataset: DatasetConfig
+    device: DeviceConfig
+    feature_map: Optional[FeatureMapConfig] = None
+    kernel: Optional[KernelConfig] = None
+    model: ModelConfig
+    evaluation: EvaluationConfig

qxmt/constants.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import Any
+
+import pennylane as qml
+import pytz
+
+MODULE_HOME: Path = Path(__file__).resolve().parents[1]
+MODULE_SRC: Path = Path(__file__).resolve().parents[0]
+
+DEFAULT_N_JOBS = 3
+
+DEFAULT_EXP_DIRC: Path = MODULE_HOME / "experiments"
+DEFAULT_EXP_DB_FILE: Path = Path("experiment.json")
+
+SUPPORTED_PLATFORMS: list[str] = ["pennylane"]
+PENNYLANE_DEVICES: tuple[Any, ...] = (qml.devices.Device, qml.Device, qml.QubitDevice)
+
+DEFAULT_MODEL_NAME: str = "model.pkl"
+
+DEFAULT_METRICS_NAME: list[str] = ["accuracy", "precision", "recall", "f1_score"]
+
+LLM_MODEL_PATH = "microsoft/Phi-3-mini-128k-instruct"
+
+TZ: pytz.BaseTzInfo = pytz.timezone("Asia/Tokyo")

qxmt/datasets/__init__.py

@@ -0,0 +1,7 @@
+from qxmt.datasets.builder import DatasetBuilder
+from qxmt.datasets.schema import Dataset
+
+__all__ = [
+    "DatasetBuilder",
+    "Dataset",
+]

qxmt/datasets/builder.py

@@ -0,0 +1,233 @@
+import inspect
+from logging import Logger
+from typing import Callable, Optional, get_type_hints
+
+import numpy as np
+from sklearn.model_selection import train_test_split
+
+from qxmt.configs import ExperimentConfig
+from qxmt.datasets.dummy import generate_linear_separable_data
+from qxmt.datasets.schema import Dataset
+from qxmt.logger import set_default_logger
+from qxmt.utils import load_object_from_yaml
+
+RAW_DATA_TYPE = np.ndarray
+RAW_LABEL_TYPE = np.ndarray
+RAW_DATASET_TYPE = tuple[RAW_DATA_TYPE, RAW_LABEL_TYPE]
+PROCESSCED_DATASET_TYPE = tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+
+LOGGER = set_default_logger(__name__)
+
+
+class DatasetBuilder:
+    def __init__(self, config: ExperimentConfig, logger: Logger = LOGGER) -> None:
+        self.config: ExperimentConfig = config
+        self.logger: Logger = logger
+
+        if self.config.dataset.raw_preprocess_logic is not None:
+            raw_preprocess_logic = load_object_from_yaml(self.config.dataset.raw_preprocess_logic)
+            self._validate_raw_preprocess_logic(raw_preprocess_logic, self.logger)
+            self.custom_raw_preprocess: Optional[Callable] = raw_preprocess_logic
+        else:
+            self.custom_raw_preprocess = None
+
+        if self.config.dataset.transform_logic is not None:
+            transform_logic = load_object_from_yaml(self.config.dataset.transform_logic)
+            self._validate_transform_logic(transform_logic, self.logger)
+            self.custom_transform: Optional[Callable] = transform_logic
+        else:
+            self.custom_transform = None
+
+    @staticmethod
+    def _validate_raw_preprocess_logic(raw_preprocess_logic: Callable, logger: Logger) -> None:
+        """Validate the custom raw preprocess function.
+
+        Args:
+            raw_preprocess_logic (Callable): custom raw preprocess function
+            logger (Logger): logger for output messages
+
+        Raises:
+            ValueError: argment lenght of the custom raw preprocess function is less than 2
+            ValueError: return type of the custom raw preprocess function is not a tuple of numpy arrays
+            ValueError: argument type of the custom raw preprocess function is not numpy array
+        """
+        type_hint_dict = get_type_hints(raw_preprocess_logic)
+        parameter_dict = inspect.signature(raw_preprocess_logic).parameters
+
+        # check argment length. -1 means return type
+        if len(type_hint_dict) - 1 != len(parameter_dict):
+            logger.warning(
+                "All arguments of the custom raw preprocess function assigned to the type hint."
+                "Input and return type validation will be skipped."
+            )
+            return
+        elif len(type_hint_dict) - 1 < 2:
+            raise ValueError("The custom raw preprocess function must have at least 2 arguments (X, y).")
+
+        # check argument type and return type
+        for arg_name, arg_type in type_hint_dict.items():
+            if (arg_name == "return") and (arg_type != RAW_DATASET_TYPE):
+                raise ValueError(
+                    "The return type of the custom raw preprocess function must be a tuple of numpy arrays."
+                )
+            # [TODO]: Handle anthor data types
+            # elif (arg_name != "return") and (arg_type != RAW_DATA_TYPE):
+            #     raise ValueError(f'The arguments of the custom raw preprocess function must be "{RAW_DATA_TYPE}".')
+
+    @staticmethod
+    def _validate_transform_logic(transform_logic: Callable, logger: Logger) -> None:
+        """Validate the custom transform function.
+
+        Args:
+            transform_logic (Callable): custom transform function
+            logger (Logger): logger for output messages
+
+        Raises:
+            ValueError: argment lenght of the custom transform function is less than 4
+            ValueError: return type of the custom transform function is not a tuple of numpy arrays
+            ValueError: argument type of the custom transform function is not numpy array
+
+        """
+        type_hint_dict = get_type_hints(transform_logic)
+        parameter_dict = inspect.signature(transform_logic).parameters
+
+        # check argment length. -1 means return type
+        if len(type_hint_dict) - 1 != len(parameter_dict):
+            logger.warning(
+                "All arguments of the custom raw preprocess function assigned to the type hint."
+                "Input and return type validation will be skipped."
+            )
+            return
+        elif len(type_hint_dict) - 1 < 4:
+            raise ValueError(
+                "The custom transform function must have at least 4 arguments (X_train, y_train, X_test, y_test)."
+            )
+
+        # check argument type and return type
+        for arg_name, arg_type in type_hint_dict.items():
+            if (arg_name == "return") and (arg_type != PROCESSCED_DATASET_TYPE):
+                raise ValueError("The return type of the custom transform function must be a tuple of numpy arrays.")
+            # # [TODO]: Handle athor data types
+            # elif (arg_name != "return") and (arg_type != RAW_DATA_TYPE):
+            #     raise ValueError(f'The arguments of the custom transform function must be "{RAW_DATA_TYPE}".')
+
+    def load(self) -> RAW_DATASET_TYPE:
+        """Load the dataset from the path defined in config.
+
+        Returns:
+            RAW_DATASET_TYPE: features and labels of the dataset
+        """
+        if self.config.dataset.type == "file":
+            # [TODO]: Implement other file formats
+            X = np.load(self.config.dataset.path.data, allow_pickle=True)
+            y = np.load(self.config.dataset.path.label, allow_pickle=True)
+        elif self.config.dataset.type == "generate":
+            # [TODO]: Implement other dataset generation methods
+            X, y = generate_linear_separable_data()
+        else:
+            raise ValueError(f"Invalid dataset type: {self.config.dataset.type}")
+
+        return X, y
+
+    def default_raw_preprocess(self, X: np.ndarray, y: np.ndarray) -> RAW_DATASET_TYPE:
+        """Default raw preprocess method. This method does not apply any preprocess.
+
+        Args:
+            X (np.ndarray): raw features of the dataset
+            y (np.ndarray): raw labels of the dataset
+
+        Returns:
+            RAW_DATASET_TYPE: raw features and labels of the dataset
+        """
+        return X, y
+
+    def raw_preprocess(self, X: np.ndarray, y: np.ndarray) -> RAW_DATASET_TYPE:
+        """Preprocess the raw dataset. This process executes before splitting the dataset.
+        ex) filtering, data sampling, etc.
+
+        Args:
+            X (np.ndarray): raw features of the dataset
+            y (np.ndarray): raw labels of the dataset
+
+        Returns:
+            RAW_DATASET_TYPE: preprocessed features and labels of the dataset
+        """
+        if self.custom_raw_preprocess is not None:
+            return self.custom_raw_preprocess(X, y)
+        else:
+            return self.default_raw_preprocess(X, y)
+
+    def split(self, X: np.ndarray, y: np.ndarray) -> PROCESSCED_DATASET_TYPE:
+        """Split the dataset into train and test sets.
+        Test set size is defined in the config.
+
+        Args:
+            X (np.ndarray): raw features of the dataset
+            y (np.ndarray): raw labels of the dataset
+
+        Returns:
+            PROCESSCED_DATASET_TYPE: train and test split of dataset (features and labels)
+        """
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=self.config.dataset.test_size, random_state=self.config.dataset.random_seed
+        )
+
+        return X_train, y_train, X_test, y_test
+
+    def default_transform(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_test: np.ndarray,
+        y_test: np.ndarray,
+    ) -> PROCESSCED_DATASET_TYPE:
+        """Default transform method. This method does not apply any transformation.
+
+        Args:
+            X_train (np.ndarray): raw features of the training data
+            y_train (np.ndarray): raw labels of the training data
+            X_test (np.ndarray): raw features of the test data
+            y_test (np.ndarray): raw labels of the test data
+
+        Returns:
+            PROCESSCED_DATASET_TYPE: train and test split of dataset (features and labels)
+        """
+        return X_train, y_train, X_test, y_test
+
+    def transform(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_test: np.ndarray,
+        y_test: np.ndarray,
+    ) -> PROCESSCED_DATASET_TYPE:
+        """Transform the dataset.
+        ex) feature scaling, dimension reduction, etc.
+
+        Args:
+            X_train (np.ndarray): raw features of the training data
+            y_train (np.ndarray): raw labels of the training data
+            X_test (np.ndarray): raw features of the test data
+            y_test (np.ndarray): raw labels of the test data
+
+        Returns:
+            PROCESSCED_DATASET_TYPE: transformed train and test split of dataset (features and labels)
+        """
+        if self.custom_transform is not None:
+            return self.custom_transform(X_train, y_train, X_test, y_test)
+        else:
+            return self.default_transform(X_train, y_train, X_test, y_test)
+
+    def build(self) -> Dataset:
+        X, y = self.load()
+        X, y = self.raw_preprocess(X, y)
+        X_train, y_train, X_test, y_test = self.split(X, y)
+        X_train_trs, y_train_trs, X_test_trs, y_test_trs = self.transform(X_train, y_train, X_test, y_test)
+
+        return Dataset(
+            X_train=X_train_trs,
+            y_train=y_train_trs,
+            X_test=X_test_trs,
+            y_test=y_test_trs,
+            config=self.config.dataset,
+        )

qxmt/datasets/dummy/__init__.py

@@ -0,0 +1,5 @@
+from qxmt.datasets.dummy.linear import generate_linear_separable_data
+
+__all__ = [
+    "generate_linear_separable_data",
+]

qxmt/datasets/dummy/linear.py

@@ -0,0 +1,26 @@
+import numpy as np
+
+
+def generate_linear_separable_data(
+    n_samples: int = 100,
+    n_features: int = 2,
+    noise: float = 0.1,
+    scale: float = 1.0,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Generate random linear separable data.
+
+    Args:
+        n_samples (int, optional): sample size. Defaults to 100.
+        n_features (int, optional): dimension of feature. Defaults to 2.
+        noise (float, optional): noise level. Defaults to 0.1.
+        scale (float, optional): scale of data. Defaults to 1.0.
+
+    Returns:
+        tuple[np.ndarray, np.ndarray]: generated data and label
+    """
+    X = scale * np.random.randn(n_samples, n_features)
+    w = scale * np.random.randn(n_features)
+    bias = scale * np.random.randn(n_samples) * noise
+    y = np.sign(X @ w + bias)
+
+    return X, y

qxmt/datasets/raw_preprocess/sampling.py

@@ -0,0 +1,22 @@
+import numpy as np
+
+from qxmt.datasets.builder import RAW_DATASET_TYPE
+
+
+def sampling_by_each_class(X: np.ndarray, y: np.ndarray, n_samples: int) -> RAW_DATASET_TYPE:
+    """Data sampling by each class
+
+    Args:
+        X (np.ndarray): input data
+        y (np.ndarray): label of input data
+
+    Returns:
+        RAW_DATASET_TYPE: sampled data
+    """
+    labels = [0, 1]
+    # n_sample = 100
+    y = np.array([int(label) for label in y])
+    indices = np.where(np.isin(y, labels))[0]
+    X, y = X[indices][:n_samples], y[indices][:n_samples]
+
+    return X, y

qxmt/datasets/schema.py

@@ -0,0 +1,32 @@
+from typing import Annotated, Any
+
+import numpy as np
+from pydantic import BaseModel, PlainSerializer, PlainValidator
+
+from qxmt.configs import DatasetConfig
+
+
+def validate(v: Any) -> np.ndarray:
+    if isinstance(v, np.ndarray):
+        return v
+    else:
+        raise TypeError(f"Expected numpy array, got {type(v)}")
+
+
+def serialize(v: np.ndarray) -> list[list[float]]:
+    return v.tolist()
+
+
+DataArray = Annotated[
+    np.ndarray,
+    PlainValidator(validate),
+    PlainSerializer(serialize),
+]
+
+
+class Dataset(BaseModel):
+    X_train: DataArray
+    y_train: DataArray
+    X_test: DataArray
+    y_test: DataArray
+    config: DatasetConfig

qxmt/datasets/transform/reduction_by_pca.py

@@ -0,0 +1,37 @@
+import numpy as np
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import StandardScaler
+
+from qxmt.datasets.builder import PROCESSCED_DATASET_TYPE
+
+
+def dimension_reduction_by_pca(
+    X_train: np.ndarray,
+    y_train: np.ndarray,
+    X_test: np.ndarray,
+    y_test: np.ndarray,
+    n_components: int,
+) -> PROCESSCED_DATASET_TYPE:
+    """Dimension reduction by PCA
+
+    Args:
+        X_train (np.ndarray): numpy array of training data
+        y_train (np.ndarray): numpy array of training label
+        X_test (np.ndarray): numpy array of testing data
+        y_test (np.ndarray): numpy array of testing label
+        n_components (int): number of components to keep
+
+    Returns:
+        PROCESSCED_DATASET_TYPE: tuple of processed dataset
+    """
+    scaler = StandardScaler()
+    scaler.fit(X_train)
+    x_train_scaled = scaler.transform(X_train)
+    x_test_scaled = scaler.transform(X_test)
+
+    pca = PCA(n_components=n_components)
+    pca.fit(x_train_scaled)
+    X_train_pca = pca.transform(x_train_scaled)
+    X_test_pca = pca.transform(x_test_scaled)
+
+    return X_train_pca, y_train, X_test_pca, y_test

qxmt/decorators.py

@@ -0,0 +1,10 @@
+from typing import Any, Callable
+
+
+def notify_long_running(func: Callable) -> Callable:
+    def wrapper(*args: dict, **kwargs: dict) -> Any:
+        print(f'Executing "{func.__name__}". This may take some time...')
+        result = func(*args, **kwargs)
+        return result
+
+    return wrapper

qxmt/devices/__init__.py

@@ -0,0 +1,5 @@
+from qxmt.devices.base import BaseDevice
+from qxmt.devices.builder import DeviceBuilder
+from qxmt.devices.device_info import get_number_of_qubits, get_platform_from_device
+
+__all__ = ["DeviceBuilder", "BaseDevice", "get_number_of_qubits", "get_platform_from_device"]

qxmt/devices/base.py

@@ -0,0 +1,32 @@
+from typing import Any, Optional
+
+from qxmt.exceptions import InvalidPlatformError
+
+
+class BaseDevice:
+    def __init__(self, platform: str, name: str, n_qubits: int, shots: Optional[int]) -> None:
+        self.platform = platform
+        self.name = name
+        self.n_qubits = n_qubits
+        self.shots = shots
+        self._set_device()
+
+    def __call__(self) -> Any:
+        return self.device
+
+    def _set_device(self) -> None:
+        """Set quantum device.
+
+        Raises:
+            InvalidPlatformError: platform is not implemented.
+        """
+        if self.platform == "pennylane":
+            from pennylane import qml
+
+            self.device = qml.device(
+                name=self.name,
+                wires=self.n_qubits,
+                shots=self.shots,
+            )
+        else:
+            raise InvalidPlatformError(f'"{self.platform}" is not implemented.')

qxmt/devices/builder.py

@@ -0,0 +1,23 @@
+from qxmt.configs import DeviceConfig
+from qxmt.devices.base import BaseDevice
+
+
+class DeviceBuilder:
+    def __init__(
+        self,
+        config: DeviceConfig,
+    ) -> None:
+        self.config: DeviceConfig = config
+
+    def build(self) -> BaseDevice:
+        """Build a quantum device. it can be a general-purpose device overseeing multiple platforms.
+
+        Returns:
+            BaseDevice: General-purpose device overseeing multiple platforms
+        """
+        return BaseDevice(
+            platform=self.config.platform,
+            name=self.config.name,
+            n_qubits=self.config.n_qubits,
+            shots=self.config.shots,
+        )

qxmt/devices/device_info.py

@@ -0,0 +1,40 @@
+from qxmt.constants import PENNYLANE_DEVICES
+from qxmt.devices.base import BaseDevice
+from qxmt.exceptions import InvalidQunatumDeviceError
+from qxmt.types import QuantumDeviceType
+
+
+def get_platform_from_device(device: BaseDevice | QuantumDeviceType) -> str:
+    """Get the platform name from the device.
+
+    Args:
+        device (BaseDevice | QuantumDeviceType): quantum device
+
+    Returns:
+        str: platform name
+    """
+    if isinstance(device, BaseDevice):
+        return device.platform
+
+    if isinstance(device, PENNYLANE_DEVICES):
+        return "pennylane"
+    else:
+        raise InvalidQunatumDeviceError(f"Device {device} is not supported.")
+
+
+def get_number_of_qubits(device: BaseDevice | QuantumDeviceType) -> int:
+    """Get the number of qubits from the device.
+
+    Args:
+        device (BaseDevice | QuantumDeviceType): quantum device
+
+    Returns:
+        int: number of qubits
+    """
+    if isinstance(device, BaseDevice):
+        return device.n_qubits
+
+    if isinstance(device, PENNYLANE_DEVICES):
+        return len(device.wires)
+    else:
+        raise InvalidQunatumDeviceError(f"Device {device} is not supported.")

qxmt/evaluation/__init__.py

@@ -0,0 +1,12 @@
+from qxmt.evaluation.base import BaseMetric
+from qxmt.evaluation.defaults import Accuracy, F1Score, Precision, Recall
+from qxmt.evaluation.evaluation import Evaluation
+
+__all__ = [
+    "BaseMetric",
+    "Accuracy",
+    "Recall",
+    "Precision",
+    "F1Score",
+    "Evaluation",
+]