Agent skill

PyHealth Clinical ML Toolkit

by davila7 in davila7/claude-code-templates

Builds machine learning pipelines on clinical data with PyHealth: EHR datasets, prediction tasks, medical code mapping, healthcare models and evaluation.

MITAuto-check passedResearch & Science

Install PyHealth Clinical ML Toolkit

skills CLI
$ npx skills add davila7/claude-code-templates --skill pyhealth -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install davila7/claude-code-templates pyhealth --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/davila7/claude-code-templates.git skills-src && mkdir -p .claude/skills && cp -r skills-src/cli-tool/components/skills/scientific/pyhealth .claude/skills/pyhealth && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
pyhealth
GitHub stars
33k
Used in
11 other repos
Token cost
~4.4k tokens
SKILL.md length
1,424 words
Files
7 (incl. references)
Skills in repo
479
Repo updated
First seen
Licence
MIT

At a glance

Builds machine learning pipelines on clinical data with PyHealth: EHR datasets, prediction tasks, medical code mapping, healthcare models and evaluation.

  • Works in 6 steps: Datasets and Data Structures → Medical Coding Translation → Clinical Prediction Tasks → …
  • Training a mortality or readmission model on MIMIC-IV records
  • SKILL.md covers Overview, When to Use This Skill, Core Capabilities and Quick Start Workflow, plus 6 more sections
  • Calls uv

What it does

PyHealth is a Python library for healthcare AI. The skill organizes work as a five-stage pipeline: load a healthcare dataset such as MIMIC-III, MIMIC-IV, eICU, OMOP or sleep EEG data, define a prediction task, pick a model, train it, then calibrate and validate for clinical use. Its quick start loads MIMIC-IV, applies a mortality prediction task, splits the data by patient and builds data loaders.

Task examples include mortality prediction, hospital readmission, length of stay and drug recommendation. The skill also covers translating between medical coding systems (ICD-9 and ICD-10, NDC, RxNorm, ATC), models such as RETAIN, SafeDrug, GAMENet, StageNet and a Transformer for EHR, and evaluation with fairness metrics, calibration, interpretability and uncertainty quantification. Reference files cover datasets, medical coding, models, preprocessing, tasks, and training and evaluation.

When your agent uses it

  • Training a mortality or readmission model on MIMIC-IV records
  • Translating diagnosis or drug codes between ICD, NDC, RxNorm and ATC
  • Building a drug recommendation model with SafeDrug or GAMENet
  • Checking a clinical model for calibration and fairness before deployment

Example prompts

  • “Load MIMIC-IV with PyHealth, set up mortality prediction and train a RETAIN model with a patient-level split.”
  • “Map these ICD-10 diagnosis codes to their parent categories with PyHealth's coding tools.”
  • “Evaluate the trained readmission model for calibration and report subgroup fairness metrics.”

Requirements

  • Python with `pyhealth` installed
  • Access to a healthcare dataset such as MIMIC-IV, eICU or OMOP

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Datasets and Data Structures
  2. Medical Coding Translation
  3. Clinical Prediction Tasks
  4. Models and Architectures
  5. Data Preprocessing
  6. Training and Evaluation

What it can do on your machine

Read from SKILL.md and the folder at commit 79182c5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • uv

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • pyhealth.readthedocs.io
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

PyHealth Clinical ML Toolkit loads about 4.4k tokens when it runs, and up to ~22k if it reads all its reference files. Until then it costs about 126 tokens; SKILL.md has 1,424 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~126
When it runs · the whole SKILL.md, loaded when a task matches
~4.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~22k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from davila7/claude-code-templates at commit 79182c5, republished under its MIT licence (© davila7). 1,424 words, ~4,382 tokens.

Download SKILL.mdSave it as .claude/skills/pyhealth/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
pyhealth
description
Comprehensive healthcare AI toolkit for developing, testing, and deploying machine learning models with clinical data. This skill should be used when working with electronic health records (EHR), clinical prediction tasks (mortality, readmission, drug recommendation), medical coding systems (ICD, NDC, ATC), physiological signals (EEG, ECG), healthcare datasets (MIMIC-III/IV, eICU, OMOP), or implementing deep learning models for healthcare applications (RETAIN, SafeDrug, Transformer, GNN).

