@nahisaho/satori 0.22.0 → 0.24.0

package/src/.github/skills/scientific-missing-data-analysis/SKILL.md

@@ -0,0 +1,312 @@
+---
+name: scientific-missing-data-analysis
+description: |
+  欠損データ解析スキル。欠損パターン診断 (MCAR/MAR/MNAR) ・
+  Little's MCAR テスト・多重代入法 (MICE) ・KNN 補完・
+  MissForest・VAE/GAIN 補完・欠損パターン可視化・Rubin's Rules。
+---
+
+# Scientific Missing Data Analysis
+
+欠損データの診断・補完・感度分析パイプラインを提供し、
+バイアスのない統計推論を実現する。
+
+## When to Use
+
+- データセットの欠損パターンを診断するとき
+- MCAR / MAR / MNAR のメカニズムを判定するとき
+- 多重代入法 (MICE) で欠損値を補完するとき
+- KNN / MissForest / 深層学習ベースの補完をするとき
+- 複数の補完結果を Rubin's Rules で統合するとき
+- 欠損パターンを可視化するとき
+
+---
+
+## Quick Start
+
+## 1. 欠損パターン診断
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+def diagnose_missing_patterns(df, output_prefix="missing"):
+    """
+    欠損パターン診断 — MCAR/MAR/MNAR 判定支援。
+
+    Parameters:
+        df: pd.DataFrame — 入力データ
+        output_prefix: str — 出力ファイル接頭辞
+    """
+    n_rows, n_cols = df.shape
+    missing_counts = df.isnull().sum()
+    missing_pct = (missing_counts / n_rows * 100).round(2)
+
+    summary = pd.DataFrame({
+        "column": df.columns,
+        "n_missing": missing_counts.values,
+        "pct_missing": missing_pct.values,
+        "dtype": df.dtypes.values
+    }).sort_values("pct_missing", ascending=False)
+
+    # 欠損パターン行列 (msno 風)
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+
+    # (1) 欠損マトリックス
+    ax = axes[0, 0]
+    missing_matrix = df.isnull().astype(int)
+    ax.imshow(missing_matrix.values[:200], aspect="auto", cmap="Greys",
+              interpolation="none")
+    ax.set_xlabel("Features")
+    ax.set_ylabel("Samples")
+    ax.set_title("Missing Pattern Matrix (first 200 rows)")
+
+    # (2) 欠損率バー
+    ax = axes[0, 1]
+    cols_with_missing = summary[summary["pct_missing"] > 0]
+    ax.barh(cols_with_missing["column"], cols_with_missing["pct_missing"])
+    ax.set_xlabel("Missing %")
+    ax.set_title("Missing Rate per Column")
+
+    # (3) 欠損相関ヒートマップ
+    ax = axes[1, 0]
+    miss_corr = df.isnull().corr()
+    sns.heatmap(miss_corr, ax=ax, cmap="RdBu_r", center=0,
+                square=True, cbar_kws={"shrink": 0.8})
+    ax.set_title("Missing Correlation")
+
+    # (4) 欠損パターン上位
+    ax = axes[1, 1]
+    patterns = df.isnull().apply(lambda x: tuple(x), axis=1)
+    pattern_counts = patterns.value_counts().head(10)
+    ax.barh(range(len(pattern_counts)),
+            pattern_counts.values)
+    ax.set_yticks(range(len(pattern_counts)))
+    ax.set_yticklabels([str(p)[:40] for p in pattern_counts.index],
+                       fontsize=7)
+    ax.set_xlabel("Count")
+    ax.set_title("Top 10 Missing Patterns")
+
+    plt.tight_layout()
+    path = f"{output_prefix}_diagnosis.png"
+    plt.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close()
+
+    print(f"Missing Diagnosis: {n_cols} cols, "
+          f"{missing_counts.sum()} total missing ({(missing_counts.sum()/(n_rows*n_cols)*100):.1f}%)")
+    return {"summary": summary, "fig": path}
+```
+
+## 2. Little's MCAR テスト
+
+```python
+def littles_mcar_test(df):
+    """
+    Little's MCAR テスト — 完全ランダム欠損の検定。
+
+    Parameters:
+        df: pd.DataFrame — 数値データのみ
+    Returns:
+        dict — chi2 統計量, p値, 判定
+    """
+    from scipy import stats
+
+    numeric_df = df.select_dtypes(include=[np.number])
+    n_rows, n_cols = numeric_df.shape
+
+    # 欠損パターンごとにグルーピング
+    patterns = numeric_df.isnull().apply(tuple, axis=1)
+    unique_patterns = patterns.unique()
+
+    # 全体平均と全体共分散
+    global_mean = numeric_df.mean()
+    global_cov = numeric_df.cov()
+
+    chi2_stat = 0.0
+    df_stat = 0
+
+    for pattern in unique_patterns:
+        mask = patterns == pattern
+        sub_df = numeric_df[mask]
+        n_j = len(sub_df)
+        if n_j < 2:
+            continue
+
+        # このパターンで観測されているカラム
+        obs_cols = [i for i, m in enumerate(pattern) if not m]
+        if len(obs_cols) == 0:
+            continue
+
+        obs_mean = sub_df.iloc[:, obs_cols].mean().values
+        exp_mean = global_mean.iloc[obs_cols].values
+        diff = obs_mean - exp_mean
+
+        obs_cov = global_cov.iloc[obs_cols, obs_cols].values
+        try:
+            cov_inv = np.linalg.pinv(obs_cov / n_j)
+        except np.linalg.LinAlgError:
+            continue
+
+        chi2_stat += diff @ cov_inv @ diff
+        df_stat += len(obs_cols)
+
+    df_stat -= n_cols  # 自由度補正
+
+    if df_stat <= 0:
+        return {"chi2": np.nan, "p_value": np.nan,
+                "conclusion": "判定不能 (自由度不足)"}
+
+    p_value = 1 - stats.chi2.cdf(chi2_stat, df_stat)
+    conclusion = "MCAR (p > 0.05)" if p_value > 0.05 else "Not MCAR (p ≤ 0.05)"
+
+    print(f"Little's MCAR test: χ²={chi2_stat:.2f}, df={df_stat}, "
+          f"p={p_value:.4f} → {conclusion}")
+    return {"chi2": chi2_stat, "df": df_stat,
+            "p_value": p_value, "conclusion": conclusion}
+```
+
+## 3. 多重代入法 (MICE)
+
+```python
+def mice_imputation(df, n_imputations=5, max_iter=10, random_state=42):
+    """
+    MICE (Multiple Imputation by Chained Equations)。
+
+    Parameters:
+        df: pd.DataFrame — 欠損を含むデータ
+        n_imputations: int — 代入データセット数
+        max_iter: int — 反復回数
+        random_state: int — 乱数シード
+    """
+    from sklearn.experimental import enable_iterative_imputer  # noqa
+    from sklearn.impute import IterativeImputer
+
+    numeric_cols = df.select_dtypes(include=[np.number]).columns
+    cat_cols = df.select_dtypes(exclude=[np.number]).columns
+
+    imputed_datasets = []
+
+    for i in range(n_imputations):
+        imputer = IterativeImputer(
+            max_iter=max_iter,
+            random_state=random_state + i,
+            sample_posterior=True)
+
+        imputed_numeric = pd.DataFrame(
+            imputer.fit_transform(df[numeric_cols]),
+            columns=numeric_cols, index=df.index)
+
+        imputed_df = imputed_numeric.copy()
+        for col in cat_cols:
+            imputed_df[col] = df[col].fillna(df[col].mode().iloc[0]
+                                              if not df[col].mode().empty else "UNKNOWN")
+
+        imputed_datasets.append(imputed_df)
+
+    print(f"MICE: {n_imputations} datasets × {max_iter} iterations, "
+          f"{len(numeric_cols)} numeric cols")
+    return imputed_datasets
+
+
+def rubins_rules(estimates, variances):
+    """
+    Rubin's Rules — 多重代入結果の統合。
+
+    Parameters:
+        estimates: list[float] — 各代入データセットからの推定値
+        variances: list[float] — 各代入データセットからの分散
+    """
+    m = len(estimates)
+    Q_bar = np.mean(estimates)
+    U_bar = np.mean(variances)  # Within-imputation variance
+    B = np.var(estimates, ddof=1)  # Between-imputation variance
+    T = U_bar + (1 + 1 / m) * B  # Total variance
+
+    # 自由度 (Barnard-Rubin)
+    r = (1 + 1 / m) * B / U_bar if U_bar > 0 else np.inf
+    df_old = (m - 1) * (1 + 1 / r) ** 2 if r > 0 else np.inf
+
+    print(f"Rubin's Rules: Q̄={Q_bar:.4f}, T={T:.4f}, "
+          f"within={U_bar:.4f}, between={B:.4f}")
+    return {"pooled_estimate": Q_bar, "total_variance": T,
+            "within_variance": U_bar, "between_variance": B,
+            "df": df_old}
+```
+
+## 4. KNN / MissForest 補完
+
+```python
+def knn_imputation(df, n_neighbors=5):
+    """
+    KNN 欠損値補完。
+
+    Parameters:
+        df: pd.DataFrame — 欠損を含むデータ
+        n_neighbors: int — 近傍数
+    """
+    from sklearn.impute import KNNImputer
+
+    numeric_cols = df.select_dtypes(include=[np.number]).columns
+    imputer = KNNImputer(n_neighbors=n_neighbors)
+    imputed = pd.DataFrame(
+        imputer.fit_transform(df[numeric_cols]),
+        columns=numeric_cols, index=df.index)
+
+    n_imputed = df[numeric_cols].isnull().sum().sum()
+    print(f"KNN Imputation (k={n_neighbors}): {n_imputed} values imputed")
+    return imputed
+
+
+def missforest_imputation(df, n_estimators=100, max_iter=10):
+    """
+    MissForest (Random Forest ベースの反復補完)。
+
+    Parameters:
+        df: pd.DataFrame — 欠損を含むデータ
+        n_estimators: int — Random Forest の木の数
+        max_iter: int — 反復回数
+    """
+    from sklearn.experimental import enable_iterative_imputer  # noqa
+    from sklearn.impute import IterativeImputer
+    from sklearn.ensemble import RandomForestRegressor
+
+    numeric_cols = df.select_dtypes(include=[np.number]).columns
+
+    imputer = IterativeImputer(
+        estimator=RandomForestRegressor(n_estimators=n_estimators,
+                                        random_state=42, n_jobs=-1),
+        max_iter=max_iter, random_state=42)
+
+    imputed = pd.DataFrame(
+        imputer.fit_transform(df[numeric_cols]),
+        columns=numeric_cols, index=df.index)
+
+    n_imputed = df[numeric_cols].isnull().sum().sum()
+    print(f"MissForest (n_trees={n_estimators}, iter={max_iter}): "
+          f"{n_imputed} values imputed")
+    return imputed
+```
+
+---
+
+## パイプライン統合
+
+```
+eda-correlation → missing-data-analysis → ml-classification
+  (探索的解析)      (欠損診断・補完)       (モデリング)
+       │                  │                     ↓
+ statistical-testing ────┘          advanced-visualization
+   (統計検定)                         (結果可視化)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `missing_diagnosis.png` | 欠損パターン可視化 | → reporting |
+| `mcar_test_result.json` | Little's MCAR テスト | → 補完戦略選択 |
+| `imputed_datasets/` | MICE 多重代入データ | → ml-classification |
+| `imputation_comparison.csv` | 補完手法比較 | → 最終選択 |

