qudas 0.1.0__py3-none-any.whl

qudas/__init__.py

@@ -0,0 +1,21 @@
+# __init__.py
+
+# バージョン情報をVERSIONファイルから読み込む
+import os
+
+# VERSIONファイルのパスを絶対パスで取得
+VERSION_FILE_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), '..', 'VERSION'
+)
+
+# VERSIONファイルからバージョンを読み込む
+try:
+    with open(VERSION_FILE_PATH) as version_file:
+        __version__ = version_file.read().strip()
+except FileNotFoundError:
+    __version__ = '0.0.1'  # デフォルトバージョンを設定
+
+from .qudata import QuData
+from .pipeline import Pipeline
+
+__all__ = ['QuData', 'Pipeline']

qudas/pipeline/__init__.py

@@ -0,0 +1,3 @@
+# pipeline/__init__.py
+
+from .pipeline import Pipeline

qudas/pipeline/pipeline.py

@@ -0,0 +1,457 @@
+from typing import Sequence, Dict, Any, Tuple, Optional
+from .steps import IteratorMixin
+
+
+class Pipeline:
+    def __init__(
+        self, steps: Sequence[Tuple[str, Any]], iterator: Optional[IteratorMixin] = None
+    ) -> None:
+        """
+        Pipelineクラスは一連のステップを受け取り、それぞれのステップを順に実行する。
+
+        Args:
+            steps (Sequence[Tuple[str, Any]]): ステップのリスト。各ステップは (名前, オブジェクト) のタプル形式。
+            iterator (Optional[IteratorMixin]): Pipeline全体を繰り返すイテレータ。イテレータは IteratorMixin 形式。デフォルト値はNone。
+        """
+        self.steps = steps
+        self.models = {step_name: None for step_name, _ in steps}
+        self.results = {step_name: None for step_name, _ in steps}
+        self.global_params = {}
+        self.global_iterator = iterator
+
+    def set_global_params(self, params: Dict[str, Any]) -> None:
+        """
+        パイプライン全体に適用するグローバルパラメータを設定する。
+
+        Args:
+            params (Dict[str, Any]): グローバルパラメータ。
+        """
+        self.global_params = params
+
+    def get_global_params(self) -> Dict[str, Any]:
+        """
+        パイプライン全体に適用されたグローバルパラメータを取得する。
+
+        Returns:
+            Dict[str, Any]: グローバルパラメータ。
+        """
+        return self.global_params
+
+    def _assign_global_params(self, step_instance):
+        """ステップが global_params を自動的に持つようにする"""
+        if not hasattr(step_instance, 'set_global_params'):
+            step_instance.global_params = self.global_params
+        else:
+            step_instance.set_global_params(self.global_params)
+
+        # models と results を共有
+        step_instance.models = self.models
+        step_instance.results = self.results
+
+    def _update_params(self, step_instance):
+        """パラメータを更新"""
+        if hasattr(step_instance, 'get_global_params'):
+            self.global_params = step_instance.get_global_params()
+
+    def _process_step(self, step: Tuple[str, Any], X: Any, y: Any, mode: str) -> Any:
+        """
+        ステップを実行する。
+
+        Args:
+            step (Tuple[str, Any]): 現在のステップ。
+            X (Any): 入力データ。
+            y (Any): ターゲットデータ。
+            mode (str): 実行モード ('fit', 'transform', 'optimize', 'predict')。
+
+        Returns:
+            Any: ステップまたはモデルによって処理されたデータ。
+        """
+        step_name, step_instance = step
+        model = self.models.get(step_name)
+
+        # モデルが存在し、transformまたはpredictを実行可能な場合
+        if model:
+            if mode == 'transform' and hasattr(model, 'transform'):
+                return model.transform(X)
+            if mode == 'predict' and hasattr(model, 'predict'):
+                return model.predict(X)
+
+        # モデルがない場合、通常のステップ処理
+        if mode == 'transform':
+            if hasattr(step_instance, 'transform'):
+                return step_instance.transform(X)
+            else:
+                return X
+
+        elif mode == 'fit' and hasattr(step_instance, 'fit'):
+            return step_instance.fit(X, y)
+
+        elif mode == 'optimize' and hasattr(step_instance, 'optimize'):
+            return step_instance.optimize(X, y)
+
+        return None
+
+    def fit(self, X: Any, y: Any = None) -> 'Pipeline':
+        """
+        各ステップを順に適用してデータを訓練する。
+
+        Args:
+            X (Any): 入力データ。
+            y (Any): ターゲットデータ。
+
+        Returns:
+            Pipeline: パイプラインオブジェクト自身。
+
+        Raises:
+            RuntimeError: 最後のステップに fit メソッドがない場合。
+        """
+
+        # 全体のglobal_iteratorのループ回数を取得
+        global_loop_num = getattr(self.global_iterator, 'loop_num', 1)
+
+        while global_loop_num > 0:
+
+            # self.stepsで処理
+            for step in self.steps:
+                step_name, step_instance = step
+
+                # 各ステップごとのループ回数を取得 (IteratorMixinのloop_num)
+                step_loop_num = getattr(step_instance, 'loop_num', 1)
+
+                while step_loop_num > 0:
+                    X = self._process_step(step, X, y, 'transform')
+
+                    # optimize を実行し、結果を y に格納
+                    if hasattr(step_instance, 'optimize'):
+
+                        # パラメータをstepと共有（処理前）
+                        self._assign_global_params(step_instance)
+
+                        self.results[step_name] = self._process_step(
+                            step, X, y, 'optimize'
+                        )
+
+                        # パラメータをstepと共有（処理後）
+                        step_instance.results = self.results
+                        self._update_params(step_instance)
+
+                    if (
+                        global_loop_num == 1
+                        and step_loop_num == 1
+                        and step_name == self.steps[-1][0]
+                    ):
+
+                        # fit を実行し、モデルを保存
+                        if hasattr(step_instance, 'fit'):
+
+                            # パラメータをstepと共有（処理前）
+                            self._assign_global_params(step_instance)
+
+                            self.models[step_name] = self._process_step(
+                                step, X, y, 'fit'
+                            )
+
+                            # パラメータをstepと共有（処理後）
+                            step_instance.models = self.models
+                            self._update_params(step_instance)
+
+                        else:
+                            # optimize メソッドが見つからなかった場合のエラー
+                            raise RuntimeError(
+                                "パイプラインの最後のステップに fit メソッドが見つかりませんでした。"
+                            )
+
+                    else:
+                        # fit を実行し、モデルを保存
+                        if hasattr(step_instance, 'fit'):
+
+                            # パラメータをstepと共有（処理前）
+                            self._assign_global_params(step_instance)
+
+                            self.models[step_name] = self._process_step(
+                                step, X, y, 'fit'
+                            )
+
+                            # パラメータをstepと共有（処理後）
+                            step_instance.models = self.models
+                            self._update_params(step_instance)
+
+                    # next_params が定義されていれば、次のパラメータを取得
+                    if hasattr(step_instance, 'next_params'):
+
+                        # パラメータをstepと共有
+                        self._assign_global_params(step_instance)
+
+                        X, y = step_instance.next_params(X, y)
+                        self._update_params(step_instance)
+
+                    # ステップごとのループ回数をデクリメント
+                    step_loop_num -= 1
+
+            # next_params が定義されていれば、次のパラメータを取得
+            if hasattr(self.global_iterator, 'next_params'):
+
+                # パラメータをstepと共有
+                self._assign_global_params(self.global_iterator)
+
+                X, y = self.global_iterator.next_params(X, y)
+                self._update_params(self.global_iterator)
+
+            # ステップごとのループ回数をデクリメント
+            global_loop_num -= 1
+
+        return self
+
+    def optimize(self, X: Any = None, y: Any = None) -> Dict[str, Any]:
+        """
+        各ステップを順に適用して最適化を実行する。
+
+        Args:
+            X (Any): 入力データ。
+            y (Any): ターゲットデータ。
+
+        Returns:
+            Dict[str, Any]: 各ステップの最適化結果。
+
+        Raises:
+            RuntimeError: 最後のステップに optimize メソッドがない場合。
+        """
+
+        # 全体のglobal_iteratorのループ回数を取得
+        global_loop_num = getattr(self.global_iterator, 'loop_num', 1)
+
+        while global_loop_num > 0:
+
+            # self.stepsで処理
+            for step in self.steps:
+                step_name, step_instance = step
+
+                # 各ステップのループ回数を取得 (IteratorMixinのloop_num)
+                step_loop_num = getattr(step_instance, 'loop_num', 1)
+
+                while step_loop_num > 0:
+
+                    # Transformer
+                    X = self._process_step(step, X, y, 'transform')
+
+                    # Estimator
+                    if hasattr(step_instance, 'fit'):
+
+                        # パラメータをstepと共有（処理前）
+                        self._assign_global_params(step_instance)
+
+                        self.models[step_name] = self._process_step(step, X, y, 'fit')
+
+                        # パラメータをstepと共有（処理後）
+                        step_instance.models = self.models
+                        self._update_params(step_instance)
+
+                    if (
+                        global_loop_num == 1
+                        and step_loop_num == 1
+                        and step_name == self.steps[-1][0]
+                    ):
+
+                        # Optimizer
+                        if hasattr(step_instance, 'optimize'):
+
+                            # パラメータをstepと共有（処理前）
+                            self._assign_global_params(step_instance)
+
+                            self.results[step_name] = self._process_step(
+                                step, X, y, 'optimize'
+                            )
+
+                            # パラメータをstepと共有（処理後）
+                            step_instance.results = self.results
+                            self._update_params(step_instance)
+
+                            return self.results
+
+                        else:
+                            # optimize メソッドが見つからなかった場合のエラー
+                            raise RuntimeError(
+                                "パイプラインの最後のステップに optimize メソッドが見つかりませんでした。"
+                            )
+
+                    else:
+                        # Optimizer
+                        if hasattr(step_instance, 'optimize'):
+
+                            # パラメータをstepと共有（処理前）
+                            self._assign_global_params(step_instance)
+
+                            self.results[step_name] = self._process_step(
+                                step, X, y, 'optimize'
+                            )
+
+                            # パラメータをstepと共有（処理後）
+                            step_instance.results = self.results
+                            self._update_params(step_instance)
+
+                    # next_params が定義されていれば、次のパラメータを取得
+                    if hasattr(step_instance, 'next_params'):
+
+                        # パラメータをstepと共有
+                        self._assign_global_params(step_instance)
+
+                        X, y = step_instance.next_params(X, y)
+                        self._update_params(step_instance)
+
+                    # ステップごとのループ回数をデクリメント
+                    step_loop_num -= 1
+
+            # next_params が定義されていれば、次のパラメータを取得
+            if hasattr(self.global_iterator, 'next_params'):
+
+                # パラメータをstepと共有
+                self._assign_global_params(self.global_iterator)
+
+                X, y = self.global_iterator.next_params(X, y)
+                self._update_params(self.global_iterator)
+
+            # ステップごとのループ回数をデクリメント
+            global_loop_num -= 1
+
+    def predict(self, X: Any = None) -> Dict[str, Any]:
+        """
+        各ステップを順に適用してデータを予測する。予測を行うためには、最後のステップで
+        IteratorMixin でないステップが predict メソッドを持っている必要がある。
+
+        Args:
+            X (Any): 入力データ。
+
+        Returns:
+            Any: 予測結果。
+
+        Raises:
+            RuntimeError: 最後のステップに predict メソッドがない場合。最後のステップで model が作成されていない場合。
+        """
+
+        # y の初期値
+        y = None
+
+        # 全体のglobal_iteratorのループ回数を取得
+        global_loop_num = getattr(self.global_iterator, 'loop_num', 1)
+
+        while global_loop_num > 0:
+
+            # self.stepsで処理
+            for step in self.steps:
+                step_name, step_instance = step
+
+                # 各ステップのループ回数を取得 (IteratorMixinのloop_num)
+                step_loop_num = getattr(step_instance, 'loop_num', 1)
+
+                # 全ステップを step_loop_num 回繰り返す
+                while step_loop_num > 0:
+
+                    # Transformer
+                    X = self._process_step(step, X, y, 'transform')
+
+                    if (
+                        global_loop_num == 1
+                        and step_loop_num == 1
+                        and step_name == self.steps[-1][0]
+                    ):
+
+                        # Predict
+                        if hasattr(step_instance, 'predict'):
+
+                            # パラメータをstepと共有（処理前）
+                            self._assign_global_params(step_instance)
+
+                            # predict 処理
+                            model = self.models[step_name]
+                            if model is not None:
+                                self.results[step_name] = model.predict(X)
+
+                                # パラメータをstepと共有（処理後）
+                                step_instance.results = self.results
+                                self._update_params(step_instance)
+
+                                return self.results
+
+                            else:
+                                # model が見つからなかった場合のエラー
+                                raise RuntimeError(
+                                    "パイプラインの最後のステップに model が見つかりませんでした。"
+                                )
+
+                        else:
+                            # predict メソッドが見つからなかった場合のエラー
+                            raise RuntimeError(
+                                "パイプラインの最後のステップに predict メソッドが見つかりませんでした。"
+                            )
+
+                    else:
+                        # Predict
+                        if hasattr(step_instance, 'predict'):
+
+                            # パラメータをstepと共有（処理前）
+                            self._assign_global_params(step_instance)
+
+                            # predict 処理
+                            model = self.models[step_name]
+                            if model is not None:
+                                self.results[step_name] = model.predict(X)
+
+                                # パラメータをstepと共有（処理後）
+                                step_instance.results = self.results
+                                self._update_params(step_instance)
+
+                    # optimize を実行し、結果を y に格納
+                    if hasattr(step_instance, 'optimize'):
+
+                        # パラメータをstepと共有（処理前）
+                        self._assign_global_params(step_instance)
+
+                        self.results[step_name] = self._process_step(
+                            step, X, y, 'optimize'
+                        )
+
+                        # パラメータをstepと共有（処理後）
+                        step_instance.results = self.results
+                        self._update_params(step_instance)
+
+                    # next_params が定義されていれば、次のパラメータを取得
+                    if hasattr(step_instance, 'next_params'):
+
+                        # パラメータをstepと共有
+                        self._assign_global_params(step_instance)
+
+                        X, y = step_instance.next_params(X, y)
+                        self._update_params(step_instance)
+
+                    # ステップごとのループ回数をデクリメント
+                    step_loop_num -= 1
+
+            # next_params が定義されていれば、次のパラメータを取得
+            if hasattr(self.global_iterator, 'next_params'):
+
+                # パラメータをstepと共有
+                self._assign_global_params(self.global_iterator)
+
+                X, y = self.global_iterator.next_params(X, y)
+                self._update_params(self.global_iterator)
+
+            # ステップごとのループ回数をデクリメント
+            global_loop_num -= 1
+
+    def get_results(self) -> Dict[str, Any]:
+        """
+        最適化結果を取得する。
+
+        Returns:
+            Dict[str, Any]: 各ステップごとの最適化結果。
+        """
+        return self.results
+
+    def get_models(self) -> Dict[str, Any]:
+        """
+        学習されたモデルを取得する。
+
+        Returns:
+            Dict[str, Any]: 各ステップごとのモデル。
+        """
+        return self.models