PyHealth: Healthcare AI Toolkit

Overview

PyHealth is a comprehensive Python library for healthcare AI that provides specialized tools, models, and datasets for clinical machine learning. Use this skill when developing healthcare prediction models, processing clinical data, working with medical coding systems, or deploying AI solutions in healthcare settings.

When to Use This Skill

Invoke this skill when:

  • Working with healthcare datasets: MIMIC-III, MIMIC-IV, eICU, OMOP, sleep EEG data, medical images
  • Clinical prediction tasks: Mortality prediction, hospital readmission, length of stay, drug recommendation
  • Medical coding: Translating between ICD-9/10, NDC, RxNorm, ATC coding systems
  • Processing clinical data: Sequential events, physiological signals, clinical text, medical images
  • Implementing healthcare models: RETAIN, SafeDrug, GAMENet, StageNet, Transformer for EHR
  • Evaluating clinical models: Fairness metrics, calibration, interpretability, uncertainty quantification

Core Capabilities

PyHealth operates through a modular 5-stage pipeline optimized for healthcare AI:

  1. Data Loading: Access 10+ healthcare datasets with standardized interfaces
  2. Task Definition: Apply 20+ predefined clinical prediction tasks or create custom tasks
  3. Model Selection: Choose from 33+ models (baselines, deep learning, healthcare-specific)
  4. Training: Train with automatic checkpointing, monitoring, and evaluation
  5. Deployment: Calibrate, interpret, and validate for clinical use

Performance: 3x faster than pandas for healthcare data processing

Quick Start Workflow

python
from pyhealth.datasets import MIMIC4Dataset
from pyhealth.tasks import mortality_prediction_mimic4_fn
from pyhealth.datasets import split_by_patient, get_dataloader
from pyhealth.models import Transformer
from pyhealth.trainer import Trainer

# 1. Load dataset and set task
dataset = MIMIC4Dataset(root="/path/to/data")
sample_dataset = dataset.set_task(mortality_prediction_mimic4_fn)

# 2. Split data
train, val, test = split_by_patient(sample_dataset, [0.7, 0.1, 0.2])

# 3. Create data loaders
train_loader = get_dataloader(train, batch_size=64, shuffle=True)
val_loader = get_dataloader(val, batch_size=64, shuffle=False)
test_loader = get_dataloader(test, batch_size=64, shuffle=False)

# 4. Initialize and train model
model = Transformer(
    dataset=sample_dataset,
    feature_keys=["diagnoses", "medications"],
    mode="binary",
    embedding_dim=128
)

trainer = Trainer(model=model, device="cuda")
trainer.train(
    train_dataloader=train_loader,
    val_dataloader=val_loader,
    epochs=50,
    monitor="pr_auc_score"
)

# 5. Evaluate
results = trainer.evaluate(test_loader)

Detailed Documentation

This skill includes comprehensive reference documentation organized by functionality. Read specific reference files as needed:

1. Datasets and Data Structures

File: references/datasets.md

Read when:

  • Loading healthcare datasets (MIMIC, eICU, OMOP, sleep EEG, etc.)
  • Understanding Event, Patient, Visit data structures
  • Processing different data types (EHR, signals, images, text)
  • Splitting data for training/validation/testing
  • Working with SampleDataset for task-specific formatting

Key Topics:

  • Core data structures (Event, Patient, Visit)
  • 10+ available datasets (EHR, physiological signals, imaging, text)
  • Data loading and iteration
  • Train/val/test splitting strategies
  • Performance optimization for large datasets
2. Medical Coding Translation

File: references/medical_coding.md

Read when:

  • Translating between medical coding systems
  • Working with diagnosis codes (ICD-9-CM, ICD-10-CM, CCS)
  • Processing medication codes (NDC, RxNorm, ATC)
  • Standardizing procedure codes (ICD-9-PROC, ICD-10-PROC)
  • Grouping codes into clinical categories
  • Handling hierarchical drug classifications

Key Topics:

  • InnerMap for within-system lookups
  • CrossMap for cross-system translation
  • Supported coding systems (ICD, NDC, ATC, CCS, RxNorm)
  • Code standardization and hierarchy traversal
  • Medication classification by therapeutic class
  • Integration with datasets
