@nahisaho/satori 0.1.0

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

@@ -0,0 +1,413 @@
+---
+name: scientific-data-preprocessing
+description: |
+  科学データの前処理パイプラインスキル。欠損値補完（KNNImputer/SimpleImputer）、
+  エンコーディング（LabelEncoder/OneHot/ダミー変数）、スケーリング（Standard/MinMax/Robust/Pareto）、
+  対数変換、外れ値処理のテンプレートを提供。全 Exp-01〜13 に横断的に適用される基盤スキル。
+---
+
+# Scientific Data Preprocessing
+
+科学データ解析における前処理の標準パイプライン。データクリーニング、変換、正規化の
+一連の手順をトレーサブルかつ再現可能な形で実装するためのテンプレート集。
+全 Exp-01〜13 に共通処理として適用される基盤スキル。
+
+## When to Use
+
+- CSV / DataFrame のデータを解析前にクリーニング・変換したいとき
+- 欠損値の補完戦略を選択する必要があるとき
+- カテゴリカル変数のエンコーディングが必要なとき
+- 数値データのスケーリング・正規化が必要なとき
+- 外れ値の検出・除去が必要なとき
+
+## Quick Start
+
+## 1. 前処理パイプライン概要
+
+```
+Raw Data
+  ├─ Step 1: データ品質チェック
+  ├─ Step 2: 欠損値処理
+  ├─ Step 3: 外れ値処理
+  ├─ Step 4: エンコーディング
+  ├─ Step 5: スケーリング / 変換
+  └─ Step 6: 品質確認レポート
+```
+
+## 2. データ品質チェック
+
+```python
+import pandas as pd
+import numpy as np
+
+def data_quality_report(df, name="dataset"):
+    """
+    データ品質レポートを出力する。
+    前処理方針の決定材料として最初に実行すること。
+    """
+    report = pd.DataFrame({
+        "dtype": df.dtypes,
+        "nunique": df.nunique(),
+        "missing_count": df.isnull().sum(),
+        "missing_pct": (df.isnull().sum() / len(df) * 100).round(2),
+        "zeros_count": (df == 0).sum(),
+    })
+
+    # 数値カラムの統計
+    numeric_cols = df.select_dtypes(include=[np.number]).columns
+    for col in numeric_cols:
+        report.loc[col, "mean"] = df[col].mean()
+        report.loc[col, "std"] = df[col].std()
+        report.loc[col, "skewness"] = df[col].skew()
+        report.loc[col, "kurtosis"] = df[col].kurtosis()
+
+    print(f"=== Data Quality Report: {name} ===")
+    print(f"Shape: {df.shape}")
+    print(f"Duplicated rows: {df.duplicated().sum()}")
+    print(f"Columns with >50% missing: "
+          f"{report[report['missing_pct'] > 50].index.tolist()}")
+    print(report.to_string())
+
+    return report
+```
+
+## 3. 欠損値処理 — 選択ガイド
+
+| 手法 | ユースケース | 注意点 |
+|---|---|---|
+| `dropna()` | 完全ケース解析、欠損 <5% | サンプルサイズ減少 |
+| `fillna(median)` | 数値データ、外れ値あり | 分布を歪めうる |
+| `fillna(mean)` | 数値データ、正規分布 | 外れ値に敏感 |
+| `SimpleImputer(strategy='most_frequent')` | カテゴリカル変数 | |
+| `KNNImputer(n_neighbors=5)` | 変数間に相関がある場合 | 計算コスト高い |
+| `IterativeImputer` | 多変量欠損パターン (MICE) | scikit-learn experimental |
+
+```python
+from sklearn.impute import SimpleImputer, KNNImputer
+
+def handle_missing_values(df, strategy="auto", numeric_cols=None, categorical_cols=None):
+    """
+    欠損値処理パイプライン。
+
+    strategy:
+        "auto"    — 欠損率に応じて自動選択
+        "drop"    — 欠損行を除去
+        "median"  — 中央値で補完
+        "knn"     — KNN で補完 (n_neighbors=5)
+    """
+    df = df.copy()
+
+    if numeric_cols is None:
+        numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    if categorical_cols is None:
+        categorical_cols = df.select_dtypes(include=["object", "category"]).columns.tolist()
+
+    if strategy == "auto":
+        missing_pct = df[numeric_cols].isnull().mean()
+        # カラムごとに最適戦略を適用
+        low_missing = missing_pct[missing_pct < 0.05].index.tolist()
+        mid_missing = missing_pct[(missing_pct >= 0.05) & (missing_pct < 0.30)].index.tolist()
+        high_missing = missing_pct[missing_pct >= 0.30].index.tolist()
+
+        # Low: 中央値補完
+        if low_missing:
+            imp = SimpleImputer(strategy="median")
+            df[low_missing] = imp.fit_transform(df[low_missing])
+
+        # Mid: KNN 補完
+        if mid_missing:
+            imp = KNNImputer(n_neighbors=5)
+            df[mid_missing] = imp.fit_transform(df[mid_missing])
+
+        # High: 警告表示のみ (ドロップ推奨)
+        if high_missing:
+            print(f"WARNING: High missing rate columns ({'>30%'}): {high_missing}")
+            print("Consider dropping these columns or using domain-specific imputation.")
+
+    elif strategy == "drop":
+        df = df.dropna(subset=numeric_cols)
+
+    elif strategy == "median":
+        imp = SimpleImputer(strategy="median")
+        df[numeric_cols] = imp.fit_transform(df[numeric_cols])
+
+    elif strategy == "knn":
+        imp = KNNImputer(n_neighbors=5)
+        df[numeric_cols] = imp.fit_transform(df[numeric_cols])
+
+    # カテゴリカル変数 → 最頻値で補完
+    if categorical_cols:
+        imp_cat = SimpleImputer(strategy="most_frequent")
+        df[categorical_cols] = imp_cat.fit_transform(df[categorical_cols])
+
+    return df
+```
+
+## 4. 外れ値処理
+
+```python
+def detect_outliers(df, columns, method="iqr", threshold=1.5):
+    """
+    外れ値を検出する。
+
+    method:
+        "iqr"     — IQR法 (Q1 - threshold*IQR, Q3 + threshold*IQR)
+        "zscore"  — Z-score 法 (|z| > threshold; default threshold=3)
+        "mad"     — MAD (Median Absolute Deviation) 法
+    """
+    outlier_mask = pd.DataFrame(False, index=df.index, columns=columns)
+
+    for col in columns:
+        vals = df[col].dropna()
+        if method == "iqr":
+            Q1, Q3 = vals.quantile(0.25), vals.quantile(0.75)
+            IQR = Q3 - Q1
+            lower, upper = Q1 - threshold * IQR, Q3 + threshold * IQR
+            outlier_mask[col] = (df[col] < lower) | (df[col] > upper)
+
+        elif method == "zscore":
+            z = np.abs((df[col] - vals.mean()) / vals.std())
+            outlier_mask[col] = z > (threshold if threshold != 1.5 else 3)
+
+        elif method == "mad":
+            median = vals.median()
+            mad = np.median(np.abs(vals - median))
+            modified_z = 0.6745 * (df[col] - median) / (mad + 1e-10)
+            outlier_mask[col] = np.abs(modified_z) > (threshold if threshold != 1.5 else 3.5)
+
+    summary = pd.DataFrame({
+        "outlier_count": outlier_mask.sum(),
+        "outlier_pct": (outlier_mask.sum() / len(df) * 100).round(2),
+    })
+
+    return outlier_mask, summary
+
+
+def handle_outliers(df, columns, method="iqr", action="clip"):
+    """
+    外れ値を処理する。
+
+    action:
+        "clip"    — 境界値にクリッピング
+        "remove"  — 外れ値行を除去
+        "nan"     — NaN に置換（後段で補完）
+    """
+    outlier_mask, summary = detect_outliers(df, columns, method=method)
+    df = df.copy()
+
+    if action == "remove":
+        any_outlier = outlier_mask.any(axis=1)
+        df = df[~any_outlier]
+
+    elif action == "clip":
+        for col in columns:
+            vals = df[col].dropna()
+            Q1, Q3 = vals.quantile(0.25), vals.quantile(0.75)
+            IQR = Q3 - Q1
+            lower, upper = Q1 - 1.5 * IQR, Q3 + 1.5 * IQR
+            df[col] = df[col].clip(lower, upper)
+
+    elif action == "nan":
+        for col in columns:
+            df.loc[outlier_mask[col], col] = np.nan
+
+    return df, summary
+```
+
+## 5. エンコーディング — 選択ガイド
+
+| 手法 | ユースケース | 適用例 |
+|---|---|---|
+| `LabelEncoder` | 順序カテゴリ、ツリー系モデル | 結晶構造タイプ → 0,1,2 |
+| `pd.get_dummies()` | 名義カテゴリ、線形モデル | 材料名 → ダミー変数 |
+| `OrdinalEncoder` | 順序のあるカテゴリ（明示的） | 低/中/高 → 0,1,2 |
+| `TargetEncoder` | 高カーディナリティ | 化合物 ID |
+
+```python
+from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
+
+def encode_categorical(df, columns, method="auto"):
+    """
+    カテゴリカル変数のエンコーディング。
+
+    method:
+        "auto"      — nunique に応じて自動選択
+        "label"     — LabelEncoder
+        "onehot"    — pd.get_dummies()
+        "ordinal"   — OrdinalEncoder
+    """
+    df = df.copy()
+    encoders = {}
+
+    for col in columns:
+        n_unique = df[col].nunique()
+
+        if method == "auto":
+            chosen = "onehot" if n_unique <= 10 else "label"
+        else:
+            chosen = method
+
+        if chosen == "label":
+            le = LabelEncoder()
+            df[col] = le.fit_transform(df[col].astype(str))
+            encoders[col] = le
+
+        elif chosen == "onehot":
+            dummies = pd.get_dummies(df[col], prefix=col, drop_first=True)
+            df = pd.concat([df.drop(columns=[col]), dummies], axis=1)
+
+        elif chosen == "ordinal":
+            oe = OrdinalEncoder()
+            df[col] = oe.fit_transform(df[[col]])
+            encoders[col] = oe
+
+    return df, encoders
+```
+
+## 6. スケーリング・変換 — 選択ガイド
+
+| 手法 | 数式 | ユースケース |
+|---|---|---|
+| `StandardScaler` | $(x - \mu) / \sigma$ | PCA 前、正規分布仮定 |
+| `MinMaxScaler` | $(x - x_{min}) / (x_{max} - x_{min})$ | NN 入力、0〜1 に正規化 |
+| `RobustScaler` | $(x - Q_2) / (Q_3 - Q_1)$ | 外れ値に頑健 |
+| Pareto Scaling | $(x - \bar{x}) / \sqrt{s}$ | メタボロミクス (Exp-07) |
+| Log2 Transform | $\log_2(x + 1)$ | カウント・発現量データ |
+| Box-Cox | $(x^\lambda - 1)/\lambda$ | 正規性改善（正値のみ） |
+
+```python
+from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
+
+def scale_features(df, columns, method="standard"):
+    """
+    特徴量スケーリング。
+
+    method:
+        "standard"  — StandardScaler (z-score)
+        "minmax"    — MinMaxScaler (0-1)
+        "robust"    — RobustScaler (IQR-based)
+        "pareto"    — Pareto scaling (metabolomics 向き)
+        "log2"      — log2(x + 1) 変換
+    """
+    df = df.copy()
+    scaler = None
+
+    if method == "standard":
+        scaler = StandardScaler()
+        df[columns] = scaler.fit_transform(df[columns])
+
+    elif method == "minmax":
+        scaler = MinMaxScaler()
+        df[columns] = scaler.fit_transform(df[columns])
+
+    elif method == "robust":
+        scaler = RobustScaler()
+        df[columns] = scaler.fit_transform(df[columns])
+
+    elif method == "pareto":
+        # Pareto scaling: (x - mean) / sqrt(std)
+        for col in columns:
+            mean = df[col].mean()
+            std = df[col].std()
+            df[col] = (df[col] - mean) / np.sqrt(std + 1e-10)
+
+    elif method == "log2":
+        for col in columns:
+            df[col] = np.log2(df[col] + 1)
+
+    return df, scaler
+```
+
+## 7. 前処理パイプライン統合テンプレート
+
+```python
+def preprocessing_pipeline(df, target_col=None, config=None):
+    """
+    全体前処理パイプライン。設定辞書で制御可能。
+
+    config 例:
+        {
+            "drop_duplicates": True,
+            "missing_strategy": "auto",
+            "outlier_method": "iqr",
+            "outlier_action": "clip",
+            "encoding_method": "auto",
+            "scaling_method": "standard",
+        }
+    """
+    if config is None:
+        config = {
+            "drop_duplicates": True,
+            "missing_strategy": "auto",
+            "outlier_method": "iqr",
+            "outlier_action": "clip",
+            "encoding_method": "auto",
+            "scaling_method": "standard",
+        }
+
+    n_original = len(df)
+
+    # Step 0: 重複除去
+    if config.get("drop_duplicates", True):
+        df = df.drop_duplicates()
+        print(f"  Removed {n_original - len(df)} duplicate rows")
+
+    # Step 1: カラム分類
+    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+    categorical_cols = df.select_dtypes(include=["object", "category"]).columns.tolist()
+    if target_col and target_col in numeric_cols:
+        numeric_cols.remove(target_col)
+    if target_col and target_col in categorical_cols:
+        categorical_cols.remove(target_col)
+
+    # Step 2: 欠損値処理
+    df = handle_missing_values(
+        df,
+        strategy=config.get("missing_strategy", "auto"),
+        numeric_cols=numeric_cols,
+        categorical_cols=categorical_cols,
+    )
+
+    # Step 3: 外れ値処理
+    if numeric_cols:
+        df, outlier_summary = handle_outliers(
+            df, numeric_cols,
+            method=config.get("outlier_method", "iqr"),
+            action=config.get("outlier_action", "clip"),
+        )
+
+    # Step 4: エンコーディング
+    if categorical_cols:
+        df, encoders = encode_categorical(
+            df, categorical_cols,
+            method=config.get("encoding_method", "auto"),
+        )
+    else:
+        encoders = {}
+
+    # Step 5: スケーリング
+    final_numeric = df.select_dtypes(include=[np.number]).columns.tolist()
+    if target_col and target_col in final_numeric:
+        final_numeric.remove(target_col)
+    if final_numeric:
+        df, scaler = scale_features(
+            df, final_numeric,
+            method=config.get("scaling_method", "standard"),
+        )
+    else:
+        scaler = None
+
+    print(f"  Preprocessing complete: {df.shape}")
+
+    return df, {"encoders": encoders, "scaler": scaler}
+```
+
+## References
+
+- **Exp-01**: `sc.pp.normalize_total()`, `sc.pp.log1p()` — scRNA-seq 固有の正規化
+- **Exp-02**: `LabelEncoder`, `pd.get_dummies()` — 化合物記述子エンコーディング
+- **Exp-03**: `StandardScaler` + `log2(x+1)` — がんデータ前処理
+- **Exp-05**: `StandardScaler`, `KNNImputer` — 毒性予測データ
+- **Exp-07**: Pareto scaling — メタボロミクスデータ
+- **Exp-12**: `MinMaxScaler`, `RobustScaler` — プロセスデータ
+- **Exp-13**: `LabelEncoder`, ダミー変数 — 材料タイプエンコーディング

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

