@nahisaho/satori 0.13.0 → 0.14.0

package/src/.github/skills/scientific-reinforcement-learning/SKILL.md

@@ -0,0 +1,280 @@
+---
+name: scientific-reinforcement-learning
+description: |
+  強化学習スキル。Stable-Baselines3 による RL エージェント訓練、
+  Gymnasium 環境構築、PufferLib 大規模マルチエージェント、
+  科学応用 (分子生成・実験最適化・ロボット制御) パイプライン。
+---
+
+# Scientific Reinforcement Learning
+
+Stable-Baselines3 / PufferLib / Gymnasium を活用した
+強化学習パイプラインを提供する。
+
+## When to Use
+
+- RL エージェントを訓練・評価するとき
+- カスタム Gymnasium 環境を構築するとき
+- 分子設計・創薬に RL を適用するとき
+- 実験パラメータの逐次最適化に RL を使うとき
+- マルチエージェント強化学習を実行するとき
+- ロボティクス・ラボオートメーションの制御方策を学習するとき
+
+---
+
+## Quick Start
+
+## 1. Stable-Baselines3 基本訓練
+
+```python
+import numpy as np
+import gymnasium as gym
+from stable_baselines3 import PPO, SAC, A2C, DQN
+from stable_baselines3.common.evaluation import evaluate_policy
+from stable_baselines3.common.vec_env import DummyVecEnv, SubprocVecEnv
+from stable_baselines3.common.callbacks import EvalCallback, CheckpointCallback
+
+
+def train_rl_agent(env_id, algorithm="PPO", total_timesteps=100_000,
+                   n_envs=4, hyperparams=None):
+    """
+    Stable-Baselines3 RL エージェント訓練。
+
+    Parameters:
+        env_id: str — Gymnasium 環境 ID (e.g., "CartPole-v1", "LunarLander-v3")
+        algorithm: str — "PPO", "SAC", "A2C", "DQN"
+        total_timesteps: int — 総訓練ステップ数
+        n_envs: int — 並列環境数
+        hyperparams: dict — ハイパーパラメータ override
+
+    K-Dense: stable-baselines3 — RL training framework
+    """
+    algo_map = {"PPO": PPO, "SAC": SAC, "A2C": A2C, "DQN": DQN}
+    AlgoClass = algo_map.get(algorithm, PPO)
+
+    # Vectorized environments
+    env = DummyVecEnv([lambda: gym.make(env_id) for _ in range(n_envs)])
+
+    # Default hyperparams per algorithm
+    default_params = {
+        "PPO": {"learning_rate": 3e-4, "n_steps": 2048, "batch_size": 64},
+        "SAC": {"learning_rate": 3e-4, "buffer_size": 1_000_000},
+        "A2C": {"learning_rate": 7e-4, "n_steps": 5},
+        "DQN": {"learning_rate": 1e-4, "buffer_size": 100_000},
+    }
+    params = default_params.get(algorithm, {})
+    if hyperparams:
+        params.update(hyperparams)
+
+    model = AlgoClass("MlpPolicy", env, verbose=1, **params)
+
+    # Callbacks
+    eval_env = gym.make(env_id)
+    eval_callback = EvalCallback(
+        eval_env, best_model_save_path="./models/best/",
+        log_path="./logs/", eval_freq=10_000,
+    )
+    checkpoint_callback = CheckpointCallback(
+        save_freq=25_000, save_path="./models/checkpoints/",
+    )
+
+    model.learn(
+        total_timesteps=total_timesteps,
+        callback=[eval_callback, checkpoint_callback],
+    )
+
+    # Evaluation
+    mean_reward, std_reward = evaluate_policy(model, eval_env, n_eval_episodes=20)
+    print(f"RL Training ({algorithm} on {env_id}): "
+          f"reward = {mean_reward:.2f} ± {std_reward:.2f}")
+
+    return model, {"mean_reward": mean_reward, "std_reward": std_reward}
+```
+
+## 2. カスタム Gymnasium 環境
+
+```python
+class MoleculeDesignEnv(gym.Env):
+    """
+    分子設計用カスタム RL 環境。
+
+    状態: 分子フィンガープリント (Morgan FP)
+    行動: 原子/結合の追加・削除・変更
+    報酬: 薬物らしさスコア (QED) + 結合親和性予測
+    """
+    metadata = {"render_modes": ["human"]}
+
+    def __init__(self, max_atoms=50, target_property="qed"):
+        super().__init__()
+        self.max_atoms = max_atoms
+        self.target_property = target_property
+
+        # Action space: discrete (add atom types, add bonds, remove)
+        self.action_space = gym.spaces.Discrete(10)
+
+        # Observation space: molecular fingerprint
+        self.observation_space = gym.spaces.Box(
+            low=0, high=1, shape=(2048,), dtype=np.float32,
+        )
+
+        self.current_mol = None
+        self.step_count = 0
+
+    def reset(self, seed=None, options=None):
+        super().reset(seed=seed)
+        self.current_mol = None  # Start from scratch
+        self.step_count = 0
+        obs = np.zeros(2048, dtype=np.float32)
+        return obs, {}
+
+    def step(self, action):
+        self.step_count += 1
+
+        # Apply action to modify molecule
+        reward = self._calculate_reward()
+        terminated = self.step_count >= self.max_atoms
+        truncated = False
+        obs = self._get_observation()
+
+        return obs, reward, terminated, truncated, {}
+
+    def _calculate_reward(self):
+        """Calculate reward based on molecular properties."""
+        if self.current_mol is None:
+            return 0.0
+        # Placeholder: QED score
+        return np.random.uniform(0, 1)
+
+    def _get_observation(self):
+        return np.zeros(2048, dtype=np.float32)
+
+
+def train_molecule_designer(total_timesteps=50_000):
+    """分子設計 RL エージェント訓練。"""
+    env = MoleculeDesignEnv()
+    model = PPO("MlpPolicy", env, verbose=1, learning_rate=1e-4)
+    model.learn(total_timesteps=total_timesteps)
+
+    mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=10)
+    print(f"Molecule Designer: reward = {mean_reward:.2f} ± {std_reward:.2f}")
+    return model
+```
+
+## 3. PufferLib 大規模マルチエージェント
+
+```python
+def setup_pufferlib_training(env_name, num_agents=8, algorithm="PPO"):
+    """
+    PufferLib マルチエージェント RL 設定。
+
+    Parameters:
+        env_name: str — PufferLib 対応環境
+        num_agents: int — エージェント数
+        algorithm: str — "PPO", "IMPALA"
+
+    K-Dense: pufferlib — Scalable multi-agent RL
+    """
+    try:
+        import pufferlib
+        import pufferlib.environments
+
+        config = {
+            "env": env_name,
+            "num_agents": num_agents,
+            "algorithm": algorithm,
+            "total_timesteps": 1_000_000,
+            "batch_size": 256,
+            "learning_rate": 2.5e-4,
+            "num_envs": 16,
+            "num_steps": 128,
+        }
+        print(f"PufferLib config: {config}")
+        return config
+
+    except ImportError:
+        print("PufferLib not installed. Install with: pip install pufferlib")
+        return None
+```
+
+## 4. 実験パラメータ逐次最適化
+
+```python
+def rl_experiment_optimizer(parameter_ranges, objective_fn,
+                            total_episodes=100, algorithm="PPO"):
+    """
+    RL による実験パラメータ逐次最適化。
+
+    Parameters:
+        parameter_ranges: dict — {param_name: (min, max)}
+        objective_fn: callable — 目的関数 (params → score)
+        total_episodes: int — 最適化エピソード数
+    """
+    n_params = len(parameter_ranges)
+    param_names = list(parameter_ranges.keys())
+
+    class ExperimentEnv(gym.Env):
+        def __init__(self):
+            super().__init__()
+            self.action_space = gym.spaces.Box(
+                low=-1, high=1, shape=(n_params,), dtype=np.float32,
+            )
+            self.observation_space = gym.spaces.Box(
+                low=-np.inf, high=np.inf,
+                shape=(n_params + 1,), dtype=np.float32,
+            )
+            self.best_score = -np.inf
+            self.history = []
+
+        def reset(self, seed=None, options=None):
+            super().reset(seed=seed)
+            self.current_params = np.zeros(n_params, dtype=np.float32)
+            return np.zeros(n_params + 1, dtype=np.float32), {}
+
+        def step(self, action):
+            # Scale action to parameter ranges
+            params = {}
+            for i, name in enumerate(param_names):
+                lo, hi = parameter_ranges[name]
+                params[name] = lo + (action[i] + 1) / 2 * (hi - lo)
+
+            score = objective_fn(params)
+            self.history.append({"params": params, "score": score})
+
+            if score > self.best_score:
+                self.best_score = score
+
+            obs = np.append(action, [score]).astype(np.float32)
+            return obs, score, False, False, {}
+
+    env = ExperimentEnv()
+    model = SAC("MlpPolicy", env, verbose=0) if algorithm == "SAC" else PPO("MlpPolicy", env, verbose=0)
+    model.learn(total_timesteps=total_episodes)
+
+    best_idx = max(range(len(env.history)), key=lambda i: env.history[i]["score"])
+    best = env.history[best_idx]
+    print(f"RL Optimization: best score = {best['score']:.4f}")
+    print(f"  Best params: {best['params']}")
+    return best, env.history
+```
+
+---
+
+## パイプライン出力
+
+| 出力ファイル | 説明 | 連携先スキル |
+|---|---|---|
+| `models/rl_model.zip` | 訓練済み RL モデル | → deep-learning (モデル統合) |
+| `results/rl_training_log.json` | 訓練曲線・メトリクス | → publication-figures |
+| `results/rl_optimization.json` | 最適化パラメータ | → doe, process-optimization |
+| `figures/rl_reward_curve.png` | 報酬曲線 | → presentation-design |
+
+## パイプライン統合
+
+```
+doe ──→ reinforcement-learning ──→ lab-automation
+  (実験計画)  (逐次最適化)          (ロボット制御)
+                    │
+                    ├──→ drug-target-profiling (分子設計 RL)
+                    ├──→ protein-design (構造最適化 RL)
+                    └──→ deep-learning (DRL パイプライン)
+```

