@brainpilot/skills 0.0.6 → 0.0.8

package/skills/05_EEG_ERP/seed-iv-skill/scripts/extract_seed_iv_features.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Extract features from SEED-IV EEG data.
+
+Supports Differential Entropy (DE), Power Spectral Density (PSD),
+and band power features for emotion recognition.
+"""
+import argparse
+import csv
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+
+
+def compute_de_features(data: np.ndarray, sfreq: float = 200.0) -> np.ndarray:
+    """Compute Differential Entropy features across frequency bands.
+
+    DE = 0.5 * log(2*pi*e*sigma^2) for each band.
+    Bands: delta (1-4), theta (4-8), alpha (8-14), beta (14-31), gamma (31-50).
+    """
+    from scipy.signal import butter, filtfilt
+
+    bands = {
+        "delta": (1, 4),
+        "theta": (4, 8),
+        "alpha": (8, 14),
+        "beta": (14, 31),
+        "gamma": (31, 50),
+    }
+
+    n_channels = data.shape[0] if data.ndim > 1 else 1
+    de_features = np.zeros((n_channels, len(bands)))
+
+    for j, (band_name, (low, high)) in enumerate(bands.items()):
+        nyq = sfreq / 2.0
+        b, a = butter(4, [low / nyq, high / nyq], btype="band")
+        if data.ndim > 1:
+            for ch in range(n_channels):
+                filtered = filtfilt(b, a, data[ch])
+                var = np.var(filtered)
+                de_features[ch, j] = 0.5 * np.log(2 * np.pi * np.e * max(var, 1e-10))
+        else:
+            filtered = filtfilt(b, a, data)
+            var = np.var(filtered)
+            de_features[0, j] = 0.5 * np.log(2 * np.pi * np.e * max(var, 1e-10))
+
+    return de_features
+
+
+def compute_psd_features(data: np.ndarray, sfreq: float = 200.0) -> np.ndarray:
+    """Compute PSD features using Welch's method."""
+    from scipy.signal import welch
+
+    n_channels = data.shape[0] if data.ndim > 1 else 1
+    bands = {
+        "delta": (1, 4),
+        "theta": (4, 8),
+        "alpha": (8, 14),
+        "beta": (14, 31),
+        "gamma": (31, 50),
+    }
+    psd_features = np.zeros((n_channels, len(bands)))
+
+    for ch in range(n_channels if data.ndim > 1 else 1):
+        signal = data[ch] if data.ndim > 1 else data
+        freqs, psd = welch(signal, fs=sfreq, nperseg=min(256, len(signal)))
+        for j, (band_name, (low, high)) in enumerate(bands.items()):
+            mask = (freqs >= low) & (freqs <= high)
+            psd_features[ch, j] = np.trapz(psd[mask], freqs[mask]) if mask.any() else 0.0
+
+    return psd_features
+
+
+def load_eeg_file(path: Path) -> tuple:
+    """Load EEG data from various formats."""
+    suffix = path.suffix.lower()
+
+    if suffix == ".mat":
+        import scipy.io as sio
+        mat = sio.loadmat(str(path))
+        # Find the data key
+        for key in mat:
+            if not key.startswith("_") and isinstance(mat[key], np.ndarray) and mat[key].ndim >= 2:
+                return mat[key], 200.0
+        raise ValueError(f"No EEG data found in {path}")
+
+    elif suffix in (".edf", ".bdf"):
+        import mne
+        raw = mne.io.read_raw_edf(str(path), preload=True, verbose=False)
+        return raw.get_data(), raw.info["sfreq"]
+
+    elif suffix == ".set":
+        import mne
+        raw = mne.io.read_raw_eeglab(str(path), preload=True, verbose=False)
+        return raw.get_data(), raw.info["sfreq"]
+
+    elif suffix == ".vhdr":
+        import mne
+        raw = mne.io.read_raw_brainvision(str(path), preload=True, verbose=False)
+        return raw.get_data(), raw.info["sfreq"]
+
+    else:
+        raise ValueError(f"Unsupported EEG format: {suffix}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Extract SEED-IV EEG features.")
+    parser.add_argument("--input", required=True, help="Path to SEED-IV BIDS directory")
+    parser.add_argument("--output", required=True, help="Output directory for features")
+    parser.add_argument("--feature-type", choices=["de", "psd", "both"], default="de",
+                        help="Feature type: de (Differential Entropy), psd, or both")
+    parser.add_argument("--subject", help="Process specific subject only")
+    parser.add_argument("--epoch-duration", type=float, default=4.0,
+                        help="Epoch duration in seconds (default: 4.0)")
+    args = parser.parse_args()
+
+    input_dir = Path(args.input).resolve()
+    if not input_dir.exists():
+        print(f"Input directory not found: {input_dir}", file=sys.stderr)
+        return 1
+
+    output_dir = Path(args.output).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Find subjects
+    if args.subject:
+        subjects = [args.subject]
+    else:
+        subjects = sorted([d.name for d in input_dir.glob("sub-*") if d.is_dir()])
+
+    band_names = ["delta", "theta", "alpha", "beta", "gamma"]
+    all_results = []
+
+    for subj in subjects:
+        subj_dir = input_dir / subj
+        # Find all EEG files
+        eeg_files = list(subj_dir.rglob("*.edf")) + list(subj_dir.rglob("*.set")) + \
+                    list(subj_dir.rglob("*.vhdr")) + list(subj_dir.rglob("*.mat"))
+
+        for eeg_file in eeg_files:
+            try:
+                data, sfreq = load_eeg_file(eeg_file)
+
+                # Epoch the data
+                epoch_samples = int(args.epoch_duration * sfreq)
+                n_epochs = data.shape[-1] // epoch_samples if data.ndim > 1 else len(data) // epoch_samples
+
+                for epoch_idx in range(n_epochs):
+                    start = epoch_idx * epoch_samples
+                    end = start + epoch_samples
+                    epoch_data = data[..., start:end] if data.ndim > 1 else data[start:end]
+
+                    if args.feature_type in ("de", "both"):
+                        de = compute_de_features(epoch_data, sfreq)
+                        row = {"subject": subj, "file": eeg_file.name, "epoch": epoch_idx, "feature": "DE"}
+                        for ch_idx in range(de.shape[0]):
+                            for band_idx, band in enumerate(band_names):
+                                row[f"ch{ch_idx}_{band}"] = f"{de[ch_idx, band_idx]:.6f}"
+                        all_results.append(row)
+
+                    if args.feature_type in ("psd", "both"):
+                        psd = compute_psd_features(epoch_data, sfreq)
+                        row = {"subject": subj, "file": eeg_file.name, "epoch": epoch_idx, "feature": "PSD"}
+                        for ch_idx in range(psd.shape[0]):
+                            for band_idx, band in enumerate(band_names):
+                                row[f"ch{ch_idx}_{band}"] = f"{psd[ch_idx, band_idx]:.6f}"
+                        all_results.append(row)
+
+            except Exception as e:
+                print(f"[WARN] Failed to process {eeg_file}: {e}", file=sys.stderr)
+
+    if not all_results:
+        print("[ERROR] No features extracted.", file=sys.stderr)
+        return 1
+
+    # Write output
+    output_path = output_dir / f"seed_iv_features_{args.feature_type}.csv"
+    fieldnames = list(all_results[0].keys())
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(all_results)
+
+    print(f"Features: {len(all_results)} epochs, {len(fieldnames)} columns -> {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/05_EEG_ERP/seed-iv-skill/scripts/validate_seed_iv.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Validate SEED-IV BIDS structure and generate compliance report.
+
+Checks directory structure, subject/session completeness, and EEG file presence.
+"""
+import argparse
+import csv
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+
+def validate_subject(subject_dir: Path) -> Dict[str, any]:
+    report = {
+        "subject": subject_dir.name,
+        "n_sessions": 0,
+        "eeg_complete": False,
+        "events_present": False,
+        "missing_files": [],
+        "warnings": [],
+    }
+
+    sessions = [d for d in subject_dir.glob("ses-*") if d.is_dir()]
+    report["n_sessions"] = len(sessions)
+
+    if not sessions:
+        # Check root-level EEG
+        eeg_dir = subject_dir / "eeg"
+        if eeg_dir.exists():
+            eeg_files = list(eeg_dir.glob("*.edf")) + list(eeg_dir.glob("*.set")) + list(eeg_dir.glob("*.vhdr"))
+            report["eeg_complete"] = len(eeg_files) > 0
+            events = list(eeg_dir.glob("*_events.tsv"))
+            report["events_present"] = len(events) > 0
+        else:
+            report["missing_files"].append("eeg/")
+    else:
+        eeg_count = 0
+        events_count = 0
+        for ses in sessions:
+            eeg_dir = ses / "eeg"
+            if eeg_dir.exists():
+                eeg_files = list(eeg_dir.glob("*.edf")) + list(eeg_dir.glob("*.set")) + list(eeg_dir.glob("*.vhdr"))
+                eeg_count += len(eeg_files)
+                events_count += len(list(eeg_dir.glob("*_events.tsv")))
+            else:
+                report["missing_files"].append(f"{ses.name}/eeg/")
+        report["eeg_complete"] = eeg_count > 0
+        report["events_present"] = events_count > 0
+
+    if report["n_sessions"] < 3:
+        report["warnings"].append(f"Only {report['n_sessions']} sessions (expected 3)")
+
+    return report
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Validate SEED-IV BIDS structure.")
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--output", required=True)
+    args = parser.parse_args()
+
+    input_dir = Path(args.input).resolve()
+    if not input_dir.exists():
+        print(f"Input directory not found: {input_dir}", file=sys.stderr)
+        return 1
+
+    subjects = sorted([d for d in input_dir.glob("sub-*") if d.is_dir()])
+    print(f"Found {len(subjects)} subjects in {input_dir}")
+
+    if not subjects:
+        print("[ERROR] No subjects found.", file=sys.stderr)
+        return 1
+
+    results = []
+    for sub_dir in subjects:
+        report = validate_subject(sub_dir)
+        results.append(report)
+
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    fieldnames = ["subject", "n_sessions", "eeg_complete", "events_present", "missing_files", "warnings"]
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for r in results:
+            r["missing_files"] = "; ".join(r["missing_files"])
+            r["warnings"] = "; ".join(r["warnings"])
+            writer.writerow(r)
+
+    print(f"\nValidation Summary:")
+    print(f"  Total subjects: {len(results)}")
+    print(f"  With EEG: {sum(1 for r in results if r['eeg_complete'])}")
+    print(f"  With events: {sum(1 for r in results if r['events_present'])}")
+    print(f"  Total sessions: {sum(r['n_sessions'] for r in results)}")
+    print(f"  Output: {output_path}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/05_EEG_ERP/seed-vig-skill/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: seed-vig-skill
+description: "Use this skill whenever the user wants an end-to-end workflow for the SEED-VIG (SJTU Emotion EEG Dataset - Vigilance) dataset, including EEG validation, preprocessing, feature extraction, and vigilance/fatigue detection. Triggers include: 'SEED-VIG', 'SEEDVIG', 'vigilance EEG', 'fatigue detection', 'drowsiness EEG', 'process SEED-VIG', or any request to run the SEED-VIG pipeline."
+license: MIT License (NeuroClaw custom skill - freely modifiable within the project)
+layer: subagent
+skill_type: dataset
+dependencies:
+  - eeg-skill
+  - bids-organizer
+  - claw-shell
+complementary_skills:
+  - brain-visualization
+---
+# SEED-VIG Skill (Dataset-Orchestration Layer)
+
+## Overview
+
+`seed-vig-skill` is the NeuroClaw orchestration skill for the **SEED-VIG (SJTU Emotion EEG Dataset - Vigilance)** dataset, developed by the BCMI Lab at Shanghai Jiao Tong University for vigilance/fatigue detection research.
+
+It strictly follows the NeuroClaw hierarchical design principles:
+- This skill **only describes WHAT needs to be done** and **which tool skill to delegate to**.
+- It contains **no implementation code or concrete commands**.
+- All concrete execution is delegated to existing base/tool skills via `claw-shell`.
+- Companion scripts in `scripts/` provide reference implementations for EEG validation, feature extraction, and vigilance classification.
+
+**Core workflow (never bypassed):**
+1. Identify input SEED-VIG data and target analysis.
+2. Generate a **numbered execution plan** clearly stating WHAT needs to be done and which tool skill will handle each step.
+3. Present the full plan, estimated runtime, resource requirements, and risks to the user and wait for explicit confirmation ("YES" / "execute" / "proceed").
+4. On confirmation, delegate every step to the appropriate skill via `claw-shell`.
+5. After execution, save all outputs in a clean directory structure (`seed_vig_output/`).
+
+**Research use only.**
+
+---
+
+## Quick Reference
+
+| Task | What needs to be done | Delegate to | Expected output |
+|---|---|---|---|
+| EEG validation | Validate SEED-VIG BIDS structure | `scripts/validate_seed_vig.py` | Validation report |
+| EEG preprocessing | Filtering, artifact removal | `eeg-skill` | `eeg_output/` preprocessed EEG |
+| Feature extraction | Band power, DE, connectivity | `scripts/extract_seed_vig_features.py` | Feature matrices |
+| Vigilance classification | Binary/multi-class vigilance detection | `scripts/classify_seed_vig.py` | Classification results |
+
+---
+
+## Dataset Characteristics
+
+- **Cohort**: 23 healthy subjects
+- **Task**: Simulated driving task (vigilance decrement paradigm)
+- **EEG System**: 17-channel EEG (ESI NeuroScan or dry electrodes)
+- **Sampling rate**: 200 Hz
+- **Reference**: Linked mastoids (M1/M2)
+- **Labels**: Vigilance levels (KSS scale or EEG-derived)
+- **Duration**: ~2 hours per subject
+- **Access**: BCMI Lab (bcmi.sjtu.edu.cn/~seed/)
+- **Format**: MATLAB .mat files (community BIDS conversion available)
+
+---
+
+## Supported Modalities
+
+| Modality | Description | Details |
+|---|---|---|
+| EEG | 17-channel EEG | ESI NeuroScan, 200 Hz |
+| Eye tracking | Eye movement data | Blinks, gaze position |
+| Peripheral | EOG, EMG | Eye/muscle artifacts |
+
+---
+
+## SEED-VIG Vigilance Labels
+
+| Label | Description | Method |
+|---|---|---|
+| KSS | Karolinska Sleepiness Scale | Self-report (1-9) |
+| EEG-based | Theta/alpha/beta power ratios | Spectral analysis |
+| Binary | Alert vs. Drowsy | Threshold-based |
+
+---
+
+## BIDS Preparation
+
+### Script: `scripts/validate_seed_vig.py`
+
+Validates SEED-VIG BIDS structure and generates a compliance report.
+
+```bash
+python skills/seed-vig-skill/scripts/validate_seed_vig.py \
+  --input /path/to/SEED-VIG/bids \
+  --output /path/to/seed_vig_output/qc/bids_validation.csv
+```
+
+Features:
+- BIDS directory structure validation
+- Subject completeness check (23 subjects)
+- EEG file presence verification
+- Vigilance label availability check
+
+---
+
+## Core Workflow (Never Bypassed)
+
+1. Identify user target: full SEED-VIG pipeline, feature extraction only, or classification only.
+2. Generate a numbered plan with tools, outputs, runtime, storage, and risks.
+3. Wait for explicit confirmation (`YES` / `execute` / `proceed`).
+4. On confirmation, run BIDS validation using `scripts/validate_seed_vig.py`.
+5. Delegate to `eeg-skill` for EEG preprocessing.
+6. Run `scripts/extract_seed_vig_features.py` for feature extraction.
+7. Run `scripts/classify_seed_vig.py` for vigilance classification.
+8. Save outputs into `seed_vig_output/`.
+
+---
+
+## Standard Output Layout
+
+```
+seed_vig_output/
+├── bids/                   # BIDS-staged data (or validation report)
+├── eeg/                    # Preprocessed EEG derivatives
+├── features/               # Extracted features (band power, DE)
+├── classification/         # Vigilance classification results
+├── qc/                     # QC summaries
+└── logs/                   # Processing logs
+```
+
+---
+
+## Benchmark Adapter Guidance
+
+For benchmark-style prompts, do not force the full orchestration when the task only asks for local SEED-VIG data validation.
+
+- If the task starts from SEED-VIG data already present on disk and only asks for BIDS validation:
+  - Skip the download stage
+  - Default to the narrow path `local SEED-VIG discovery -> BIDS validation -> report`
+- In benchmark mode, do not require explicit confirmation before presenting the validation solution.
+
+---
+
+## Safety and Execution Policy
+- No execution before explicit plan confirmation.
+- All execution must be routed via `claw-shell`.
+- Missing dependencies must be resolved by `dependency-planner` before running.
+
+---
+
+## Important Notes and Limitations
+- 17-channel EEG provides limited spatial resolution compared to high-density systems.
+- Simulated driving may not fully replicate real-world drowsiness.
+- Theta/alpha/beta power ratios are commonly used spectral features for vigilance detection.
+- Cross-subject calibration is often needed due to individual differences in EEG patterns.
+- `seed-vig-skill` is orchestration-only; detailed preprocessing logic remains in modality skills.
+
+---
+
+## When to Call This Skill
+- User asks for end-to-end SEED-VIG workflow.
+- User asks to process SEED-VIG EEG data.
+- User needs BIDS validation for SEED-VIG data.
+- User asks for EEG-based vigilance/fatigue detection analysis.
+- User asks for drowsiness detection or alertness monitoring.
+
+---
+
+## Complementary / Related Skills
+- `eeg-skill` → EEG preprocessing and feature extraction
+- `bids-organizer` → BIDS validation and organization
+- `brain-visualization` → visualization of derivatives
+- `dependency-planner` → dependency resolution
+- `conda-env-manager` → environment management
+- `claw-shell` → command execution
+
+---
+
+## Reference
+- SEED-VIG: https://bcmi.sjtu.edu.cn/~seed/
+- BCMI Lab, Shanghai Jiao Tong University
+- Wei et al. (2017): EEG-based vigilance estimation using extreme learning machines. Neurocomputing.
+
+Created At: 2026-05-06 14:21 HKT
+Last Updated At: 2026-05-06 14:21 HKT
+Author: chengwang96

package/skills/05_EEG_ERP/seed-vig-skill/scripts/classify_seed_vig.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Classify vigilance states from SEED-VIG features.
+
+Supports binary (alert vs. drowsy) and multi-class vigilance detection.
+"""
+import argparse
+import csv
+import json
+import sys
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import numpy as np
+
+
+def load_features(features_path: Path) -> Tuple[np.ndarray, np.ndarray, List[str]]:
+    """Load features and labels from CSV."""
+    import pandas as pd
+    df = pd.read_csv(features_path)
+
+    label_col = None
+    for col in ["vigilance", "label", "kss", "state"]:
+        if col in df.columns:
+            label_col = col
+            break
+
+    if label_col is None:
+        raise ValueError("No vigilance label column found")
+
+    feature_cols = [c for c in df.columns if c.startswith("ch") and "_" in c]
+
+    X = df[feature_cols].values.astype(float)
+    y_raw = df[label_col].values
+
+    # Binarize if needed (e.g., KSS 1-4 -> alert, 5-9 -> drowsy)
+    try:
+        y = y_raw.astype(int)
+        if y.max() > 2:
+            y = (y >= 5).astype(int)  # KSS-based binarization
+    except ValueError:
+        unique = np.unique(y_raw)
+        y = np.array([0 if v == unique[0] else 1 for v in y_raw])
+
+    subjects = df["subject"].tolist() if "subject" in df.columns else [f"sub-{i}" for i in range(len(y))]
+
+    return X, y, subjects
+
+
+def classify_svm(X: np.ndarray, y: np.ndarray, subjects: List[str]) -> Dict:
+    """SVM classification with LOSO CV."""
+    from sklearn.svm import SVC
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.model_selection import LeaveOneGroupOut
+    from sklearn.metrics import classification_report, roc_auc_score
+
+    scaler = StandardScaler()
+    logo = LeaveOneGroupOut()
+    y_pred_all, y_true_all, y_score_all = [], [], []
+
+    for train_idx, test_idx in logo.split(X, y, subjects):
+        X_train = scaler.fit_transform(X[train_idx])
+        X_test = scaler.transform(X[test_idx])
+        svm = SVC(kernel="rbf", C=1.0, gamma="scale", probability=True)
+        svm.fit(X_train, y[train_idx])
+        y_pred_all.extend(svm.predict(X_test))
+        y_true_all.extend(y[test_idx])
+        y_score_all.extend(svm.predict_proba(X_test)[:, 1])
+
+    y_pred_all = np.array(y_pred_all)
+    y_true_all = np.array(y_true_all)
+    y_score_all = np.array(y_score_all)
+
+    accuracy = float(np.mean(y_pred_all == y_true_all))
+    try:
+        auc = float(roc_auc_score(y_true_all, y_score_all))
+    except ValueError:
+        auc = 0.0
+
+    return {
+        "method": "SVM (RBF)",
+        "cv": "Leave-One-Subject-Out",
+        "accuracy": accuracy,
+        "auc": auc,
+        "n_subjects": len(set(subjects)),
+        "n_samples": len(y_true_all),
+    }
+
+
+def classify_rf(X: np.ndarray, y: np.ndarray, subjects: List[str]) -> Dict:
+    """Random Forest classification with LOSO CV."""
+    from sklearn.ensemble import RandomForestClassifier
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.model_selection import LeaveOneGroupOut
+    from sklearn.metrics import roc_auc_score
+
+    scaler = StandardScaler()
+    logo = LeaveOneGroupOut()
+    y_pred_all, y_true_all, y_score_all = [], [], []
+
+    for train_idx, test_idx in logo.split(X, y, subjects):
+        X_train = scaler.fit_transform(X[train_idx])
+        X_test = scaler.transform(X[test_idx])
+        rf = RandomForestClassifier(n_estimators=100, random_state=42)
+        rf.fit(X_train, y[train_idx])
+        y_pred_all.extend(rf.predict(X_test))
+        y_true_all.extend(y[test_idx])
+        y_score_all.extend(rf.predict_proba(X_test)[:, 1])
+
+    y_pred_all = np.array(y_pred_all)
+    y_true_all = np.array(y_true_all)
+    y_score_all = np.array(y_score_all)
+
+    accuracy = float(np.mean(y_pred_all == y_true_all))
+    try:
+        auc = float(roc_auc_score(y_true_all, y_score_all))
+    except ValueError:
+        auc = 0.0
+
+    return {
+        "method": "Random Forest (100 trees)",
+        "cv": "Leave-One-Subject-Out",
+        "accuracy": accuracy,
+        "auc": auc,
+        "n_subjects": len(set(subjects)),
+        "n_samples": len(y_true_all),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Classify SEED-VIG vigilance states.")
+    parser.add_argument("--input", required=True, help="Path to features CSV")
+    parser.add_argument("--output", required=True, help="Output path for results")
+    parser.add_argument("--method", choices=["svm", "rf", "both"], default="both")
+    args = parser.parse_args()
+
+    input_path = Path(args.input).resolve()
+    if not input_path.exists():
+        print(f"Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    X, y, subjects = load_features(input_path)
+    print(f"Loaded {len(y)} samples, classes: {np.unique(y)}, {len(set(subjects))} subjects")
+
+    results = []
+    if args.method in ("svm", "both"):
+        svm_result = classify_svm(X, y, subjects)
+        results.append(svm_result)
+        print(f"SVM accuracy: {svm_result['accuracy']:.4f}, AUC: {svm_result['auc']:.4f}")
+
+    if args.method in ("rf", "both"):
+        rf_result = classify_rf(X, y, subjects)
+        results.append(rf_result)
+        print(f"RF accuracy: {rf_result['accuracy']:.4f}, AUC: {rf_result['auc']:.4f}")
+
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(results, f, indent=2, default=str)
+
+    print(f"Results saved to {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())