@nahisaho/satori 0.24.0 → 0.25.1

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

@@ -0,0 +1,241 @@
+---
+name: scientific-federated-learning
+description: |
+  連合学習スキル。Flower フレームワークによる FL パイプライン・
+  FedAvg/FedProx/FedOpt 集約戦略・差分プライバシー (DP-SGD)・
+  非 IID データ分割・通信効率化。
+---
+
+# Scientific Federated Learning
+
+プライバシー保護型分散機械学習を実現する連合学習パイプラインを提供する。
+
+## When to Use
+
+- 複数施設・組織のデータを集約せずにモデル学習するとき
+- 医療データ・個人情報を含むデータで ML を行うとき
+- 差分プライバシーを適用した学習が必要なとき
+- 非 IID データ分割下での連合学習を設計するとき
+- 通信効率を考慮した分散学習を構築するとき
+
+---
+
+## Quick Start
+
+## 1. Flower 連合学習パイプライン
+
+```python
+import flwr as fl
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+
+
+def create_fl_client(model, train_loader, val_loader,
+                     device="cpu"):
+    """
+    Flower クライアント生成。
+
+    Parameters:
+        model: nn.Module — PyTorch モデル
+        train_loader: DataLoader — 訓練データ
+        val_loader: DataLoader — 検証データ
+        device: str — "cpu" / "cuda"
+    """
+    import torch
+
+    class SatoriFlClient(fl.client.NumPyClient):
+        def get_parameters(self, config):
+            return [val.cpu().numpy()
+                    for val in model.parameters()]
+
+        def set_parameters(self, parameters):
+            for param, new_val in zip(model.parameters(), parameters):
+                param.data = torch.tensor(new_val).to(device)
+
+        def fit(self, parameters, config):
+            self.set_parameters(parameters)
+            model.train()
+            optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
+            criterion = torch.nn.CrossEntropyLoss()
+
+            epochs = config.get("local_epochs", 1)
+            for _ in range(epochs):
+                for X, y in train_loader:
+                    X, y = X.to(device), y.to(device)
+                    optimizer.zero_grad()
+                    loss = criterion(model(X), y)
+                    loss.backward()
+                    optimizer.step()
+
+            return self.get_parameters(config), len(train_loader.dataset), {}
+
+        def evaluate(self, parameters, config):
+            self.set_parameters(parameters)
+            model.eval()
+            criterion = torch.nn.CrossEntropyLoss()
+            total_loss, correct, total = 0.0, 0, 0
+
+            with torch.no_grad():
+                for X, y in val_loader:
+                    X, y = X.to(device), y.to(device)
+                    preds = model(X)
+                    total_loss += criterion(preds, y).item() * len(y)
+                    correct += (preds.argmax(1) == y).sum().item()
+                    total += len(y)
+
+            return total_loss / total, total, {"accuracy": correct / total}
+
+    return SatoriFlClient()
+
+
+def create_fl_strategy(algorithm="fedavg", min_clients=2,
+                       fraction_fit=1.0, fraction_evaluate=1.0,
+                       proximal_mu=0.1):
+    """
+    連合学習集約戦略の選択。
+
+    Parameters:
+        algorithm: str — "fedavg" / "fedprox" / "fedopt" / "fedadam"
+        min_clients: int — 最小クライアント数
+        fraction_fit: float — 学習参加率
+        fraction_evaluate: float — 評価参加率
+        proximal_mu: float — FedProx 近接項の強度
+    """
+    common = dict(
+        min_fit_clients=min_clients,
+        min_evaluate_clients=min_clients,
+        min_available_clients=min_clients,
+        fraction_fit=fraction_fit,
+        fraction_evaluate=fraction_evaluate,
+    )
+
+    strategies = {
+        "fedavg": fl.server.strategy.FedAvg(**common),
+        "fedprox": fl.server.strategy.FedProx(
+            proximal_mu=proximal_mu, **common),
+        "fedadam": fl.server.strategy.FedAdam(
+            eta=1e-1, eta_l=1e-1, tau=1e-9, **common),
+    }
+
+    strategy = strategies.get(algorithm, strategies["fedavg"])
+    print(f"FL Strategy: {algorithm} | min_clients={min_clients}")
+    return strategy
+```
+
+## 2. 差分プライバシー (DP-SGD)
+
+```python
+def apply_differential_privacy(model, train_loader,
+                               target_epsilon=1.0,
+                               target_delta=1e-5,
+                               max_grad_norm=1.0,
+                               noise_multiplier=1.1,
+                               epochs=10, lr=1e-3):
+    """
+    Opacus DP-SGD による差分プライバシー学習。
+
+    Parameters:
+        model: nn.Module — PyTorch モデル
+        train_loader: DataLoader — 訓練データ
+        target_epsilon: float — プライバシーバジェット ε
+        target_delta: float — プライバシーパラメータ δ
+        max_grad_norm: float — 勾配クリッピングノルム
+        noise_multiplier: float — ノイズ乗数 σ
+        epochs: int — 学習エポック数
+        lr: float — 学習率
+    """
+    import torch
+    from opacus import PrivacyEngine
+
+    optimizer = torch.optim.SGD(model.parameters(), lr=lr)
+    privacy_engine = PrivacyEngine()
+
+    model, optimizer, train_loader = privacy_engine.make_private_with_epsilon(
+        module=model,
+        optimizer=optimizer,
+        data_loader=train_loader,
+        epochs=epochs,
+        target_epsilon=target_epsilon,
+        target_delta=target_delta,
+        max_grad_norm=max_grad_norm,
+    )
+
+    criterion = torch.nn.CrossEntropyLoss()
+    history = []
+
+    for epoch in range(epochs):
+        model.train()
+        total_loss = 0
+        for X, y in train_loader:
+            optimizer.zero_grad()
+            loss = criterion(model(X), y)
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+
+        epsilon = privacy_engine.get_epsilon(delta=target_delta)
+        history.append({"epoch": epoch + 1,
+                        "loss": total_loss / len(train_loader),
+                        "epsilon": epsilon})
+        print(f"Epoch {epoch+1}: loss={total_loss/len(train_loader):.4f}, "
+              f"ε={epsilon:.2f}")
+
+    import pandas as pd
+    return pd.DataFrame(history)
+```
+
+## 3. 非 IID データ分割
+
+```python
+def create_non_iid_splits(dataset_labels, n_clients=5,
+                          alpha=0.5, seed=42):
+    """
+    Dirichlet 分布ベースの非 IID データ分割。
+
+    Parameters:
+        dataset_labels: np.ndarray — 全データのラベル配列
+        n_clients: int — クライアント数
+        alpha: float — Dirichlet α (小さいほど偏りが大きい)
+        seed: int — 乱数シード
+    """
+    rng = np.random.default_rng(seed)
+    n_classes = len(np.unique(dataset_labels))
+    client_indices = [[] for _ in range(n_clients)]
+
+    for c in range(n_classes):
+        class_idx = np.where(dataset_labels == c)[0]
+        proportions = rng.dirichlet(np.repeat(alpha, n_clients))
+        split_points = (np.cumsum(proportions) * len(class_idx)).astype(int)
+        splits = np.split(class_idx, split_points[:-1])
+        for i, split in enumerate(splits):
+            client_indices[i].extend(split.tolist())
+
+    # 分布サマリー
+    for i, indices in enumerate(client_indices):
+        labels = dataset_labels[indices]
+        unique, counts = np.unique(labels, return_counts=True)
+        dist = dict(zip(unique.tolist(), counts.tolist()))
+        print(f"Client {i}: {len(indices)} samples, dist={dist}")
+
+    return client_indices
+```
+
+---
+
+## パイプライン統合
+
+```
+[プライバシー要件] → federated-learning → model-monitoring
+                      (連合学習)              (モデル監視)
+                           │
+                    deep-learning ← transfer-learning
+                      (基盤 NN)       (転移学習)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `fl_strategy_config.json` | FL 集約設定 | → サーバー起動 |
+| `dp_training_history.csv` | DP 学習履歴 | → model-monitoring |
+| `client_splits.json` | 非 IID 分割情報 | → FL クライアント |

package/src/.github/skills/scientific-multi-task-learning/SKILL.md

@@ -0,0 +1,238 @@
+---
+name: scientific-multi-task-learning
+description: |
+  マルチタスク学習スキル。Hard/Soft Parameter Sharing・
+  GradNorm 勾配正規化・PCGrad 勾配投影・
+  タスクバランシング・補助タスク設計。
+---
+
+# Scientific Multi-Task Learning
+
+複数の関連タスクを同時に学習し、共有表現を活用して
+各タスクの汎化性能を向上させるパイプラインを提供する。
+
+## When to Use
+
+- 複数の関連予測タスクを同時に実行するとき
+- 共有表現を学習してデータ効率を高めたいとき
+- 主タスク + 補助タスクの構成で学習するとき
+- タスク間の勾配干渉を解消するとき
+- マルチ出力回帰・分類を設計するとき
+
+---
+
+## Quick Start
+
+## 1. Hard Parameter Sharing MTL
+
+```python
+import torch
+import torch.nn as nn
+from typing import Dict, List, Tuple
+
+
+class HardSharingMTL(nn.Module):
+    """
+    Hard Parameter Sharing マルチタスクモデル。
+
+    共有エンコーダ + タスク別ヘッドの構成。
+    """
+
+    def __init__(self, input_dim, shared_dims, task_configs):
+        """
+        Parameters:
+            input_dim: int — 入力次元
+            shared_dims: list[int] — 共有層のユニット数
+            task_configs: dict — {task_name: {"output_dim": int, "head_dims": [int]}}
+        """
+        super().__init__()
+
+        # 共有エンコーダ
+        layers = []
+        in_d = input_dim
+        for d in shared_dims:
+            layers.extend([nn.Linear(in_d, d), nn.ReLU(),
+                           nn.BatchNorm1d(d), nn.Dropout(0.2)])
+            in_d = d
+        self.shared_encoder = nn.Sequential(*layers)
+
+        # タスク別ヘッド
+        self.task_heads = nn.ModuleDict()
+        for name, config in task_configs.items():
+            head_layers = []
+            h_in = in_d
+            for h_d in config.get("head_dims", [64]):
+                head_layers.extend([nn.Linear(h_in, h_d), nn.ReLU()])
+                h_in = h_d
+            head_layers.append(nn.Linear(h_in, config["output_dim"]))
+            self.task_heads[name] = nn.Sequential(*head_layers)
+
+    def forward(self, x):
+        shared = self.shared_encoder(x)
+        return {name: head(shared) for name, head in self.task_heads.items()}
+
+
+def train_mtl_model(model, train_loader, task_losses,
+                    task_weights=None, epochs=50,
+                    lr=1e-3, device="cpu"):
+    """
+    MTL モデルの学習。
+
+    Parameters:
+        model: HardSharingMTL — MTL モデル
+        train_loader: DataLoader — {task_name: (X, y)} バッチ
+        task_losses: dict — {task_name: loss_fn}
+        task_weights: dict | None — {task_name: float} タスク重み
+        epochs: int — 学習エポック数
+        lr: float — 学習率
+        device: str — デバイス
+    """
+    import pandas as pd
+
+    if task_weights is None:
+        task_weights = {name: 1.0 for name in task_losses}
+
+    model.to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    history = []
+
+    for epoch in range(epochs):
+        model.train()
+        epoch_losses = {name: 0.0 for name in task_losses}
+
+        for batch in train_loader:
+            X = batch["X"].to(device)
+            outputs = model(X)
+            optimizer.zero_grad()
+
+            total_loss = 0
+            for name, loss_fn in task_losses.items():
+                y = batch[name].to(device)
+                task_loss = loss_fn(outputs[name], y)
+                total_loss += task_weights[name] * task_loss
+                epoch_losses[name] += task_loss.item()
+
+            total_loss.backward()
+            optimizer.step()
+
+        record = {"epoch": epoch + 1}
+        for name in task_losses:
+            record[f"loss_{name}"] = epoch_losses[name] / len(train_loader)
+        history.append(record)
+
+        if (epoch + 1) % 10 == 0:
+            losses_str = " | ".join(
+                f"{n}={epoch_losses[n]/len(train_loader):.4f}"
+                for n in task_losses)
+            print(f"Epoch {epoch+1}: {losses_str}")
+
+    return pd.DataFrame(history)
+```
+
+## 2. GradNorm — 動的タスクバランシング
+
+```python
+def gradnorm_balance(model, task_losses, train_loader,
+                     alpha=1.5, epochs=50, lr=1e-3, device="cpu"):
+    """
+    GradNorm による動的タスク重みバランシング。
+
+    Parameters:
+        model: HardSharingMTL — MTL モデル
+        task_losses: dict — {task_name: loss_fn}
+        train_loader: DataLoader
+        alpha: float — GradNorm 非対称度パラメータ
+        epochs: int — 学習エポック
+        lr: float — 学習率
+        device: str — デバイス
+    """
+    import pandas as pd
+
+    task_names = list(task_losses.keys())
+    n_tasks = len(task_names)
+    log_weights = torch.zeros(n_tasks, requires_grad=True, device=device)
+
+    model.to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    weight_optimizer = torch.optim.Adam([log_weights], lr=0.025)
+
+    initial_losses = None
+    history = []
+
+    for epoch in range(epochs):
+        model.train()
+        epoch_losses = {n: 0.0 for n in task_names}
+
+        for batch in train_loader:
+            X = batch["X"].to(device)
+            outputs = model(X)
+
+            weights = torch.softmax(log_weights, dim=0) * n_tasks
+            losses = []
+            for i, name in enumerate(task_names):
+                y = batch[name].to(device)
+                task_loss = task_losses[name](outputs[name], y)
+                losses.append(task_loss)
+                epoch_losses[name] += task_loss.item()
+
+            if initial_losses is None:
+                initial_losses = [l.item() for l in losses]
+
+            total_loss = sum(w * l for w, l in zip(weights, losses))
+
+            optimizer.zero_grad()
+            weight_optimizer.zero_grad()
+            total_loss.backward(retain_graph=True)
+
+            # GradNorm 更新
+            shared_params = list(model.shared_encoder.parameters())
+            norms = []
+            for l in losses:
+                g = torch.autograd.grad(l, shared_params[-1],
+                                        retain_graph=True)[0]
+                norms.append(torch.norm(g))
+
+            avg_norm = torch.stack(norms).mean()
+            loss_ratios = torch.tensor(
+                [l.item() / il for l, il in
+                 zip(losses, initial_losses)], device=device)
+            relative_inv = loss_ratios / loss_ratios.mean()
+            target_norms = avg_norm * (relative_inv ** alpha)
+
+            gradnorm_loss = sum(
+                torch.abs(n - t) for n, t in
+                zip(norms, target_norms))
+            gradnorm_loss.backward()
+
+            optimizer.step()
+            weight_optimizer.step()
+
+        record = {"epoch": epoch + 1}
+        for i, name in enumerate(task_names):
+            record[f"loss_{name}"] = epoch_losses[name] / len(train_loader)
+            record[f"weight_{name}"] = (
+                torch.softmax(log_weights, 0) * n_tasks)[i].item()
+        history.append(record)
+
+    return pd.DataFrame(history)
+```
+
+---
+
+## パイプライン統合
+
+```
+[複数タスク定義] → multi-task-learning → feature-importance
+                     (共有表現学習)        (特徴量解釈)
+                          │
+                   deep-learning ← transfer-learning
+                    (基盤 NN)        (転移学習)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `mtl_model.pt` | MTL モデル | → 推論 |
+| `mtl_history.csv` | タスク別学習履歴 | → 可視化 |
+| `gradnorm_weights.csv` | 動的タスク重み推移 | → バランシング分析 |