package/src/.github/skills/scientific-symbolic-mathematics/SKILL.md

@@ -0,0 +1,277 @@
+---
+name: scientific-symbolic-mathematics
+description: |
+  記号数学スキル。SymPy による解析的微積分・線形代数・微分方程式求解、
+  記号式の LaTeX 変換、数値計算との統合、科学モデリング用
+  記号計算パイプライン。
+---
+
+# Scientific Symbolic Mathematics
+
+SymPy を中心とした記号数学 (Computer Algebra System)
+パイプラインを提供する。
+
+## When to Use
+
+- 微分方程式を解析的に解くとき
+- 数式の記号的微分・積分を行うとき
+- 行列の固有値・固有ベクトルを記号的に求めるとき
+- 科学モデルのパラメータに関する感度解析を記号的に行うとき
+- 数式を LaTeX 形式に変換するとき
+- 記号解と数値解を比較検証するとき
+
+---
+
+## Quick Start
+
+## 1. 微分方程式の解析解
+
+```python
+import sympy as sp
+from sympy import (
+    symbols, Function, Eq, dsolve, classify_ode,
+    exp, sin, cos, sqrt, pi, oo, integrate, diff,
+    Matrix, latex, simplify, factor, expand, solve,
+    Rational, Sum, Product, series,
+)
+import numpy as np
+
+
+def solve_ode(ode_expr, dependent_var, independent_var, ics=None):
+    """
+    常微分方程式の解析解。
+
+    Parameters:
+        ode_expr: sympy.Eq — ODE (e.g., Eq(f(x).diff(x, 2) + f(x), 0))
+        dependent_var: sympy.Function — 従属変数
+        independent_var: sympy.Symbol — 独立変数
+        ics: dict — 初期条件 {f(0): 1, f'(0): 0}
+
+    K-Dense: sympy — Symbolic mathematics
+    """
+    # Classify ODE
+    classification = classify_ode(ode_expr, dependent_var(independent_var))
+    print(f"ODE classification: {classification[:3]}")
+
+    # Solve
+    solution = dsolve(ode_expr, dependent_var(independent_var), ics=ics)
+
+    print(f"Solution: {solution}")
+    print(f"LaTeX: {latex(solution)}")
+    return solution
+
+
+# Example: damped harmonic oscillator
+x, t, omega, gamma = symbols("x t omega gamma", positive=True)
+f = Function("f")
+
+# f''(t) + 2γf'(t) + ω²f(t) = 0
+damped_ode = Eq(f(t).diff(t, 2) + 2*gamma*f(t).diff(t) + omega**2*f(t), 0)
+```
+
+## 2. 記号的微積分
+
+```python
+def symbolic_calculus(expr, var, operations=None):
+    """
+    記号的微積分操作。
+
+    Parameters:
+        expr: sympy expression — 数式
+        var: sympy.Symbol — 変数
+        operations: list — ["diff", "integrate", "series", "limit"]
+    """
+    if operations is None:
+        operations = ["diff", "integrate"]
+
+    results = {}
+
+    if "diff" in operations:
+        deriv = diff(expr, var)
+        results["derivative"] = {"expr": deriv, "latex": latex(deriv)}
+        print(f"d/d{var}({expr}) = {deriv}")
+
+    if "integrate" in operations:
+        integral = integrate(expr, var)
+        results["integral"] = {"expr": integral, "latex": latex(integral)}
+        print(f"∫{expr} d{var} = {integral}")
+
+    if "series" in operations:
+        ser = series(expr, var, 0, n=6)
+        results["series"] = {"expr": ser, "latex": latex(ser)}
+        print(f"Taylor series: {ser}")
+
+    if "limit" in operations:
+        from sympy import limit as sp_limit
+        lim = sp_limit(expr, var, oo)
+        results["limit"] = {"expr": lim, "latex": latex(lim)}
+        print(f"lim({var}→∞) {expr} = {lim}")
+
+    return results
+```
+
+## 3. 線形代数 (記号的)
+
+```python
+def symbolic_linear_algebra(matrix_data):
+    """
+    記号的線形代数 — 固有値・固有ベクトル・行列分解。
+
+    Parameters:
+        matrix_data: list of lists — 行列要素 (記号含む)
+    """
+    M = Matrix(matrix_data)
+    print(f"Matrix ({M.rows}×{M.cols}):")
+    sp.pprint(M)
+
+    results = {}
+
+    # Determinant
+    det = M.det()
+    results["determinant"] = {"expr": det, "latex": latex(det)}
+    print(f"\nDeterminant: {det}")
+
+    # Eigenvalues & eigenvectors
+    eigenvals = M.eigenvals()
+    results["eigenvalues"] = {str(k): v for k, v in eigenvals.items()}
+    print(f"Eigenvalues: {eigenvals}")
+
+    eigenvects = M.eigenvects()
+    results["eigenvectors"] = [
+        {"eigenvalue": str(ev[0]), "multiplicity": ev[1],
+         "vectors": [str(v) for v in ev[2]]}
+        for ev in eigenvects
+    ]
+
+    # Characteristic polynomial
+    lam = symbols("lambda")
+    char_poly = M.charpoly(lam)
+    results["characteristic_polynomial"] = {
+        "expr": str(char_poly.as_expr()),
+        "latex": latex(char_poly.as_expr()),
+    }
+    print(f"Characteristic polynomial: {char_poly.as_expr()}")
+
+    # Inverse (if nonsingular)
+    if det != 0:
+        inv = M.inv()
+        results["inverse"] = {"latex": latex(inv)}
+        print(f"Inverse exists: {M.rows}×{M.cols}")
+
+    return results
+```
+
+## 4. 科学モデリング (薬物動態学 PK モデル例)
+
+```python
+def pk_compartment_model(n_compartments=1):
+    """
+    薬物動態学コンパートメントモデルの記号的解法。
+
+    Parameters:
+        n_compartments: int — 1 (1-compartment) or 2 (2-compartment)
+    """
+    t = symbols("t", positive=True)
+
+    if n_compartments == 1:
+        # 1-compartment: dC/dt = -ke * C
+        C = Function("C")
+        ke, C0 = symbols("k_e C_0", positive=True)
+        ode = Eq(C(t).diff(t), -ke * C(t))
+        solution = dsolve(ode, C(t), ics={C(0): C0})
+
+        # Half-life
+        t_half = sp.solve(Eq(solution.rhs, C0/2), t)[0]
+
+        # AUC (0→∞)
+        auc = integrate(solution.rhs, (t, 0, oo))
+
+        result = {
+            "model": "1-compartment IV bolus",
+            "ode": latex(ode),
+            "solution": latex(solution),
+            "half_life": latex(t_half),
+            "auc_inf": latex(auc),
+        }
+        print(f"PK 1-compartment: C(t) = {solution.rhs}")
+        print(f"  t½ = {t_half}")
+        print(f"  AUC(0→∞) = {auc}")
+
+    elif n_compartments == 2:
+        # 2-compartment model
+        C1, C2 = Function("C1"), Function("C2")
+        k10, k12, k21, D, V1 = symbols("k_10 k_12 k_21 D V_1", positive=True)
+
+        ode1 = Eq(C1(t).diff(t), -(k10 + k12)*C1(t) + k21*C2(t))
+        ode2 = Eq(C2(t).diff(t), k12*C1(t) - k21*C2(t))
+
+        system = [ode1, ode2]
+        solution = sp.dsolve(system, [C1(t), C2(t)])
+
+        result = {
+            "model": "2-compartment IV bolus",
+            "system": [latex(eq) for eq in system],
+            "solution": [latex(sol) for sol in solution],
+        }
+        print(f"PK 2-compartment system defined")
+        for sol in solution:
+            print(f"  {sol}")
+
+    return result
+```
+
+## 5. LaTeX 数式エクスポート
+
+```python
+def export_equations_latex(equations, output_file="equations.tex"):
+    """
+    記号数式を LaTeX ファイルにエクスポート。
+
+    Parameters:
+        equations: dict — {name: sympy_expr}
+        output_file: str — 出力 LaTeX パス
+    """
+    lines = [
+        r"\documentclass{article}",
+        r"\usepackage{amsmath,amssymb}",
+        r"\begin{document}",
+        "",
+    ]
+
+    for name, expr in equations.items():
+        lines.append(f"% {name}")
+        lines.append(r"\begin{equation}")
+        lines.append(f"  {latex(expr)}")
+        lines.append(r"\end{equation}")
+        lines.append("")
+
+    lines.append(r"\end{document}")
+
+    with open(output_file, "w") as f:
+        f.write("\n".join(lines))
+
+    print(f"LaTeX exported: {output_file} ({len(equations)} equations)")
+    return output_file
+```
+
+---
+
+## パイプライン出力
+
+| 出力ファイル | 説明 | 連携先スキル |
+|---|---|---|
+| `results/symbolic_solutions.json` | 記号解 (LaTeX 形式) | → latex-formatter, academic-writing |
+| `results/ode_solutions.json` | ODE 解析解 | → systems-biology, admet-pharmacokinetics |
+| `equations.tex` | LaTeX 数式集 | → latex-formatter |
+| `figures/symbolic_plot.png` | 記号解の可視化 | → publication-figures |
+
+## パイプライン統合
+
+```
+systems-biology ──→ symbolic-mathematics ──→ latex-formatter
+  (SBML/ODE)         (SymPy 解析解)         (LaTeX 変換)
+                           │
+                           ├──→ admet-pharmacokinetics (PK モデル)
+                           ├──→ bayesian-statistics (尤度導出)
+                           └──→ computational-materials (バンド理論)
+```