@nahisaho/satori 0.22.0 → 0.23.0

package/src/.github/skills/scientific-advanced-visualization/SKILL.md

@@ -0,0 +1,310 @@
+---
+name: scientific-advanced-visualization
+description: |
+  科学データ高度可視化スキル。Plotly インタラクティブ 3D ・
+  Altair 宣言的可視化・Seaborn 統計プロット・
+  アニメーション・Parallel Coordinates・出版品質図。
+---
+
+# Scientific Advanced Visualization
+
+科学データのインタラクティブ可視化・3D レンダリング・
+出版品質図・アニメーションを提供する。
+
+## When to Use
+
+- インタラクティブな 3D 散布図・サーフェスプロットを描くとき
+- Plotly / Altair で動的可視化を作成するとき
+- 多変量データを Parallel Coordinates / Radar で可視化するとき
+- 論文投稿用の出版品質 (Nature/Science style) 図を作成するとき
+- 時系列・シミュレーション結果のアニメーションを作成するとき
+- 複数パネルの複合図を作成するとき
+
+---
+
+## Quick Start
+
+## 1. Plotly インタラクティブ 3D
+
+```python
+import numpy as np
+import pandas as pd
+
+
+def plotly_3d_scatter(df, x, y, z, color=None, size=None,
+                      title="3D Scatter Plot"):
+    """
+    Plotly 3D 散布図。
+
+    Parameters:
+        df: pd.DataFrame — データ
+        x, y, z: str — 軸カラム名
+        color: str | None — 色分けカラム
+        size: str | None — サイズカラム
+        title: str — タイトル
+    """
+    import plotly.express as px
+
+    fig = px.scatter_3d(df, x=x, y=y, z=z, color=color, size=size,
+                        title=title, opacity=0.7)
+    fig.update_layout(
+        scene=dict(
+            xaxis_title=x, yaxis_title=y, zaxis_title=z),
+        width=900, height=700)
+
+    path = "3d_scatter.html"
+    fig.write_html(path)
+    print(f"3D Scatter: {len(df)} points → {path}")
+    return fig
+
+
+def plotly_surface(X_grid, Y_grid, Z_grid, title="Surface Plot"):
+    """
+    Plotly 3D サーフェスプロット。
+
+    Parameters:
+        X_grid, Y_grid, Z_grid: np.ndarray — メッシュグリッド
+        title: str — タイトル
+    """
+    import plotly.graph_objects as go
+
+    fig = go.Figure(data=[go.Surface(x=X_grid, y=Y_grid, z=Z_grid,
+                                     colorscale="Viridis")])
+    fig.update_layout(
+        title=title,
+        scene=dict(xaxis_title="X", yaxis_title="Y", zaxis_title="Z"),
+        width=900, height=700)
+
+    path = "surface_plot.html"
+    fig.write_html(path)
+    print(f"Surface: {Z_grid.shape} grid → {path}")
+    return fig
+```
+
+## 2. Altair 宣言的可視化
+
+```python
+def altair_faceted_chart(df, x, y, color, facet_col=None,
+                         chart_type="scatter"):
+    """
+    Altair 宣言的ファセット付きチャート。
+
+    Parameters:
+        df: pd.DataFrame — データ
+        x, y: str — 軸カラム
+        color: str — 色分けカラム
+        facet_col: str | None — ファセットカラム
+        chart_type: str — "scatter" / "line" / "bar" / "box"
+    """
+    import altair as alt
+
+    base = alt.Chart(df).encode(
+        x=alt.X(x, scale=alt.Scale(zero=False)),
+        y=alt.Y(y, scale=alt.Scale(zero=False)),
+        color=color)
+
+    if chart_type == "scatter":
+        chart = base.mark_circle(size=60, opacity=0.7)
+    elif chart_type == "line":
+        chart = base.mark_line()
+    elif chart_type == "bar":
+        chart = base.mark_bar()
+    elif chart_type == "box":
+        chart = base.mark_boxplot()
+    else:
+        chart = base.mark_circle()
+
+    if facet_col:
+        chart = chart.facet(facet_col, columns=3)
+
+    chart = chart.properties(width=300, height=250).interactive()
+
+    path = "altair_chart.html"
+    chart.save(path)
+    print(f"Altair {chart_type}: {len(df)} rows → {path}")
+    return chart
+```
+
+## 3. 多変量可視化
+
+```python
+def parallel_coordinates_plot(df, class_col, features=None,
+                              title="Parallel Coordinates"):
+    """
+    Parallel Coordinates プロット。
+
+    Parameters:
+        df: pd.DataFrame — データ
+        class_col: str — 分類カラム
+        features: list[str] | None — 表示特徴量 (None で全数値)
+        title: str — タイトル
+    """
+    import plotly.express as px
+
+    if features is None:
+        features = df.select_dtypes(include=[np.number]).columns.tolist()
+        if class_col in features:
+            features.remove(class_col)
+
+    fig = px.parallel_coordinates(
+        df, color=class_col, dimensions=features,
+        title=title, color_continuous_scale=px.colors.diverging.Tealrose)
+
+    fig.update_layout(width=1000, height=500)
+
+    path = "parallel_coordinates.html"
+    fig.write_html(path)
+    print(f"Parallel Coordinates: {len(features)} dims → {path}")
+    return fig
+
+
+def radar_chart(categories, values_dict, title="Radar Chart"):
+    """
+    Radar (Spider) チャート — 複数グループ比較。
+
+    Parameters:
+        categories: list[str] — 軸ラベル
+        values_dict: dict[str, list[float]] — {グループ名: 値リスト}
+        title: str — タイトル
+    """
+    import plotly.graph_objects as go
+
+    fig = go.Figure()
+
+    for name, vals in values_dict.items():
+        fig.add_trace(go.Scatterpolar(
+            r=vals + [vals[0]],
+            theta=categories + [categories[0]],
+            fill="toself", name=name, opacity=0.6))
+
+    fig.update_layout(
+        polar=dict(radialaxis=dict(visible=True)),
+        title=title, width=600, height=500)
+
+    path = "radar_chart.html"
+    fig.write_html(path)
+    print(f"Radar: {len(values_dict)} groups × {len(categories)} axes → {path}")
+    return fig
+```
+
+## 4. 出版品質図 (Nature/Science style)
+
+```python
+def publication_figure(plot_func, figsize=(3.5, 2.8),
+                       dpi=300, style="nature",
+                       output="publication_fig.pdf"):
+    """
+    出版品質 (Nature/Science style) 図生成。
+
+    Parameters:
+        plot_func: callable — matplotlib 描画関数 (ax を引数に取る)
+        figsize: tuple — 図サイズ (インチ, Nature 1 col = 3.5in)
+        dpi: int — 解像度
+        style: str — "nature" / "science" / "acs"
+        output: str — 出力パス (.pdf / .svg / .png)
+    """
+    import matplotlib.pyplot as plt
+    import matplotlib as mpl
+
+    # Nature/Science スタイル設定
+    style_params = {
+        "nature": {
+            "font.family": "Arial",
+            "font.size": 7,
+            "axes.linewidth": 0.5,
+            "xtick.major.width": 0.5,
+            "ytick.major.width": 0.5,
+            "lines.linewidth": 1.0,
+            "lines.markersize": 3,
+        },
+        "science": {
+            "font.family": "Helvetica",
+            "font.size": 8,
+            "axes.linewidth": 0.6,
+            "xtick.major.width": 0.6,
+            "ytick.major.width": 0.6,
+            "lines.linewidth": 1.2,
+            "lines.markersize": 4,
+        },
+        "acs": {
+            "font.family": "Arial",
+            "font.size": 9,
+            "axes.linewidth": 0.5,
+            "xtick.major.width": 0.5,
+            "ytick.major.width": 0.5,
+            "lines.linewidth": 1.0,
+            "lines.markersize": 4,
+        }
+    }
+
+    with mpl.rc_context(style_params.get(style, style_params["nature"])):
+        fig, ax = plt.subplots(figsize=figsize)
+        plot_func(ax)
+        ax.spines["top"].set_visible(False)
+        ax.spines["right"].set_visible(False)
+        plt.tight_layout()
+        fig.savefig(output, dpi=dpi, bbox_inches="tight")
+        plt.close()
+
+    print(f"Publication figure ({style}): {figsize} @ {dpi}dpi → {output}")
+    return output
+```
+
+## 5. アニメーション
+
+```python
+def create_animation(data_frames, x_col, y_col, time_col,
+                     title="Animation", fps=10):
+    """
+    Plotly アニメーション。
+
+    Parameters:
+        data_frames: pd.DataFrame — 時間列を含むデータ
+        x_col, y_col: str — 軸カラム
+        time_col: str — 時間 / フレームカラム
+        title: str — タイトル
+        fps: int — フレームレート
+    """
+    import plotly.express as px
+
+    fig = px.scatter(data_frames, x=x_col, y=y_col,
+                     animation_frame=time_col,
+                     title=title, opacity=0.7,
+                     range_x=[data_frames[x_col].min() * 0.9,
+                              data_frames[x_col].max() * 1.1],
+                     range_y=[data_frames[y_col].min() * 0.9,
+                              data_frames[y_col].max() * 1.1])
+
+    fig.update_layout(
+        width=800, height=600,
+        updatemenus=[dict(type="buttons",
+                          buttons=[dict(label="▶ Play",
+                                        method="animate",
+                                        args=[None, {"frame": {"duration": 1000 // fps}}])])])
+
+    path = "animation.html"
+    fig.write_html(path)
+    print(f"Animation: {data_frames[time_col].nunique()} frames @ {fps}fps → {path}")
+    return fig
+```
+
+---
+
+## パイプライン統合
+
+```
+eda-correlation → advanced-visualization → presentation-design
+  (探索的解析)      (高度可視化)             (プレゼンテーション)
+       │                  │                       ↓
+ pca-tsne ───────────────┘           interactive-dashboard
+  (次元削減)                           (ダッシュボード)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `3d_scatter.html` | インタラクティブ 3D 散布図 | → dashboard |
+| `publication_fig.pdf` | 出版品質図 | → presentation |
+| `parallel_coordinates.html` | 多変量可視化 | → reporting |
+| `animation.html` | アニメーション | → presentation |

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 |