PyHealth : Boîte à outils pour l'IA en santé

Vue d'ensemble

PyHealth est une bibliothèque Python complète pour l'IA en santé qui fournit des outils spécialisés, des modèles et des ensembles de données pour l'apprentissage automatique clinique. Utilisez cette skill lors du développement de modèles de prédiction en santé, du traitement de données cliniques, du travail avec des systèmes de codage médical ou du déploiement de solutions IA dans des environnements de santé.

Quand utiliser cette skill

Invoquez cette skill quand :

Travailler avec des ensembles de données en santé : MIMIC-III, MIMIC-IV, eICU, OMOP, données EEG du sommeil, images médicales
Tâches de prédiction clinique : Prédiction de mortalité, réadmission à l'hôpital, durée de séjour, recommandation de médicaments
Codage médical : Traduction entre les systèmes de codage ICD-9/10, NDC, RxNorm, ATC
Traitement de données cliniques : Événements séquentiels, signaux physiologiques, texte clinique, images médicales
Implémentation de modèles en santé : RETAIN, SafeDrug, GAMENet, StageNet, Transformer pour EHR
Évaluation de modèles cliniques : Métriques d'équité, calibrage, interprétabilité, quantification de l'incertitude

Capacités principales

PyHealth fonctionne via un pipeline modulaire à 5 étapes optimisé pour l'IA en santé :

Chargement de données : Accès à plus de 10 ensembles de données en santé avec interfaces standardisées
Définition de tâche : Application de plus de 20 tâches de prédiction clinique prédéfinies ou création de tâches personnalisées
Sélection de modèle : Choix parmi 33+ modèles (baselines, apprentissage profond, spécifiques à la santé)
Entraînement : Entraînement avec sauvegarde automatique, surveillance et évaluation
Déploiement : Calibrage, interprétation et validation pour utilisation clinique

Performance : 3x plus rapide que pandas pour le traitement de données en santé

Flux de démarrage rapide

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. Charger l'ensemble de données et définir la tâche
dataset = MIMIC4Dataset(root="/path/to/data")
sample_dataset = dataset.set_task(mortality_prediction_mimic4_fn)

# 2. Diviser les données
train, val, test = split_by_patient(sample_dataset, [0.7, 0.1, 0.2])

# 3. Créer des chargeurs de données
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. Initialiser et entraîner le modèle
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. Évaluer
results = trainer.evaluate(test_loader)

Documentation détaillée

Cette skill inclut une documentation de référence complète organisée par fonctionnalité. Lisez les fichiers de référence spécifiques selon vos besoins :

1. Ensembles de données et structures de données

Fichier : references/datasets.md

À lire quand :

Charger des ensembles de données en santé (MIMIC, eICU, OMOP, EEG du sommeil, etc.)
Comprendre les structures de données Event, Patient, Visit
Traiter différents types de données (EHR, signaux, images, texte)
Diviser les données pour entraînement/validation/test
Travailler avec SampleDataset pour le formatage spécifique à la tâche

Sujets clés :

Structures de données principales (Event, Patient, Visit)
10+ ensembles de données disponibles (EHR, signaux physiologiques, imagerie, texte)
Chargement et itération des données
Stratégies de division train/val/test
Optimisation des performances pour les grands ensembles de données

2. Traduction de codes médicaux

Fichier : references/medical_coding.md

À lire quand :

Traduire entre les systèmes de codage médical
Travailler avec des codes de diagnostic (ICD-9-CM, ICD-10-CM, CCS)
Traiter les codes de médicaments (NDC, RxNorm, ATC)
Standardiser les codes de procédure (ICD-9-PROC, ICD-10-PROC)
Regrouper les codes en catégories cliniques
Gérer les classifications hiérarchiques de médicaments

Sujets clés :

InnerMap pour les recherches intrasystème
CrossMap pour la traduction intersystème
Systèmes de codage supportés (ICD, NDC, ATC, CCS, RxNorm)
Standardisation de codes et traversée hiérarchique
Classification des médicaments par classe thérapeutique
Intégration avec les ensembles de données

3. Tâches de prédiction clinique

Fichier : references/tasks.md

À lire quand :

Définir des objectifs de prédiction clinique
Utiliser des tâches prédéfinies (mortalité, réadmission, recommandation de médicaments)
Travailler avec des tâches basées sur EHR, signaux, imagerie ou texte
Créer des tâches de prédiction personnalisées
Configurer les schémas d'entrée/sortie pour les modèles
Appliquer la logique de filtrage spécifique à la tâche

Sujets clés :

20+ tâches cliniques prédéfinies
Tâches EHR (mortalité, réadmission, durée de séjour, recommandation de médicaments)
Tâches de signal (classification du sommeil, analyse EEG, détection de crises)
Tâches d'imagerie (classification des radiographies thoraciques COVID-19)
Tâches texte (codage médical, classification de spécialité)
Modèles de création de tâches personnalisées

