@nahisaho/satori 0.22.0 → 0.24.0

package/src/.github/skills/scientific-automl/SKILL.md

@@ -0,0 +1,264 @@
+---
+name: scientific-automl
+description: |
+  AutoML パイプラインスキル。Optuna ハイパーパラメータ最適化・
+  FLAML 高速 AutoML・Auto-sklearn モデル選択・
+  NAS (Neural Architecture Search)・
+  特徴量エンジニアリング自動化・モデル比較パイプライン。
+---
+
+# Scientific AutoML
+
+ハイパーパラメータ最適化・モデル選択・特徴量エンジニアリングを
+自動化する AutoML パイプラインを提供する。
+
+## When to Use
+
+- Optuna/Hyperopt でハイパーパラメータを最適化するとき
+- 複数モデルの自動比較・選択を行うとき
+- FLAML/Auto-sklearn で高速な AutoML を実行するとき
+- 特徴量エンジニアリングを自動化するとき
+- Neural Architecture Search (NAS) を設計するとき
+- モデル選択根拠のレポートを生成するとき
+
+---
+
+## Quick Start
+
+## 1. Optuna ハイパーパラメータ最適化
+
+```python
+import optuna
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import cross_val_score
+from sklearn.ensemble import (
+    RandomForestClassifier, GradientBoostingClassifier)
+from sklearn.svm import SVC
+from sklearn.metrics import make_scorer, f1_score
+
+
+def optuna_optimize(X, y, model_type="rf", n_trials=100,
+                    cv=5, scoring="f1_macro", direction="maximize"):
+    """
+    Optuna ベース ハイパーパラメータ最適化。
+
+    Parameters:
+        X: np.ndarray — 特徴量
+        y: np.ndarray — ラベル
+        model_type: str — "rf" / "gbm" / "svm"
+        n_trials: int — 試行回数
+        cv: int — CV 分割数
+        scoring: str — 評価指標
+        direction: str — "maximize" / "minimize"
+    """
+    def objective(trial):
+        if model_type == "rf":
+            params = {
+                "n_estimators": trial.suggest_int("n_estimators", 50, 500),
+                "max_depth": trial.suggest_int("max_depth", 3, 20),
+                "min_samples_split": trial.suggest_int("min_samples_split", 2, 20),
+                "min_samples_leaf": trial.suggest_int("min_samples_leaf", 1, 10),
+                "max_features": trial.suggest_categorical(
+                    "max_features", ["sqrt", "log2", None]),
+            }
+            model = RandomForestClassifier(**params, random_state=42)
+
+        elif model_type == "gbm":
+            params = {
+                "n_estimators": trial.suggest_int("n_estimators", 50, 500),
+                "max_depth": trial.suggest_int("max_depth", 3, 10),
+                "learning_rate": trial.suggest_float("learning_rate", 0.01, 0.3, log=True),
+                "subsample": trial.suggest_float("subsample", 0.5, 1.0),
+                "min_samples_split": trial.suggest_int("min_samples_split", 2, 20),
+            }
+            model = GradientBoostingClassifier(**params, random_state=42)
+
+        elif model_type == "svm":
+            params = {
+                "C": trial.suggest_float("C", 0.01, 100, log=True),
+                "kernel": trial.suggest_categorical(
+                    "kernel", ["rbf", "poly", "sigmoid"]),
+                "gamma": trial.suggest_categorical("gamma", ["scale", "auto"]),
+            }
+            model = SVC(**params, probability=True, random_state=42)
+
+        scores = cross_val_score(model, X, y, cv=cv, scoring=scoring)
+        return scores.mean()
+
+    optuna.logging.set_verbosity(optuna.logging.WARNING)
+    study = optuna.create_study(direction=direction)
+    study.optimize(objective, n_trials=n_trials, show_progress_bar=True)
+
+    print(f"Optuna ({model_type}): best {scoring} = {study.best_value:.4f}")
+    print(f"  Best params: {study.best_params}")
+    return study
+```
+
+## 2. マルチモデル AutoML パイプライン
+
+```python
+from sklearn.linear_model import LogisticRegression
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.neural_network import MLPClassifier
+
+
+def automl_model_selection(X, y, cv=5, scoring="f1_macro",
+                           n_trials_per_model=50):
+    """
+    AutoML マルチモデル選択パイプライン。
+
+    Parameters:
+        X: np.ndarray — 特徴量
+        y: np.ndarray — ラベル
+        cv: int — CV 分割数
+        scoring: str — 評価指標
+        n_trials_per_model: int — モデルあたり試行数
+    """
+    model_types = ["rf", "gbm", "svm"]
+    results = []
+
+    for mt in model_types:
+        study = optuna_optimize(
+            X, y, model_type=mt,
+            n_trials=n_trials_per_model, cv=cv, scoring=scoring)
+        results.append({
+            "model_type": mt,
+            "best_score": round(study.best_value, 4),
+            "best_params": study.best_params,
+            "n_trials": len(study.trials),
+        })
+
+    # 簡易モデル (ベースライン)
+    baselines = [
+        ("logistic", LogisticRegression(max_iter=1000, random_state=42)),
+        ("knn", KNeighborsClassifier()),
+        ("dt", DecisionTreeClassifier(random_state=42)),
+    ]
+    for name, model in baselines:
+        scores = cross_val_score(model, X, y, cv=cv, scoring=scoring)
+        results.append({
+            "model_type": name,
+            "best_score": round(scores.mean(), 4),
+            "best_params": {},
+            "n_trials": 1,
+        })
+
+    df = pd.DataFrame(results).sort_values("best_score", ascending=False)
+    best = df.iloc[0]
+    print(f"AutoML: best = {best['model_type']} "
+          f"({scoring} = {best['best_score']})")
+    return df
+```
+
+## 3. 自動特徴量エンジニアリング
+
+```python
+from sklearn.preprocessing import PolynomialFeatures, StandardScaler
+from sklearn.feature_selection import SelectKBest, mutual_info_classif
+
+
+def auto_feature_engineering(X, y, max_poly_degree=2,
+                             top_k=None, interactions_only=False):
+    """
+    自動特徴量エンジニアリング。
+
+    Parameters:
+        X: np.ndarray — 元特徴量
+        y: np.ndarray — ラベル
+        max_poly_degree: int — 多項式次数
+        top_k: int | None — 選択する特徴量数
+        interactions_only: bool — 交互作用のみ
+    """
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+
+    # 多項式特徴量
+    poly = PolynomialFeatures(
+        degree=max_poly_degree,
+        interaction_only=interactions_only,
+        include_bias=False)
+    X_poly = poly.fit_transform(X_scaled)
+
+    # 特徴量選択
+    if top_k is None:
+        top_k = min(X_poly.shape[1], X.shape[1] * 3)
+
+    selector = SelectKBest(mutual_info_classif, k=min(top_k, X_poly.shape[1]))
+    X_selected = selector.fit_transform(X_poly, y)
+
+    print(f"Feature engineering: {X.shape[1]} → {X_poly.shape[1]} "
+          f"→ {X_selected.shape[1]} features")
+    return X_selected, poly, selector
+```
+
+## 4. Optuna 可視化レポート
+
+```python
+def automl_report(study, output_dir="results"):
+    """
+    Optuna Study 可視化レポート。
+
+    Parameters:
+        study: optuna.Study — 最適化結果
+        output_dir: str — 出力ディレクトリ
+    """
+    from pathlib import Path
+    import matplotlib.pyplot as plt
+
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    # パラメータ重要度
+    try:
+        importances = optuna.importance.get_param_importances(study)
+        fig, ax = plt.subplots(figsize=(8, 5))
+        params = list(importances.keys())
+        values = list(importances.values())
+        ax.barh(params, values)
+        ax.set_xlabel("Importance")
+        ax.set_title("Hyperparameter Importance")
+        fig.tight_layout()
+        fig.savefig(out / "param_importance.png", dpi=150)
+        plt.close(fig)
+    except Exception:
+        pass
+
+    # 最適化履歴
+    trials_df = study.trials_dataframe()
+    trials_df.to_csv(out / "optuna_trials.csv", index=False)
+
+    # ベストパラメータ
+    best = {
+        "best_value": study.best_value,
+        "best_params": study.best_params,
+        "n_trials": len(study.trials),
+    }
+
+    print(f"AutoML report → {out}")
+    return best
+```
+
+---
+
+## パイプライン統合
+
+```
+eda-correlation → automl → ensemble-methods
+  (データ探索)     (モデル選択)  (アンサンブル)
+       │               │              ↓
+  feature-importance ──┘     uncertainty-quantification
+    (特徴量解釈)              (不確実性定量化)
+       │
+  active-learning
+    (能動学習)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `optuna_trials.csv` | 試行履歴 | → 可視化 |
+| `param_importance.png` | パラメータ重要度 | → レポート |
+| `model_comparison.csv` | モデル比較 | → ensemble-methods |

package/src/.github/skills/scientific-causal-ml/SKILL.md

@@ -0,0 +1,240 @@
+---
+name: scientific-causal-ml
+description: |
+  因果機械学習スキル。DoWhy 因果モデル・EconML CATE 推定・
+  Double/Debiased ML・Causal Forest・メタラーナー (S/T/X)・
+  異質的処置効果 (HTE)・因果特徴量選択。
+---
+
+# Scientific Causal ML
+
+機械学習ベースの因果推論パイプラインを提供し、
+異質的処置効果 (HTE) の推定と因果特徴量発見を実現する。
+
+## When to Use
+
+- 処置効果が個人/サブグループで異なるとき (HTE 推定)
+- Causal Forest で非パラメトリック因果効果を推定するとき
+- Double ML で高次元データの処置効果を推定するとき
+- メタラーナー (S/T/X-learner) で CATE を推定するとき
+- DoWhy で因果モデルの同定・推定・反論をするとき
+- 因果特徴量選択で重要な効果修飾因子を発見するとき
+
+> **Note**: 統計的因果推論 (PSM/IPW/DID/RDD) は `scientific-causal-inference` を参照。
+
+---
+
+## Quick Start
+
+## 1. DoWhy 因果モデル
+
+```python
+import numpy as np
+import pandas as pd
+
+
+def dowhy_causal_model(df, treatment, outcome, common_causes,
+                       effect_modifiers=None, method="backdoor.linear_regression"):
+    """
+    DoWhy 因果推論パイプライン (同定→推定→反論)。
+
+    Parameters:
+        df: pd.DataFrame — 観測データ
+        treatment: str — 処置変数
+        outcome: str — 結果変数
+        common_causes: list[str] — 共変量
+        effect_modifiers: list[str] | None — 効果修飾因子
+        method: str — 推定手法
+    """
+    import dowhy
+
+    model = dowhy.CausalModel(
+        data=df,
+        treatment=treatment,
+        outcome=outcome,
+        common_causes=common_causes,
+        effect_modifiers=effect_modifiers)
+
+    # 同定
+    estimand = model.identify_effect(proceed_when_unidentifiable=True)
+    print(f"Identified estimand: {estimand.get_frontdoor_variables()}")
+
+    # 推定
+    estimate = model.estimate_effect(
+        estimand, method_name=method)
+    print(f"ATE = {estimate.value:.4f} (95% CI: [{estimate.get_confidence_intervals()[0]:.4f}, "
+          f"{estimate.get_confidence_intervals()[1]:.4f}])")
+
+    # 反論テスト
+    refutations = {}
+    for refuter_name in ["random_common_cause", "placebo_treatment_refuter",
+                         "data_subset_refuter"]:
+        try:
+            refutation = model.refute_estimate(
+                estimand, estimate, method_name=refuter_name)
+            refutations[refuter_name] = {
+                "new_effect": float(refutation.new_effect),
+                "p_value": getattr(refutation, "refutation_result", {}).get("p_value", None)
+            }
+        except Exception:
+            pass
+
+    print(f"Refutation tests: {len(refutations)} passed")
+    return {"model": model, "estimand": estimand,
+            "estimate": estimate, "refutations": refutations}
+```
+
+## 2. EconML Double ML / Causal Forest
+
+```python
+def double_ml_estimate(df, treatment, outcome, features,
+                       n_splits=5, model_type="linear"):
+    """
+    Double/Debiased ML による処置効果推定。
+
+    Parameters:
+        df: pd.DataFrame — データ
+        treatment: str — 処置変数
+        outcome: str — 結果変数
+        features: list[str] — 共変量
+        n_splits: int — クロスフィッティング分割数
+        model_type: str — "linear" / "forest"
+    """
+    from econml.dml import LinearDML, CausalForestDML
+
+    Y = df[outcome].values
+    T = df[treatment].values
+    X = df[features].values
+
+    if model_type == "linear":
+        est = LinearDML(cv=n_splits, random_state=42)
+    else:
+        est = CausalForestDML(
+            n_estimators=200, cv=n_splits, random_state=42)
+
+    est.fit(Y, T, X=X)
+
+    ate = est.ate(X)
+    ate_ci = est.ate_interval(X, alpha=0.05)
+
+    # CATE (個人レベル)
+    cate = est.effect(X)
+    cate_ci = est.effect_interval(X, alpha=0.05)
+
+    result_df = pd.DataFrame(X, columns=features)
+    result_df["cate"] = cate
+    result_df["cate_lower"] = cate_ci[0]
+    result_df["cate_upper"] = cate_ci[1]
+
+    print(f"Double ML ({model_type}): ATE={ate:.4f} "
+          f"[{ate_ci[0]:.4f}, {ate_ci[1]:.4f}]")
+    print(f"  CATE range: [{cate.min():.4f}, {cate.max():.4f}]")
+    return {"ate": ate, "ate_ci": ate_ci,
+            "cate_df": result_df, "model": est}
+
+
+def causal_forest(df, treatment, outcome, features,
+                  n_estimators=500):
+    """
+    Causal Forest — 非パラメトリック HTE 推定。
+
+    Parameters:
+        df: pd.DataFrame — データ
+        treatment: str — 処置変数 (binary)
+        outcome: str — 結果変数
+        features: list[str] — 共変量
+        n_estimators: int — 木の数
+    """
+    from econml.dml import CausalForestDML
+
+    Y = df[outcome].values
+    T = df[treatment].values
+    X = df[features].values
+
+    cf = CausalForestDML(
+        n_estimators=n_estimators, random_state=42,
+        min_samples_leaf=10)
+    cf.fit(Y, T, X=X)
+
+    cate = cf.effect(X)
+    cate_ci = cf.effect_interval(X, alpha=0.05)
+
+    # 特徴量重要度 (因果)
+    importances = cf.feature_importances_
+    feat_imp = pd.DataFrame({
+        "feature": features,
+        "causal_importance": importances
+    }).sort_values("causal_importance", ascending=False)
+
+    print(f"Causal Forest: {n_estimators} trees, "
+          f"CATE median={np.median(cate):.4f}")
+    print(f"  Top causal features: {feat_imp.head(5).to_dict('records')}")
+    return {"cate": cate, "cate_ci": cate_ci,
+            "feature_importance": feat_imp, "model": cf}
+```
+
+## 3. メタラーナー (S/T/X-Learner)
+
+```python
+def meta_learner(df, treatment, outcome, features,
+                 learner_type="t", base_model=None):
+    """
+    メタラーナーによる CATE 推定。
+
+    Parameters:
+        df: pd.DataFrame — データ
+        treatment: str — 処置変数 (binary 0/1)
+        outcome: str — 結果変数
+        features: list[str] — 共変量
+        learner_type: str — "s" / "t" / "x"
+        base_model: BaseEstimator | None — ベースモデル
+    """
+    from econml.metalearners import SLearner, TLearner, XLearner
+    from sklearn.ensemble import GradientBoostingRegressor
+
+    if base_model is None:
+        base_model = GradientBoostingRegressor(
+            n_estimators=200, max_depth=5, random_state=42)
+
+    Y = df[outcome].values
+    T = df[treatment].values
+    X = df[features].values
+
+    learners = {"s": SLearner, "t": TLearner, "x": XLearner}
+    LearnerClass = learners[learner_type]
+
+    if learner_type == "s":
+        est = LearnerClass(overall_model=base_model)
+    else:
+        est = LearnerClass(models=base_model)
+
+    est.fit(Y, T, X=X)
+    cate = est.effect(X)
+
+    result_df = pd.DataFrame(X, columns=features)
+    result_df["cate"] = cate
+
+    print(f"{learner_type.upper()}-Learner: "
+          f"CATE mean={cate.mean():.4f}, std={cate.std():.4f}")
+    return {"cate": cate, "cate_df": result_df, "model": est}
+```
+
+---
+
+## パイプライン統合
+
+```
+causal-inference → causal-ml → feature-importance
+   (統計的因果)    (因果 ML)     (特徴量解釈)
+        │               │              ↓
+  clinical-trial ───────┘      explainable-ai
+   (臨床試験)                   (説明可能 AI)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `dowhy_causal_model.json` | DoWhy 因果モデル | → reporting |
+| `cate_estimates.csv` | CATE 推定値 | → precision-medicine |
+| `causal_feature_importance.csv` | 因果特徴量重要度 | → explainable-ai |