package/src/.github/skills/scientific-neural-architecture-search/SKILL.md

@@ -0,0 +1,206 @@
+---
+name: scientific-neural-architecture-search
+description: |
+  ニューラルアーキテクチャ探索 (NAS) スキル。DARTS 微分可能 NAS・
+  Optuna NAS 統合・効率的ネットワーク設計・探索空間定義・
+  Pareto 最適化 (精度 vs FLOPS)。
+---
+
+# Scientific Neural Architecture Search
+
+ニューラルネットワーク構造の自動探索・最適化パイプラインを提供する。
+
+## When to Use
+
+- NN アーキテクチャを自動的に最適化したいとき
+- 精度と計算コストの Pareto 最適解を探索するとき
+- 探索空間を定義して効率的な構造探索を行うとき
+- DARTS 系の微分可能 NAS を実装するとき
+- モデル圧縮・効率化を自動化するとき
+
+---
+
+## Quick Start
+
+## 1. Optuna NAS — ネットワーク構造探索
+
+```python
+import optuna
+import torch
+import torch.nn as nn
+from typing import Dict, Any
+
+
+def optuna_nas(train_loader, val_loader, search_space=None,
+               n_trials=50, n_epochs=10, device="cpu",
+               direction="maximize", metric="accuracy"):
+    """
+    Optuna によるニューラルアーキテクチャ探索。
+
+    Parameters:
+        train_loader: DataLoader — 訓練データ
+        val_loader: DataLoader — 検証データ
+        search_space: dict | None — カスタム探索空間
+        n_trials: int — 試行回数
+        n_epochs: int — 各試行の学習エポック数
+        device: str — "cpu" / "cuda"
+        direction: str — "maximize" / "minimize"
+        metric: str — 最適化指標名
+    """
+    input_dim = next(iter(train_loader))[0].shape[1]
+    n_classes = len(torch.unique(
+        torch.cat([y for _, y in train_loader])))
+
+    def build_model(trial):
+        n_layers = trial.suggest_int("n_layers", 1, 5)
+        layers = []
+        in_features = input_dim
+
+        for i in range(n_layers):
+            out_features = trial.suggest_int(
+                f"n_units_l{i}", 16, 512, log=True)
+            layers.append(nn.Linear(in_features, out_features))
+
+            activation = trial.suggest_categorical(
+                f"activation_l{i}", ["relu", "gelu", "silu"])
+            act_map = {"relu": nn.ReLU(), "gelu": nn.GELU(),
+                       "silu": nn.SiLU()}
+            layers.append(act_map[activation])
+
+            dropout = trial.suggest_float(
+                f"dropout_l{i}", 0.0, 0.5)
+            if dropout > 0:
+                layers.append(nn.Dropout(dropout))
+
+            use_bn = trial.suggest_categorical(
+                f"batchnorm_l{i}", [True, False])
+            if use_bn:
+                layers.append(nn.BatchNorm1d(out_features))
+
+            in_features = out_features
+
+        layers.append(nn.Linear(in_features, n_classes))
+        return nn.Sequential(*layers)
+
+    def objective(trial):
+        model = build_model(trial).to(device)
+        lr = trial.suggest_float("lr", 1e-5, 1e-1, log=True)
+        optimizer_name = trial.suggest_categorical(
+            "optimizer", ["Adam", "AdamW", "SGD"])
+
+        opt_cls = getattr(torch.optim, optimizer_name)
+        optimizer = opt_cls(model.parameters(), lr=lr)
+        criterion = nn.CrossEntropyLoss()
+
+        for epoch in range(n_epochs):
+            model.train()
+            for X, y in train_loader:
+                X, y = X.to(device), y.to(device)
+                optimizer.zero_grad()
+                loss = criterion(model(X), y)
+                loss.backward()
+                optimizer.step()
+
+            # 枝刈り
+            model.eval()
+            correct, total = 0, 0
+            with torch.no_grad():
+                for X, y in val_loader:
+                    X, y = X.to(device), y.to(device)
+                    correct += (model(X).argmax(1) == y).sum().item()
+                    total += len(y)
+
+            trial.report(correct / total, epoch)
+            if trial.should_prune():
+                raise optuna.TrialPruned()
+
+        return correct / total
+
+    study = optuna.create_study(
+        direction=direction,
+        pruner=optuna.pruners.MedianPruner(n_warmup_steps=3))
+    study.optimize(objective, n_trials=n_trials)
+
+    print(f"Best {metric}: {study.best_value:.4f}")
+    print(f"Best params: {study.best_params}")
+    return study
+
+
+def nas_pareto_search(train_loader, val_loader,
+                      n_trials=100, device="cpu"):
+    """
+    多目的 NAS — 精度 vs モデルサイズの Pareto 最適化。
+
+    Parameters:
+        train_loader: DataLoader — 訓練データ
+        val_loader: DataLoader — 検証データ
+        n_trials: int — 試行回数
+        device: str — デバイス
+    """
+
+    def objective(trial):
+        n_layers = trial.suggest_int("n_layers", 1, 4)
+        total_params = 0
+        in_f = next(iter(train_loader))[0].shape[1]
+        n_classes = len(torch.unique(
+            torch.cat([y for _, y in val_loader])))
+
+        layers = []
+        for i in range(n_layers):
+            out_f = trial.suggest_int(f"units_{i}", 8, 256, log=True)
+            layers.append(nn.Linear(in_f, out_f))
+            layers.append(nn.ReLU())
+            total_params += in_f * out_f + out_f
+            in_f = out_f
+        layers.append(nn.Linear(in_f, n_classes))
+        total_params += in_f * n_classes + n_classes
+
+        model = nn.Sequential(*layers).to(device)
+        optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
+        criterion = nn.CrossEntropyLoss()
+
+        for _ in range(5):
+            model.train()
+            for X, y in train_loader:
+                X, y = X.to(device), y.to(device)
+                optimizer.zero_grad()
+                criterion(model(X), y).backward()
+                optimizer.step()
+
+        model.eval()
+        correct, total = 0, 0
+        with torch.no_grad():
+            for X, y in val_loader:
+                X, y = X.to(device), y.to(device)
+                correct += (model(X).argmax(1) == y).sum().item()
+                total += len(y)
+
+        return correct / total, total_params
+
+    study = optuna.create_study(
+        directions=["maximize", "minimize"])
+    study.optimize(objective, n_trials=n_trials)
+
+    print(f"Pareto front: {len(study.best_trials)} solutions")
+    return study
+```
+
+---
+
+## パイプライン統合
+
+```
+[タスク定義] → neural-architecture-search → deep-learning
+                     (構造探索)                 (本格学習)
+                          │
+                   automl ← ensemble-methods
+                  (HPO)      (アンサンブル)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `nas_study.pkl` | Optuna Study | → 最良構造抽出 |
+| `pareto_front.csv` | Pareto 最適解群 | → モデル選択 |
+| `best_architecture.json` | 最良アーキテクチャ | → deep-learning |