4. Modèles et architectures

Fichier : references/models.md

À lire quand :

Sélectionner des modèles pour la prédiction clinique
Comprendre les architectures et capacités de modèles
Choisir entre les modèles à usage général et ceux spécifiques à la santé
Implémenter des modèles interprétables (RETAIN, AdaCare)
Travailler avec la recommandation de médicaments (SafeDrug, GAMENet)
Utiliser les réseaux de neurones graphiques pour la santé
Configurer les hyperparamètres des modèles

Sujets clés :

33+ modèles disponibles
À usage général : Logistic Regression, MLP, CNN, RNN, Transformer, GNN
Spécifiques à la santé : RETAIN, SafeDrug, GAMENet, StageNet, AdaCare
Sélection de modèles par type de tâche et type de données
Considérations d'interprétabilité
Exigences en ressources de calcul
Directives d'optimisation des hyperparamètres

5. Prétraitement de données

Fichier : references/preprocessing.md

À lire quand :

Prétraiter les données cliniques pour les modèles
Gérer les événements séquentiels et les données de séries temporelles
Traiter les signaux physiologiques (EEG, ECG)
Normaliser les valeurs de laboratoire et les signes vitaux
Préparer les labels pour différents types de tâches
Construire des vocabulaires de features
Gérer les données manquantes et les valeurs aberrantes

Sujets clés :

15+ types de processeurs
Traitement de séquences (padding, troncature)
Traitement de signaux (filtrage, segmentation)
Extraction et codage de features
Processeurs de labels (binaire, multi-classe, multi-label, régression)
Prétraitement texte et image
Flux de travail de prétraitement courants

6. Entraînement et évaluation

Fichier : references/training_evaluation.md

À lire quand :

Entraîner des modèles avec la classe Trainer
Évaluer les performances du modèle
Calculer les métriques cliniques
Évaluer l'équité du modèle entre les groupes démographiques
Calibrer les prédictions pour la fiabilité
Quantifier l'incertitude de prédiction
Interpréter les prédictions du modèle
Préparer les modèles pour le déploiement clinique

Sujets clés :

Classe Trainer (entraînement, évaluation, inférence)
Métriques pour les tâches binaires, multi-classe, multi-label et régression
Métriques d'équité pour l'évaluation des biais
Méthodes de calibrage (Platt scaling, temperature scaling)
Quantification de l'incertitude (conformal prediction, MC dropout)
Outils d'interprétabilité (visualisation d'attention, SHAP, ChEFER)
Exemple complet de pipeline d'entraînement

Installation

uv pip install pyhealth

Exigences :

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

Cas d'usage courants

Cas d'usage 1 : Prédiction de mortalité aux soins intensifs

Objectif : Prédire la mortalité des patients en unité de soins intensifs

Approche :

Charger l'ensemble de données MIMIC-IV → Lire references/datasets.md
Appliquer la tâche de prédiction de mortalité → Lire references/tasks.md
Sélectionner un modèle interprétable (RETAIN) → Lire references/models.md
Entraîner et évaluer → Lire references/training_evaluation.md
Interpréter les prédictions pour utilisation clinique → Lire references/training_evaluation.md

Cas d'usage 2 : Recommandation sécurisée de médicaments

Objectif : Recommander des médicaments tout en évitant les interactions médicamenteuses

Approche :

Charger l'ensemble de données EHR (MIMIC-IV ou OMOP) → Lire references/datasets.md
Appliquer la tâche de recommandation de médicaments → Lire references/tasks.md
Utiliser le modèle SafeDrug avec contraintes DDI → Lire references/models.md
Prétraiter les codes de médicaments → Lire references/medical_coding.md
Évaluer avec des métriques multi-label → Lire references/training_evaluation.md

Cas d'usage 3 : Prédiction de réadmission à l'hôpital

Objectif : Identifier les patients à risque de réadmission dans les 30 jours

Approche :

Charger les données EHR multi-sites (eICU ou OMOP) → Lire references/datasets.md
Appliquer la tâche de prédiction de réadmission → Lire references/tasks.md
Gérer le déséquilibre des classes dans le prétraitement → Lire references/preprocessing.md
Entraîner le modèle Transformer → Lire references/models.md
Calibrer les prédictions et évaluer l'équité → Lire references/training_evaluation.md

Cas d'usage 4 : Diagnostic des troubles du sommeil

Objectif : Classifier les stades du sommeil à partir de signaux EEG

Approche :