qudas/pipeline/steps/__init__.py

@@ -0,0 +1,5 @@
+# pipeline/steps/__init__.py
+
+from .base import BaseStep
+from .optimizer_mixin import OptimizerMixin
+from .iterator_mixin import IteratorMixin

qudas/pipeline/steps/base.py

@@ -0,0 +1,27 @@
+from abc import ABC
+
+
+class BaseStep(ABC):
+    def __init__(self):
+        self.global_params = {}
+        self.local_params = {}
+
+    def set_global_params(self, params: dict) -> None:
+        """
+        グローバルパラメータを設定するメソッド。
+        デフォルトでは何もしないため、必要なステップだけがオーバーライドする。
+
+        Args:
+            params (dict): グローバルパラメータの辞書。
+        """
+        self.global_params = params
+
+    def get_global_params(self) -> dict:
+        """
+        グローバルパラメータを取得するメソッド。
+        デフォルトでは空の辞書を返すため、必要なステップだけがオーバーライドする。
+
+        Returns:
+            dict: グローバルパラメータの辞書。
+        """
+        return self.global_params

qudas/pipeline/steps/iterator_mixin.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from typing import Any, Tuple
+from .base import BaseStep
+
+
+class IteratorMixin(BaseStep, ABC):
+    """
+    パイプラインステップ内で使用するイテレータ用のMixinクラス。
+    このMixinクラスは次のパラメータセットを生成する `next_params` メソッドの実装を要求します。
+    """
+
+    def __init__(self, loop_num: int = 1) -> None:
+        super().__init__()
+        self.loop_num = loop_num  # デフォルトで1回のループ
+        self.models = None
+        self.results = None
+
+    @abstractmethod
+    def next_params(self, X: Any, y: Any = None, **iter_params) -> Tuple[Any, Any]:
+        """
+        次のパラメータセットを生成する抽象メソッド。
+
+        Args:
+            X (Any): 入力データ。
+            y (Any): ターゲットデータ。
+            **iter_params: 追加のパラメータ。
+
+        Returns:
+            Tuple[Any, Any]: 次の入力データとターゲットデータ。
+        """
+        pass

