@nahisaho/satori 0.1.0

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

@@ -0,0 +1,360 @@
+---
+name: scientific-doe
+description: |
+  実験計画法（DOE）スキル。直交配列表（L9/L16/L27）、中心複合計画（CCD）、
+  Box-Behnken 設計、D-最適計画、応答曲面法（RSM）、交互作用解析、
+  ベイズ最適化（Gaussian Process）、効果プロット（主効果/交互作用/pareto）の
+  テンプレートを提供。
+---
+
+# Scientific Design of Experiments (DOE)
+
+体系的な実験計画と最適化のためのスキル。直交表による因子スクリーニングから
+RSM による最適条件探索、ベイズ最適化による逐次最適化まで、実験の各段階に
+対応するテンプレートを提供する。
+
+## When to Use
+
+- 多因子実験の計画（因子・水準の設計）が必要なとき
+- 直交表やCCD で実験回数を最小化したいとき
+- 主効果・交互作用の寄与率を定量化するとき
+- 応答曲面で最適条件を探索するとき
+- ベイズ最適化で逐次実験を行いたいとき
+
+---
+
+## Quick Start
+
+## 1. 因子設計テンプレート
+
+```python
+import numpy as np
+import pandas as pd
+
+def define_factors(factor_dict):
+    """
+    因子定義テンプレート。
+
+    factor_dict 例:
+    {
+        "Temperature": {"levels": [200, 250, 300], "unit": "°C", "type": "continuous"},
+        "Pressure": {"levels": [1, 5, 10], "unit": "mTorr", "type": "continuous"},
+        "Gas_Ratio": {"levels": [0.2, 0.5, 0.8], "unit": "-", "type": "continuous"},
+        "Material": {"levels": ["ZnO", "ITO", "TiO2"], "unit": "-", "type": "categorical"},
+    }
+    """
+    summary = pd.DataFrame([
+        {"Factor": k, "Levels": len(v["levels"]), "Values": str(v["levels"]),
+         "Unit": v["unit"], "Type": v["type"]}
+        for k, v in factor_dict.items()
+    ])
+    print("=== Factor Design ===")
+    print(summary.to_string(index=False))
+    return summary
+```
+
+## 2. 直交配列表
+
+```python
+# 田口 L9 直交表 (3 因子 × 3 水準)
+L9 = np.array([
+    [0, 0, 0],
+    [0, 1, 1],
+    [0, 2, 2],
+    [1, 0, 1],
+    [1, 1, 2],
+    [1, 2, 0],
+    [2, 0, 2],
+    [2, 1, 0],
+    [2, 2, 1],
+])
+
+def generate_taguchi_design(factor_dict, array="L9"):
+    """
+    田口直交表から実験計画を生成する。
+
+    Available arrays: L4(2^3), L9(3^3-4), L16(2^15), L27(3^13)
+    """
+    arrays = {
+        "L9": L9,
+        "L4": np.array([[0,0,0],[0,1,1],[1,0,1],[1,1,0]]),
+    }
+    oa = arrays.get(array, L9)
+    factors = list(factor_dict.keys())
+
+    runs = []
+    for row in oa:
+        run = {}
+        for i, factor in enumerate(factors[:oa.shape[1]]):
+            levels = factor_dict[factor]["levels"]
+            run[factor] = levels[row[i] % len(levels)]
+        runs.append(run)
+
+    design_df = pd.DataFrame(runs)
+    design_df.index.name = "Run"
+    design_df.index += 1
+    return design_df
+```
+
+## 3. 中心複合計画 (CCD)
+
+```python
+from itertools import product
+
+def central_composite_design(factor_dict, alpha="rotatable", center_points=3):
+    """
+    中心複合計画 (Central Composite Design) を生成する。
+
+    Components:
+        - 2^k 完全実施要因計画 (cube points)
+        - 2k 軸点 (axial/star points)
+        - n_c 中心点
+
+    alpha:
+        "rotatable"  — α = (2^k)^(1/4) (回転可能)
+        "face"       — α = 1 (面心)
+        float        — 任意の値
+    """
+    continuous_factors = {k: v for k, v in factor_dict.items()
+                         if v["type"] == "continuous"}
+    factor_names = list(continuous_factors.keys())
+    k = len(factor_names)
+
+    if alpha == "rotatable":
+        alpha_val = (2 ** k) ** 0.25
+    elif alpha == "face":
+        alpha_val = 1.0
+    else:
+        alpha_val = float(alpha)
+
+    # コード化: -1, 0, +1
+    midpoints = {}
+    half_ranges = {}
+    for name, info in continuous_factors.items():
+        levels = info["levels"]
+        mid = (max(levels) + min(levels)) / 2
+        half = (max(levels) - min(levels)) / 2
+        midpoints[name] = mid
+        half_ranges[name] = half
+
+    runs = []
+
+    # Cube points (2^k)
+    for combo in product([-1, 1], repeat=k):
+        run = {factor_names[i]: midpoints[factor_names[i]] + combo[i] * half_ranges[factor_names[i]]
+               for i in range(k)}
+        run["_type"] = "cube"
+        runs.append(run)
+
+    # Axial points (2k)
+    for i in range(k):
+        for direction in [-1, 1]:
+            run = {name: midpoints[name] for name in factor_names}
+            run[factor_names[i]] = midpoints[factor_names[i]] + direction * alpha_val * half_ranges[factor_names[i]]
+            run["_type"] = "axial"
+            runs.append(run)
+
+    # Center points
+    for _ in range(center_points):
+        run = {name: midpoints[name] for name in factor_names}
+        run["_type"] = "center"
+        runs.append(run)
+
+    design_df = pd.DataFrame(runs)
+    design_df.index.name = "Run"
+    design_df.index += 1
+    return design_df
+```
+
+## 4. 分散分析 (ANOVA) — 因子効果解析
+
+```python
+from scipy.stats import f_oneway
+
+def anova_factor_effects(design_df, response_col, factor_cols):
+    """
+    各因子の主効果を ANOVA で評価する。
+
+    Returns:
+        DataFrame with Factor, SS, DF, MS, F_value, p_value, contribution_pct
+    """
+    ss_total = np.sum((design_df[response_col] - design_df[response_col].mean())**2)
+    results = []
+
+    for factor in factor_cols:
+        groups = [group[response_col].values
+                  for _, group in design_df.groupby(factor)]
+        if len(groups) < 2:
+            continue
+        f_val, p_val = f_oneway(*groups)
+
+        # SS_factor
+        grand_mean = design_df[response_col].mean()
+        ss_factor = sum(len(g) * (np.mean(g) - grand_mean)**2 for g in groups)
+        df_factor = len(groups) - 1
+        ms_factor = ss_factor / df_factor
+
+        results.append({
+            "Factor": factor,
+            "SS": ss_factor,
+            "DF": df_factor,
+            "MS": ms_factor,
+            "F_value": f_val,
+            "p_value": p_val,
+            "Contribution_pct": ss_factor / ss_total * 100 if ss_total > 0 else 0,
+        })
+
+    return pd.DataFrame(results).sort_values("Contribution_pct", ascending=False)
+```
+
+## 5. 主効果プロット
+
+```python
+import matplotlib.pyplot as plt
+
+def main_effects_plot(design_df, response_col, factor_cols, figsize=None):
+    """全因子の主効果プロットを描画する。"""
+    n = len(factor_cols)
+    if figsize is None:
+        figsize = (4 * n, 4)
+
+    fig, axes = plt.subplots(1, n, figsize=figsize, sharey=True)
+    if n == 1:
+        axes = [axes]
+
+    grand_mean = design_df[response_col].mean()
+
+    for ax, factor in zip(axes, factor_cols):
+        means = design_df.groupby(factor)[response_col].mean()
+        ax.plot(range(len(means)), means.values, "bo-", linewidth=2, markersize=8)
+        ax.axhline(grand_mean, color="gray", linestyle="--", alpha=0.5)
+        ax.set_xticks(range(len(means)))
+        ax.set_xticklabels(means.index, rotation=45)
+        ax.set_xlabel(factor)
+        ax.grid(alpha=0.3)
+
+    axes[0].set_ylabel(response_col)
+    plt.suptitle("Main Effects Plot", fontweight="bold", y=1.02)
+    plt.tight_layout()
+    plt.savefig("figures/main_effects_plot.png", dpi=300, bbox_inches="tight")
+    plt.close()
+```
+
+## 6. ベイズ最適化（Gaussian Process）
+
+```python
+from sklearn.gaussian_process import GaussianProcessRegressor
+from sklearn.gaussian_process.kernels import Matern
+
+def bayesian_optimization(objective_func, bounds, n_initial=5,
+                           n_iterations=20, kappa=2.576):
+    """
+    ベイズ最適化（Gaussian Process + Expected Improvement）。
+
+    Parameters:
+        objective_func: callable f(x) → y (最大化)
+        bounds: dict {"param": (low, high)}
+        n_initial: 初期ランダムサンプリング数
+        n_iterations: 最適化ステップ数
+        kappa: 探索-活用トレードオフ (UCB の κ)
+    """
+    from scipy.optimize import minimize as scipy_minimize
+    from scipy.stats import norm
+
+    param_names = list(bounds.keys())
+    lows = np.array([bounds[p][0] for p in param_names])
+    highs = np.array([bounds[p][1] for p in param_names])
+
+    # 初期サンプリング
+    X_init = np.random.uniform(lows, highs, size=(n_initial, len(param_names)))
+    y_init = np.array([objective_func(dict(zip(param_names, x))) for x in X_init])
+
+    X_observed = X_init.tolist()
+    y_observed = y_init.tolist()
+
+    gp = GaussianProcessRegressor(kernel=Matern(nu=2.5), n_restarts_optimizer=5,
+                                   random_state=42)
+
+    for i in range(n_iterations):
+        X_arr = np.array(X_observed)
+        y_arr = np.array(y_observed)
+        gp.fit(X_arr, y_arr)
+
+        # UCB acquisition function
+        def neg_ucb(x):
+            mu, sigma = gp.predict(x.reshape(1, -1), return_std=True)
+            return -(mu + kappa * sigma)
+
+        # 複数の開始点から最適化
+        best_x = None
+        best_val = float("inf")
+        for _ in range(10):
+            x0 = np.random.uniform(lows, highs)
+            res = scipy_minimize(neg_ucb, x0, bounds=list(zip(lows, highs)),
+                                method="L-BFGS-B")
+            if res.fun < best_val:
+                best_val = res.fun
+                best_x = res.x
+
+        # 新しい点を評価
+        y_new = objective_func(dict(zip(param_names, best_x)))
+        X_observed.append(best_x.tolist())
+        y_observed.append(y_new)
+
+    # 最適解
+    best_idx = np.argmax(y_observed)
+    best_params = dict(zip(param_names, X_observed[best_idx]))
+    best_y = y_observed[best_idx]
+
+    return {
+        "best_params": best_params,
+        "best_value": best_y,
+        "X_history": np.array(X_observed),
+        "y_history": np.array(y_observed),
+        "gp_model": gp,
+    }
+```
+
+## 7. 交互作用プロット
+
+```python
+def interaction_plot(design_df, response_col, factor1, factor2, figsize=(8, 6)):
+    """2 因子間の交互作用プロットを描画する。"""
+    fig, ax = plt.subplots(figsize=figsize)
+
+    for level2, group in design_df.groupby(factor2):
+        means = group.groupby(factor1)[response_col].mean()
+        ax.plot(range(len(means)), means.values, "o-", linewidth=2,
+                markersize=8, label=f"{factor2}={level2}")
+
+    ax.set_xticks(range(len(means)))
+    ax.set_xticklabels(means.index)
+    ax.set_xlabel(factor1)
+    ax.set_ylabel(response_col)
+    ax.set_title(f"Interaction Plot: {factor1} × {factor2}", fontweight="bold")
+    ax.legend()
+    ax.grid(alpha=0.3)
+    plt.tight_layout()
+    plt.savefig("figures/interaction_plot.png", dpi=300, bbox_inches="tight")
+    plt.close()
+```
+
+## References
+
+### Output Files
+
+| ファイル | 形式 |
+|---|---|
+| `results/experimental_design.csv` | CSV |
+| `results/anova_factor_effects.csv` | CSV |
+| `results/bayesian_optimization_history.csv` | CSV |
+| `figures/main_effects_plot.png` | PNG |
+| `figures/interaction_plot.png` | PNG |
+| `figures/bayesian_convergence.png` | PNG |
+
+#### 依存パッケージ
+
+```
+scipy>=1.10
+scikit-learn>=1.3
+```