3. Clinical Prediction Tasks

File: references/tasks.md

Read when:

  • Defining clinical prediction objectives
  • Using predefined tasks (mortality, readmission, drug recommendation)
  • Working with EHR, signal, imaging, or text-based tasks
  • Creating custom prediction tasks
  • Setting up input/output schemas for models
  • Applying task-specific filtering logic

Key Topics:

  • 20+ predefined clinical tasks
  • EHR tasks (mortality, readmission, length of stay, drug recommendation)
  • Signal tasks (sleep staging, EEG analysis, seizure detection)
  • Imaging tasks (COVID-19 chest X-ray classification)
  • Text tasks (medical coding, specialty classification)
  • Custom task creation patterns
4. Models and Architectures

File: references/models.md

Read when:

  • Selecting models for clinical prediction
  • Understanding model architectures and capabilities
  • Choosing between general-purpose and healthcare-specific models
  • Implementing interpretable models (RETAIN, AdaCare)
  • Working with medication recommendation (SafeDrug, GAMENet)
  • Using graph neural networks for healthcare
  • Configuring model hyperparameters

Key Topics:

  • 33+ available models
  • General-purpose: Logistic Regression, MLP, CNN, RNN, Transformer, GNN
  • Healthcare-specific: RETAIN, SafeDrug, GAMENet, StageNet, AdaCare
  • Model selection by task type and data type
  • Interpretability considerations
  • Computational requirements
  • Hyperparameter tuning guidelines
5. Data Preprocessing

File: references/preprocessing.md

Read when:

  • Preprocessing clinical data for models
  • Handling sequential events and time-series data
  • Processing physiological signals (EEG, ECG)
  • Normalizing lab values and vital signs
  • Preparing labels for different task types
  • Building feature vocabularies
  • Managing missing data and outliers

Key Topics:

  • 15+ processor types
  • Sequence processing (padding, truncation)
  • Signal processing (filtering, segmentation)
  • Feature extraction and encoding
  • Label processors (binary, multi-class, multi-label, regression)
  • Text and image preprocessing
  • Common preprocessing workflows
6. Training and Evaluation

File: references/training_evaluation.md

Read when:

  • Training models with the Trainer class
  • Evaluating model performance
  • Computing clinical metrics
  • Assessing model fairness across demographics
  • Calibrating predictions for reliability
  • Quantifying prediction uncertainty
  • Interpreting model predictions
  • Preparing models for clinical deployment

Key Topics:

  • Trainer class (train, evaluate, inference)
  • Metrics for binary, multi-class, multi-label, regression tasks
  • Fairness metrics for bias assessment
  • Calibration methods (Platt scaling, temperature scaling)
  • Uncertainty quantification (conformal prediction, MC dropout)
  • Interpretability tools (attention visualization, SHAP, ChEFER)
  • Complete training pipeline example

Installation

bash
uv pip install pyhealth

Requirements:

  • Python ≥ 3.7
  • PyTorch ≥ 1.8
  • NumPy, pandas, scikit-learn

Common Use Cases

Use Case 1: ICU Mortality Prediction

Objective: Predict patient mortality in intensive care unit

Approach:

  1. Load MIMIC-IV dataset → Read references/datasets.md
  2. Apply mortality prediction task → Read references/tasks.md
  3. Select interpretable model (RETAIN) → Read references/models.md
  4. Train and evaluate → Read references/training_evaluation.md
  5. Interpret predictions for clinical use → Read references/training_evaluation.md
Use Case 2: Safe Medication Recommendation

Objective: Recommend medications while avoiding drug-drug interactions

Approach:

  1. Load EHR dataset (MIMIC-IV or OMOP) → Read references/datasets.md
  2. Apply drug recommendation task → Read references/tasks.md
  3. Use SafeDrug model with DDI constraints → Read references/models.md
  4. Preprocess medication codes → Read references/medical_coding.md
  5. Evaluate with multi-label metrics → Read references/training_evaluation.md
Use Case 3: Hospital Readmission Prediction

Objective: Identify patients at risk of 30-day readmission

