spmkit-learn 1.0.0__tar.gz

spmkit_learn-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shota Inoue
+
+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.

spmkit_learn-1.0.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: spmkit-learn
+Version: 1.0.0
+Summary: Meta-Sparse Modeling Library for Chemical Data Prediction.
+Author-email: Shota Inoue <inoue.shota@st.kitasato-u.ac.jp>
+License: Proprietary
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<=1.26.4,>=1.25.2
+Requires-Dist: scikit-learn==1.6.0
+Requires-Dist: matplotlib>=3.7.0
+Dynamic: license-file
+
+# spmkit
+
+**spmkit** is meta-sparse modeling library for chemical data prediction.
+
+-----
+
+## Installation
+
+```bash
+# via wheel binary
+pip install spmkit-***.whl
+
+# via gzip source
+pip install spmkit-***.tar.gz
+```

spmkit_learn-1.0.0/README.md

@@ -0,0 +1,15 @@
+# spmkit
+
+**spmkit** is meta-sparse modeling library for chemical data prediction.
+
+-----
+
+## Installation
+
+```bash
+# via wheel binary
+pip install spmkit-***.whl
+
+# via gzip source
+pip install spmkit-***.tar.gz
+```

spmkit_learn-1.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "spmkit-learn"
+version = "1.0.0"
+description = "Meta-Sparse Modeling Library for Chemical Data Prediction."
+readme = "README.md"
+requires-python = ">=3.10"
+
+authors = [
+    { name = "Shota Inoue", email = "inoue.shota@st.kitasato-u.ac.jp" }
+]
+
+dependencies = [
+    "numpy >= 1.25.2, <= 1.26.4",
+    "scikit-learn == 1.6.0",
+    "matplotlib >= 3.7.0",
+]
+
+license = { text = "Proprietary" }
+
+classifiers = [
+    "License :: Other/Proprietary License",
+
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+
+    "Operating System :: OS Independent",
+
+    "Intended Audience :: Science/Research",
+
+    "Topic :: Scientific/Engineering :: Chemistry",
+]
+
+[tool.setuptools.packages.find]
+include = ["spmkit*"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+spmkit = [
+    "assets/*.ttf",
+]

spmkit_learn-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spmkit_learn-1.0.0/spmkit/__init__.py

@@ -0,0 +1 @@
+from . import models, plots

spmkit_learn-1.0.0/spmkit/models/__init__.py

@@ -0,0 +1,4 @@
+from .exhaustive_search import ExhaustiveSearch
+from .stability_selection import StabilitySelection
+
+__all__ = ["ExhaustiveSearch", "StabilitySelection"]

spmkit_learn-1.0.0/spmkit/models/exhaustive_search.py

@@ -0,0 +1,314 @@
+import multiprocessing as mp
+from dataclasses import dataclass
+from functools import partial
+from itertools import combinations
+from typing import Literal
+
+import numpy as np
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import (
+    mean_squared_error,
+)
+from sklearn.model_selection import KFold
+from tqdm.auto import tqdm
+
+
+@dataclass
+class Result:
+    score: float
+    weights: np.ndarray
+    feature: np.ndarray
+    model: LinearRegression | list[LinearRegression]
+
+
+# 回帰器
+def _regressor(combo, X, y, sort_criteria):
+    # 特徴量を切り出す
+    idx = np.array(combo)
+    X_slice = X[:, idx]
+
+    # モデル定義
+    model = LinearRegression()
+
+    # fit
+    model.fit(X_slice, y)
+
+    # predict
+    y_pred = model.predict(X_slice)
+
+    # score
+    score = (
+        _get_aic(X_slice, y, y_pred)
+        if sort_criteria == "aic"
+        else _get_bic(X_slice, y, y_pred)
+    )
+
+    # idx, coef は元の特徴量ベクトル (size p) へ埋め込む
+    weights = np.zeros(X.shape[1], dtype=float)
+    weights[idx] = model.coef_
+    feature = np.zeros(X.shape[1], dtype=int)
+    feature[idx] = 1
+
+    return Result(
+        score=score,
+        weights=weights,
+        feature=feature,
+        model=model,
+    )
+
+
+def _regressor_cv(combo, X, y, split):
+    # 特徴量を切り出す
+    idx = np.array(combo)
+    X_slice = X[:, idx]
+
+    # モデル定義
+    model = LinearRegression()
+
+    # internal k-fold split
+    cves = []
+    coefs = []
+    models = []
+
+    for train_index, test_index in split:
+        # split
+        X_train, X_test = X_slice[train_index], X_slice[test_index]
+        y_train, y_test = y[train_index], y[test_index]
+
+        # fit
+        model.fit(X_train, y_train)
+
+        # save model
+        models.append(model)
+
+        # predict
+        y_pred = model.predict(X_test)
+
+        # compute cve
+        cve = mean_squared_error(y_test, y_pred)
+        cves.append(cve)
+
+        # coefs
+        coefs.append(model.coef_)
+
+    # fold 平均 CVE, coefs
+    cve = np.mean(cves)
+    coefs = np.mean(coefs)
+
+    # idx, coef は元の特徴量ベクトル (size p) へ埋め込む
+    weights = np.zeros(X.shape[1], dtype=float)
+    weights[idx] = coefs
+    feature = np.zeros(X.shape[1], dtype=int)
+    feature[idx] = 1
+
+    return Result(
+        score=cve,
+        weights=weights,
+        feature=feature,
+        model=models,
+    )
+
+
+# スコア計算関数
+def _get_aic(X, y, y_pred):
+    rss = np.sum((y - y_pred) ** 2)
+    n = len(y)
+    k = X.shape[1] + 1
+    aic = n * np.log(rss / n) + 2 * k
+    return aic
+
+
+def _get_bic(X, y, y_pred):
+    rss = np.sum((y - y_pred) ** 2)
+    n = len(y)
+    k = X.shape[1] + 1
+    bic = n * np.log(rss / n) + k * np.log(n)
+    return bic
+
+
+# exhaustive search
+class ExhaustiveSearch:
+    """線形重回帰モデルの全探索
+
+    Parameters
+    ----------
+    sort_criteria : {"cve", "aic", "bic"}, default="cve"
+        学習済みモデルをソートする基準 (交差検証誤差もしくは AIC, BIC)
+    random_state : int, default=42
+        ランダムシード
+    n_fold : int, default=5
+        交差検証を用いる場合の分割数
+
+    Attributes
+    ----------
+    result_ : ndarray
+        基準に基づてソートされた学習済みモデルの重みとスコア
+
+    """
+
+    def __init__(
+        self,
+        sort_criteria: Literal["cve", "aic", "bic"] = "cve",
+        random_state: int = 42,
+        n_fold: int = 5,
+    ):
+        if sort_criteria not in {"cve", "aic", "bic"}:
+            raise ValueError(
+                f"sort_criteria must be one of 'cve', 'aic', 'bic', got {sort_criteria!r}",
+            )
+
+        self.sort_criteria = sort_criteria
+        self.n_fold = n_fold
+        self.random_state = random_state
+
+        self.results_ = None
+        self._best_mask = None
+
+        # ランダムシード固定
+        np.random.seed(self.random_state)
+
+    def fit(self, X, y, n_jobs: int = -1):
+        """モデルを学習させる
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            訓練データのデザイン行列
+        y : array-like of shape (n_samples,)
+            教師ラベルの配列
+        n_jobs : int, default=-1
+            CPU プロセス数 (-1 を指定すると全ての CPU コアを消費)
+
+        Returns
+        -------
+        self
+            学習済みインスタンス
+
+        """
+        # ndarray にキャスト
+        X, y = np.asarray(X), np.asarray(y)
+
+        # 全ての特徴量の組み合わせを生成する
+        combos = []
+        for k in range(1, X.shape[1] + 1):
+            combos.extend(combinations(range(X.shape[1]), k))
+
+        print(f"model sorting criteria to be used: {self.sort_criteria.upper()}")
+
+        if self.sort_criteria == "cve":
+            # k-fold
+            kf = KFold(
+                n_splits=self.n_fold,
+                random_state=self.random_state,
+                shuffle=True,
+            )
+            split = list(kf.split(X, y))
+            worker = partial(
+                _regressor_cv,
+                X=X,
+                y=y,
+                split=split,
+            )
+        else:
+            worker = partial(
+                _regressor,
+                X=X,
+                y=y,
+                sort_criteria=self.sort_criteria,
+            )
+
+        # 並列実行
+        with mp.Pool(processes=mp.cpu_count() if n_jobs == -1 else n_jobs) as pool:
+            results = list(
+                tqdm(
+                    pool.imap_unordered(worker, combos),
+                    total=len(combos),
+                    desc="progress",
+                ),
+            )
+
+        # sort
+        results.sort(key=lambda res: res.score)
+        self.results_ = np.array(results)
+        return self
+
+    def get_scores(self):
+        """ソート済みのスコアを取得する
+
+        Returns
+        -------
+        ndarray of shape (2**n_features - 1,)
+            ソートされたスコアの配列
+
+        """
+        return np.array([res.score for res in self.results_])
+
+    def get_weights(self):
+        """基準に基づいてソートされた学習済みモデルの重みを取得する
+
+        Returns
+        -------
+        ndarray of shape (n_features, 2**n_features - 1)
+            ソートされた学習済みモデルの重み行列
+
+        """
+        return np.array([res.weights for res in self.results_]).T
+
+    def get_features(self):
+        """基準に基づいてソートされた、各特徴量の有無を表す One-hot ベクトルを取得する
+
+        Returns
+        -------
+        ndarray of shape (2**n_features - 1,)
+            各特徴量の有無を表す One-hot ベクトルの配列
+
+        """
+        return np.array([res.feature for res in self.results_])
+
+    def predict(self, X, rank: int = 0):
+        """指定したランクの学習済みモデルによる予測を行う
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            デザイン行列
+        rank : int, default=0
+            モデルランク
+
+        Returns
+        -------
+        ndarray of shape (n_samples,)
+            指定したランクの学習済みモデルによる予測値
+
+        """
+        # rank を指定してモデルを取り出す
+        model = self.results_[rank].model
+
+        # ndarray にキャスト
+        X = np.asarray(X)
+
+        # スライス
+        X_slice = X[:, self.results_[rank].feature.astype(bool)]
+
+        if self.sort_criteria == "cve":
+            y_preds = []
+            for fold in model:
+                y_pred = fold.predict(X_slice)
+                y_preds.append(y_pred)
+            return np.mean(y_preds, axis=0)
+
+        y_pred = model.predict(X_slice)
+        return y_pred
+
+    def get_ave_importances(self):
+        """特徴量重要度 (平均絶対標準化回帰係数) とその標準偏差を取得する
+
+        Returns
+        -------
+        ndarray of shape (n_features, 2)
+            特徴量重要度 (平均絶対標準化回帰係数) とその標準偏差
+
+        """
+        weights = self.get_weights()
+        weights_abs = np.abs(weights)
+        return np.vstack([weights_abs.mean(axis=1), weights_abs.std(axis=1)]).T

spmkit_learn-1.0.0/spmkit/models/stability_selection.py

@@ -0,0 +1,335 @@
+import multiprocessing as mp
+from functools import partial
+from itertools import product
+from typing import Literal
+
+import numpy as np
+from sklearn.linear_model import Lasso
+from sklearn.preprocessing import StandardScaler
+from tqdm.auto import tqdm
+
+
+# 各イテレーションで特徴量選択を行い、特徴量ごとに選択されたかどうかを返すメソッド
+def _selector(iters, X, y, alphas, eps, max_iter, random_state):
+    # イテレータ
+    subsample_idx, alpha_idx = iters
+
+    # サブサンプル
+    X_subsample = X[subsample_idx]
+    y_subsample = y[subsample_idx]
+
+    # alpha
+    alpha = alphas[alpha_idx]
+
+    # 標準化
+    scaler = StandardScaler()
+    X_subsample_scaled = scaler.fit_transform(X_subsample)
+
+    # モデル定義
+    model = Lasso(
+        alpha=alpha,
+        random_state=random_state,
+        max_iter=max_iter,
+    )
+
+    # 学習
+    model.fit(X_subsample_scaled, y_subsample)
+
+    # 選択された特徴量を 0/1 で収集
+    selection = (np.abs(model.coef_) > eps).astype(int)
+
+    return selection, alpha_idx
+
+
+# Stability Selection を行うクラス
+class StabilitySelection:
+    """Stability Selection (N. Meinshausen and P. Bühlmann, J. R. Stat. Soc. B (2010).).
+
+    Parameters
+    ----------
+    subsample_iter : int, default=100
+        サブサンプリング回数
+    subsample_frac : float, default=0.5
+        サブサンプリング比率 (0.0 から 1.0 の値)
+    n_alphas : int, default=100
+        正則化係数 (alpha) の値をサンプリングする回数
+    min_alpha : float, default=1e-6
+        サンプリングされる alpha の最小値
+    max_alpha : float, default=1.0
+        サンプリングされる alpha の最大値
+    eps : float, default=1e-6
+        LASSO が特徴量選択を行う際の閾値
+    lasso_max_iter : int, default=1000
+        LASSO の最大反復回数
+    random_state : int, default=42
+        ランダムシード
+
+    Attributes
+    ----------
+    alphas_ : ndarray of shape (n_alphas,)
+        サンプリングされた alpha の配列
+    selection_path_ : ndarray of shape (n_features, n_alphas)
+        各特徴量における alpha ごとの選択確率プロファイル
+
+    """
+
+    def __init__(
+        self,
+        subsample_iter: int = 100,
+        subsample_frac: float = 0.5,
+        n_alphas: int = 100,
+        min_alpha: float = 1e-6,
+        max_alpha: float = 1.0,
+        eps: float = 1e-6,
+        lasso_max_iter: int = 1000,
+        random_state: int = 42,
+    ):
+        self.subsample_iter = subsample_iter  # サブサンプリング回数
+        self.subsample_frac = subsample_frac  # サブサンプリング比率
+        self.n_alphas = n_alphas  # LASSO の正則化係数の探索回数
+        self.min_alpha = min_alpha  # LASSO の正則化係数の最小値
+        self.max_alpha = max_alpha  # LASSO の正則化係数の最大値
+        self.eps = eps  # スパースとみなす閾値
+        self.lasso_max_iter = lasso_max_iter  # LASSO の最大反復回数
+        self.random_state = random_state  # ランダムシード
+
+        self.alphas_ = None  # alpha のプロファイル
+        self.selection_path_ = None  # 選択確率
+
+        # ランダムシード固定
+        np.random.seed(self.random_state)
+
+    # 学習を実行する関数
+    def fit(self, X, y, n_jobs: int = -1):
+        """モデルを学習させる
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            訓練データのデザイン行列
+        y : array-like of shape (n_samples,)
+            教師ラベルの配列
+        n_jobs : int, default=-1
+            CPU プロセス数 (-1 を指定すると全ての CPU コアを消費)
+
+        Returns
+        -------
+        self
+            学習済みインスタンス
+
+        """
+        # ndarray にキャスト
+        X, y = np.asarray(X), np.asarray(y)
+
+        # データサイズ
+        n_sample = X.shape[0]
+        n_subsample = int(n_sample * self.subsample_frac)
+
+        # サブサンプリング用の index を生成
+        # 重複を許さない
+        subsample_indices = []
+        seen = set()
+        subsample_count = 0
+        subsample_max_iter = int(self.subsample_iter * 10)
+
+        while len(subsample_indices) < self.subsample_iter:
+            if subsample_count > subsample_max_iter:
+                break
+
+            subsample_count += 1
+
+            indice = np.random.choice(n_sample, n_subsample, replace=False)
+            key = tuple(sorted(indice))
+
+            if key not in seen:
+                subsample_indices.append(indice)
+                seen.add(key)
+
+        # alpha を走査
+        self.alphas_ = np.logspace(
+            np.log10(self.min_alpha),
+            np.log10(self.max_alpha),
+            self.n_alphas,
+        )
+        alpha_indices = list(range(len(self.alphas_)))
+
+        # 特徴量選択器の初期化
+        worker = partial(
+            _selector,
+            X=X,
+            y=y,
+            alphas=self.alphas_,
+            eps=self.eps,
+            max_iter=self.lasso_max_iter,
+            random_state=self.random_state,
+        )
+
+        # ループするイテレータ
+        iters = product(subsample_indices, alpha_indices)
+
+        # 並列で選択を実行
+        tot_iters = len(subsample_indices) * len(alpha_indices)
+        with mp.Pool(processes=mp.cpu_count() if n_jobs == -1 else n_jobs) as pool:
+            selections = list(
+                tqdm(
+                    pool.imap_unordered(worker, iters),
+                    total=tot_iters,
+                    desc="progress",
+                ),
+            )
+
+        # 特徴量・alpha ごとの選択回数
+        selection_counts = np.zeros((X.shape[1], len(alpha_indices)), dtype=int)
+        for sele in selections:
+            selection_counts[:, sele[1]] += sele[0]
+
+        # 特徴量・alpha ごとの選択確率
+        self.selection_path_ = selection_counts / self.subsample_iter
+        return self
+
+    # 選択確率を取得
+    def get_selection_path(self):
+        """各特徴量における alpha ごとの選択確率プロファイルを取得する
+
+        Returns
+        -------
+        selection_path_ : ndarray of shape (n_features, n_alphas)
+            各特徴量における alpha ごとの選択確率プロファイル
+
+        """
+        return self.selection_path_
+
+    # alphas を取得
+    def get_alphas(self):
+        """サンプリングされた alpha の配列を取得する
+
+        Returns
+        -------
+        alphas_ : ndarray of shape (n_alphas,)
+            サンプリングされた alpha の配列
+
+        """
+        return self.alphas_
+
+    # alpha のスライス
+    def _get_alpha_domain(
+        self,
+        lower_alpha: float | None,
+        upper_alpha: float | None,
+    ):
+        if lower_alpha is None:
+            lower_alpha = self.min_alpha
+        if upper_alpha is None:
+            upper_alpha = self.max_alpha
+
+        if lower_alpha < self.min_alpha:
+            return ValueError(
+                "'lower_alpha' must be greater than or equal to 'min_alpha'.",
+            )
+        if upper_alpha > self.max_alpha:
+            return ValueError(
+                "'upper_alpha' must be less than or equal to 'max_alpha'.",
+            )
+
+        # alpha を指定した領域に制限
+        alpha_indice = np.where(
+            (self.alphas_ >= lower_alpha) & (self.alphas_ < upper_alpha),
+        )[0]
+        domain = self.selection_path_[:, alpha_indice]
+        return domain
+
+    def get_ave_selection_probs(
+        self,
+        lower_alpha: float | None = None,
+        upper_alpha: float | None = None,
+    ):
+        """指定した alpha の領域について、特徴量ごとの平均選択率とその標準偏差を取得する
+
+        Parameters
+        ----------
+        lower_alpha : float, optional
+            alpha の下界
+        upper_alpha : float, optional
+            alpha の上界
+
+        Returns
+        -------
+        ndarray of shape (n_features, 2)
+            特徴量ごとの平均選択率とその標準偏差
+
+        """
+        domain = self._get_alpha_domain(
+            lower_alpha=lower_alpha,
+            upper_alpha=upper_alpha,
+        )
+
+        # 平均選択率とその標準偏差
+        return np.vstack([domain.mean(axis=1), domain.std(axis=1)]).T
+
+    def get_mask(
+        self,
+        lower_alpha: float | None = None,
+        upper_alpha: float | None = None,
+        selection_th: float = 0.5,
+        astype: Literal["bool", "int"] = "bool",
+    ):
+        """指定した alpha の領域について、特徴量が選択されたかどうかを表すマスク配列を取得する
+
+        Parameters
+        ----------
+        lower_alpha : float, optional
+            alpha の下界
+        upper_alpha : float, optional
+            alpha の上界
+        selection_th : float, default=0.5
+            特徴量選択の閾値 (0.0 から 1.0 の値)
+        astype : {"bool", "int"}, default="bool"
+            マスク配列の型
+
+        Returns
+        -------
+        ndarray of shape (n_features,)
+            特徴量が選択されたかどうかを表すマスク配列
+
+        """
+        selection_probs = self.get_ave_selection_probs(
+            lower_alpha=lower_alpha,
+            upper_alpha=upper_alpha,
+        )
+        mask = selection_probs[:, 0] >= selection_th
+        if astype == "int":
+            mask = mask.astype(int)
+        return mask
+
+    def transform(
+        self,
+        X,
+        lower_alpha: float | None = None,
+        upper_alpha: float | None = None,
+        selection_th: float = 0.5,
+    ):
+        """指定した alpha の領域について、デザイン行列をスパース表現に変換する
+
+        Parameters
+        ----------
+        lower_alpha : float, optional
+            alpha の下界
+        upper_alpha : float, optional
+            alpha の上界
+        selection_th : float, default=0.5
+            特徴量選択の閾値 (0.0 から 1.0 の値)
+
+        Returns
+        -------
+        ndarray of shape (n_samples, n_features)
+            デザイン行列のスパース表現
+
+        """
+        X = np.asarray(X)
+        mask = self.get_mask(
+            lower_alpha=lower_alpha,
+            upper_alpha=upper_alpha,
+            selection_th=selection_th,
+        )
+        X[:, ~mask] = 0.0
+        return X

spmkit_learn-1.0.0/spmkit/plots.py

@@ -0,0 +1,320 @@
+from importlib.resources import files
+from typing import Literal
+
+import matplotlib.colors as cl
+import matplotlib.font_manager as fm
+import matplotlib.pyplot as plt
+import matplotlib.ticker as tick
+import numpy as np
+
+
+def _init():
+    arial_path = files("spmkit.assets") / "Arial.ttf"
+    arial = fm.FontProperties(fname=arial_path)
+    plt.rcParams["font.family"] = arial.get_name()
+    plt.rcParams["mathtext.fontset"] = "cm"
+    plt.rcParams["xtick.direction"] = "in"
+    plt.rcParams["ytick.direction"] = "in"
+    plt.rcParams["font.size"] = 14
+    plt.gca().spines["right"].set_visible(True)
+    plt.gca().spines["top"].set_visible(True)
+    plt.gca().spines["bottom"].set_visible(True)
+    plt.gca().spines["left"].set_visible(True)
+    plt.gca().spines["top"].set_linewidth(2)
+    plt.gca().spines["left"].set_linewidth(2)
+    plt.gca().spines["bottom"].set_linewidth(2)
+    plt.gca().spines["right"].set_linewidth(2)
+    plt.xticks(fontproperties=arial.get_name())
+    plt.yticks(fontproperties=arial.get_name())
+    plt.tick_params(left=True, width=2, length=5)
+
+
+def selection_path_plot(ax, selection_path, alphas, feature_names=None):
+    """各特徴量における alpha ごとの選択確率プロファイルを表示する
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        `matplotlib.axes.Axes`
+    selection_path : array-like of shape (n_features, n_alphas)
+        各特徴量における alpha ごとの選択確率プロファイル
+    alphas_ : array-like of shape (n_alphas,)
+        サンプリングされた alpha の配列
+    feature_names : array-like of shape (n_features,), optional
+        各特徴量の名称
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        更新済みの `matplotlib.axes.Axes`
+
+    """
+    _init()
+    selection_path, alphas = np.asarray(selection_path), np.asarray(alphas)
+    if feature_names is None:
+        feature_names = [f"feature {l + 1}" for l in range(selection_path.shape[0])]
+
+    for i, feat in enumerate(selection_path):
+        ax.plot(alphas, feat, label=feature_names[i])
+    ax.set_xscale("log", base=10)
+    ax.set_ylim(0.0, 1.0)
+    ax.set_xlabel(r"$\alpha$", fontsize=16)
+    ax.set_ylabel("Selection probability", fontsize=16)
+    ax.legend()
+    return ax
+
+
+def ave_selection_probs_bar_plot(
+    ax,
+    selection_probs,
+    selection_th=None,
+    feature_names=None,
+    bar_color="limegreen",
+    vline_color="red",
+    errorbar=False,
+):
+    """特徴量ごとの平均選択率を表示する
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        `matplotlib.axes.Axes`
+    selection_probs : ndarray of shape (n_features, 2)
+        特徴量ごとの平均選択率とその標準偏差
+    selection_th : float, optional
+        特徴量選択の閾値 (0.0 から 1.0 の値)
+    feature_names : array-like of shape (n_features,), optional
+        各特徴量の名称
+    bar_color : str, default="limegreen"
+        バーの色
+    vline_color : str, default="red"
+        分割線の色
+    errorbar : bool, default=False
+        エラーバーを表示するかどうか
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        更新済みの `matplotlib.axes.Axes`
+
+    """
+    _init()
+    selection_probs = np.asarray(selection_probs)
+    if feature_names is None:
+        feature_names = [f"feature {l + 1}" for l in range(selection_probs.shape[0])]
+
+    # ソート
+    sort_indice = np.argsort(selection_probs[:, 0])
+    selection_probs_sorted = selection_probs[sort_indice]
+    feature_names_sorted = np.array(feature_names)[sort_indice]
+
+    ax.barh(
+        feature_names_sorted,
+        selection_probs_sorted[:, 0],
+        xerr=selection_probs_sorted[:, 1] if errorbar else 0,
+        capsize=2,
+        height=1.0,
+        edgecolor="black",
+        color=bar_color,
+    )
+
+    if selection_th is not None:
+        ax.axvline(
+            selection_th,
+            linestyle="dashed",
+            linewidth=1.5,
+            label="Threshold",
+            color=vline_color,
+        )
+        ax.legend()
+
+    ax.set_xlim(0.0, 1.0)
+    ax.set_xlabel("Average of selection probability", fontsize=16)
+    ax.set_ylabel("Features", fontsize=16)
+    return ax
+
+
+def weight_diagram(
+    ax,
+    weights,
+    feature_names=None,
+    pos_color="red",
+    neg_color="dodgerblue",
+    mid_color="whitesmoke",
+    xscale: Literal["linear", "log2"] = "linear",
+):
+    """全ての学習済みモデルの重みを表示する
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        `matplotlib.axes.Axes`
+    weights : array-like of shape (n_features, 2**n_features - 1)
+        ソートされた学習済みモデルの重み行列
+    feature_names : array-like of shape (n_features,), optional
+        各特徴量の名称
+    pos_color : str, default="red"
+        重みが正となる場合の色
+    neg_color : str, default="dodgerblue"
+        重みが負となる場合の色
+    mid_color : str, default="lightgray"
+        重みがゼロとなる場合の色
+    xscale : {"linear", "log2"}, default="linear"
+        横軸のスケール
+
+    Returns
+    -------
+    matplotlib.collections.QuadMesh
+        更新済みの `matplotlib.collections.QuadMesh`
+
+    """
+    _init()
+    weights = np.asarray(weights)
+    n_features, n_models = weights.shape
+
+    if feature_names is None:
+        feature_names = [f"feature {l + 1}" for l in range(n_features)]
+
+    # ranks = np.arange(1, n_models + 1)
+    x = np.arange(0.5, n_models + 1.5)
+    y = np.arange(n_features + 1)
+
+    im = ax.pcolormesh(
+        x,
+        y,
+        weights,
+        cmap=cl.LinearSegmentedColormap.from_list(
+            "weight_diagram",
+            [neg_color, mid_color, pos_color],
+        ),
+        norm=cl.TwoSlopeNorm(
+            vcenter=0.0,
+        ),
+    )
+
+    ax.set_xlim(1, n_models + 1)
+    if xscale == "log2":
+        ax.set_xscale("log", base=2)
+    ax.xaxis.set_major_locator(tick.LogLocator(base=2))
+    ax.xaxis.set_major_formatter(tick.LogFormatterMathtext(base=2))
+    ax.set_yticklabels(feature_names)
+    ax.set_yticks(np.arange(len(feature_names)) + 0.5)
+    ax.set_xlabel("Rank", fontsize=16)
+    ax.set_ylabel("Features", fontsize=16)
+    return im
+
+
+def coefs_waterfall_plot(
+    ax,
+    weights,
+    rank=0,
+    feature_names=None,
+    pos_color="red",
+    neg_color="dodgerblue",
+):
+    """指定したランクのモデルの重みを絶対値順にソートして表示する
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        `matplotlib.axes.Axes`
+    weights : array-like of shape (n_features, 2**n_features - 1)
+        ソートされた学習済みモデルの重み行列
+    rank : int, default=0
+        モデルランク
+    feature_names : array-like of shape (n_features,), optional
+        各特徴量の名称
+    pos_color : str, default="red"
+        重みが正となる場合の色
+    neg_color : str, default="dodgerblue"
+        重みが負となる場合の色
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        更新済みの `matplotlib.axes.Axes`
+
+    """
+    _init()
+    weights = np.asarray(weights)
+    coefs = weights[:, rank]
+    n_features = coefs.shape[0]
+
+    if feature_names is None:
+        feature_names = [f"feature {l + 1}" for l in range(n_features)]
+
+    colors = [pos_color if v >= 0 else neg_color for v in coefs]
+
+    # 回帰係数がゼロとなる特徴量を落とす
+    filter_indice = np.where(coefs != 0)[0]
+    coefs_filtered = coefs[filter_indice]
+    feature_names_filtered = np.array(feature_names)[filter_indice]
+
+    # ソート
+    sort_indice = np.argsort(np.abs(coefs_filtered))
+    coefs_sorted = coefs_filtered[sort_indice]
+    feature_names_sorted = feature_names_filtered[sort_indice]
+
+    ax.barh(
+        feature_names_sorted,
+        coefs_sorted,
+        color=colors,
+        height=1.0,
+        edgecolor="black",
+    )
+    ax.axvline(x=0, color="black", linewidth=2)
+    ax.set_xlabel("Standardized coefficient", fontsize=16)
+    ax.set_ylabel("Features", fontsize=16)
+    return ax
+
+
+def ave_importances_bar_plot(
+    ax,
+    importances,
+    feature_names=None,
+    bar_color="limegreen",
+    errorbar=False,
+):
+    """特徴量重要度 (平均絶対標準化回帰係数) を表示する
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        `matplotlib.axes.Axes`
+    importances : array-like of shape (n_features, 2)
+        特徴量重要度 (平均絶対標準化回帰係数) とその標準偏差
+    feature_names : array-like of shape (n_features,), optional
+        各特徴量の名称
+    bar_color : str, default="limegreen"
+        バーの色
+    errorbar : bool, default=False
+        エラーバーを表示するかどうか
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        更新済みの `matplotlib.axes.Axes`
+
+    """
+    _init()
+    importances = np.asarray(importances)
+    if feature_names is None:
+        feature_names = [f"feature {l + 1}" for l in range(importances.shape[0])]
+
+    # ソート
+    sort_indice = np.argsort(importances[:, 0])
+    importances_sorted = importances[sort_indice]
+    feature_names_sorted = np.array(feature_names)[sort_indice]
+
+    ax.barh(
+        feature_names_sorted,
+        importances_sorted[:, 0],
+        xerr=importances_sorted[:, 1] if errorbar else 0,
+        capsize=2,
+        height=1.0,
+        edgecolor="black",
+        color=bar_color,
+    )
+    ax.set_xlabel("Feature importance", fontsize=16)
+    ax.set_ylabel("Features", fontsize=16)
+    return ax

spmkit_learn-1.0.0/spmkit_learn.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: spmkit-learn
+Version: 1.0.0
+Summary: Meta-Sparse Modeling Library for Chemical Data Prediction.
+Author-email: Shota Inoue <inoue.shota@st.kitasato-u.ac.jp>
+License: Proprietary
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<=1.26.4,>=1.25.2
+Requires-Dist: scikit-learn==1.6.0
+Requires-Dist: matplotlib>=3.7.0
+Dynamic: license-file
+
+# spmkit
+
+**spmkit** is meta-sparse modeling library for chemical data prediction.
+
+-----
+
+## Installation
+
+```bash
+# via wheel binary
+pip install spmkit-***.whl
+
+# via gzip source
+pip install spmkit-***.tar.gz
+```

spmkit_learn-1.0.0/spmkit_learn.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+spmkit/__init__.py
+spmkit/plots.py
+spmkit/assets/Arial.ttf
+spmkit/models/__init__.py
+spmkit/models/exhaustive_search.py
+spmkit/models/stability_selection.py
+spmkit_learn.egg-info/PKG-INFO
+spmkit_learn.egg-info/SOURCES.txt
+spmkit_learn.egg-info/dependency_links.txt
+spmkit_learn.egg-info/requires.txt
+spmkit_learn.egg-info/top_level.txt
+test/test.py

spmkit_learn-1.0.0/spmkit_learn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

spmkit_learn-1.0.0/spmkit_learn.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy<=1.26.4,>=1.25.2
+scikit-learn==1.6.0
+matplotlib>=3.7.0

spmkit_learn-1.0.0/spmkit_learn.egg-info/top_level.txt

@@ -0,0 +1 @@
+spmkit

spmkit_learn-1.0.0/test/test.py

@@ -0,0 +1,29 @@
+import pandas as pd
+
+# Wine Quality データセットをダウンロードする
+from sklearn.datasets import fetch_openml
+from spmkit.models import StabilitySelection
+
+# データフェッチ
+dataset = fetch_openml(data_id=43257, as_frame=True)
+
+# 不要な列を削除し、X, y に分割
+X = dataset.data.drop(["quality", "id"], axis=1)
+y = dataset.data["quality"]
+
+# StabilitySelection モデルを定義
+model = StabilitySelection(
+    subsample_iter=1000,
+    n_alphas=100,
+    min_alpha=1e-6,
+    max_alpha=1.0,
+    random_state=42,
+)
+
+# 特徴量選択を実行
+model.fit(X, y)
+
+# alpha ごとの選択確率を算出
+selection_path = pd.DataFrame(model.selection_path_, index=X.columns)
+
+print(selection_path)