package/src/.github/skills/scientific-eda-correlation/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: scientific-eda-correlation
+description: |
+  探索的データ解析（EDA）と相関分析のスキル。データの分布可視化、相関ヒートマップ、
+  散布図行列の作成を行う際に使用。Scientific Skills Exp-02, 12, 13 で確立したパターン。
+---
+
+# Scientific EDA & Correlation Analysis
+
+探索的データ解析（Exploratory Data Analysis）のパイプラインスキル。
+データ理解の初期段階で使用し、分布・外れ値・変数間相関を把握する。
+
+## When to Use
+
+- 新しいデータセットを受け取ったとき
+- 変数間の関係性を把握したいとき
+- 相関ヒートマップを作成したいとき
+- 材料別・群別のボックスプロット比較が必要なとき
+
+## Quick Start
+
+## 標準パイプライン
+
+### 1. 記述統計量の算出
+
+```python
+import pandas as pd
+import numpy as np
+
+def descriptive_statistics(df, numeric_cols, group_col=None):
+    """記述統計量を算出して CSV に保存する。"""
+    if group_col:
+        stats = df.groupby(group_col)[numeric_cols].describe()
+    else:
+        stats = df[numeric_cols].describe()
+    stats.to_csv("results/descriptive_statistics.csv")
+    return stats
+```
+
+### 2. 分布可視化（ボックスプロット + バイオリンプロット）
+
+```python
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+def plot_distributions(df, variables, group_col, figsize=(20, 16), ncols=3):
+    """群別のボックスプロットを変数ごとに描画する。"""
+    nrows = (len(variables) + ncols - 1) // ncols
+    fig, axes = plt.subplots(nrows, ncols, figsize=figsize)
+    axes = axes.flatten()
+
+    for i, var in enumerate(variables):
+        sns.boxplot(data=df, x=group_col, y=var, ax=axes[i],
+                    palette="Set2", showfliers=True)
+        axes[i].set_title(var, fontsize=12, fontweight="bold")
+        axes[i].tick_params(axis="x", rotation=45)
+
+    for j in range(i + 1, len(axes)):
+        axes[j].set_visible(False)
+
+    plt.tight_layout()
+    plt.savefig("figures/distribution_boxplots.png", dpi=300, bbox_inches="tight")
+    plt.close()
+```
+
+### 3. 相関ヒートマップ（Exp-02 / Exp-13 パターン）
+
+```python
+def plot_correlation_heatmap(df, numeric_cols, block_boundaries=None,
+                              figsize=(14, 12), method="pearson"):
+    """
+    相関ヒートマップを描画する。
+    block_boundaries: PSP などの階層境界を示す線の位置リスト（オプション）。
+    """
+    corr = df[numeric_cols].corr(method=method)
+
+    fig, ax = plt.subplots(figsize=figsize)
+    mask = np.triu(np.ones_like(corr, dtype=bool), k=1)
+    sns.heatmap(corr, mask=mask, annot=True, fmt=".2f",
+                cmap="RdBu_r", center=0, vmin=-1, vmax=1,
+                square=True, linewidths=0.5, ax=ax,
+                annot_kws={"size": 8})
+
+    # 階層境界線（PSP ブロック分離）
+    if block_boundaries:
+        for b in block_boundaries:
+            ax.axhline(y=b, color="black", linewidth=2)
+            ax.axvline(x=b, color="black", linewidth=2)
+
+    ax.set_title("Correlation Heatmap", fontsize=14, fontweight="bold")
+    plt.tight_layout()
+    plt.savefig("figures/correlation_heatmap.png", dpi=300, bbox_inches="tight")
+    plt.close()
+    return corr
+```
+
+### 4. 散布図行列
+
+```python
+def plot_scatter_matrix(df, variables, hue_col, figsize=(16, 14)):
+    """主要変数の散布図行列を描画する。"""
+    g = sns.pairplot(df[variables + [hue_col]], hue=hue_col,
+                     diag_kind="kde", palette="Set2",
+                     plot_kws={"alpha": 0.6, "s": 30})
+    g.fig.suptitle("Scatter Matrix", y=1.02, fontsize=14, fontweight="bold")
+    plt.savefig("figures/scatter_matrix.png", dpi=300, bbox_inches="tight")
+    plt.close()
+```
+
+### 5. PSP ブロック相関分析（Exp-13 独自）
+
+```python
+def psp_block_correlation(df, process_cols, structure_cols, property_cols):
+    """Process→Structure→Property の 3 ブロック相関を個別に算出する。"""
+    ps_corr = df[process_cols + structure_cols].corr().loc[process_cols, structure_cols]
+    sp_corr = df[structure_cols + property_cols].corr().loc[structure_cols, property_cols]
+    pp_corr = df[process_cols + property_cols].corr().loc[process_cols, property_cols]
+
+    ps_corr.to_csv("results/PSP_process_structure_corr.csv")
+    sp_corr.to_csv("results/PSP_structure_property_corr.csv")
+    pp_corr.to_csv("results/PSP_process_property_corr.csv")
+
+    return ps_corr, sp_corr, pp_corr
+```
+
+## References
+
+### Output Files
+
+| ファイル | 形式 |
+|---|---|
+| `results/descriptive_statistics.csv` | CSV |
+| `figures/distribution_boxplots.png` | PNG (300 DPI) |
+| `figures/correlation_heatmap.png` | PNG (300 DPI) |
+| `figures/scatter_matrix.png` | PNG (300 DPI) |
+
+#### 参照実験
+
+- **Exp-02**: `sns.heatmap` 相関ヒートマップの基本パターン
+- **Exp-12**: 8 プロセスパラメータの EDA
+- **Exp-13**: PSP 3 ブロック相関行列