package/src/.github/skills/scientific-model-monitoring/SKILL.md

@@ -0,0 +1,247 @@
+---
+name: scientific-model-monitoring
+description: |
+  MLOps モデル監視スキル。データドリフト検出 (Evidently/NannyML)・
+  モデル性能劣化検出・特徴量ドリフト・コンセプトドリフト・
+  A/B テスト統計・モデルレジストリ・再学習トリガー。
+---
+
+# Scientific Model Monitoring
+
+本番環境の ML モデル監視パイプラインを提供し、
+データドリフト・性能劣化を検出して再学習トリガーを実現する。
+
+## When to Use
+
+- デプロイ済みモデルの予測品質を継続監視するとき
+- データドリフト (共変量シフト) を検出するとき
+- コンセプトドリフト (P(Y|X) の変化) を検出するとき
+- A/B テストで新旧モデルを比較するとき
+- 特徴量分布の変化を追跡するとき
+- 再学習トリガーの自動化ルールを設定するとき
+
+---
+
+## Quick Start
+
+## 1. データドリフト検出
+
+```python
+import numpy as np
+import pandas as pd
+from scipy import stats
+
+
+def detect_data_drift(reference_df, current_df,
+                      method="ks", threshold=0.05):
+    """
+    データドリフト検出 — 参照データ vs 現在データ。
+
+    Parameters:
+        reference_df: pd.DataFrame — 学習時データ (参照)
+        current_df: pd.DataFrame — 推論時データ (現在)
+        method: str — "ks" (KS 検定) / "psi" (PSI) / "wasserstein"
+        threshold: float — 有意水準 or PSI 閾値
+    """
+    numeric_cols = reference_df.select_dtypes(include=[np.number]).columns
+    common_cols = [c for c in numeric_cols if c in current_df.columns]
+
+    drift_results = []
+
+    for col in common_cols:
+        ref_vals = reference_df[col].dropna().values
+        cur_vals = current_df[col].dropna().values
+
+        if method == "ks":
+            stat, p_value = stats.ks_2samp(ref_vals, cur_vals)
+            is_drift = p_value < threshold
+            drift_results.append({
+                "feature": col, "statistic": stat,
+                "p_value": p_value, "is_drift": is_drift})
+
+        elif method == "psi":
+            # Population Stability Index
+            psi_val = _compute_psi(ref_vals, cur_vals)
+            is_drift = psi_val > 0.2  # >0.2 = significant shift
+            drift_results.append({
+                "feature": col, "psi": psi_val,
+                "is_drift": is_drift,
+                "severity": "high" if psi_val > 0.25 else
+                            "medium" if psi_val > 0.1 else "low"})
+
+        elif method == "wasserstein":
+            w_dist = stats.wasserstein_distance(ref_vals, cur_vals)
+            ref_std = np.std(ref_vals)
+            normalized = w_dist / ref_std if ref_std > 0 else w_dist
+            is_drift = normalized > 0.1
+            drift_results.append({
+                "feature": col, "wasserstein": w_dist,
+                "normalized": normalized, "is_drift": is_drift})
+
+    result_df = pd.DataFrame(drift_results)
+    n_drift = result_df["is_drift"].sum()
+    print(f"Data Drift ({method}): {n_drift}/{len(common_cols)} features drifted")
+    return result_df
+
+
+def _compute_psi(expected, actual, n_bins=10):
+    """PSI (Population Stability Index) 計算。"""
+    breakpoints = np.quantile(expected, np.linspace(0, 1, n_bins + 1))
+    breakpoints[0] = -np.inf
+    breakpoints[-1] = np.inf
+
+    expected_pct = np.histogram(expected, bins=breakpoints)[0] / len(expected)
+    actual_pct = np.histogram(actual, bins=breakpoints)[0] / len(actual)
+
+    expected_pct = np.clip(expected_pct, 1e-4, None)
+    actual_pct = np.clip(actual_pct, 1e-4, None)
+
+    psi = np.sum((actual_pct - expected_pct) * np.log(actual_pct / expected_pct))
+    return psi
+```
+
+## 2. モデル性能劣化検出
+
+```python
+def detect_performance_degradation(y_true_batches, y_pred_batches,
+                                    metric="accuracy",
+                                    window_size=10, alert_threshold=0.05):
+    """
+    モデル性能劣化のスライディングウィンドウ検出。
+
+    Parameters:
+        y_true_batches: list[np.ndarray] — バッチごとの真値
+        y_pred_batches: list[np.ndarray] — バッチごとの予測値
+        metric: str — "accuracy" / "f1" / "rmse" / "auc"
+        window_size: int — 移動平均ウィンドウ
+        alert_threshold: float — 性能低下アラート閾値
+    """
+    from sklearn.metrics import accuracy_score, f1_score, mean_squared_error
+    from sklearn.metrics import roc_auc_score
+    import matplotlib.pyplot as plt
+
+    metric_funcs = {
+        "accuracy": accuracy_score,
+        "f1": lambda y, p: f1_score(y, p, average="macro"),
+        "rmse": lambda y, p: -np.sqrt(mean_squared_error(y, p)),
+        "auc": lambda y, p: roc_auc_score(y, p)
+    }
+
+    func = metric_funcs[metric]
+    scores = [func(yt, yp) for yt, yp in zip(y_true_batches, y_pred_batches)]
+
+    # 移動平均
+    scores_arr = np.array(scores)
+    if len(scores_arr) >= window_size:
+        ma = np.convolve(scores_arr, np.ones(window_size)/window_size, mode="valid")
+    else:
+        ma = scores_arr
+
+    # ベースライン (最初の window_size バッチ)
+    baseline = np.mean(scores_arr[:window_size])
+    current = np.mean(scores_arr[-window_size:])
+    degradation = baseline - current
+
+    is_degraded = degradation > alert_threshold
+
+    # 可視化
+    fig, ax = plt.subplots(figsize=(12, 5))
+    ax.plot(scores, "b-o", markersize=3, alpha=0.5, label="Batch score")
+    if len(ma) > 0:
+        ax.plot(range(window_size - 1, window_size - 1 + len(ma)),
+                ma, "r-", linewidth=2, label=f"MA({window_size})")
+    ax.axhline(baseline, color="g", linestyle="--",
+               label=f"Baseline={baseline:.4f}")
+    ax.axhline(baseline - alert_threshold, color="orange", linestyle="--",
+               label=f"Alert={baseline - alert_threshold:.4f}")
+    ax.set_xlabel("Batch")
+    ax.set_ylabel(metric)
+    ax.set_title(f"Model Performance Monitoring ({metric})")
+    ax.legend()
+
+    path = "performance_monitoring.png"
+    plt.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close()
+
+    status = "DEGRADED ⚠️" if is_degraded else "OK ✓"
+    print(f"Performance ({metric}): baseline={baseline:.4f}, "
+          f"current={current:.4f}, Δ={degradation:.4f} → {status}")
+    return {"baseline": baseline, "current": current,
+            "degradation": degradation, "is_degraded": is_degraded,
+            "scores": scores, "fig": path}
+```
+
+## 3. A/B テスト統計
+
+```python
+def ab_test_models(y_true, preds_a, preds_b, metric="accuracy",
+                   n_bootstrap=10000, alpha=0.05):
+    """
+    A/B テスト — 2 モデルの統計的比較。
+
+    Parameters:
+        y_true: np.ndarray — 真値
+        preds_a: np.ndarray — モデル A 予測
+        preds_b: np.ndarray — モデル B 予測
+        metric: str — 評価指標
+        n_bootstrap: int — ブートストラップ回数
+        alpha: float — 有意水準
+    """
+    from sklearn.metrics import accuracy_score, f1_score, mean_squared_error
+
+    metric_funcs = {
+        "accuracy": accuracy_score,
+        "f1": lambda y, p: f1_score(y, p, average="macro"),
+        "rmse": lambda y, p: np.sqrt(mean_squared_error(y, p))
+    }
+
+    func = metric_funcs[metric]
+    score_a = func(y_true, preds_a)
+    score_b = func(y_true, preds_b)
+
+    # Bootstrap confidence interval for difference
+    diffs = []
+    n = len(y_true)
+    rng = np.random.RandomState(42)
+
+    for _ in range(n_bootstrap):
+        idx = rng.choice(n, n, replace=True)
+        sa = func(y_true[idx], preds_a[idx])
+        sb = func(y_true[idx], preds_b[idx])
+        diffs.append(sb - sa)
+
+    diffs = np.array(diffs)
+    ci_lower = np.percentile(diffs, 100 * alpha / 2)
+    ci_upper = np.percentile(diffs, 100 * (1 - alpha / 2))
+    p_value = np.mean(diffs <= 0)  # P(B ≤ A)
+
+    winner = "B" if ci_lower > 0 else ("A" if ci_upper < 0 else "Tie")
+
+    print(f"A/B Test ({metric}): A={score_a:.4f}, B={score_b:.4f}")
+    print(f"  Δ(B-A)={score_b - score_a:.4f}, "
+          f"95% CI=[{ci_lower:.4f}, {ci_upper:.4f}], "
+          f"p={p_value:.4f} → Winner: {winner}")
+    return {"score_a": score_a, "score_b": score_b,
+            "diff": score_b - score_a, "ci": (ci_lower, ci_upper),
+            "p_value": p_value, "winner": winner}
+```
+
+---
+
+## パイプライン統合
+
+```
+ensemble-methods → model-monitoring → anomaly-detection
+  (モデル構築)      (監視)             (異常検知)
+       │                │                  ↓
+  automl ──────────────┘          active-learning
+   (AutoML)                        (再学習)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `drift_report.csv` | ドリフト検出結果 | → 再学習判断 |
+| `performance_monitoring.png` | 性能推移 | → reporting |
+| `ab_test_result.json` | A/B テスト結果 | → デプロイ判断 |