Approach:

  1. Load multi-site EHR data (eICU or OMOP) → Read references/datasets.md
  2. Apply readmission prediction task → Read references/tasks.md
  3. Handle class imbalance in preprocessing → Read references/preprocessing.md
  4. Train Transformer model → Read references/models.md
  5. Calibrate predictions and assess fairness → Read references/training_evaluation.md
Use Case 4: Sleep Disorder Diagnosis

Objective: Classify sleep stages from EEG signals

Approach:

  1. Load sleep EEG dataset (SleepEDF, SHHS) → Read references/datasets.md
  2. Apply sleep staging task → Read references/tasks.md
  3. Preprocess EEG signals (filtering, segmentation) → Read references/preprocessing.md
  4. Train CNN or RNN model → Read references/models.md
  5. Evaluate per-stage performance → Read references/training_evaluation.md
Show full SKILL.md (555 more words)Show less
Use Case 5: Medical Code Translation

Objective: Standardize diagnoses across different coding systems

Approach:

  1. Read references/medical_coding.md for comprehensive guidance
  2. Use CrossMap to translate between ICD-9, ICD-10, CCS
  3. Group codes into clinically meaningful categories
  4. Integrate with dataset processing
Use Case 6: Clinical Text to ICD Coding

Objective: Automatically assign ICD codes from clinical notes

Approach:

  1. Load MIMIC-III with clinical text → Read references/datasets.md
  2. Apply ICD coding task → Read references/tasks.md
  3. Preprocess clinical text → Read references/preprocessing.md
  4. Use TransformersModel (ClinicalBERT) → Read references/models.md
  5. Evaluate with multi-label metrics → Read references/training_evaluation.md

Best Practices

Data Handling
  1. Always split by patient: Prevent data leakage by ensuring no patient appears in multiple splits

    python
    from pyhealth.datasets import split_by_patient
    train, val, test = split_by_patient(dataset, [0.7, 0.1, 0.2])
  2. Check dataset statistics: Understand your data before modeling

    python
    print(dataset.stats())  # Patients, visits, events, code distributions
  3. Use appropriate preprocessing: Match processors to data types (see references/preprocessing.md)

Model Development
  1. Start with baselines: Establish baseline performance with simple models

    • Logistic Regression for binary/multi-class tasks
    • MLP for initial deep learning baseline
  2. Choose task-appropriate models:

    • Interpretability needed → RETAIN, AdaCare
    • Drug recommendation → SafeDrug, GAMENet
    • Long sequences → Transformer
    • Graph relationships → GNN
  3. Monitor validation metrics: Use appropriate metrics for task and handle class imbalance

    • Binary classification: AUROC, AUPRC (especially for rare events)
    • Multi-class: macro-F1 (for imbalanced), weighted-F1
    • Multi-label: Jaccard, example-F1
    • Regression: MAE, RMSE
Clinical Deployment
  1. Calibrate predictions: Ensure probabilities are reliable (see references/training_evaluation.md)

  2. Assess fairness: Evaluate across demographic groups to detect bias

  3. Quantify uncertainty: Provide confidence estimates for predictions

  4. Interpret predictions: Use attention weights, SHAP, or ChEFER for clinical trust

  5. Validate thoroughly: Use held-out test sets from different time periods or sites

Limitations and Considerations

Data Requirements
  • Large datasets: Deep learning models require sufficient data (thousands of patients)
  • Data quality: Missing data and coding errors impact performance
  • Temporal consistency: Ensure train/test split respects temporal ordering when needed
Clinical Validation
  • External validation: Test on data from different hospitals/systems
  • Prospective evaluation: Validate in real clinical settings before deployment
  • Clinical review: Have clinicians review predictions and interpretations
  • Ethical considerations: Address privacy (HIPAA/GDPR), fairness, and safety
Computational Resources
  • GPU recommended: For training deep learning models efficiently
  • Memory requirements: Large datasets may require 16GB+ RAM
  • Storage: Healthcare datasets can be 10s-100s of GB

Troubleshooting

Common Issues

ImportError for dataset:

  • Ensure dataset files are downloaded and path is correct
  • Check PyHealth version compatibility

Out of memory:

  • Reduce batch size
  • Reduce sequence length (max_seq_length)
  • Use gradient accumulation
  • Process data in chunks