Charger l'ensemble de données EEG du sommeil (SleepEDF, SHHS) → Lire references/datasets.md
Appliquer la tâche de classification du sommeil → Lire references/tasks.md
Prétraiter les signaux EEG (filtrage, segmentation) → Lire references/preprocessing.md
Entraîner un modèle CNN ou RNN → Lire references/models.md
Évaluer les performances par stade → Lire references/training_evaluation.md

Cas d'usage 5 : Traduction de codes médicaux

Objectif : Standardiser les diagnostics entre différents systèmes de codage

Approche :

Lire references/medical_coding.md pour les directives complètes
Utiliser CrossMap pour traduire entre ICD-9, ICD-10, CCS
Regrouper les codes en catégories cliniquement significatives
Intégrer au traitement des ensembles de données

Cas d'usage 6 : Codage ICD à partir du texte clinique

Objectif : Assigner automatiquement les codes ICD à partir des notes cliniques

Approche :

Charger MIMIC-III avec texte clinique → Lire references/datasets.md
Appliquer la tâche de codage ICD → Lire references/tasks.md
Prétraiter le texte clinique → Lire references/preprocessing.md
Utiliser TransformersModel (ClinicalBERT) → Lire references/models.md
Évaluer avec des métriques multi-label → Lire references/training_evaluation.md

Bonnes pratiques

Manipulation de données

Toujours diviser par patient : Prévenir la fuite de données en assurant qu'aucun patient n'apparaît dans plusieurs divisions
```
from pyhealth.datasets import split_by_patient
train, val, test = split_by_patient(dataset, [0.7, 0.1, 0.2])
```
Vérifier les statistiques de l'ensemble de données : Comprendre vos données avant la modélisation
```
print(dataset.stats())  # Patients, visites, événements, distributions de codes
```
Utiliser le prétraitement approprié : Adapter les processeurs aux types de données (voir references/preprocessing.md)

Développement de modèles

Commencer par des baselines : Établir les performances de référence avec des modèles simples
- Logistic Regression pour les tâches binaires/multi-classe
- MLP pour une baseline d'apprentissage profond initial
Choisir des modèles adaptés à la tâche :
- Interprétabilité requise → RETAIN, AdaCare
- Recommandation de médicaments → SafeDrug, GAMENet
- Longues séquences → Transformer
- Relations graphiques → GNN
Surveiller les métriques de validation : Utiliser des métriques appropriées à la tâche et gérer le déséquilibre de classe
- Classification binaire : AUROC, AUPRC (particulièrement pour les événements rares)
- Multi-classe : macro-F1 (pour données déséquilibrées), weighted-F1
- Multi-label : Jaccard, example-F1
- Régression : MAE, RMSE

Déploiement clinique

Calibrer les prédictions : Assurer que les probabilités sont fiables (voir references/training_evaluation.md)
Évaluer l'équité : Évaluer les performances entre groupes démographiques pour détecter les biais
Quantifier l'incertitude : Fournir des estimations de confiance pour les prédictions
Interpréter les prédictions : Utiliser les poids d'attention, SHAP ou ChEFER pour la confiance clinique
Valider complètement : Utiliser des ensembles de test réservés à partir de périodes ou sites différents

Limitations et considérations

Exigences en données

Grands ensembles de données : Les modèles d'apprentissage profond nécessitent des données suffisantes (des milliers de patients)
Qualité des données : Les données manquantes et les erreurs de codage impactent les performances
Cohérence temporelle : Assurer que la division train/test respecte l'ordre temporel si nécessaire

Validation clinique

Validation externe : Tester sur des données provenant d'hôpitaux/systèmes différents
Évaluation prospective : Valider dans des environnements cliniques réels avant le déploiement
Examen clinique : Faire examiner les prédictions et interprétations par des cliniciens
Considérations éthiques : Aborder la confidentialité (HIPAA/GDPR), l'équité et la sécurité

Ressources de calcul

GPU recommandé : Pour entraîner efficacement les modèles d'apprentissage profond
Exigences en mémoire : Les grands ensembles de données peuvent nécessiter 16 GB+ de RAM
Stockage : Les ensembles de données en santé peuvent faire 10s-100s de GB

Dépannage

Problèmes courants

ImportError pour l'ensemble de données :

Assurer que les fichiers d'ensemble de données sont téléchargés et le chemin est correct
Vérifier la compatibilité de la version PyHealth

Mémoire insuffisante :

Réduire la taille du batch
Réduire la longueur des séquences (max_seq_length)
Utiliser l'accumulation de gradients
Traiter les données par chunks

Performances faibles :

Vérifier le déséquilibre de classe et utiliser les métriques appropriées (AUPRC vs AUROC)
Vérifier le prétraitement (normalisation, gestion des données manquantes)
Augmenter la capacité du modèle ou les epochs d'entraînement
Vérifier la fuite de données dans la division train/test

