@nahisaho/satori 0.13.0 → 0.15.0

package/src/.github/skills/scientific-deep-chemistry/SKILL.md

@@ -0,0 +1,350 @@
+---
+name: scientific-deep-chemistry
+description: |
+  深層学習分子特性予測スキル。DeepChem による GCN/MPNN/AttentiveFP
+  分子特性予測・MoleculeNet ベンチマーク・ChemBERTa/GROVER
+  事前学習モデル・分子フィンガープリントフィーチャライザ。
+---
+
+# Scientific Deep Chemistry
+
+DeepChem を活用した深層学習ベース分子特性予測パイプラインを提供する。
+グラフニューラルネットワーク (GCN/MPNN/AttentiveFP)、MoleculeNet
+ベンチマーク、事前学習モデル (ChemBERTa/GROVER)。
+
+## When to Use
+
+- 分子の ADMET/物性を深層学習で予測するとき
+- MoleculeNet ベンチマークデータセットを使うとき
+- GCN / MPNN / AttentiveFP モデルを訓練するとき
+- ChemBERTa で分子表現学習を行うとき
+- 毒性予測 (Tox21, ToxCast) を行うとき
+- 薬理活性予測の分子特徴量を生成するとき
+
+---
+
+## Quick Start
+
+## 1. MoleculeNet データセット読込み
+
+```python
+import deepchem as dc
+import numpy as np
+import pandas as pd
+
+
+def load_moleculenet(dataset_name="delaney", featurizer="GraphConv",
+                     split="scaffold"):
+    """
+    MoleculeNet ベンチマークデータセット読込み。
+
+    Parameters:
+        dataset_name: str — データセット名
+          ("delaney", "tox21", "bbbp", "hiv", "muv", "pcba",
+           "sider", "clintox", "freesolv", "lipo")
+        featurizer: str — 特徴量化手法
+          ("GraphConv", "ECFP", "Weave", "MolGraphConv")
+        split: str — 分割方法 ("scaffold", "random", "stratified")
+
+    K-Dense: deepchem
+    """
+    loader_map = {
+        "delaney": dc.molnet.load_delaney,
+        "tox21": dc.molnet.load_tox21,
+        "bbbp": dc.molnet.load_bbbp,
+        "hiv": dc.molnet.load_hiv,
+        "muv": dc.molnet.load_muv,
+        "pcba": dc.molnet.load_pcba,
+        "sider": dc.molnet.load_sider,
+        "clintox": dc.molnet.load_clintox,
+        "freesolv": dc.molnet.load_freesolv,
+        "lipo": dc.molnet.load_lipo,
+    }
+
+    if dataset_name not in loader_map:
+        raise ValueError(f"Unknown dataset: {dataset_name}")
+
+    tasks, datasets, transformers = loader_map[dataset_name](
+        featurizer=featurizer, splitter=split
+    )
+    train, valid, test = datasets
+
+    print(f"MoleculeNet '{dataset_name}':")
+    print(f"  Tasks: {len(tasks)}")
+    print(f"  Train: {len(train)}, Valid: {len(valid)}, Test: {len(test)}")
+    print(f"  Featurizer: {featurizer}, Split: {split}")
+    return tasks, (train, valid, test), transformers
+```
+
+## 2. GCN モデル訓練
+
+```python
+def train_gcn(train_data, valid_data, tasks, n_epochs=50,
+              learning_rate=0.001, batch_size=64):
+    """
+    Graph Convolutional Network (GCN) モデル訓練。
+
+    Parameters:
+        train_data: dc.data.Dataset — 訓練データ
+        valid_data: dc.data.Dataset — 検証データ
+        tasks: list — タスク名リスト
+        n_epochs: int — エポック数
+    """
+    model = dc.models.GraphConvModel(
+        n_tasks=len(tasks),
+        mode="classification" if len(tasks) > 1 else "regression",
+        batch_size=batch_size,
+        learning_rate=learning_rate,
+    )
+
+    for epoch in range(n_epochs):
+        loss = model.fit(train_data, nb_epoch=1)
+        if (epoch + 1) % 10 == 0:
+            metric = dc.metrics.Metric(
+                dc.metrics.roc_auc_score if len(tasks) > 1
+                else dc.metrics.pearson_r2_score
+            )
+            train_score = model.evaluate(train_data, [metric])
+            valid_score = model.evaluate(valid_data, [metric])
+            print(f"  Epoch {epoch+1}: "
+                  f"train={list(train_score.values())[0]:.4f}, "
+                  f"valid={list(valid_score.values())[0]:.4f}")
+
+    return model
+```
+
+## 3. MPNN モデル訓練
+
+```python
+def train_mpnn(train_data, valid_data, tasks, n_epochs=50,
+               learning_rate=0.001):
+    """
+    Message Passing Neural Network (MPNN) 訓練。
+
+    Parameters:
+        train_data: dc.data.Dataset — GraphConv 特徴量訓練データ
+        valid_data: dc.data.Dataset — 検証データ
+        tasks: list — タスク名リスト
+    """
+    model = dc.models.MPNNModel(
+        n_tasks=len(tasks),
+        mode="classification" if len(tasks) > 1 else "regression",
+        learning_rate=learning_rate,
+        node_out_feats=64,
+        edge_hidden_feats=128,
+        num_step_message_passing=3,
+    )
+
+    model.fit(train_data, nb_epoch=n_epochs)
+
+    metric = dc.metrics.Metric(
+        dc.metrics.roc_auc_score if len(tasks) > 1
+        else dc.metrics.pearson_r2_score
+    )
+    valid_score = model.evaluate(valid_data, [metric])
+    print(f"MPNN: valid score = {list(valid_score.values())[0]:.4f}")
+    return model
+```
+
+## 4. AttentiveFP モデル訓練
+
+```python
+def train_attentivefp(train_data, valid_data, tasks, n_epochs=50,
+                      learning_rate=0.001, num_layers=2):
+    """
+    AttentiveFP (Attention-based Fingerprint) 訓練。
+
+    Parameters:
+        train_data: dc.data.Dataset — 訓練データ
+        valid_data: dc.data.Dataset — 検証データ
+        tasks: list — タスク名
+        num_layers: int — GATレイヤー数
+    """
+    model = dc.models.AttentiveFPModel(
+        n_tasks=len(tasks),
+        mode="classification" if len(tasks) > 1 else "regression",
+        learning_rate=learning_rate,
+        num_layers=num_layers,
+        graph_feat_size=200,
+        num_timesteps=2,
+    )
+
+    model.fit(train_data, nb_epoch=n_epochs)
+
+    metric = dc.metrics.Metric(
+        dc.metrics.roc_auc_score if len(tasks) > 1
+        else dc.metrics.pearson_r2_score
+    )
+    valid_score = model.evaluate(valid_data, [metric])
+    print(f"AttentiveFP: valid score = {list(valid_score.values())[0]:.4f}")
+    return model
+```
+
+## 5. ChemBERTa 分子表現学習
+
+```python
+def chemberta_embeddings(smiles_list, model_name="seyonec/ChemBERTa-zinc-base-v1"):
+    """
+    ChemBERTa で SMILES → 分子埋込みベクトル。
+
+    Parameters:
+        smiles_list: list — SMILES 文字列リスト
+        model_name: str — HuggingFace モデル名
+    """
+    from transformers import AutoTokenizer, AutoModel
+    import torch
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModel.from_pretrained(model_name)
+    model.eval()
+
+    embeddings = []
+    batch_size = 32
+
+    for i in range(0, len(smiles_list), batch_size):
+        batch = smiles_list[i:i+batch_size]
+        inputs = tokenizer(batch, padding=True, truncation=True,
+                          max_length=512, return_tensors="pt")
+
+        with torch.no_grad():
+            outputs = model(**inputs)
+            # CLS トークン埋込み
+            cls_emb = outputs.last_hidden_state[:, 0, :].numpy()
+            embeddings.append(cls_emb)
+
+    embeddings = np.vstack(embeddings)
+    print(f"ChemBERTa: {len(smiles_list)} molecules → "
+          f"{embeddings.shape[1]}D embeddings")
+    return embeddings
+```
+
+## 6. モデル比較ベンチマーク
+
+```python
+def benchmark_models(dataset_name="tox21", models_to_test=None,
+                     n_epochs=30):
+    """
+    複数モデルのベンチマーク比較。
+
+    Parameters:
+        dataset_name: str — MoleculeNet データセット
+        models_to_test: list — テストモデル名
+        n_epochs: int — エポック数
+    """
+    if models_to_test is None:
+        models_to_test = ["GCN", "MPNN", "AttentiveFP"]
+
+    results = {}
+
+    for model_name in models_to_test:
+        featurizer = "GraphConv" if model_name != "ECFP_RF" else "ECFP"
+        tasks, (train, valid, test), transformers = load_moleculenet(
+            dataset_name, featurizer=featurizer
+        )
+
+        is_classification = len(tasks) > 1 or dataset_name in [
+            "tox21", "bbbp", "hiv", "sider", "clintox"
+        ]
+
+        if model_name == "GCN":
+            model = train_gcn(train, valid, tasks, n_epochs=n_epochs)
+        elif model_name == "MPNN":
+            model = train_mpnn(train, valid, tasks, n_epochs=n_epochs)
+        elif model_name == "AttentiveFP":
+            model = train_attentivefp(train, valid, tasks, n_epochs=n_epochs)
+        else:
+            continue
+
+        metric = dc.metrics.Metric(
+            dc.metrics.roc_auc_score if is_classification
+            else dc.metrics.pearson_r2_score
+        )
+        test_score = model.evaluate(test, [metric])
+        results[model_name] = list(test_score.values())[0]
+
+    print(f"\nBenchmark on '{dataset_name}':")
+    for name, score in sorted(results.items(), key=lambda x: -x[1]):
+        print(f"  {name}: {score:.4f}")
+    return results
+```
+
+## 7. 分子特性予測パイプライン
+
+```python
+def molecular_prediction_pipeline(smiles_list, property_name="solubility",
+                                   model_type="AttentiveFP"):
+    """
+    SMILES → 分子特性予測 統合パイプライン。
+
+    Parameters:
+        smiles_list: list — SMILES リスト
+        property_name: str — 予測対象物性
+        model_type: str — 使用モデル
+    """
+    # データセットマッピング
+    property_dataset = {
+        "solubility": "delaney",
+        "toxicity": "tox21",
+        "bbb_penetration": "bbbp",
+        "hiv_activity": "hiv",
+        "lipophilicity": "lipo",
+        "solvation_energy": "freesolv",
+    }
+
+    dataset_name = property_dataset.get(property_name, "delaney")
+
+    # 1) ベンチマークデータで訓練
+    tasks, (train, valid, test), transformers = load_moleculenet(
+        dataset_name, featurizer="GraphConv"
+    )
+
+    if model_type == "GCN":
+        model = train_gcn(train, valid, tasks)
+    elif model_type == "AttentiveFP":
+        model = train_attentivefp(train, valid, tasks)
+    else:
+        model = train_mpnn(train, valid, tasks)
+
+    # 2) 新規分子を予測
+    featurizer = dc.feat.MolGraphConvFeaturizer()
+    features = featurizer.featurize(smiles_list)
+    pred_dataset = dc.data.NumpyDataset(X=features)
+    predictions = model.predict(pred_dataset)
+
+    results = []
+    for smi, pred in zip(smiles_list, predictions):
+        results.append({
+            "smiles": smi,
+            "prediction": float(pred[0]) if pred.ndim > 1 else float(pred),
+            "property": property_name,
+            "model": model_type,
+        })
+
+    df = pd.DataFrame(results)
+    print(f"Predictions: {len(df)} molecules, property='{property_name}'")
+    return df
+```
+
+---
+
+## パイプライン統合
+
+```
+cheminformatics → deep-chemistry → drug-target-profiling
+  (RDKit/SMILES)   (GCN/MPNN/FP)   (ChEMBL/標的)
+       │                  │                ↓
+molecular-docking ───────┘         admet-pharmacokinetics
+  (AutoDock/Vina)      │            (ADMET予測)
+                       ↓
+                  md-simulation
+                  (分子動力学検証)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `results/predictions.csv` | 分子特性予測値 | → drug-target-profiling |
+| `results/benchmark.json` | モデルベンチマーク結果 | — |
+| `results/embeddings.npy` | ChemBERTa 埋込み | → cheminformatics |
+| `results/model/` | 訓練済みモデル | → admet-pharmacokinetics |

package/src/.github/skills/scientific-ebi-databases/SKILL.md

@@ -0,0 +1,280 @@
+---
+name: scientific-ebi-databases
+description: |
+  EBI データベース群統合アクセススキル。EBI Search 横断検索、ENA Browser
+  ヌクレオチドアーカイブ、BioStudies 研究データ、dbfetch エントリ取得、
+  MetaboLights メタボロミクスリポジトリの統合パイプライン。
+---
+
+# Scientific EBI Databases
+
+EBI Search / ENA Browser / BioStudies / dbfetch / MetaboLights を統合した
+EBI データベース群アクセスパイプラインを提供する。
+
+## When to Use
+
+- EBI Search で複数データベースを横断検索するとき
+- ENA (European Nucleotide Archive) で配列データを検索するとき
+- BioStudies で研究プロジェクトデータを探すとき
+- dbfetch でエントリを一括取得するとき
+- MetaboLights でメタボロミクス実験データにアクセスするとき
+
+---
+
+## Quick Start
+
+## 1. EBI Search 横断検索
+
+```python
+import requests
+import pandas as pd
+
+EBI_SEARCH_API = "https://www.ebi.ac.uk/ebisearch/ws/rest"
+
+
+def search_ebi(query, domain="allebi", size=25, fields=None):
+    """
+    EBI Search 横断検索 — 複数 EBI データベースを一括検索。
+
+    Parameters:
+        query: str — 検索クエリ
+        domain: str — 検索ドメイン ("allebi", "uniprot", "pdb", "ena", etc.)
+        size: int — 最大取得数
+        fields: list — 返却フィールド
+
+    ToolUniverse:
+        EBI_Search_query(query=query, domain=domain)
+        EBI_Search_get_entry(domain=domain, entry_id=entry_id)
+    """
+    params = {
+        "query": query,
+        "size": size,
+        "format": "json",
+    }
+    if fields:
+        params["fields"] = ",".join(fields)
+
+    resp = requests.get(f"{EBI_SEARCH_API}/{domain}", params=params)
+    resp.raise_for_status()
+    data = resp.json()
+
+    results = []
+    for entry in data.get("entries", []):
+        row = {"id": entry.get("id", ""), "source": entry.get("source", "")}
+        for field in entry.get("fields", {}):
+            row[field] = entry["fields"][field][0] if entry["fields"][field] else ""
+        results.append(row)
+
+    df = pd.DataFrame(results)
+    total = data.get("hitCount", 0)
+    print(f"EBI Search [{domain}] '{query}': {total} total hits, {len(df)} returned")
+    return df
+```
+
+## 2. ENA (European Nucleotide Archive) 配列検索
+
+```python
+ENA_API = "https://www.ebi.ac.uk/ena/browser/api"
+
+
+def search_ena(query, result_type="sequence", limit=100):
+    """
+    ENA ヌクレオチドアーカイブ検索。
+
+    Parameters:
+        query: str — 検索クエリ or Taxon ID
+        result_type: str — "sequence", "read_run", "analysis", "study"
+        limit: int — 最大取得数
+
+    ToolUniverse:
+        ENA_search(query=query, result=result_type)
+        ENA_get_entry(accession=accession)
+    """
+    params = {
+        "query": query,
+        "result": result_type,
+        "limit": limit,
+        "format": "json",
+    }
+    resp = requests.get(f"{ENA_API}/search", params=params)
+    resp.raise_for_status()
+    data = resp.json()
+
+    df = pd.DataFrame(data) if isinstance(data, list) else pd.DataFrame()
+    print(f"ENA search '{query}' [{result_type}]: {len(df)} entries")
+    return df
+
+
+def get_ena_entry(accession, display="json"):
+    """
+    ENA アクセッション番号によるエントリ取得。
+
+    Parameters:
+        accession: str — ENA accession (e.g., "ERS000001", "ERR000001")
+    """
+    resp = requests.get(
+        f"{ENA_API}/entry/{accession}",
+        params={"display": display}
+    )
+    resp.raise_for_status()
+    print(f"ENA entry {accession}: retrieved")
+    return resp.json() if display == "json" else resp.text
+```
+
+## 3. BioStudies 研究データ検索
+
+```python
+BIOSTUDIES_API = "https://www.ebi.ac.uk/biostudies/api/v1"
+
+
+def search_biostudies(query, page_size=25):
+    """
+    BioStudies 研究プロジェクトデータ検索。
+
+    Parameters:
+        query: str — 検索クエリ
+        page_size: int — ページサイズ
+
+    ToolUniverse:
+        BioStudies_search(query=query)
+        BioStudies_get_study(accession=accession)
+    """
+    params = {"query": query, "pageSize": page_size}
+    resp = requests.get(f"{BIOSTUDIES_API}/search", params=params)
+    resp.raise_for_status()
+    data = resp.json()
+
+    results = []
+    for hit in data.get("hits", []):
+        results.append({
+            "accession": hit.get("accno", ""),
+            "title": hit.get("title", ""),
+            "author": hit.get("author", ""),
+            "release_date": hit.get("rtime", ""),
+            "type": hit.get("type", ""),
+            "files": hit.get("files", 0),
+            "links": hit.get("links", 0),
+        })
+
+    df = pd.DataFrame(results)
+    total = data.get("totalHits", 0)
+    print(f"BioStudies search '{query}': {total} total, {len(df)} returned")
+    return df
+```
+
+## 4. dbfetch エントリ一括取得
+
+```python
+DBFETCH_API = "https://www.ebi.ac.uk/Tools/dbfetch/dbfetch"
+
+
+def dbfetch(db, ids, format_type="json", style="raw"):
+    """
+    dbfetch — EBI データベースエントリ一括取得。
+
+    Parameters:
+        db: str — データベース名 (e.g., "uniprotkb", "embl", "pdb")
+        ids: list — ID リスト
+        format_type: str — 出力形式 ("json", "fasta", "xml")
+        style: str — スタイル ("raw", "html")
+
+    ToolUniverse:
+        dbfetch_get_entries(db=db, ids=ids, format=format_type)
+    """
+    ids_str = ",".join(ids) if isinstance(ids, list) else ids
+    params = {
+        "db": db,
+        "id": ids_str,
+        "format": format_type,
+        "style": style,
+    }
+    resp = requests.get(DBFETCH_API, params=params)
+    resp.raise_for_status()
+
+    print(f"dbfetch [{db}]: {len(ids) if isinstance(ids, list) else 1} entries, "
+          f"format={format_type}")
+    if format_type == "json":
+        return resp.json()
+    return resp.text
+```
+
+## 5. MetaboLights メタボロミクスリポジトリ
+
+```python
+METABOLIGHTS_API = "https://www.ebi.ac.uk/metabolights/ws"
+
+
+def search_metabolights(query):
+    """
+    MetaboLights メタボロミクス実験データ検索。
+
+    Parameters:
+        query: str — 検索クエリ (化合物名、疾患名、生物種)
+
+    ToolUniverse:
+        MetaboLights_search_studies(query=query)
+        MetaboLights_get_study(study_id=study_id)
+    """
+    resp = requests.get(
+        f"{METABOLIGHTS_API}/studies/search",
+        params={"query": query}
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    results = []
+    for study in data.get("content", []):
+        results.append({
+            "study_id": study.get("studyIdentifier", ""),
+            "title": study.get("title", ""),
+            "organism": study.get("organism", ""),
+            "description": (study.get("description") or "")[:200],
+            "submission_date": study.get("submissionDate", ""),
+            "status": study.get("studyStatus", ""),
+        })
+
+    df = pd.DataFrame(results)
+    print(f"MetaboLights search '{query}': {len(df)} studies")
+    return df
+
+
+def get_metabolights_study(study_id):
+    """MetaboLights 個別研究取得。"""
+    resp = requests.get(f"{METABOLIGHTS_API}/studies/{study_id}")
+    resp.raise_for_status()
+    data = resp.json()
+    print(f"MetaboLights {study_id}: {data.get('title', '')[:80]}")
+    return data
+```
+
+---
+
+## 利用可能ツール
+
+| ToolUniverse カテゴリ | 主なツール |
+|---|---|
+| `ebi_search` | `EBI_Search_query`, `EBI_Search_get_entry` |
+| `ena_browser` | `ENA_search`, `ENA_get_entry` |
+| `biostudies` | `BioStudies_search`, `BioStudies_get_study` |
+| `dbfetch` | `dbfetch_get_entries` |
+| `metabolights` | `MetaboLights_search_studies`, `MetaboLights_get_study` |
+
+## パイプライン出力
+
+| 出力ファイル | 説明 | 連携先スキル |
+|---|---|---|
+| `results/ebi_search.csv` | EBI 横断検索結果 | → bioinformatics, literature-search |
+| `results/ena_sequences.fasta` | ENA 配列データ | → genome-sequence-tools, sequence-analysis |
+| `results/biostudies_metadata.json` | 研究プロジェクト情報 | → multi-omics, systematic-review |
+| `results/metabolights_study.json` | メタボロミクスデータ | → metabolomics, metabolomics-databases |
+
+## パイプライン統合
+
+```
+genome-sequence-tools ──→ ebi-databases ──→ metabolomics-databases
+  (NCBI/BLAST)           (ENA/EBI Search)   (HMDB/MetaCyc)
+                              │
+                              ├──→ bioinformatics (配列データ)
+                              ├──→ sequence-analysis (FASTA)
+                              └──→ structural-proteomics (PDBe cross-ref)
+```