Poor performance:

  • Check class imbalance and use appropriate metrics (AUPRC vs AUROC)
  • Verify preprocessing (normalization, missing data handling)
  • Increase model capacity or training epochs
  • Check for data leakage in train/test split

Slow training:

  • Use GPU (device="cuda")
  • Increase batch size (if memory allows)
  • Reduce sequence length
  • Use more efficient model (CNN vs Transformer)
Getting Help

Example: Complete Workflow

python
# Complete mortality prediction pipeline
from pyhealth.datasets import MIMIC4Dataset
from pyhealth.tasks import mortality_prediction_mimic4_fn
from pyhealth.datasets import split_by_patient, get_dataloader
from pyhealth.models import RETAIN
from pyhealth.trainer import Trainer

# 1. Load dataset
print("Loading MIMIC-IV dataset...")
dataset = MIMIC4Dataset(root="/data/mimic4")
print(dataset.stats())

# 2. Define task
print("Setting mortality prediction task...")
sample_dataset = dataset.set_task(mortality_prediction_mimic4_fn)
print(f"Generated {len(sample_dataset)} samples")

# 3. Split data (by patient to prevent leakage)
print("Splitting data...")
train_ds, val_ds, test_ds = split_by_patient(
    sample_dataset, ratios=[0.7, 0.1, 0.2], seed=42
)

# 4. Create data loaders
train_loader = get_dataloader(train_ds, batch_size=64, shuffle=True)
val_loader = get_dataloader(val_ds, batch_size=64)
test_loader = get_dataloader(test_ds, batch_size=64)

# 5. Initialize interpretable model
print("Initializing RETAIN model...")
model = RETAIN(
    dataset=sample_dataset,
    feature_keys=["diagnoses", "procedures", "medications"],
    mode="binary",
    embedding_dim=128,
    hidden_dim=128
)

# 6. Train model
print("Training model...")
trainer = Trainer(model=model, device="cuda")
trainer.train(
    train_dataloader=train_loader,
    val_dataloader=val_loader,
    epochs=50,
    optimizer="Adam",
    learning_rate=1e-3,
    weight_decay=1e-5,
    monitor="pr_auc_score",  # Use AUPRC for imbalanced data
    monitor_criterion="max",
    save_path="./checkpoints/mortality_retain"
)

# 7. Evaluate on test set
print("Evaluating on test set...")
test_results = trainer.evaluate(
    test_loader,
    metrics=["accuracy", "precision", "recall", "f1_score",
             "roc_auc_score", "pr_auc_score"]
)

print("\nTest Results:")
for metric, value in test_results.items():
    print(f"  {metric}: {value:.4f}")

# 8. Get predictions with attention for interpretation
predictions = trainer.inference(
    test_loader,
    additional_outputs=["visit_attention", "feature_attention"],
    return_patient_ids=True
)

# 9. Analyze a high-risk patient
high_risk_idx = predictions["y_pred"].argmax()
patient_id = predictions["patient_ids"][high_risk_idx]
visit_attn = predictions["visit_attention"][high_risk_idx]
feature_attn = predictions["feature_attention"][high_risk_idx]

print(f"\nHigh-risk patient: {patient_id}")
print(f"Risk score: {predictions['y_pred'][high_risk_idx]:.3f}")
print(f"Most influential visit: {visit_attn.argmax()}")
print(f"Most important features: {feature_attn[visit_attn.argmax()].argsort()[-5:]}")

# 10. Save model for deployment
trainer.save("./models/mortality_retain_final.pt")
print("\nModel saved successfully!")

Resources

For detailed information on each component, refer to the comprehensive reference files in the references/ directory:

  • datasets.md: Data structures, loading, and splitting (4,500 words)
  • medical_coding.md: Code translation and standardization (3,800 words)
  • tasks.md: Clinical prediction tasks and custom task creation (4,200 words)
  • models.md: Model architectures and selection guidelines (5,100 words)
  • preprocessing.md: Data processors and preprocessing workflows (4,600 words)
  • training_evaluation.md: Training, metrics, calibration, interpretability (5,900 words)

Total comprehensive documentation: ~28,000 words across modular reference files.