package/src/.github/skills/scientific-feature-importance/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: scientific-feature-importance
+description: |
+  特徴量重要度分析のスキル。Tree-based Feature Importance と Permutation Importance を
+  用いて予測モデルの説明可能性を向上させる際に使用。
+  Scientific Skills Exp-05, 12, 13 で確立したパターン。
+---
+
+# Scientific Feature Importance Analysis
+
+機械学習モデルの「どの特徴量が予測に最も寄与しているか」を定量化するスキル。
+Tree-based Importance（MDI）と Permutation Importance の 2 手法を併用して
+ロバストな解釈を提供する。
+
+## When to Use
+
+- 機械学習モデルの予測結果を解釈したいとき
+- どのプロセスパラメータが最も影響力を持つか知りたいとき
+- 特徴量選択の根拠が必要なとき
+- 複数ターゲット変数に対する重要度の比較
+
+## Quick Start
+
+## 標準パイプライン
+
+### 1. Tree-based Feature Importance（MDI）
+
+```python
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+def tree_feature_importance(model, feature_names, target_name,
+                            top_n=10, figsize=(10, 6)):
+    """
+    Tree ベースモデルの .feature_importances_ を取得して棒グラフで描画する。
+    RandomForest, GradientBoosting, ExtraTrees に対応。
+    """
+    importances = model.feature_importances_
+    fi_df = pd.DataFrame({
+        "Feature": feature_names,
+        "Importance": importances,
+    }).sort_values("Importance", ascending=False)
+
+    fig, ax = plt.subplots(figsize=figsize)
+    top = fi_df.head(top_n)
+    ax.barh(range(len(top)), top["Importance"].values[::-1],
+            color="steelblue", edgecolor="black")
+    ax.set_yticks(range(len(top)))
+    ax.set_yticklabels(top["Feature"].values[::-1])
+    ax.set_xlabel("Feature Importance (MDI)")
+    ax.set_title(f"Feature Importance: {target_name}", fontweight="bold")
+    plt.tight_layout()
+    plt.savefig(f"figures/feature_importance_{target_name}.png",
+                dpi=300, bbox_inches="tight")
+    plt.close()
+
+    return fi_df
+```
+
+### 2. Permutation Importance
+
+```python
+from sklearn.inspection import permutation_importance
+
+def permutation_feature_importance(model, X_test, y_test, feature_names,
+                                    target_name, n_repeats=10,
+                                    top_n=10, figsize=(10, 6)):
+    """
+    Permutation Importance を算出。モデルの種類によらず適用可能。
+    """
+    result = permutation_importance(model, X_test, y_test,
+                                   n_repeats=n_repeats, random_state=42)
+    pi_df = pd.DataFrame({
+        "Feature": feature_names,
+        "Importance_mean": result.importances_mean,
+        "Importance_std": result.importances_std,
+    }).sort_values("Importance_mean", ascending=False)
+
+    fig, ax = plt.subplots(figsize=figsize)
+    top = pi_df.head(top_n)
+    ax.barh(range(len(top)), top["Importance_mean"].values[::-1],
+            xerr=top["Importance_std"].values[::-1],
+            color="coral", edgecolor="black", capsize=3)
+    ax.set_yticks(range(len(top)))
+    ax.set_yticklabels(top["Feature"].values[::-1])
+    ax.set_xlabel("Permutation Importance")
+    ax.set_title(f"Permutation Importance: {target_name}", fontweight="bold")
+    plt.tight_layout()
+    plt.savefig(f"figures/permutation_importance_{target_name}.png",
+                dpi=300, bbox_inches="tight")
+    plt.close()
+
+    return pi_df
+```
+
+### 3. マルチターゲット重要度パネル（Exp-13 パターン）
+
+```python
+def multi_target_importance_panel(models_dict, feature_names,
+                                   top_n=10, ncols=3, figsize=(20, 16)):
+    """
+    複数ターゲットの特徴量重要度を一つの Figure にまとめて描画する。
+    models_dict: {target_name: fitted_model}
+    """
+    targets = list(models_dict.keys())
+    nrows = (len(targets) + ncols - 1) // ncols
+    fig, axes = plt.subplots(nrows, ncols, figsize=figsize)
+    axes = axes.flatten()
+
+    all_importances = []
+
+    for i, target in enumerate(targets):
+        model = models_dict[target]
+        if not hasattr(model, "feature_importances_"):
+            axes[i].text(0.5, 0.5, f"{target}\n(No FI available)",
+                        ha="center", va="center", transform=axes[i].transAxes)
+            continue
+
+        importances = model.feature_importances_
+        fi_df = pd.DataFrame({
+            "Feature": feature_names,
+            "Importance": importances,
+            "Target": target,
+        }).sort_values("Importance", ascending=False)
+
+        all_importances.append(fi_df)
+
+        top = fi_df.head(top_n)
+        axes[i].barh(range(len(top)), top["Importance"].values[::-1],
+                    color="steelblue", edgecolor="black")
+        axes[i].set_yticks(range(len(top)))
+        axes[i].set_yticklabels(top["Feature"].values[::-1], fontsize=8)
+        axes[i].set_xlabel("Importance", fontsize=9)
+        axes[i].set_title(target, fontweight="bold", fontsize=10)
+
+    for j in range(i + 1, len(axes)):
+        axes[j].set_visible(False)
+
+    plt.suptitle("Feature Importance by Target", fontsize=14, fontweight="bold")
+    plt.tight_layout()
+    plt.savefig("figures/feature_importance_panel.png", dpi=300, bbox_inches="tight")
+    plt.close()
+
+    # 全重要度を CSV 保存
+    if all_importances:
+        combined = pd.concat(all_importances, ignore_index=True)
+        combined.to_csv("results/feature_importance.csv", index=False)
+        return combined
+    return pd.DataFrame()
+```
+
+### 4. 部分依存プロット（PDP）
+
+```python
+from sklearn.inspection import PartialDependenceDisplay
+
+def partial_dependence_plots(model, X_train, feature_names,
+                              top_features, target_name, figsize=(16, 10)):
+    """上位特徴量の部分依存プロットを描画する。"""
+    feature_indices = [list(feature_names).index(f) for f in top_features
+                       if f in feature_names]
+
+    fig, ax = plt.subplots(figsize=figsize)
+    PartialDependenceDisplay.from_estimator(
+        model, X_train, feature_indices,
+        feature_names=feature_names, ax=ax
+    )
+    plt.suptitle(f"Partial Dependence: {target_name}", fontweight="bold")
+    plt.tight_layout()
+    plt.savefig(f"figures/pdp_{target_name}.png", dpi=300, bbox_inches="tight")
+    plt.close()
+```
+
+## パラメータ–物性マッピング表の自動生成
+
+```python
+def generate_importance_mapping_table(all_fi_df, top_n=3):
+    """各ターゲットの上位 N 特徴量をまとめた対応表を生成する。"""
+    mapping = []
+    for target in all_fi_df["Target"].unique():
+        subset = all_fi_df[all_fi_df["Target"] == target].nlargest(top_n, "Importance")
+        for rank, (_, row) in enumerate(subset.iterrows(), 1):
+            mapping.append({
+                "Target": target,
+                f"Rank_{rank}": row["Feature"],
+                f"Importance_{rank}": f"{row['Importance']:.4f}",
+            })
+    return pd.DataFrame(mapping)
+```
+
+## References
+
+### Output Files
+
+| ファイル | 形式 |
+|---|---|
+| `results/feature_importance.csv` | CSV |
+| `figures/feature_importance_*.png` | PNG |
+| `figures/permutation_importance_*.png` | PNG |
+| `figures/feature_importance_panel.png` | PNG |
+| `figures/pdp_*.png` | PNG |
+
+#### 参照実験
+
+- **Exp-05**: Tree-based + Permutation Importance（毒性予測）
+- **Exp-12**: 6 モデルの特徴量重要度比較（エッチング）
+- **Exp-13**: マルチターゲットパネル + パラメータ–物性マッピング表