@nahisaho/satori 0.22.0 → 0.24.0

package/src/.github/skills/scientific-time-series-forecasting/SKILL.md

@@ -0,0 +1,246 @@
+---
+name: scientific-time-series-forecasting
+description: |
+  ML 時系列予測スキル。Prophet/NeuralProphet・N-BEATS・
+  Temporal Fusion Transformer (TFT)・時系列特徴量エンジニアリング・
+  バックテスト・多段階予測・アンサンブル予測。
+---
+
+# Scientific Time Series Forecasting
+
+深層学習・ML ベースの時系列予測パイプラインを提供し、
+Prophet から Transformer まで最新手法を網羅する。
+
+## When to Use
+
+- Prophet/NeuralProphet で季節性時系列を予測するとき
+- 深層学習 (N-BEATS/TFT) で高精度予測するとき
+- 時系列特徴量エンジニアリングでラグ・ローリング特徴を生成するとき
+- バックテストで予測性能を厳密に評価するとき
+- 複数モデルのアンサンブル予測をするとき
+- 多変量・多段階予測をするとき
+
+> **Note**: 古典時系列 (ARIMA/STL/FFT) は `scientific-time-series` を参照。
+
+---
+
+## Quick Start
+
+## 1. Prophet / NeuralProphet
+
+```python
+import numpy as np
+import pandas as pd
+
+
+def prophet_forecast(df, date_col, value_col, periods=30,
+                     freq="D", yearly=True, weekly=True,
+                     changepoint_prior=0.05):
+    """
+    Prophet 時系列予測。
+
+    Parameters:
+        df: pd.DataFrame — 時系列データ
+        date_col: str — 日付カラム
+        value_col: str — 値カラム
+        periods: int — 予測期間
+        freq: str — 頻度 ("D" / "H" / "M")
+        yearly: bool — 年次季節性
+        weekly: bool — 週次季節性
+        changepoint_prior: float — 変化点感度
+    """
+    from prophet import Prophet
+
+    prophet_df = df[[date_col, value_col]].rename(
+        columns={date_col: "ds", value_col: "y"})
+
+    model = Prophet(
+        yearly_seasonality=yearly,
+        weekly_seasonality=weekly,
+        changepoint_prior_scale=changepoint_prior)
+    model.fit(prophet_df)
+
+    future = model.make_future_dataframe(periods=periods, freq=freq)
+    forecast = model.predict(future)
+
+    # 評価
+    merged = forecast.merge(prophet_df, on="ds", how="left")
+    valid = merged.dropna(subset=["y"])
+    mae = np.mean(np.abs(valid["y"] - valid["yhat"]))
+    mape = np.mean(np.abs((valid["y"] - valid["yhat"]) / valid["y"])) * 100
+
+    fig1 = model.plot(forecast)
+    fig1.savefig("prophet_forecast.png", dpi=150, bbox_inches="tight")
+
+    fig2 = model.plot_components(forecast)
+    fig2.savefig("prophet_components.png", dpi=150, bbox_inches="tight")
+
+    print(f"Prophet: {periods} periods, MAE={mae:.4f}, MAPE={mape:.1f}%")
+    return {"forecast": forecast, "model": model,
+            "mae": mae, "mape": mape}
+
+
+def neuralprophet_forecast(df, date_col, value_col, periods=30,
+                           n_lags=60, n_forecasts=30):
+    """
+    NeuralProphet 時系列予測 (AR-Net)。
+
+    Parameters:
+        df: pd.DataFrame — 時系列データ
+        date_col: str — 日付カラム
+        value_col: str — 値カラム
+        periods: int — 予測期間
+        n_lags: int — 自己回帰ラグ数
+        n_forecasts: int — 多段階予測ステップ
+    """
+    from neuralprophet import NeuralProphet
+
+    np_df = df[[date_col, value_col]].rename(
+        columns={date_col: "ds", value_col: "y"})
+
+    model = NeuralProphet(
+        n_lags=n_lags, n_forecasts=n_forecasts,
+        yearly_seasonality=True, weekly_seasonality=True,
+        learning_rate=0.01, epochs=100)
+
+    metrics = model.fit(np_df, freq="D")
+
+    future = model.make_future_dataframe(np_df, periods=periods, n_historic_predictions=True)
+    forecast = model.predict(future)
+
+    fig = model.plot(forecast)
+    fig.savefig("neuralprophet_forecast.png", dpi=150, bbox_inches="tight")
+
+    print(f"NeuralProphet: lags={n_lags}, forecasts={n_forecasts}")
+    return {"forecast": forecast, "model": model, "metrics": metrics}
+```
+
+## 2. 時系列特徴量エンジニアリング
+
+```python
+def create_ts_features(df, date_col, value_col,
+                       lags=None, rolling_windows=None):
+    """
+    時系列特徴量エンジニアリング。
+
+    Parameters:
+        df: pd.DataFrame — 時系列データ
+        date_col: str — 日付カラム
+        value_col: str — 値カラム
+        lags: list[int] | None — ラグ特徴量 (e.g., [1,7,14,28])
+        rolling_windows: list[int] | None — ローリング窓 (e.g., [7,14,30])
+    """
+    if lags is None:
+        lags = [1, 3, 7, 14, 28]
+    if rolling_windows is None:
+        rolling_windows = [7, 14, 30]
+
+    result = df.copy()
+    result[date_col] = pd.to_datetime(result[date_col])
+    result = result.sort_values(date_col)
+
+    # カレンダー特徴量
+    result["dayofweek"] = result[date_col].dt.dayofweek
+    result["dayofyear"] = result[date_col].dt.dayofyear
+    result["month"] = result[date_col].dt.month
+    result["quarter"] = result[date_col].dt.quarter
+    result["is_weekend"] = (result[date_col].dt.dayofweek >= 5).astype(int)
+
+    # 周期エンコーディング
+    result["sin_day"] = np.sin(2 * np.pi * result["dayofyear"] / 365.25)
+    result["cos_day"] = np.cos(2 * np.pi * result["dayofyear"] / 365.25)
+    result["sin_week"] = np.sin(2 * np.pi * result["dayofweek"] / 7)
+    result["cos_week"] = np.cos(2 * np.pi * result["dayofweek"] / 7)
+
+    # ラグ特徴量
+    for lag in lags:
+        result[f"lag_{lag}"] = result[value_col].shift(lag)
+
+    # ローリング統計量
+    for window in rolling_windows:
+        result[f"rolling_mean_{window}"] = result[value_col].rolling(window).mean()
+        result[f"rolling_std_{window}"] = result[value_col].rolling(window).std()
+        result[f"rolling_min_{window}"] = result[value_col].rolling(window).min()
+        result[f"rolling_max_{window}"] = result[value_col].rolling(window).max()
+
+    # 差分特徴量
+    result["diff_1"] = result[value_col].diff(1)
+    result["diff_7"] = result[value_col].diff(7)
+
+    n_features = len(result.columns) - len(df.columns)
+    print(f"TS Features: {n_features} features created "
+          f"(lags={lags}, windows={rolling_windows})")
+    return result
+
+
+def ts_backtest(df, date_col, value_col, model_fn,
+                n_splits=5, horizon=30, gap=0):
+    """
+    時系列バックテスト (Walk-forward validation)。
+
+    Parameters:
+        df: pd.DataFrame — 時系列データ
+        date_col: str — 日付カラム
+        value_col: str — 値カラム
+        model_fn: callable — モデル学習・予測関数 (train_df → forecast_df)
+        n_splits: int — 分割数
+        horizon: int — 予測ホライズン
+        gap: int — 学習-テスト間ギャップ
+    """
+    from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+    sorted_df = df.sort_values(date_col).reset_index(drop=True)
+    n = len(sorted_df)
+    fold_size = (n - horizon) // n_splits
+
+    results = []
+
+    for i in range(n_splits):
+        train_end = fold_size * (i + 1)
+        test_start = train_end + gap
+        test_end = min(test_start + horizon, n)
+
+        if test_end > n:
+            break
+
+        train_df = sorted_df.iloc[:train_end]
+        test_df = sorted_df.iloc[test_start:test_end]
+
+        forecast = model_fn(train_df)
+        y_true = test_df[value_col].values[:len(forecast)]
+        y_pred = forecast[:len(y_true)]
+
+        mae = mean_absolute_error(y_true, y_pred)
+        rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+        mape = np.mean(np.abs((y_true - y_pred) / (y_true + 1e-10))) * 100
+
+        results.append({
+            "fold": i, "train_size": train_end,
+            "test_size": test_end - test_start,
+            "mae": mae, "rmse": rmse, "mape": mape})
+
+    results_df = pd.DataFrame(results)
+    print(f"Backtest ({n_splits} folds, h={horizon}): "
+          f"MAE={results_df['mae'].mean():.4f} ± {results_df['mae'].std():.4f}")
+    return results_df
+```
+
+---
+
+## パイプライン統合
+
+```
+time-series → time-series-forecasting → model-monitoring
+  (古典解析)    (ML 予測)                 (監視)
+       │              │                       ↓
+ spectral-signal ────┘             anomaly-detection
+  (周波数解析)                       (異常検知)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `prophet_forecast.png` | Prophet 予測結果 | → presentation |
+| `ts_features.csv` | 時系列特徴量 | → ml-regression |
+| `backtest_results.csv` | バックテスト結果 | → model selection |

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

@@ -0,0 +1,298 @@
+---
+name: scientific-transfer-learning
+description: |
+  転移学習・ドメイン適応スキル。事前学習モデルファインチューニング・
+  Few-shot / Zero-shot 学習・ドメイン適応 (DA)・
+  知識蒸留・マルチタスク学習・科学ドメイン特化モデル転移。
+---
+
+# Scientific Transfer Learning
+
+事前学習モデルの科学データへの転移・ドメイン適応・
+Few-shot 学習パイプラインを提供する。
+
+## When to Use
+
+- 事前学習済みモデル (ImageNet/BERT) をファインチューニングするとき
+- 小規模科学データセットで高精度を実現したいとき
+- ドメイン適応で異なるデータ分布間のギャップを埋めるとき
+- Few-shot 学習で数例から分類するとき
+- 知識蒸留で大規模モデルを軽量化するとき
+- マルチタスク学習で複数タスクを共同学習するとき
+
+---
+
+## Quick Start
+
+## 1. Vision モデルファインチューニング
+
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+import numpy as np
+
+
+def finetune_vision_model(train_loader, val_loader,
+                          model_name="resnet50",
+                          num_classes=10, epochs=20,
+                          lr=1e-4, freeze_backbone=True):
+    """
+    Vision モデルファインチューニング。
+
+    Parameters:
+        train_loader: DataLoader — 学習データ
+        val_loader: DataLoader — 検証データ
+        model_name: str — "resnet50" / "vit_b_16" / "efficientnet_b0"
+        num_classes: int — クラス数
+        epochs: int — エポック数
+        lr: float — 学習率
+        freeze_backbone: bool — バックボーン凍結
+    """
+    import torchvision.models as models
+
+    # モデルロード
+    model_fn = getattr(models, model_name)
+    weights_name = model_name.replace("_", "").title() + "_Weights"
+    try:
+        weights = getattr(models, weights_name).DEFAULT
+    except AttributeError:
+        weights = "DEFAULT"
+    model = model_fn(weights=weights)
+
+    # 最終層置換
+    if hasattr(model, "fc"):
+        in_features = model.fc.in_features
+        model.fc = nn.Linear(in_features, num_classes)
+    elif hasattr(model, "classifier"):
+        if isinstance(model.classifier, nn.Sequential):
+            in_features = model.classifier[-1].in_features
+            model.classifier[-1] = nn.Linear(in_features, num_classes)
+        else:
+            in_features = model.classifier.in_features
+            model.classifier = nn.Linear(in_features, num_classes)
+    elif hasattr(model, "heads"):
+        in_features = model.heads.head.in_features
+        model.heads.head = nn.Linear(in_features, num_classes)
+
+    # バックボーン凍結
+    if freeze_backbone:
+        for name, param in model.named_parameters():
+            if "fc" not in name and "classifier" not in name and "heads" not in name:
+                param.requires_grad = False
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = model.to(device)
+
+    optimizer = torch.optim.AdamW(
+        filter(lambda p: p.requires_grad, model.parameters()), lr=lr)
+    criterion = nn.CrossEntropyLoss()
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, epochs)
+
+    best_acc = 0.0
+    history = []
+
+    for epoch in range(epochs):
+        model.train()
+        train_loss = 0.0
+        for X_batch, y_batch in train_loader:
+            X_batch, y_batch = X_batch.to(device), y_batch.to(device)
+            optimizer.zero_grad()
+            outputs = model(X_batch)
+            loss = criterion(outputs, y_batch)
+            loss.backward()
+            optimizer.step()
+            train_loss += loss.item()
+        scheduler.step()
+
+        # Validation
+        model.eval()
+        correct = total = 0
+        with torch.no_grad():
+            for X_batch, y_batch in val_loader:
+                X_batch, y_batch = X_batch.to(device), y_batch.to(device)
+                outputs = model(X_batch)
+                _, predicted = outputs.max(1)
+                total += y_batch.size(0)
+                correct += predicted.eq(y_batch).sum().item()
+
+        val_acc = correct / total
+        history.append({"epoch": epoch, "train_loss": train_loss / len(train_loader),
+                        "val_acc": val_acc})
+        if val_acc > best_acc:
+            best_acc = val_acc
+
+    print(f"Finetune {model_name}: best val acc = {best_acc:.4f}")
+    return model, history
+```
+
+## 2. NLP モデルファインチューニング
+
+```python
+def finetune_text_classifier(train_texts, train_labels,
+                             val_texts, val_labels,
+                             model_name="dmis-lab/biobert-base-cased-v1.2",
+                             num_labels=2, epochs=5, lr=2e-5):
+    """
+    BERT/BioBERT テキスト分類ファインチューニング。
+
+    Parameters:
+        train_texts: list[str] — 学習テキスト
+        train_labels: list[int] — 学習ラベル
+        val_texts: list[str] — 検証テキスト
+        val_labels: list[int] — 検証ラベル
+        model_name: str — HuggingFace モデル名
+        num_labels: int — ラベル数
+        epochs: int — エポック数
+        lr: float — 学習率
+    """
+    from transformers import (
+        AutoTokenizer, AutoModelForSequenceClassification,
+        TrainingArguments, Trainer)
+    from datasets import Dataset
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_name, num_labels=num_labels)
+
+    def tokenize(examples):
+        return tokenizer(examples["text"], truncation=True,
+                         padding="max_length", max_length=512)
+
+    train_ds = Dataset.from_dict({"text": train_texts, "label": train_labels})
+    val_ds = Dataset.from_dict({"text": val_texts, "label": val_labels})
+    train_ds = train_ds.map(tokenize, batched=True)
+    val_ds = val_ds.map(tokenize, batched=True)
+
+    args = TrainingArguments(
+        output_dir="./ft_output", num_train_epochs=epochs,
+        per_device_train_batch_size=16, learning_rate=lr,
+        evaluation_strategy="epoch", save_strategy="epoch",
+        load_best_model_at_end=True, metric_for_best_model="accuracy")
+
+    def compute_metrics(eval_pred):
+        preds = np.argmax(eval_pred.predictions, axis=-1)
+        acc = (preds == eval_pred.label_ids).mean()
+        return {"accuracy": acc}
+
+    trainer = Trainer(model=model, args=args, train_dataset=train_ds,
+                      eval_dataset=val_ds, compute_metrics=compute_metrics)
+    trainer.train()
+
+    metrics = trainer.evaluate()
+    print(f"Finetune {model_name}: val acc = {metrics['eval_accuracy']:.4f}")
+    return model, tokenizer, metrics
+```
+
+## 3. Few-shot 学習
+
+```python
+def prototypical_network(support_X, support_y, query_X,
+                         feature_extractor=None):
+    """
+    Prototypical Network — Few-shot 分類。
+
+    Parameters:
+        support_X: np.ndarray — サポートセット特徴量
+        support_y: np.ndarray — サポートラベル
+        query_X: np.ndarray — クエリセット特徴量
+        feature_extractor: callable | None — 特徴量抽出器
+    """
+    if feature_extractor is not None:
+        support_emb = feature_extractor(support_X)
+        query_emb = feature_extractor(query_X)
+    else:
+        support_emb = support_X
+        query_emb = query_X
+
+    classes = np.unique(support_y)
+    prototypes = np.array([
+        support_emb[support_y == c].mean(axis=0) for c in classes])
+
+    # ユークリッド距離
+    dists = np.array([
+        np.linalg.norm(query_emb - p, axis=1) for p in prototypes]).T
+
+    predictions = classes[np.argmin(dists, axis=1)]
+    confidences = np.exp(-dists.min(axis=1))
+
+    print(f"Few-shot: {len(classes)} classes, "
+          f"{len(support_y)} support → {len(query_X)} query")
+    return predictions, confidences
+```
+
+## 4. 知識蒸留
+
+```python
+def knowledge_distillation(teacher, student, train_loader,
+                           epochs=20, temperature=4.0, alpha=0.7,
+                           lr=1e-3):
+    """
+    知識蒸留 (Teacher → Student)。
+
+    Parameters:
+        teacher: nn.Module — 教師モデル (frozen)
+        student: nn.Module — 生徒モデル
+        train_loader: DataLoader — 学習データ
+        epochs: int — エポック数
+        temperature: float — 蒸留温度
+        alpha: float — soft loss の重み
+        lr: float — 学習率
+    """
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    teacher = teacher.to(device).eval()
+    student = student.to(device)
+
+    optimizer = torch.optim.AdamW(student.parameters(), lr=lr)
+    ce_loss = nn.CrossEntropyLoss()
+    kl_loss = nn.KLDivLoss(reduction="batchmean")
+
+    for epoch in range(epochs):
+        student.train()
+        total_loss = 0.0
+        for X_batch, y_batch in train_loader:
+            X_batch, y_batch = X_batch.to(device), y_batch.to(device)
+
+            with torch.no_grad():
+                teacher_logits = teacher(X_batch)
+
+            student_logits = student(X_batch)
+
+            soft_loss = kl_loss(
+                nn.functional.log_softmax(student_logits / temperature, dim=1),
+                nn.functional.softmax(teacher_logits / temperature, dim=1)
+            ) * (temperature ** 2)
+
+            hard_loss = ce_loss(student_logits, y_batch)
+            loss = alpha * soft_loss + (1 - alpha) * hard_loss
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            total_loss += loss.item()
+
+        print(f"  Epoch {epoch}: loss = {total_loss / len(train_loader):.4f}")
+
+    print(f"Distillation: T={temperature}, α={alpha}, {epochs} epochs")
+    return student
+```
+
+---
+
+## パイプライン統合
+
+```
+deep-learning → transfer-learning → active-learning
+  (モデル設計)    (転移・適応)       (効率的ラベル付け)
+       │               │                 ↓
+  healthcare-ai ───────┘       ensemble-methods
+    (臨床 AI)                    (アンサンブル)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `ft_model.pt` | ファインチューニング済みモデル | → 推論 |
+| `ft_history.csv` | 学習履歴 | → visualization |
+| `few_shot_predictions.csv` | Few-shot 予測 | → 評価 |