© davila7, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (references) in cli-tool/components/skills/scientific/pyhealth of davila7/claude-code-templates.

  • SKILL.md
  • references/datasets.md
  • references/medical_coding.md
  • references/models.md
  • references/preprocessing.md
  • references/tasks.md
  • references/training_evaluation.md

Open the folder on GitHubat commit 79182c5

Used in 11 other repositories

We found 15 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 11 other GitHub owners. This page covers the copy in davila7/claude-code-templates, which our catalogue first saw on October 7, 2026.

Compare with similar skills

PyHealth Clinical ML Toolkit next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

PyHealth Clinical ML Toolkit compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
PyHealth Clinical ML Toolkit this skilldavila7/claude-code-templates33k11 repos~4.4kAutomated safety check: PassMIT
PyhealthBioTender-max/awesome-bio-agent-skills200—~1.8kAutomated safety check: PassCustom licence
Scaffold Examplecomet-ml/comet-examples174—~1kAutomated safety check: PassNone
Scikit Learn Machine Learningjaechang-hits/SciAgent-Skills3741 repos~4kAutomated safety check: PassBSD-3-Clause
Qiskit 2.x Quantum ML Referenceaiming-lab/AutoResearchClaw15k—~4.7kAutomated safety check: PassMIT
tangermeme Genomic Model Analysisjmschrei/tangermeme318—~1.6kAutomated safety check: PassMIT