Entraînement lent :

Utiliser le GPU (device="cuda")
Augmenter la taille du batch (si la mémoire le permet)
Réduire la longueur des séquences
Utiliser un modèle plus efficace (CNN vs Transformer)

Obtenir de l'aide

Documentation : https://pyhealth.readthedocs.io/
GitHub Issues : https://github.com/sunlabuiuc/PyHealth/issues
Tutoriels : 7 tutoriels principaux + 5 pipelines pratiques disponibles en ligne

Exemple : Flux de travail complet

# Pipeline complet de prédiction de mortalité
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. Charger l'ensemble de données
print("Chargement de l'ensemble de données MIMIC-IV...")
dataset = MIMIC4Dataset(root="/data/mimic4")
print(dataset.stats())

# 2. Définir la tâche
print("Définition de la tâche de prédiction de mortalité...")
sample_dataset = dataset.set_task(mortality_prediction_mimic4_fn)
print(f"Généré {len(sample_dataset)} échantillons")

# 3. Diviser les données (par patient pour éviter la fuite)
print("Division des données...")
train_ds, val_ds, test_ds = split_by_patient(
    sample_dataset, ratios=[0.7, 0.1, 0.2], seed=42
)

# 4. Créer les chargeurs de données
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. Initialiser un modèle interprétable
print("Initialisation du modèle RETAIN...")
model = RETAIN(
    dataset=sample_dataset,
    feature_keys=["diagnoses", "procedures", "medications"],
    mode="binary",
    embedding_dim=128,
    hidden_dim=128
)

# 6. Entraîner le modèle
print("Entraînement du modèle...")
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",  # Utiliser AUPRC pour données déséquilibrées
    monitor_criterion="max",
    save_path="./checkpoints/mortality_retain"
)

# 7. Évaluer sur l'ensemble de test
print("Évaluation sur l'ensemble de test...")
test_results = trainer.evaluate(
    test_loader,
    metrics=["accuracy", "precision", "recall", "f1_score",
             "roc_auc_score", "pr_auc_score"]
)

print("\nRésultats du test :")
for metric, value in test_results.items():
    print(f"  {metric}: {value:.4f}")

# 8. Obtenir les prédictions avec attention pour interprétation
predictions = trainer.inference(
    test_loader,
    additional_outputs=["visit_attention", "feature_attention"],
    return_patient_ids=True
)

# 9. Analyser un patient à haut risque
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"\nPatient à haut risque : {patient_id}")
print(f"Score de risque : {predictions['y_pred'][high_risk_idx]:.3f}")
print(f"Visite la plus influente : {visit_attn.argmax()}")
print(f"Features les plus importantes : {feature_attn[visit_attn.argmax()].argsort()[-5:]}")

# 10. Sauvegarder le modèle pour le déploiement
trainer.save("./models/mortality_retain_final.pt")
print("\nModèle sauvegardé avec succès !")

Ressources

Pour obtenir des informations détaillées sur chaque composant, consultez les fichiers de référence complets dans le répertoire references/ :

datasets.md : Structures de données, chargement et division (4 500 mots)
medical_coding.md : Traduction et standardisation de codes (3 800 mots)
tasks.md : Tâches de prédiction clinique et création de tâches personnalisées (4 200 mots)
models.md : Architectures de modèles et directives de sélection (5 100 mots)
preprocessing.md : Processeurs de données et flux de travail de prétraitement (4 600 mots)
training_evaluation.md : Entraînement, métriques, calibrage, interprétabilité (5 900 mots)

Documentation complète totale : ~28 000 mots répartis sur les fichiers de référence modulaires.

PyHealth : Boîte à outils pour l'IA en santé

Vue d'ensemble

Quand utiliser cette skill

Capacités principales

Flux de démarrage rapide

Documentation détaillée

1. Ensembles de données et structures de données

2. Traduction de codes médicaux

3. Tâches de prédiction clinique

4. Modèles et architectures

5. Prétraitement de données

6. Entraînement et évaluation

Installation

Cas d'usage courants

Cas d'usage 1 : Prédiction de mortalité aux soins intensifs

Cas d'usage 2 : Recommandation sécurisée de médicaments

Cas d'usage 3 : Prédiction de réadmission à l'hôpital

Cas d'usage 4 : Diagnostic des troubles du sommeil

Cas d'usage 5 : Traduction de codes médicaux

Cas d'usage 6 : Codage ICD à partir du texte clinique

Bonnes pratiques

Manipulation de données

Développement de modèles

Déploiement clinique

Limitations et considérations

Exigences en données

Validation clinique

Ressources de calcul

Dépannage

Problèmes courants

Obtenir de l'aide

Exemple : Flux de travail complet

Ressources

Skills similaires