@nahisaho/satori 0.24.0 → 0.25.0

package/src/.github/skills/scientific-statistical-simulation/SKILL.md

@@ -0,0 +1,227 @@
+---
+name: scientific-statistical-simulation
+description: |
+  統計シミュレーションスキル。Monte Carlo 法・Bootstrap 推論・
+  Permutation Test・統計的検出力分析・確率的リスク評価。
+---
+
+# Scientific Statistical Simulation
+
+コンピュータベースの統計シミュレーションにより、
+推論の不確実性定量化・検出力設計・リスク評価を行う。
+
+## When to Use
+
+- Monte Carlo シミュレーションで確率分布を推定するとき
+- Bootstrap で信頼区間を算出するとき
+- Permutation Test でノンパラメトリック検定を行うとき
+- 実験前に必要なサンプルサイズを検出力分析で決めるとき
+- リスクシナリオの確率的評価を行うとき
+
+---
+
+## Quick Start
+
+## 1. Monte Carlo シミュレーション
+
+```python
+import numpy as np
+import pandas as pd
+from typing import Callable, Dict, Any
+
+
+def monte_carlo_simulation(func, param_distributions,
+                           n_simulations=10000, seed=42,
+                           summary_quantiles=None):
+    """
+    Monte Carlo シミュレーション。
+
+    Parameters:
+        func: Callable — シミュレーション対象関数 (dict → float)
+        param_distributions: dict — {param_name: scipy.stats distribution}
+        n_simulations: int — シミュレーション回数
+        seed: int — 乱数シード
+        summary_quantiles: list[float] | None — サマリー分位点
+    """
+    rng = np.random.default_rng(seed)
+    if summary_quantiles is None:
+        summary_quantiles = [0.025, 0.25, 0.5, 0.75, 0.975]
+
+    results = []
+    param_samples = {}
+
+    # パラメータサンプリング
+    for name, dist in param_distributions.items():
+        param_samples[name] = dist.rvs(
+            size=n_simulations, random_state=rng)
+
+    # シミュレーション実行
+    for i in range(n_simulations):
+        params = {name: samples[i]
+                  for name, samples in param_samples.items()}
+        results.append(func(params))
+
+    results = np.array(results)
+
+    # サマリー統計
+    summary = {
+        "mean": np.mean(results),
+        "std": np.std(results),
+        "min": np.min(results),
+        "max": np.max(results),
+    }
+    for q in summary_quantiles:
+        summary[f"q{q:.3f}"] = np.quantile(results, q)
+
+    print(f"Monte Carlo ({n_simulations} runs):")
+    print(f"  Mean={summary['mean']:.4f} ± {summary['std']:.4f}")
+    print(f"  95% CI: [{summary.get('q0.025', 'N/A'):.4f}, "
+          f"{summary.get('q0.975', 'N/A'):.4f}]")
+
+    return {"results": results, "summary": summary,
+            "param_samples": param_samples}
+```
+
+## 2. Bootstrap 推論
+
+```python
+def bootstrap_inference(data, statistic_fn, n_bootstrap=10000,
+                        confidence_level=0.95, method="bca",
+                        seed=42):
+    """
+    Bootstrap 信頼区間推定。
+
+    Parameters:
+        data: np.ndarray — データ
+        statistic_fn: Callable — 統計量計算関数 (data → float)
+        n_bootstrap: int — Bootstrap 回数
+        confidence_level: float — 信頼水準
+        method: str — "percentile" / "bca" / "basic"
+        seed: int — 乱数シード
+    """
+    rng = np.random.default_rng(seed)
+    n = len(data)
+    observed = statistic_fn(data)
+
+    # Bootstrap 標本
+    boot_stats = np.array([
+        statistic_fn(data[rng.integers(0, n, size=n)])
+        for _ in range(n_bootstrap)])
+
+    alpha = 1 - confidence_level
+    if method == "percentile":
+        ci_low = np.quantile(boot_stats, alpha / 2)
+        ci_high = np.quantile(boot_stats, 1 - alpha / 2)
+    elif method == "bca":
+        from scipy import stats as sp_stats
+        # Bias correction
+        z0 = sp_stats.norm.ppf(np.mean(boot_stats < observed))
+        # Acceleration (jackknife)
+        jack_stats = np.array([
+            statistic_fn(np.delete(data, i)) for i in range(n)])
+        jack_mean = jack_stats.mean()
+        a = (np.sum((jack_mean - jack_stats) ** 3) /
+             (6 * np.sum((jack_mean - jack_stats) ** 2) ** 1.5 + 1e-10))
+        z_alpha = sp_stats.norm.ppf([alpha / 2, 1 - alpha / 2])
+        adjusted = sp_stats.norm.cdf(
+            z0 + (z0 + z_alpha) / (1 - a * (z0 + z_alpha)))
+        ci_low = np.quantile(boot_stats, adjusted[0])
+        ci_high = np.quantile(boot_stats, adjusted[1])
+    else:  # basic
+        ci_low = 2 * observed - np.quantile(boot_stats, 1 - alpha / 2)
+        ci_high = 2 * observed - np.quantile(boot_stats, alpha / 2)
+
+    result = {
+        "observed": observed,
+        "boot_mean": np.mean(boot_stats),
+        "boot_std": np.std(boot_stats),
+        "ci_low": ci_low, "ci_high": ci_high,
+        "method": method,
+        "confidence_level": confidence_level,
+    }
+    print(f"Bootstrap ({method}): {observed:.4f} "
+          f"[{ci_low:.4f}, {ci_high:.4f}] ({confidence_level:.0%} CI)")
+    return result, boot_stats
+```
+
+## 3. 統計的検出力分析
+
+```python
+def power_analysis(effect_size_range=None, n_range=None,
+                   alpha=0.05, test_type="two-sample-t",
+                   n_simulations=5000, seed=42):
+    """
+    シミュレーションベース統計的検出力分析。
+
+    Parameters:
+        effect_size_range: list[float] | None — 効果量の範囲
+        n_range: list[int] | None — サンプルサイズの範囲
+        alpha: float — 有意水準
+        test_type: str — "two-sample-t" / "paired-t" / "chi-square"
+        n_simulations: int — 各条件のシミュレーション回数
+        seed: int — 乱数シード
+    """
+    from scipy import stats as sp_stats
+
+    rng = np.random.default_rng(seed)
+    if effect_size_range is None:
+        effect_size_range = [0.2, 0.5, 0.8]
+    if n_range is None:
+        n_range = [10, 20, 30, 50, 100, 200]
+
+    records = []
+    for es in effect_size_range:
+        for n in n_range:
+            rejections = 0
+            for _ in range(n_simulations):
+                if test_type == "two-sample-t":
+                    x = rng.normal(0, 1, n)
+                    y = rng.normal(es, 1, n)
+                    _, p = sp_stats.ttest_ind(x, y)
+                elif test_type == "paired-t":
+                    diff = rng.normal(es, 1, n)
+                    _, p = sp_stats.ttest_1samp(diff, 0)
+                else:
+                    raise ValueError(f"Unknown test: {test_type}")
+
+                if p < alpha:
+                    rejections += 1
+
+            power = rejections / n_simulations
+            records.append({
+                "effect_size": es, "n": n,
+                "power": power, "alpha": alpha,
+            })
+
+    df = pd.DataFrame(records)
+    for es in effect_size_range:
+        sub = df[df["effect_size"] == es]
+        adequate = sub[sub["power"] >= 0.8]
+        if len(adequate) > 0:
+            min_n = adequate["n"].min()
+            print(f"d={es}: min N={min_n} for power≥0.80")
+        else:
+            print(f"d={es}: power<0.80 for all tested N")
+
+    return df
+```
+
+---
+
+## パイプライン統合
+
+```
+[仮説設計] → statistical-simulation → statistical-testing
+               (シミュレーション)        (本解析)
+                      │
+               doe ← adaptive-experiments
+           (実験計画)   (適応実験)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `mc_results.npz` | Monte Carlo 結果 | → リスク評価 |
+| `bootstrap_ci.csv` | 信頼区間 | → 統計レポート |
+| `power_analysis.csv` | 検出力カーブ | → DOE サンプルサイズ |

package/src/.github/skills/scientific-streaming-analytics/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: scientific-streaming-analytics
+description: |
+  ストリーミング解析スキル。River オンライン学習・
+  リアルタイム異常検知・ストリーミング統計・
+  増分データ可視化・概念ドリフト検出。
+---
+
+# Scientific Streaming Analytics
+
+データストリームに対するリアルタイム学習・異常検知・
+統計モニタリングパイプラインを提供する。
+
+## When to Use
+
+- データが逐次的に到着するストリーミング環境のとき
+- オンライン学習で逐次モデル更新が必要なとき
+- リアルタイム異常検知を実装するとき
+- 概念ドリフトを検出・対応するとき
+- メモリ制約下で増分的に統計量を計算するとき
+
+---
+
+## Quick Start
+
+## 1. River オンライン学習
+
+```python
+from river import (
+    compose, preprocessing, linear_model, metrics,
+    tree, ensemble, drift)
+import pandas as pd
+import numpy as np
+
+
+def online_learning_pipeline(stream_data, model_type="ht",
+                             target_col="y",
+                             feature_cols=None):
+    """
+    River オンライン学習パイプライン。
+
+    Parameters:
+        stream_data: iterable — (X_dict, y) のストリーム or DataFrame
+        model_type: str — "ht" (Hoeffding Tree) / "lr" / "arf"
+        target_col: str — 目標変数名
+        feature_cols: list[str] | None — 特徴量カラム
+    """
+    models = {
+        "ht": tree.HoeffdingTreeClassifier(),
+        "lr": compose.Pipeline(
+            preprocessing.StandardScaler(),
+            linear_model.LogisticRegression()),
+        "arf": ensemble.AdaptiveRandomForestClassifier(
+            n_models=10, seed=42),
+    }
+    model = models.get(model_type, models["ht"])
+    metric = metrics.Accuracy()
+    history = []
+
+    if isinstance(stream_data, pd.DataFrame):
+        if feature_cols is None:
+            feature_cols = [c for c in stream_data.columns
+                           if c != target_col]
+        iterator = (
+            (row[feature_cols].to_dict(), row[target_col])
+            for _, row in stream_data.iterrows())
+    else:
+        iterator = stream_data
+
+    for i, (x, y) in enumerate(iterator):
+        y_pred = model.predict_one(x)
+        if y_pred is not None:
+            metric.update(y, y_pred)
+        model.learn_one(x, y)
+
+        if (i + 1) % 100 == 0:
+            history.append({
+                "step": i + 1,
+                "accuracy": metric.get(),
+            })
+
+    print(f"Online {model_type}: {metric}")
+    return model, pd.DataFrame(history)
+```
+
+## 2. ストリーミング異常検知
+
+```python
+def streaming_anomaly_detection(stream_data, window_size=100,
+                                threshold_sigma=3.0,
+                                method="zscore"):
+    """
+    ストリーミング異常検知。
+
+    Parameters:
+        stream_data: iterable — 数値ストリーム
+        window_size: int — スライディングウィンドウサイズ
+        threshold_sigma: float — 異常判定の σ 閾値
+        method: str — "zscore" / "iqr" / "ewma"
+    """
+    from collections import deque
+
+    window = deque(maxlen=window_size)
+    results = []
+    ewma_mean = None
+    ewma_var = None
+    alpha = 2.0 / (window_size + 1)
+
+    for i, value in enumerate(stream_data):
+        is_anomaly = False
+
+        if method == "zscore" and len(window) >= 10:
+            mean = np.mean(window)
+            std = np.std(window) + 1e-10
+            z = abs(value - mean) / std
+            is_anomaly = z > threshold_sigma
+
+        elif method == "iqr" and len(window) >= 10:
+            q1, q3 = np.percentile(window, [25, 75])
+            iqr = q3 - q1
+            lower = q1 - 1.5 * iqr
+            upper = q3 + 1.5 * iqr
+            is_anomaly = value < lower or value > upper
+
+        elif method == "ewma":
+            if ewma_mean is None:
+                ewma_mean = value
+                ewma_var = 0
+            else:
+                ewma_mean = alpha * value + (1 - alpha) * ewma_mean
+                ewma_var = alpha * (value - ewma_mean) ** 2 + \
+                    (1 - alpha) * ewma_var
+                ewma_std = np.sqrt(ewma_var) + 1e-10
+                is_anomaly = abs(value - ewma_mean) / ewma_std > threshold_sigma
+
+        window.append(value)
+        results.append({
+            "step": i, "value": value,
+            "is_anomaly": is_anomaly,
+        })
+
+    df = pd.DataFrame(results)
+    n_anomalies = df["is_anomaly"].sum()
+    print(f"Streaming anomaly ({method}): "
+          f"{n_anomalies}/{len(df)} anomalies detected "
+          f"({n_anomalies/len(df):.1%})")
+    return df
+```
+
+## 3. 概念ドリフト検出
+
+```python
+def concept_drift_detection(stream_data, target_col="y",
+                            feature_cols=None,
+                            detector_type="adwin"):
+    """
+    概念ドリフト検出。
+
+    Parameters:
+        stream_data: pd.DataFrame — ストリームデータ
+        target_col: str — 目標変数名
+        feature_cols: list[str] | None — 特徴量カラム
+        detector_type: str — "adwin" / "ddm" / "eddm"
+    """
+    detectors = {
+        "adwin": drift.ADWIN(delta=0.002),
+        "ddm": drift.DDM(min_num_instances=30),
+        "eddm": drift.EDDM(),
+    }
+    detector = detectors.get(detector_type, detectors["adwin"])
+
+    model = tree.HoeffdingTreeClassifier()
+    metric = metrics.Accuracy()
+    drift_points = []
+
+    if feature_cols is None:
+        feature_cols = [c for c in stream_data.columns
+                       if c != target_col]
+
+    for i, (_, row) in enumerate(stream_data.iterrows()):
+        x = row[feature_cols].to_dict()
+        y = row[target_col]
+        y_pred = model.predict_one(x)
+
+        if y_pred is not None:
+            is_correct = int(y_pred == y)
+            metric.update(y, y_pred)
+            detector.update(is_correct)
+
+            if detector.drift_detected:
+                drift_points.append({
+                    "step": i,
+                    "accuracy_at_drift": metric.get(),
+                })
+                print(f"⚠ Drift at step {i}, acc={metric.get():.3f}")
+
+        model.learn_one(x, y)
+
+    print(f"Total drifts: {len(drift_points)}")
+    return pd.DataFrame(drift_points)
+```
+
+---
+
+## パイプライン統合
+
+```
+[データストリーム] → streaming-analytics → model-monitoring
+                       (オンライン学習)      (性能監視)
+                            │
+                    anomaly-detection ← data-profiling
+                      (バッチ異常検知)    (データ品質)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `online_model.pkl` | オンラインモデル | → 推論 |
+| `stream_anomalies.csv` | 異常検知結果 | → alerting |
+| `drift_report.csv` | ドリフト検出点 | → model-monitoring |