@nahisaho/satori 0.23.0 → 0.25.0

package/src/.github/skills/scientific-geospatial-analysis/SKILL.md

@@ -0,0 +1,274 @@
+---
+name: scientific-geospatial-analysis
+description: |
+  地理空間データ解析スキル。GeoPandas ベクターデータ処理・
+  Rasterio ラスター解析・Folium/Kepler.gl インタラクティブ地図・
+  空間自己相関 (Moran's I)・クリギング補間・CRS 変換。
+---
+
+# Scientific Geospatial Analysis
+
+地理空間データの前処理・空間統計・インタラクティブ地図可視化
+パイプラインを提供する。
+
+## When to Use
+
+- GeoPandas でベクターデータ (Shapefile/GeoJSON) を処理するとき
+- ラスターデータ (GeoTIFF) を読み込み解析するとき
+- 空間自己相関 (Moran's I / LISA) を検定するとき
+- クリギング (Kriging) で空間補間するとき
+- Folium/Kepler.gl でインタラクティブ地図を作成するとき
+- CRS (座標参照系) 変換・空間結合をするとき
+
+> **Note**: 環境特化 GIS (SoilGrids/WorldClim) は `scientific-environmental-geodata` を参照。
+
+---
+
+## Quick Start
+
+## 1. GeoPandas ベクターデータ処理
+
+```python
+import numpy as np
+import pandas as pd
+
+
+def load_and_process_geodata(filepath, target_crs="EPSG:4326"):
+    """
+    GeoPandas ベクター/ポイントデータ読み込み・CRS 変換。
+
+    Parameters:
+        filepath: str — Shapefile / GeoJSON / GPKG パス
+        target_crs: str — 変換先座標系
+    """
+    import geopandas as gpd
+
+    gdf = gpd.read_file(filepath)
+    original_crs = gdf.crs
+
+    if gdf.crs != target_crs:
+        gdf = gdf.to_crs(target_crs)
+
+    # 基本統計
+    bounds = gdf.total_bounds  # [minx, miny, maxx, maxy]
+    geom_types = gdf.geometry.geom_type.value_counts().to_dict()
+
+    print(f"GeoData: {len(gdf)} features, CRS: {original_crs} → {target_crs}")
+    print(f"  Bounds: [{bounds[0]:.4f}, {bounds[1]:.4f}] "
+          f"to [{bounds[2]:.4f}, {bounds[3]:.4f}]")
+    print(f"  Geometry types: {geom_types}")
+    return gdf
+
+
+def spatial_join(gdf_left, gdf_right, how="inner", predicate="intersects"):
+    """
+    空間結合 (Spatial Join)。
+
+    Parameters:
+        gdf_left: GeoDataFrame — 左テーブル
+        gdf_right: GeoDataFrame — 右テーブル
+        how: str — "inner" / "left" / "right"
+        predicate: str — "intersects" / "within" / "contains"
+    """
+    import geopandas as gpd
+
+    if gdf_left.crs != gdf_right.crs:
+        gdf_right = gdf_right.to_crs(gdf_left.crs)
+
+    joined = gpd.sjoin(gdf_left, gdf_right, how=how, predicate=predicate)
+
+    print(f"Spatial Join ({predicate}, {how}): "
+          f"{len(gdf_left)} × {len(gdf_right)} → {len(joined)}")
+    return joined
+```
+
+## 2. 空間自己相関 (Moran's I / LISA)
+
+```python
+def spatial_autocorrelation(gdf, value_col, weight_type="queen"):
+    """
+    空間自己相関検定 — Global Moran's I + LISA。
+
+    Parameters:
+        gdf: GeoDataFrame — ジオメトリ + 属性データ
+        value_col: str — 解析対象カラム
+        weight_type: str — "queen" / "rook" / "knn"
+    """
+    from libpysal.weights import Queen, Rook, KNN
+    from esda.moran import Moran, Moran_Local
+    import matplotlib.pyplot as plt
+
+    # 空間重み行列
+    if weight_type == "queen":
+        w = Queen.from_dataframe(gdf)
+    elif weight_type == "rook":
+        w = Rook.from_dataframe(gdf)
+    elif weight_type == "knn":
+        w = KNN.from_dataframe(gdf, k=5)
+
+    w.transform = "r"
+    y = gdf[value_col].values
+
+    # Global Moran's I
+    moran_global = Moran(y, w)
+
+    # LISA (Local Indicators of Spatial Association)
+    moran_local = Moran_Local(y, w)
+
+    gdf = gdf.copy()
+    gdf["lisa_cluster"] = moran_local.q  # 1=HH, 2=LH, 3=LL, 4=HL
+    gdf["lisa_significant"] = moran_local.p_sim < 0.05
+    gdf["local_moran_i"] = moran_local.Is
+
+    # 可視化
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 7))
+
+    gdf.plot(column=value_col, ax=ax1, legend=True,
+             cmap="RdYlBu_r", edgecolor="gray", linewidth=0.3)
+    ax1.set_title(f"{value_col} (Moran's I={moran_global.I:.4f}, "
+                  f"p={moran_global.p_sim:.4f})")
+
+    cluster_labels = {1: "High-High", 2: "Low-High",
+                      3: "Low-Low", 4: "High-Low", 0: "Not Significant"}
+    sig_gdf = gdf[gdf["lisa_significant"]]
+    if len(sig_gdf) > 0:
+        sig_gdf.plot(column="lisa_cluster", ax=ax2,
+                     categorical=True, legend=True,
+                     edgecolor="gray", linewidth=0.3)
+    ax2.set_title("LISA Clusters (p < 0.05)")
+
+    plt.tight_layout()
+    path = "spatial_autocorrelation.png"
+    plt.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close()
+
+    print(f"Moran's I = {moran_global.I:.4f}, p = {moran_global.p_sim:.4f}")
+    print(f"LISA: {gdf['lisa_significant'].sum()} significant clusters")
+    return {"moran_i": moran_global.I, "p_value": moran_global.p_sim,
+            "gdf": gdf, "fig": path}
+```
+
+## 3. クリギング空間補間
+
+```python
+def kriging_interpolation(points_df, x_col, y_col, value_col,
+                          grid_resolution=100,
+                          variogram_model="spherical"):
+    """
+    Ordinary Kriging 空間補間。
+
+    Parameters:
+        points_df: pd.DataFrame — 観測点データ
+        x_col, y_col: str — 座標カラム
+        value_col: str — 補間対象カラム
+        grid_resolution: int — グリッド解像度
+        variogram_model: str — "spherical" / "exponential" / "gaussian"
+    """
+    from pykrige.ok import OrdinaryKriging
+    import matplotlib.pyplot as plt
+
+    x = points_df[x_col].values
+    y = points_df[y_col].values
+    z = points_df[value_col].values
+
+    ok = OrdinaryKriging(
+        x, y, z,
+        variogram_model=variogram_model,
+        verbose=False, enable_plotting=False)
+
+    grid_x = np.linspace(x.min(), x.max(), grid_resolution)
+    grid_y = np.linspace(y.min(), y.max(), grid_resolution)
+    z_pred, ss_pred = ok.execute("grid", grid_x, grid_y)
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+
+    im1 = ax1.imshow(z_pred, origin="lower",
+                     extent=[x.min(), x.max(), y.min(), y.max()],
+                     cmap="viridis")
+    ax1.scatter(x, y, c="red", s=10, edgecolors="black", linewidths=0.5)
+    ax1.set_title(f"Kriging Prediction ({variogram_model})")
+    plt.colorbar(im1, ax=ax1)
+
+    im2 = ax2.imshow(ss_pred, origin="lower",
+                     extent=[x.min(), x.max(), y.min(), y.max()],
+                     cmap="Reds")
+    ax2.set_title("Kriging Variance (Uncertainty)")
+    plt.colorbar(im2, ax=ax2)
+
+    plt.tight_layout()
+    path = "kriging_result.png"
+    plt.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close()
+
+    print(f"Kriging ({variogram_model}): {grid_resolution}×{grid_resolution} grid, "
+          f"{len(x)} observation points")
+    return {"z_pred": z_pred, "variance": ss_pred,
+            "grid_x": grid_x, "grid_y": grid_y, "fig": path}
+```
+
+## 4. Folium インタラクティブ地図
+
+```python
+def interactive_map(gdf, value_col=None, popup_cols=None,
+                    tiles="CartoDB positron",
+                    output="interactive_map.html"):
+    """
+    Folium インタラクティブ地図。
+
+    Parameters:
+        gdf: GeoDataFrame — 地理空間データ
+        value_col: str | None — Choropleth カラム
+        popup_cols: list[str] | None — ポップアップ表示カラム
+        tiles: str — タイル名
+        output: str — 出力 HTML
+    """
+    import folium
+
+    center = [gdf.geometry.centroid.y.mean(),
+              gdf.geometry.centroid.x.mean()]
+    m = folium.Map(location=center, zoom_start=8, tiles=tiles)
+
+    if value_col and gdf.geometry.geom_type.iloc[0] in ["Polygon", "MultiPolygon"]:
+        folium.Choropleth(
+            geo_data=gdf.__geo_interface__,
+            data=gdf, columns=[gdf.index.name or "index", value_col],
+            key_on="feature.id",
+            fill_color="YlOrRd",
+            legend_name=value_col
+        ).add_to(m)
+    else:
+        for _, row in gdf.iterrows():
+            popup_text = ""
+            if popup_cols:
+                popup_text = "<br>".join(
+                    [f"<b>{c}</b>: {row[c]}" for c in popup_cols])
+            folium.CircleMarker(
+                location=[row.geometry.centroid.y, row.geometry.centroid.x],
+                radius=5, popup=popup_text,
+                color="blue", fill=True
+            ).add_to(m)
+
+    m.save(output)
+    print(f"Interactive map → {output} ({len(gdf)} features)")
+    return output
+```
+
+---
+
+## パイプライン統合
+
+```
+environmental-geodata → geospatial-analysis → advanced-visualization
+  (環境データ取得)        (空間解析)             (高度可視化)
+         │                     │                      ↓
+  epidemiology ───────────────┘          interactive-dashboard
+    (空間疫学)                              (ダッシュボード)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `spatial_autocorrelation.png` | Moran's I + LISA | → reporting |
+| `kriging_result.png` | クリギング補間 | → visualization |
+| `interactive_map.html` | Folium 地図 | → dashboard |

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 テスト結果 | → デプロイ判断 |