@nahisaho/satori 0.14.0 → 0.16.0

package/src/.github/skills/scientific-data-submission/SKILL.md

@@ -0,0 +1,357 @@
+---
+name: scientific-data-submission
+description: |
+  科学データ登録・アーカイブスキル。GenBank/SRA 配列登録・
+  ENA 配列アーカイブ・GEO 発現データ登録・BioProject/BioSample
+  メタデータ管理・FAIR 原則準拠データ共有。
+---
+
+# Scientific Data Submission
+
+GenBank / SRA / ENA / GEO / BioProject を活用した科学データの
+登録・アーカイブパイプラインを提供する。FAIR 原則に準拠した
+配列データ・発現データ・メタデータの公開準備。
+
+## When to Use
+
+- 配列データを GenBank/DDBJ/ENA に登録するとき
+- RNA-seq/WGS データを SRA にアーカイブするとき
+- GEO にマイクロアレイ/RNA-seq 発現データを登録するとき
+- BioProject/BioSample でメタデータを構造化するとき
+- 論文投稿時にデータアクセッション番号が必要なとき
+- FAIR 原則 (Findable, Accessible, Interoperable, Reusable) に準拠するとき
+
+---
+
+## Quick Start
+
+## 1. BioProject/BioSample メタデータ作成
+
+```python
+import json
+import pandas as pd
+from pathlib import Path
+from datetime import date
+
+
+def create_bioproject_metadata(title, description, organism,
+                                data_type="Genome Sequencing",
+                                relevance="Medical"):
+    """
+    BioProject メタデータ XML/JSON 生成。
+
+    Parameters:
+        title: str — プロジェクトタイトル
+        description: str — プロジェクト説明
+        organism: str — 生物種名
+        data_type: str — データ種別
+        relevance: str — 関連分野
+    """
+    bioproject = {
+        "Project": {
+            "ProjectID": {"ArchiveID": {"accession": "PRJNA_PENDING"}},
+            "Descriptor": {
+                "Title": title,
+                "Description": description,
+                "Relevance": relevance,
+            },
+            "ProjectType": {
+                "ProjectTypeSubmission": {
+                    "Target": {
+                        "Organism": {"OrganismName": organism},
+                    },
+                    "Method": {"MethodType": data_type},
+                    "Objectives": {"Data": {"DataType": data_type}},
+                }
+            },
+        }
+    }
+
+    print(f"BioProject metadata created:")
+    print(f"  Title: {title}")
+    print(f"  Organism: {organism}")
+    print(f"  Data type: {data_type}")
+    return bioproject
+
+
+def create_biosample_table(samples, organism, package="Generic"):
+    """
+    BioSample TSV テンプレート生成。
+
+    Parameters:
+        samples: list[dict] — サンプル情報
+        organism: str — 生物種名
+        package: str — BioSample パッケージ
+    """
+    required_fields = [
+        "sample_name", "organism", "collection_date",
+        "geo_loc_name", "tissue", "description",
+    ]
+
+    rows = []
+    for s in samples:
+        row = {
+            "sample_name": s.get("name", ""),
+            "organism": organism,
+            "collection_date": s.get("date", str(date.today())),
+            "geo_loc_name": s.get("location", "not collected"),
+            "tissue": s.get("tissue", "not applicable"),
+            "description": s.get("description", ""),
+        }
+        row.update({k: v for k, v in s.items()
+                     if k not in ["name", "date", "location"]})
+        rows.append(row)
+
+    df = pd.DataFrame(rows)
+    print(f"BioSample table: {len(df)} samples, package='{package}'")
+    return df
+```
+
+## 2. GenBank 配列登録準備
+
+```python
+def prepare_genbank_submission(sequences, annotations, output_dir="submission"):
+    """
+    GenBank 配列登録用 .sqn ファイル準備。
+
+    Parameters:
+        sequences: dict — {seq_id: sequence_string}
+        annotations: dict — {seq_id: {gene, product, organism, ...}}
+        output_dir: str — 出力ディレクトリ
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # FASTA 生成
+    fasta_path = output_dir / "sequences.fsa"
+    with open(fasta_path, "w") as f:
+        for seq_id, seq in sequences.items():
+            ann = annotations.get(seq_id, {})
+            organism = ann.get("organism", "Unknown organism")
+            f.write(f">{seq_id} [organism={organism}]\n")
+            # 80文字折返し
+            for i in range(0, len(seq), 80):
+                f.write(seq[i:i+80] + "\n")
+
+    # Feature Table 生成
+    tbl_path = output_dir / "sequences.tbl"
+    with open(tbl_path, "w") as f:
+        for seq_id, ann in annotations.items():
+            f.write(f">Feature {seq_id}\n")
+            if "gene" in ann:
+                f.write(f"1\t{len(sequences[seq_id])}\tgene\n")
+                f.write(f"\t\t\tgene\t{ann['gene']}\n")
+            if "product" in ann:
+                f.write(f"1\t{len(sequences[seq_id])}\tCDS\n")
+                f.write(f"\t\t\tproduct\t{ann['product']}\n")
+
+    # Template 生成
+    template = {
+        "source": {
+            "organism": list(annotations.values())[0].get("organism", ""),
+            "mol_type": "genomic DNA",
+        },
+        "submitter": {
+            "name": "AutoSubmission",
+        },
+    }
+
+    template_path = output_dir / "template.json"
+    with open(template_path, "w") as f:
+        json.dump(template, f, indent=2)
+
+    print(f"GenBank submission prepared: {len(sequences)} sequences")
+    print(f"  FASTA: {fasta_path}")
+    print(f"  Feature Table: {tbl_path}")
+    return {"fasta": str(fasta_path), "tbl": str(tbl_path)}
+```
+
+## 3. SRA メタデータ & アップロード
+
+```python
+def prepare_sra_metadata(samples, library_strategy="WGS",
+                          library_source="GENOMIC",
+                          platform="ILLUMINA",
+                          instrument_model="Illumina NovaSeq 6000"):
+    """
+    SRA メタデータ TSV 生成。
+
+    Parameters:
+        samples: list[dict] — {biosample, title, file_r1, file_r2}
+        library_strategy: str — WGS/RNA-Seq/AMPLICON/etc.
+        library_source: str — GENOMIC/TRANSCRIPTOMIC/etc.
+        platform: str — ILLUMINA/OXFORD_NANOPORE/etc.
+    """
+    rows = []
+    for s in samples:
+        rows.append({
+            "biosample_accession": s.get("biosample", "SAMN_PENDING"),
+            "library_ID": s.get("library_id", s.get("title", "")),
+            "title": s.get("title", ""),
+            "library_strategy": library_strategy,
+            "library_source": library_source,
+            "library_selection": s.get("selection", "RANDOM"),
+            "library_layout": "paired" if s.get("file_r2") else "single",
+            "platform": platform,
+            "instrument_model": instrument_model,
+            "filetype": "fastq",
+            "filename": s.get("file_r1", ""),
+            "filename2": s.get("file_r2", ""),
+        })
+
+    df = pd.DataFrame(rows)
+    print(f"SRA metadata: {len(df)} runs, strategy={library_strategy}")
+    return df
+
+
+def sra_upload_ascp(files, destination, ascp_key=None):
+    """
+    Aspera (ascp) による SRA データ高速アップロード。
+
+    Parameters:
+        files: list — アップロードファイルリスト
+        destination: str — SRA アップロード先
+        ascp_key: str — Aspera SSH キーパス
+    """
+    import subprocess
+
+    if ascp_key is None:
+        ascp_key = Path.home() / ".aspera/connect/etc/asperaweb_id_dsa.openssh"
+
+    for f in files:
+        cmd = [
+            "ascp", "-i", str(ascp_key),
+            "-QT", "-l", "300m", "-k", "1",
+            str(f), destination,
+        ]
+        print(f"Uploading: {f}")
+        subprocess.run(cmd, check=True)
+
+    print(f"SRA upload complete: {len(files)} files")
+```
+
+## 4. GEO 発現データ登録
+
+```python
+def prepare_geo_submission(expression_matrix, sample_metadata,
+                            platform="GPL16791", output_dir="geo_submission"):
+    """
+    GEO SOFT 形式サブミッション準備。
+
+    Parameters:
+        expression_matrix: pd.DataFrame — 遺伝子 × サンプルマトリクス
+        sample_metadata: pd.DataFrame — サンプルメタデータ
+        platform: str — GEO プラットフォーム ID
+        output_dir: str — 出力ディレクトリ
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # SOFT テンプレート
+    soft_path = output_dir / "submission.soft"
+    with open(soft_path, "w") as f:
+        # Series section
+        f.write("^SERIES\n")
+        f.write("!Series_title = \n")
+        f.write("!Series_summary = \n")
+        f.write(f"!Series_platform_id = {platform}\n")
+
+        # Sample sections
+        for col in expression_matrix.columns:
+            meta = sample_metadata[sample_metadata["sample_id"] == col]
+            f.write(f"\n^SAMPLE = {col}\n")
+            f.write(f"!Sample_title = {col}\n")
+            if len(meta) > 0:
+                for key, val in meta.iloc[0].items():
+                    if key != "sample_id":
+                        f.write(f"!Sample_characteristics_ch1 = {key}: {val}\n")
+
+    # Matrix file
+    matrix_path = output_dir / "expression_matrix.txt"
+    expression_matrix.to_csv(matrix_path, sep="\t")
+
+    # Raw data files list
+    raw_files_path = output_dir / "raw_files.txt"
+    with open(raw_files_path, "w") as f:
+        for col in expression_matrix.columns:
+            f.write(f"{col}.fastq.gz\n")
+
+    print(f"GEO submission: {expression_matrix.shape[1]} samples, "
+          f"{expression_matrix.shape[0]} genes")
+    return {"soft": str(soft_path), "matrix": str(matrix_path)}
+```
+
+## 5. FAIR データ検証チェックリスト
+
+```python
+def fair_checklist(submission_package):
+    """
+    FAIR 原則準拠チェックリスト。
+
+    Parameters:
+        submission_package: dict — 登録パッケージ情報
+    """
+    checks = {
+        "Findable": {
+            "F1_persistent_id": bool(submission_package.get("accession")),
+            "F2_metadata_rich": bool(submission_package.get("metadata")),
+            "F3_id_in_metadata": True,
+            "F4_searchable_registry": bool(submission_package.get("repository")),
+        },
+        "Accessible": {
+            "A1_retrievable_protocol": bool(submission_package.get("access_url")),
+            "A1_1_open_protocol": True,
+            "A2_metadata_persists": True,
+        },
+        "Interoperable": {
+            "I1_formal_language": bool(submission_package.get("format")),
+            "I2_fair_vocabularies": bool(submission_package.get("ontology_terms")),
+            "I3_qualified_references": bool(submission_package.get("references")),
+        },
+        "Reusable": {
+            "R1_usage_license": bool(submission_package.get("license")),
+            "R1_1_community_standards": bool(submission_package.get("standard")),
+            "R1_2_provenance": bool(submission_package.get("methods")),
+        },
+    }
+
+    total = 0
+    passed = 0
+    for principle, items in checks.items():
+        for check, status in items.items():
+            total += 1
+            if status:
+                passed += 1
+
+    score = passed / total * 100 if total > 0 else 0
+    print(f"FAIR checklist: {passed}/{total} ({score:.0f}%)")
+    for principle, items in checks.items():
+        n_pass = sum(items.values())
+        print(f"  {principle}: {n_pass}/{len(items)}")
+
+    return checks
+```
+
+---
+
+## パイプライン統合
+
+```
+bioinformatics → data-submission → literature-search
+  (解析完了)       (データ登録)       (論文投稿時)
+       │                │                  ↓
+lab-data-management ───┘           academic-writing
+  (Benchling/OMERO)    │            (論文執筆)
+                       ↓
+                 ebi-databases
+                 (ENA/BioStudies 連携)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `submission/sequences.fsa` | GenBank 登録用 FASTA | → bioinformatics |
+| `submission/sra_metadata.tsv` | SRA メタデータ | → ebi-databases |
+| `geo_submission/submission.soft` | GEO SOFT テンプレート | → gene-expression |
+| `submission/fair_report.json` | FAIR チェックリスト結果 | → academic-writing |

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 |