@nahisaho/satori 0.23.0 → 0.25.0

package/src/.github/skills/scientific-reproducible-reporting/SKILL.md

@@ -0,0 +1,330 @@
+---
+name: scientific-reproducible-reporting
+description: |
+  再現可能レポーティングスキル。Quarto 科学文書・
+  Jupyter Book 多章構成・Papermill パラメトリック実行・
+  nbconvert 自動変換・Sphinx-Gallery コード例ドキュメント。
+---
+
+# Scientific Reproducible Reporting
+
+再現可能な科学レポート・文書生成パイプラインを提供し、
+コード → 実行 → 文書化の自動化を実現する。
+
+## When to Use
+
+- Quarto で再現可能な科学文書を作成するとき
+- Jupyter Book で多章構成の文書を構築するとき
+- Papermill でパラメトリック実行を自動化するとき
+- nbconvert でノートブックを各種形式に変換するとき
+- CI/CD で解析レポートを自動生成するとき
+- 複数パラメータセットで解析を繰り返し実行するとき
+
+---
+
+## Quick Start
+
+## 1. Quarto 科学文書テンプレート
+
+```python
+import os
+
+
+def generate_quarto_document(title="Scientific Analysis Report",
+                             author="SATORI",
+                             format_type="html",
+                             output_dir="quarto_project"):
+    """
+    Quarto 科学文書テンプレート生成。
+
+    Parameters:
+        title: str — ドキュメントタイトル
+        author: str — 著者名
+        format_type: str — "html" / "pdf" / "docx" / "revealjs"
+        output_dir: str — 出力ディレクトリ
+    """
+    os.makedirs(output_dir, exist_ok=True)
+
+    # _quarto.yml
+    quarto_config = f"""project:
+  type: default
+  output-dir: _output
+
+format:
+  {format_type}:
+    toc: true
+    toc-depth: 3
+    number-sections: true
+    code-fold: true
+    code-tools: true
+    theme: cosmo
+
+execute:
+  echo: true
+  warning: false
+  cache: true
+
+bibliography: references.bib
+csl: nature.csl
+"""
+
+    # メインドキュメント
+    main_qmd = f"""---
+title: "{title}"
+author: "{author}"
+date: today
+format:
+  {format_type}:
+    code-fold: true
+    code-tools: true
+jupyter: python3
+---
+
+## はじめに
+
+このレポートは SATORI スキルを用いた再現可能な科学解析文書です。
+
+```{{python}}
+#| label: setup
+#| echo: false
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import warnings
+warnings.filterwarnings("ignore")
+
+# パラメータ (Papermill 互換)
+n_samples = 1000
+random_seed = 42
+```
+
+## データ概要
+
+```{{python}}
+#| label: data-summary
+#| tbl-cap: "データセット概要"
+
+np.random.seed(random_seed)
+df = pd.DataFrame({{
+    "x": np.random.randn(n_samples),
+    "y": np.random.randn(n_samples),
+    "group": np.random.choice(["A", "B", "C"], n_samples)
+}})
+df.describe()
+```
+
+## 可視化
+
+```{{python}}
+#| label: fig-scatter
+#| fig-cap: "散布図"
+
+fig, ax = plt.subplots(figsize=(8, 6))
+for g, sub in df.groupby("group"):
+    ax.scatter(sub["x"], sub["y"], label=g, alpha=0.6, s=20)
+ax.legend()
+ax.set_xlabel("X")
+ax.set_ylabel("Y")
+plt.show()
+```
+
+## 結論
+
+解析結果のサマリーを記載する。
+
+## References
+"""
+
+    # references.bib (空テンプレート)
+    bib_template = """@article{example2024,
+  title={Example Reference},
+  author={Author, A.},
+  journal={Journal},
+  year={2024}
+}
+"""
+
+    with open(os.path.join(output_dir, "_quarto.yml"), "w") as f:
+        f.write(quarto_config)
+    with open(os.path.join(output_dir, "report.qmd"), "w") as f:
+        f.write(main_qmd)
+    with open(os.path.join(output_dir, "references.bib"), "w") as f:
+        f.write(bib_template)
+
+    print(f"Quarto project → {output_dir}/")
+    print(f"  Build: cd {output_dir} && quarto render report.qmd")
+    return output_dir
+```
+
+## 2. Papermill パラメトリック実行
+
+```python
+def papermill_parametric_run(template_notebook, output_dir,
+                             parameter_sets, kernel="python3"):
+    """
+    Papermill パラメトリック実行 — 複数パラメータセットで自動実行。
+
+    Parameters:
+        template_notebook: str — テンプレートノートブックパス
+        output_dir: str — 出力ディレクトリ
+        parameter_sets: list[dict] — パラメータセットのリスト
+        kernel: str — カーネル名
+    """
+    import papermill as pm
+
+    os.makedirs(output_dir, exist_ok=True)
+    results = []
+
+    for i, params in enumerate(parameter_sets):
+        output_path = os.path.join(output_dir, f"run_{i:03d}.ipynb")
+        try:
+            pm.execute_notebook(
+                template_notebook,
+                output_path,
+                parameters=params,
+                kernel_name=kernel)
+            results.append({
+                "run": i, "params": params,
+                "output": output_path, "status": "success"})
+        except Exception as e:
+            results.append({
+                "run": i, "params": params,
+                "output": output_path, "status": f"error: {str(e)}"})
+
+    import pandas as pd
+    results_df = pd.DataFrame(results)
+    n_success = (results_df["status"] == "success").sum()
+    print(f"Papermill: {n_success}/{len(parameter_sets)} runs succeeded")
+    return results_df
+```
+
+## 3. Jupyter Book 多章構成
+
+```python
+def generate_jupyter_book(title="Scientific Analysis Book",
+                          chapters=None,
+                          output_dir="jupyter_book"):
+    """
+    Jupyter Book プロジェクトテンプレート生成。
+
+    Parameters:
+        title: str — 書籍タイトル
+        chapters: list[dict] | None — 章情報 [{"title": ..., "file": ...}]
+        output_dir: str — 出力ディレクトリ
+    """
+    os.makedirs(output_dir, exist_ok=True)
+
+    if chapters is None:
+        chapters = [
+            {"title": "Introduction", "file": "intro"},
+            {"title": "Data Loading", "file": "ch01_data"},
+            {"title": "Exploratory Analysis", "file": "ch02_eda"},
+            {"title": "Modeling", "file": "ch03_model"},
+            {"title": "Results", "file": "ch04_results"},
+        ]
+
+    # _config.yml
+    config = f"""title: "{title}"
+author: SATORI
+execute:
+  execute_notebooks: auto
+  timeout: 600
+repository:
+  url: ""
+launch_buttons:
+  binderhub_url: ""
+sphinx:
+  extra_extensions:
+    - sphinx_proof
+"""
+
+    # _toc.yml
+    toc_entries = "\n".join(
+        [f"  - file: {ch['file']}" for ch in chapters])
+    toc = f"""format: jb-book
+root: intro
+chapters:
+{toc_entries}
+"""
+
+    with open(os.path.join(output_dir, "_config.yml"), "w") as f:
+        f.write(config)
+    with open(os.path.join(output_dir, "_toc.yml"), "w") as f:
+        f.write(toc)
+
+    # 各章テンプレート
+    for ch in chapters:
+        filepath = os.path.join(output_dir, f"{ch['file']}.md")
+        if not os.path.exists(filepath):
+            content = f"# {ch['title']}\n\nThis chapter covers {ch['title'].lower()}.\n"
+            with open(filepath, "w") as f:
+                f.write(content)
+
+    print(f"Jupyter Book → {output_dir}/")
+    print(f"  Build: jupyter-book build {output_dir}")
+    return output_dir
+```
+
+## 4. nbconvert 自動変換
+
+```python
+def batch_convert_notebooks(notebook_dir, output_format="html",
+                            output_dir=None, execute=True):
+    """
+    ノートブック一括変換。
+
+    Parameters:
+        notebook_dir: str — ノートブックディレクトリ
+        output_format: str — "html" / "pdf" / "markdown" / "script"
+        output_dir: str | None — 出力先 (None=同ディレクトリ)
+        execute: bool — 実行後に変換
+    """
+    import subprocess
+    import glob
+
+    notebooks = sorted(glob.glob(os.path.join(notebook_dir, "*.ipynb")))
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+
+    results = []
+    for nb_path in notebooks:
+        cmd = ["jupyter", "nbconvert", f"--to={output_format}"]
+        if execute:
+            cmd.append("--execute")
+        if output_dir:
+            cmd.extend(["--output-dir", output_dir])
+        cmd.append(nb_path)
+
+        try:
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+            results.append({"notebook": nb_path, "status": "success"})
+        except subprocess.CalledProcessError as e:
+            results.append({"notebook": nb_path, "status": f"error: {e.stderr[:100]}"})
+
+    import pandas as pd
+    results_df = pd.DataFrame(results)
+    n_ok = (results_df["status"] == "success").sum()
+    print(f"nbconvert ({output_format}): {n_ok}/{len(notebooks)} converted")
+    return results_df
+```
+
+---
+
+## パイプライン統合
+
+```
+[解析完了] → reproducible-reporting → presentation-design
+              (レポート自動生成)         (プレゼン作成)
+                     │                        ↓
+            interactive-dashboard      academic-writing
+              (ダッシュボード)           (論文執筆)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `quarto_project/` | Quarto プロジェクト | → quarto render |
+| `papermill_runs/` | パラメトリック実行結果 | → 集計 |
+| `jupyter_book/` | Jupyter Book プロジェクト | → jb build |

package/src/.github/skills/scientific-semi-supervised-learning/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: scientific-semi-supervised-learning
+description: |
+  半教師あり学習スキル。Self-Training・Label Propagation・
+  MixMatch/FixMatch・Pseudo-Labeling・ラベル効率評価。
+---
+
+# Scientific Semi-Supervised Learning
+
+少量のラベル付きデータと大量の未ラベルデータを活用する
+半教師あり学習パイプラインを提供する。
+
+## When to Use
+
+- ラベル付きデータが少量しかないとき
+- アノテーションコストが高く全量ラベリングが困難なとき
+- Self-Training で反復的にラベルを拡張するとき
+- グラフベースの Label Propagation を適用するとき
+- Pseudo-Labeling の信頼度閾値を設計するとき
+
+---
+
+## Quick Start
+
+## 1. Self-Training パイプライン
+
+```python
+import numpy as np
+import pandas as pd
+from sklearn.base import clone
+from sklearn.metrics import accuracy_score, classification_report
+
+
+def self_training_pipeline(X_labeled, y_labeled, X_unlabeled,
+                           base_estimator=None, threshold=0.95,
+                           max_iterations=10, batch_size=None,
+                           X_test=None, y_test=None):
+    """
+    Self-Training 半教師あり学習。
+
+    Parameters:
+        X_labeled: np.ndarray — ラベル付き特徴量
+        y_labeled: np.ndarray — ラベル
+        X_unlabeled: np.ndarray — 未ラベル特徴量
+        base_estimator: sklearn estimator | None — 基底分類器
+        threshold: float — Pseudo-Label 採用閾値
+        max_iterations: int — 最大反復回数
+        batch_size: int | None — 各反復で追加するサンプル数上限
+        X_test: np.ndarray | None — テスト特徴量
+        y_test: np.ndarray | None — テストラベル
+    """
+    from sklearn.ensemble import GradientBoostingClassifier
+
+    if base_estimator is None:
+        base_estimator = GradientBoostingClassifier(
+            n_estimators=100, random_state=42)
+
+    X_train = X_labeled.copy()
+    y_train = y_labeled.copy()
+    X_pool = X_unlabeled.copy()
+    history = []
+
+    for iteration in range(max_iterations):
+        if len(X_pool) == 0:
+            print(f"Iteration {iteration}: Pool exhausted")
+            break
+
+        model = clone(base_estimator)
+        model.fit(X_train, y_train)
+        proba = model.predict_proba(X_pool)
+        max_proba = proba.max(axis=1)
+        pseudo_labels = proba.argmax(axis=1)
+
+        confident_mask = max_proba >= threshold
+        n_confident = confident_mask.sum()
+
+        if batch_size and n_confident > batch_size:
+            top_idx = np.argsort(max_proba)[-batch_size:]
+            confident_mask = np.zeros(len(X_pool), dtype=bool)
+            confident_mask[top_idx] = True
+            n_confident = batch_size
+
+        if n_confident == 0:
+            print(f"Iteration {iteration}: No confident samples")
+            break
+
+        X_train = np.vstack([X_train, X_pool[confident_mask]])
+        y_train = np.concatenate([
+            y_train, pseudo_labels[confident_mask]])
+        X_pool = X_pool[~confident_mask]
+
+        record = {"iteration": iteration,
+                  "n_labeled": len(X_train),
+                  "n_pool": len(X_pool),
+                  "n_added": int(n_confident),
+                  "mean_confidence": float(max_proba[confident_mask].mean())}
+
+        if X_test is not None and y_test is not None:
+            test_acc = accuracy_score(y_test, model.predict(X_test))
+            record["test_accuracy"] = test_acc
+
+        history.append(record)
+        print(f"Iter {iteration}: +{n_confident} samples, "
+              f"total={len(X_train)}, pool={len(X_pool)}")
+
+    final_model = clone(base_estimator)
+    final_model.fit(X_train, y_train)
+    return final_model, pd.DataFrame(history)
+```
+
+## 2. Label Propagation
+
+```python
+def label_propagation_ssl(X_all, y_partial, kernel="rbf",
+                          gamma=20, n_neighbors=7,
+                          max_iter=1000):
+    """
+    グラフベース Label Propagation。
+
+    Parameters:
+        X_all: np.ndarray — 全サンプル特徴量 (ラベル付き+未ラベル)
+        y_partial: np.ndarray — ラベル (-1 = 未ラベル)
+        kernel: str — "rbf" / "knn"
+        gamma: float — RBF カーネルの γ
+        n_neighbors: int — KNN カーネルの k
+        max_iter: int — 最大反復回数
+    """
+    from sklearn.semi_supervised import (
+        LabelPropagation, LabelSpreading)
+
+    models = {
+        "propagation": LabelPropagation(
+            kernel=kernel, gamma=gamma,
+            n_neighbors=n_neighbors, max_iter=max_iter),
+        "spreading": LabelSpreading(
+            kernel=kernel, gamma=gamma,
+            n_neighbors=n_neighbors, max_iter=max_iter, alpha=0.2),
+    }
+
+    results = {}
+    for name, model in models.items():
+        model.fit(X_all, y_partial)
+        y_pred = model.transduction_
+        n_propagated = (y_partial == -1).sum()
+        results[name] = {
+            "model": model,
+            "predictions": y_pred,
+            "n_propagated": int(n_propagated),
+            "label_distributions": model.label_distributions_,
+        }
+        print(f"{name}: propagated {n_propagated} labels")
+
+    return results
+```
+
+## 3. Pseudo-Labeling 品質評価
+
+```python
+def evaluate_pseudo_labels(y_true_unlabeled, pseudo_labels,
+                           confidences, thresholds=None):
+    """
+    Pseudo-Label の品質を評価。
+
+    Parameters:
+        y_true_unlabeled: np.ndarray — 真のラベル (評価用)
+        pseudo_labels: np.ndarray — 予測した疑似ラベル
+        confidences: np.ndarray — 各予測の信頼度
+        thresholds: list[float] | None — 閾値リスト
+    """
+    if thresholds is None:
+        thresholds = [0.5, 0.7, 0.8, 0.9, 0.95, 0.99]
+
+    records = []
+    for t in thresholds:
+        mask = confidences >= t
+        if mask.sum() == 0:
+            continue
+        acc = accuracy_score(y_true_unlabeled[mask],
+                             pseudo_labels[mask])
+        records.append({
+            "threshold": t,
+            "n_selected": int(mask.sum()),
+            "coverage": float(mask.mean()),
+            "pseudo_accuracy": acc,
+        })
+        print(f"τ={t:.2f}: {mask.sum()} samples, "
+              f"coverage={mask.mean():.1%}, acc={acc:.3f}")
+
+    return pd.DataFrame(records)
+```
+
+---
+
+## パイプライン統合
+
+```
+[少量ラベル] → semi-supervised-learning → ml-classification
+                   (ラベル拡張)              (本分類)
+                        │
+                 active-learning ← data-profiling
+                  (能動学習)       (データ品質)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `self_training_history.csv` | 反復学習履歴 | → 収束分析 |
+| `pseudo_label_quality.csv` | 疑似ラベル品質 | → 閾値選択 |
+| `propagated_labels.npy` | 伝播ラベル | → ml-classification |