@@ -0,0 +1,244 @@
+---
+name: scientific-data-simulation
+description: |
+  物理・化学・生物学に基づく合成データ生成のスキル。実験データが不足する場合に、
+  ドメイン知識を反映したシミュレーションデータを生成する際に使用。
+  Scientific Skills Exp-06, 07, 08, 09, 12, 13 で確立したパターン。
+---
+
+# Scientific Data Simulation & Generation
+
+物理法則・化学モデル・生物学的知見に基づいて、現実的なシミュレーションデータを
+生成するスキル。実データの不足を補い、ML パイプラインの開発・検証を可能にする。
+
+## When to Use
+
+- 実験データが未取得または不十分なとき
+- ML パイプラインのプロトタイピングに合成データが必要なとき
+- 特定の物理・化学法則に基づくデータ生成
+- 既知の因果関係を組み込んだベンチマークデータの作成
+
+## Quick Start
+
+## 設計原則
+
+1. **物理モデルベース**: 単純な正規分布ではなく、ドメインの因果関係を反映する
+2. **ノイズの付加**: 実験の不確実性を模擬する適切なノイズレベル
+3. **材料/群の多様性**: 複数の材料種・条件を生成し、群間差を反映
+4. **範囲の現実性**: パラメータ範囲は実験装置・物理限界に基づく
+
+## データ生成テンプレート
+
+### 1. プロセスデータ生成（Exp-12, 13 パターン）
+
+```python
+import numpy as np
+import pandas as pd
+
+def generate_process_dataset(n_samples=500, seed=42):
+    """
+    物理ベースのプロセスデータを生成するテンプレート。
+    因果関係: Process → Structure → Property
+    """
+    rng = np.random.default_rng(seed)
+
+    # === Process パラメータ（独立変数）===
+    temperature = rng.uniform(25, 500, n_samples)      # °C
+    pressure = rng.uniform(0.1, 5.0, n_samples)        # Pa
+    power = rng.uniform(50, 500, n_samples)             # W
+    time = rng.uniform(5, 120, n_samples)               # min
+
+    # === Structure 変数（Process に依存）===
+    # 物理モデル：因果関係を組み込む
+    dep_rate = (
+        0.5
+        + 0.02 * power                    # 出力依存
+        - 0.005 * pressure ** 2           # 高圧での飽和
+        + rng.normal(0, 0.5, n_samples)   # ノイズ
+    )
+    dep_rate = np.clip(dep_rate, 0.1, 30)
+
+    thickness = dep_rate * time
+    thickness = np.clip(thickness, 5, 2000)
+
+    crystallite_size = (
+        5
+        + 0.1 * temperature               # 温度依存（アレニウス的）
+        + 0.01 * time                      # 時間依存
+        + rng.normal(0, 2, n_samples)      # ノイズ
+    )
+    crystallite_size = np.clip(crystallite_size, 2, 80)
+
+    # === Property 変数（Structure に依存）===
+    resistivity = (
+        1e-2
+        * np.exp(-0.005 * temperature)      # 温度活性化
+        * (1 + 0.01 * pressure)
+        * np.exp(rng.normal(0, 0.3, n_samples))  # 対数正規ノイズ
+    )
+
+    transmittance = (
+        95
+        - 0.02 * thickness                  # 膜厚依存
+        + 0.05 * crystallite_size            # 結晶子サイズ依存
+        + rng.normal(0, 1, n_samples)
+    )
+    transmittance = np.clip(transmittance, 40, 98)
+
+    df = pd.DataFrame({
+        "Temperature": temperature,
+        "Pressure": pressure,
+        "Power": power,
+        "Time": time,
+        "Deposition_Rate": dep_rate,
+        "Thickness": thickness,
+        "Crystallite_Size": crystallite_size,
+        "Resistivity": resistivity,
+        "Transmittance": transmittance,
+    })
+
+    return df
+```
+
+### 2. 多材料データ生成（Exp-13 パターン）
+
+```python
+def generate_multi_material_dataset(materials, n_per_material=100, seed=42):
+    """
+    複数材料の PSP データを生成する。
+    materials: {"ZnO": {"Tm": 2248, "Eg": 3.3}, ...} の辞書
+    """
+    rng = np.random.default_rng(seed)
+    all_data = []
+
+    for mat_name, props in materials.items():
+        n = n_per_material
+        Tm = props["Tm"]  # 融点 (K)
+        Eg = props["Eg"]  # バンドギャップ (eV)
+
+        # Process
+        Tsub = rng.uniform(25, 500, n)
+        Pwork = rng.uniform(0.1, 5.0, n)
+        Power = rng.uniform(50, 500, n)
+
+        # Structure（材料依存の因果関係）
+        T_homologous = (Tsub + 273.15) / Tm  # 相同温度
+        crystallite = 5 + 80 * T_homologous + rng.normal(0, 3, n)
+        crystallite = np.clip(crystallite, 2, 80)
+
+        # Property（材料固有値 + プロセス依存変動）
+        bandgap = Eg + rng.normal(0, 0.1, n)
+
+        data = pd.DataFrame({
+            "Material": mat_name,
+            "Substrate_Temp": Tsub,
+            "Working_Pressure": Pwork,
+            "Power": Power,
+            "T_homologous": T_homologous,
+            "Crystallite_Size": crystallite,
+            "Bandgap": bandgap,
+        })
+        all_data.append(data)
+
+    return pd.concat(all_data, ignore_index=True)
+```
+
+### 3. 臨床試験データ生成（Exp-06 パターン）
+
+```python
+def generate_clinical_trial_data(n_total=500, effect_size=0.3, seed=42):
+    """RCT シミュレーションデータを生成する。"""
+    rng = np.random.default_rng(seed)
+    n_per_arm = n_total // 2
+
+    # 人口統計
+    ages = np.concatenate([
+        rng.normal(55, 12, n_per_arm),
+        rng.normal(55, 12, n_per_arm),
+    ])
+    sex = rng.choice(["M", "F"], n_total)
+    group = np.array(["Treatment"] * n_per_arm + ["Control"] * n_per_arm)
+
+    # 主要エンドポイント
+    baseline = rng.normal(100, 15, n_total)
+    treatment_effect = np.where(group == "Treatment", effect_size * 15, 0)
+    endpoint = baseline + treatment_effect + rng.normal(0, 10, n_total)
+
+    # 生存時間（指数分布）
+    survival_time = rng.exponential(
+        np.where(group == "Treatment", 365 * 2, 365 * 1.5),
+        n_total
+    )
+    event = rng.binomial(1, 0.7, n_total)
+
+    return pd.DataFrame({
+        "Patient_ID": range(1, n_total + 1),
+        "Group": group,
+        "Age": ages.astype(int),
+        "Sex": sex,
+        "Baseline": baseline,
+        "Endpoint": endpoint,
+        "Survival_Time": survival_time,
+        "Event": event,
+    })
+```
+
+### 4. スペクトルデータ生成（Exp-08, 11 パターン）
+
+```python
+def generate_spectrum(wavenumbers, peak_positions, peak_heights,
+                       peak_widths, noise_level=0.02, seed=None):
+    """
+    ガウスピーク合成によるスペクトルを生成する。
+    ラマン / IR / UV-Vis などに汎用。
+    """
+    rng = np.random.default_rng(seed)
+    spectrum = np.zeros_like(wavenumbers, dtype=float)
+
+    for pos, height, width in zip(peak_positions, peak_heights, peak_widths):
+        spectrum += height * np.exp(-0.5 * ((wavenumbers - pos) / width) ** 2)
+
+    # ノイズ付加
+    spectrum += rng.normal(0, noise_level * spectrum.max(), len(wavenumbers))
+    return spectrum
+
+
+def generate_ecg_beat(t, hr=72):
+    """合成 ECG 波形（PQRST パターン）を生成する。"""
+    beat_duration = 60.0 / hr
+    # P 波、QRS 群、T 波のガウス重ね合わせ
+    p_wave = 0.1 * np.exp(-((t % beat_duration - 0.16) / 0.04) ** 2)
+    qrs = 1.0 * np.exp(-((t % beat_duration - 0.25) / 0.01) ** 2)
+    q_wave = -0.15 * np.exp(-((t % beat_duration - 0.22) / 0.015) ** 2)
+    s_wave = -0.1 * np.exp(-((t % beat_duration - 0.28) / 0.015) ** 2)
+    t_wave = 0.2 * np.exp(-((t % beat_duration - 0.40) / 0.05) ** 2)
+    return p_wave + q_wave + qrs + s_wave + t_wave
+```
+
+## 品質チェックリスト
+
+生成データの品質を保証するためのチェック項目：
+
+- [ ] パラメータ範囲が物理的に現実的か
+- [ ] 因果関係の方向が正しいか（温度↑ → 結晶子サイズ↑ など）
+- [ ] ノイズレベルが実験の再現性に対応するか
+- [ ] 外れ値の割合が現実的か（通常 1-5%）
+- [ ] 変数間の相関構造が既知の物理法則と一致するか
+- [ ] 群間差が効果量として検出可能な水準か
+
+## References
+
+### Output Files
+
+| ファイル | 形式 |
+|---|---|
+| `data/<dataset_name>.csv` | CSV |
+
+#### 参照実験
+
+- **Exp-06**: 臨床試験 RCT シミュレーション（500 名、2 群）
+- **Exp-07**: メタボロミクス合成データ（100 サンプル × 200 代謝物）
+- **Exp-08**: 合成 ECG/EEG 信号（PQRST、帯域合成）
+- **Exp-09**: コドンバイアス反映ゲノム配列
+- **Exp-12**: エッチングプロセスデータ（500 サンプル × 8 パラメータ）
+- **Exp-13**: 薄膜成膜データ（600 サンプル × 6 材料 × PSP 3 階層）