Similar skills

  • Pyhealth

    BioTender-max/awesome-bio-agent-skills

    Build clinical/healthcare deep-learning pipelines with PyHealth — loading EHR/signal/imaging datasets (MIMIC-III/IV, eICU, OMOP, SleepEDF, ChestXray14, EHRShot), defining tasks (mortality…

    200 GitHub stars~1.8k tokensUpdated 3 mo ago
    Research & ScienceAuto-check passed
  • Scaffold Example

    comet-ml/comet-examples

    Scaffold a brand-new Comet example in this repo from the canonical template under templates/integration-example/.

    174 GitHub stars~1k tokensUpdated 1 mo ago
    AI & LLM EngineeringAuto-check passed
  • Scikit Learn Machine Learning

    jaechang-hits/SciAgent-Skills

    Classical ML in Python: classification, regression, clustering, dim reduction, evaluation, tuning, preprocessing pipelines.

    374 GitHub starsUsed in 1 repo~4k tokens
    Data & AnalyticsAuto-check passed
  • Qiskit 2.x Quantum ML Reference

    aiming-lab/AutoResearchClaw

    Reference patterns for writing qiskit 2.x code for variational quantum machine learning: feature maps, VQC training, VQE for chemistry, MPS circuits and noise models.

    15k GitHub stars~4.7k tokensUpdated 1 mo ago
    Research & ScienceAuto-check passed
  • Routes agents to the right tangermeme reference for analyzing trained genomic deep learning models, from attributions and motif experiments to variant effects and design.

    318 GitHub stars~1.6k tokensUpdated today
    Research & ScienceAuto-check passed
  • PyTorch Lightning Training

    Orchestra-Research/AI-Research-SKILLs

    Shows how to organize PyTorch training with Lightning's LightningModule and Trainer, covering validation, DDP, callbacks and learning-rate scheduling.

    13k GitHub starsUsed in 6 repos~2.3k tokens
    AI & LLM EngineeringAuto-check passed

More from davila7/claude-code-templates

All 479 skills in this repo
  • Perplexity Web Search

    davila7/claude-code-templates

    Runs web-grounded searches through Perplexity's Sonar models over OpenRouter for current events, recent literature and cited facts beyond the model's training cutoff.

    33k GitHub starsUsed in 11 repos~3.5k tokens
    Auto-check: notes
  • Neuropixels Data Analysis

    davila7/claude-code-templates

    Analyzes Neuropixels recordings from SpikeGLX or Open Ephys through preprocessing, drift correction, Kilosort4 spike sorting, quality metrics and curation.

    33k GitHub starsUsed in 9 repos~2.8k tokens
    Auto-check passed
  • Scientific Venue Templates

    davila7/claude-code-templates

    Supplies LaTeX templates and formatting rules for journals, conferences, posters, and grant proposals, then can check a draft against them.

    33k GitHub starsUsed in 9 repos~5.1k tokens
    Auto-check: notes
  • Brand Voice Content Creator

    davila7/claude-code-templates

    Analyzes a brand's existing writing to lock in a consistent voice, then builds SEO blog posts and platform-specific social content around it.

    33k GitHub starsUsed in 3 repos~1.9k tokens
    Auto-check passed
  • CAPA Officer

    davila7/claude-code-templates

    Guides corrective and preventive action (CAPA) work in a quality management system, from initiation and root cause analysis through effectiveness verification.

    33k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed
  • Fda Consultant Specialist

    davila7/claude-code-templates

    Senior FDA consultant and specialist for medical device companies including HIPAA compliance and requirement management.

    33k GitHub starsUsed in 1 repo~2.7k tokens
    Auto-check passed

Works with

Questions about PyHealth Clinical ML Toolkit

What does PyHealth Clinical ML Toolkit do?

Builds machine learning pipelines on clinical data with PyHealth: EHR datasets, prediction tasks, medical code mapping, healthcare models and evaluation. PyHealth is a Python library for healthcare AI. The skill organizes work as a five-stage pipeline: load a healthcare dataset such as MIMIC-III, MIMIC-IV, eICU, OMOP or sleep EEG data, define a prediction task, pick a model, train it, then calibrate and validate for clinical use.

When should I use PyHealth Clinical ML Toolkit?

PyHealth Clinical ML Toolkit fits situations like: training a mortality or readmission model on MIMIC-IV records; translating diagnosis or drug codes between ICD, NDC, RxNorm and ATC; building a drug recommendation model with SafeDrug or GAMENet; checking a clinical model for calibration and fairness before deployment.

How do I install PyHealth Clinical ML Toolkit in Claude Code?

Run `npx skills add davila7/claude-code-templates --skill pyhealth -a claude-code`. Or copy the skill folder (cli-tool/components/skills/scientific/pyhealth in davila7/claude-code-templates) into .claude/skills/pyhealth in your project. Claude Code loads it when a task matches its description.

How do I install PyHealth Clinical ML Toolkit in Codex?

Run `npx skills add davila7/claude-code-templates --skill pyhealth -a codex`. Or copy the skill folder (cli-tool/components/skills/scientific/pyhealth in davila7/claude-code-templates) into .agents/skills/pyhealth in your project. Codex loads it when a task matches its description.

Can I use PyHealth Clinical ML Toolkit in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add davila7/claude-code-templates --skill pyhealth -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/pyhealth, .gemini/skills/pyhealth, .github/skills/pyhealth and .opencode/skills/pyhealth in your project.

What does PyHealth Clinical ML Toolkit need to run?

Going by SKILL.md and its folder, PyHealth Clinical ML Toolkit needs the command-line tools its instructions call (uv). Our summary lists: Python with `pyhealth` installed; Access to a healthcare dataset such as MIMIC-IV, eICU or OMOP.

Does PyHealth Clinical ML Toolkit access the network?

SKILL.md names 2 domains. As links in the text: pyhealth.readthedocs.io and github.com. This is read from the text; nothing was executed.

Is PyHealth Clinical ML Toolkit safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does PyHealth Clinical ML Toolkit use?

PyHealth Clinical ML Toolkit is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does PyHealth Clinical ML Toolkit use?

About 4.4k tokens (SKILL.md is roughly 18k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 18k tokens, read only when the agent opens those files.

What are the alternatives to PyHealth Clinical ML Toolkit?

Skills that share tags, products or a category with PyHealth Clinical ML Toolkit: Pyhealth (BioTender-max/awesome-bio-agent-skills, 200 stars), Scaffold Example (comet-ml/comet-examples, 174 stars), Scikit Learn Machine Learning (jaechang-hits/SciAgent-Skills, 374 stars) and Qiskit 2.x Quantum ML Reference (aiming-lab/AutoResearchClaw, 15k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains PyHealth Clinical ML Toolkit?

davila7 (a GitHub user) maintains it in davila7/claude-code-templates, which has 32,552 GitHub stars. The repository holds 479 skills in this directory. The repository was last updated on October 11, 2026.

Source: davila7/claude-code-templates on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.