qudas/pipeline/steps/optimizer_mixin.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from .base import BaseStep
+
+
+class OptimizerMixin(BaseStep, ABC):
+    """
+    パイプラインステップ内で使用する最適化処理用のMixinクラス。
+    このMixinクラスは、`transform` および `optimize` メソッドをサポートし、`optimize` メソッドの実装を必須とします。
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.models = None
+        self.results = None
+
+    def transform(self, X: Any) -> Any:
+        """
+        オプションの変換メソッド。サブクラスでオーバーライド可能。
+
+        Args:
+            X (Any): 入力データ。
+
+        Returns:
+            Any: 変換後のデータ。
+        """
+        return X  # デフォルトでは変換しない
+
+    @abstractmethod
+    def optimize(self, X: Any = None, y: Any = None, **fit_params) -> Any:
+        """
+        抽象的な最適化メソッド。
+
+        Args:
+            X (Any): 入力データ。
+            y (Any): ターゲットデータ。
+            **fit_params: 追加のパラメータ。
+
+        Returns:
+            Any: 最適化結果。
+        """
+        pass

qudas/qudata/__init__.py

@@ -0,0 +1,9 @@
+# qudata/__init__.py
+
+# QuData, QuDataInput, QuDataOutput, QuDataBase クラスを外部から直接インポートできるようにする
+from .qudata import QuData
+from .qudata_input import QuDataInput
+from .qudata_output import QuDataOutput
+from .qudata_base import QuDataBase
+
+__all__ = ['QuData', 'QuDataInput', 'QuDataOutput', 'QuDataBase']

qudas/qudata/qudata.py

@@ -0,0 +1,35 @@
+from .qudata_input import QuDataInput
+from .qudata_output import QuDataOutput
+from typing import Optional, Dict, Any
+
+
+class QuData:
+
+    @classmethod
+    def input(cls, prob: Optional[Dict[str, Any]] = None) -> QuDataInput:
+        """
+        クラスメソッドとして QuDataInput のインスタンスを作成し、引数を受け取る。
+
+        Args:
+            prob (dict, optional): QuDataInput の引数となる最適化問題データ。
+
+        Returns:
+            QuDataInput のインスタンス。
+        """
+        return QuDataInput(prob)
+
+    @classmethod
+    def output(
+        cls, result: Optional[Dict[str, Any]] = None, result_type: Optional[str] = None
+    ) -> QuDataOutput:
+        """
+        クラスメソッドとして QuDataOutput のインスタンスを作成し、引数を受け取る。
+
+        Args:
+            result (dict, optional): QuDataOutput の引数となる計算結果データ。
+            result_type (str, optional): 結果の形式。
+
+        Returns:
+            QuDataOutput のインスタンス。
+        """
+        return QuDataOutput(result, result_type)

qudas/qudata/qudata_base.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+
+class QuDataBase(ABC):
+    def __init__(self, data: Dict[str, Any] = None):
+        """
+        初期データを格納する抽象クラス。
+
+        Args:
+            data (dict, optional): 入力または出力データ。デフォルトはNone。
+        """
+        self.data = {}
+
+        if data is None:
+            self.data = {}
+        elif isinstance(data, dict):
+            self.data = data
+        else:
+            raise TypeError(f"{type(data)}は対応していない型です。")
+
+    # @abstractmethod
+    # def from_xxx(self, data):
+    #     """サブクラスで実装されるべき抽象メソッド"""
+    #     pass
+
+    # @abstractmethod
+    # def to_xxx(self):
+    #     """サブクラスで実装されるべき抽象メソッド"""
+    #     pass