scikit-survival : Analyse de survie en Python

Vue d'ensemble

scikit-survival est une bibliothèque Python pour l'analyse de survie construite sur scikit-learn. Elle fournit des outils spécialisés pour l'analyse du délai avant événement, en gérant le défi unique des données censurées où certaines observations ne sont que partiellement connues.

L'analyse de survie vise à établir des connexions entre les covariables et le moment d'un événement, en tenant compte des enregistrements censurés (notamment les données censurées à droite issues d'études où les participants n'expérimentent pas d'événements pendant les périodes d'observation).

Quand utiliser cette skill

Utilisez cette skill quand :

Vous effectuez une analyse de survie ou une modélisation du délai avant événement
Vous travaillez avec des données censurées (censurées à droite, à gauche ou par intervalle)
Vous ajustez des modèles de risques proportionnels de Cox (standard ou pénalisés)
Vous construisez des modèles de survie d'ensemble (Random Survival Forests, Gradient Boosting)
Vous entraînez des machines à vecteurs de support pour la survie
Vous évaluez la performance des modèles de survie (indice de concordance, score de Brier, AUC dépendant du temps)
Vous estimez les courbes de Kaplan-Meier ou Nelson-Aalen
Vous analysez les risques concurrents
Vous prétraitez les données de survie ou gérez les valeurs manquantes dans les ensembles de données de survie
Vous menez une analyse quelconque utilisant la bibliothèque scikit-survival

Capacités principales

1. Types de modèles et sélection

scikit-survival propose plusieurs familles de modèles, chacune adaptée à différents scénarios :

Modèles de risques proportionnels de Cox

À utiliser pour : Analyse de survie standard avec coefficients interprétables

CoxPHSurvivalAnalysis : Modèle Cox basique
CoxnetSurvivalAnalysis : Cox pénalisé avec filet élastique pour données haute dimension
IPCRidge : Régression Ridge pour modèles de temps de défaillance accélérée

Voir : references/cox-models.md pour des conseils détaillés sur les modèles Cox, la régularisation et l'interprétation

Méthodes d'ensemble

À utiliser pour : Performance prédictive élevée avec relations non-linéaires complexes

RandomSurvivalForest : Méthode d'ensemble robuste et non-paramétrique
GradientBoostingSurvivalAnalysis : Boosting basé sur arbres pour la performance maximale
ComponentwiseGradientBoostingSurvivalAnalysis : Boosting linéaire avec sélection de features
ExtraSurvivalTrees : Arbres extrêmement randomisés pour une régularisation additionnelle

Voir : references/ensemble-models.md pour des conseils complets sur les méthodes d'ensemble, l'ajustement des hyperparamètres et quand utiliser chaque modèle

Machines à vecteurs de support pour la survie

À utiliser pour : Ensembles de données de taille moyenne avec apprentissage à marge

FastSurvivalSVM : SVM linéaire optimisé pour la vitesse
FastKernelSurvivalSVM : SVM à noyau pour relations non-linéaires
HingeLossSurvivalSVM : SVM avec perte de charnière
ClinicalKernelTransform : Noyau spécialisé pour données cliniques + moléculaires

Voir : references/svm-models.md pour des conseils SVM détaillés, la sélection de noyau et l'ajustement des hyperparamètres

Arbre de décision pour la sélection du modèle

Début
├─ Données haute dimension (p > n) ?
│  ├─ Oui → CoxnetSurvivalAnalysis (filet élastique)
│  └─ Non → Continuer
│
├─ Avez-vous besoin de coefficients interprétables ?
│  ├─ Oui → CoxPHSurvivalAnalysis ou ComponentwiseGradientBoostingSurvivalAnalysis
│  └─ Non → Continuer
│
├─ Relations non-linéaires complexes attendues ?
│  ├─ Oui
│  │  ├─ Grand ensemble (n > 1000) → GradientBoostingSurvivalAnalysis
│  │  ├─ Ensemble moyen → RandomSurvivalForest ou FastKernelSurvivalSVM
│  │  └─ Petit ensemble → RandomSurvivalForest
│  └─ Non → CoxPHSurvivalAnalysis ou FastSurvivalSVM
│
└─ Pour la performance maximale → Essayez plusieurs modèles et comparez

2. Préparation et prétraitement des données

Avant la modélisation, préparez correctement les données de survie :

Création d'outcomes de survie

from sksurv.util import Surv

# À partir de tableaux séparés
y = Surv.from_arrays(event=event_array, time=time_array)

# À partir d'un DataFrame
y = Surv.from_dataframe('event', 'time', df)

Étapes de prétraitement essentielles

Gérer les valeurs manquantes : Stratégies d'imputation pour les features
Encoder les variables catégorielles : Encodage one-hot ou label encoding
Standardiser les features : Critique pour les SVM et les modèles Cox régularisés
Valider la qualité des données : Vérifier les temps négatifs, les événements suffisants par feature
Train-test split : Maintenir des taux de censure similaires entre les splits

Voir : references/data-handling.md pour les workflows complets de prétraitement, la validation des données et les bonnes pratiques

3. Évaluation du modèle

L'évaluation appropriée est critique pour les modèles de survie. Utilisez des métriques appropriées qui tiennent compte de la censure :

Indice de concordance (C-index)

Métrique primaire pour le classement/discrimination :

C-index de Harrell : À utiliser pour censure faible (<40%)
C-index d'Uno : À utiliser pour censure modérée à élevée (>40%) - plus robuste

from sksurv.metrics import concordance_index_censored, concordance_index_ipcw

# C-index de Harrell
c_harrell = concordance_index_censored(y_test['event'], y_test['time'], risk_scores)[0]

# C-index d'Uno (recommandé)
c_uno = concordance_index_ipcw(y_train, y_test, risk_scores)[0]

AUC dépendant du temps

Évaluer la discrimination à des points temporels spécifiques :

from sksurv.metrics import cumulative_dynamic_auc

times = [365, 730, 1095]  # 1, 2, 3 ans
auc, mean_auc = cumulative_dynamic_auc(y_train, y_test, risk_scores, times)

Score de Brier

Évaluer la discrimination et l'étalonnage :

from sksurv.metrics import integrated_brier_score

ibs = integrated_brier_score(y_train, y_test, survival_functions, times)

Voir : references/evaluation-metrics.md pour des conseils complets d'évaluation, la sélection des métriques et l'utilisation des scoreurs avec validation croisée

4. Analyse des risques concurrents

Gérer les situations avec plusieurs types d'événements mutuellement exclusifs :

from sksurv.nonparametric import cumulative_incidence_competing_risks

# Estimer l'incidence cumulée pour chaque type d'événement
time_points, cif_event1, cif_event2 = cumulative_incidence_competing_risks(y)

Utiliser les risques concurrents quand :

Plusieurs types d'événements mutuellement exclusifs existent (ex. décès par différentes causes)
L'occurrence d'un événement empêche les autres
Vous avez besoin d'estimations de probabilité pour des types d'événements spécifiques

Voir : references/competing-risks.md pour les méthodes détaillées des risques concurrents, les modèles de risques spécifiques à la cause et l'interprétation

5. Estimation non-paramétrique

Estimez les fonctions de survie sans hypothèses paramétriques :

Estimateur de Kaplan-Meier

from sksurv.nonparametric import kaplan_meier_estimator

time, survival_prob = kaplan_meier_estimator(y['event'], y['time'])

Estimateur de Nelson-Aalen

from sksurv.nonparametric import nelson_aalen_estimator

time, cumulative_hazard = nelson_aalen_estimator(y['event'], y['time'])

Workflows typiques

Workflow 1 : Analyse de survie standard

from sksurv.datasets import load_breast_cancer
from sksurv.linear_model import CoxPHSurvivalAnalysis
from sksurv.metrics import concordance_index_ipcw
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# 1. Charger et préparer les données
X, y = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 2. Prétraiter
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 3. Ajuster le modèle
estimator = CoxPHSurvivalAnalysis()
estimator.fit(X_train_scaled, y_train)

# 4. Prédire
risk_scores = estimator.predict(X_test_scaled)

# 5. Évaluer
c_index = concordance_index_ipcw(y_train, y_test, risk_scores)[0]
print(f"C-index: {c_index:.3f}")

Workflow 2 : Données haute dimension avec sélection de features

from sksurv.linear_model import CoxnetSurvivalAnalysis
from sklearn.model_selection import GridSearchCV
from sksurv.metrics import as_concordance_index_ipcw_scorer

# 1. Utiliser Cox pénalisé pour la sélection de features
estimator = CoxnetSurvivalAnalysis(l1_ratio=0.9)  # De type Lasso

# 2. Ajuster la régularisation avec validation croisée
param_grid = {'alpha_min_ratio': [0.01, 0.001]}
cv = GridSearchCV(estimator, param_grid,
                  scoring=as_concordance_index_ipcw_scorer(), cv=5)
cv.fit(X, y)

# 3. Identifier les features sélectionnées
best_model = cv.best_estimator_
selected_features = np.where(best_model.coef_ != 0)[0]

Workflow 3 : Méthode d'ensemble pour la performance maximale

from sksurv.ensemble import GradientBoostingSurvivalAnalysis
from sklearn.model_selection import GridSearchCV

# 1. Définir la grille de paramètres
param_grid = {
    'learning_rate': [0.01, 0.05, 0.1],
    'n_estimators': [100, 200, 300],
    'max_depth': [3, 5, 7]
}

# 2. Recherche sur grille
gbs = GradientBoostingSurvivalAnalysis()
cv = GridSearchCV(gbs, param_grid, cv=5,
                  scoring=as_concordance_index_ipcw_scorer(), n_jobs=-1)
cv.fit(X_train, y_train)

# 3. Évaluer le meilleur modèle
best_model = cv.best_estimator_
risk_scores = best_model.predict(X_test)
c_index = concordance_index_ipcw(y_train, y_test, risk_scores)[0]

Workflow 4 : Comparaison compréhensive de modèles

from sksurv.linear_model import CoxPHSurvivalAnalysis
from sksurv.ensemble import RandomSurvivalForest, GradientBoostingSurvivalAnalysis
from sksurv.svm import FastSurvivalSVM
from sksurv.metrics import concordance_index_ipcw, integrated_brier_score

# Définir les modèles
models = {
    'Cox': CoxPHSurvivalAnalysis(),
    'RSF': RandomSurvivalForest(n_estimators=100, random_state=42),
    'GBS': GradientBoostingSurvivalAnalysis(random_state=42),
    'SVM': FastSurvivalSVM(random_state=42)
}

# Évaluer chaque modèle
results = {}
for name, model in models.items():
    model.fit(X_train_scaled, y_train)
    risk_scores = model.predict(X_test_scaled)
    c_index = concordance_index_ipcw(y_train, y_test, risk_scores)[0]
    results[name] = c_index
    print(f"{name}: C-index = {c_index:.3f}")

# Sélectionner le meilleur modèle
best_model_name = max(results, key=results.get)
print(f"\nMeilleur modèle : {best_model_name}")

Intégration avec scikit-learn

scikit-survival s'intègre pleinement à l'écosystème scikit-learn :

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score, GridSearchCV

# Utiliser les pipelines
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', CoxPHSurvivalAnalysis())
])

# Utiliser la validation croisée
scores = cross_val_score(pipeline, X, y, cv=5,
                         scoring=as_concordance_index_ipcw_scorer())

# Utiliser la recherche sur grille
param_grid = {'model__alpha': [0.1, 1.0, 10.0]}
cv = GridSearchCV(pipeline, param_grid, cv=5)
cv.fit(X, y)

Bonnes pratiques

Toujours standardiser les features pour les SVM et les modèles Cox régularisés
Utiliser le C-index d'Uno à la place de celui de Harrell quand la censure > 40%
Rapporter plusieurs métriques d'évaluation (C-index, score de Brier intégré, AUC dépendant du temps)
Vérifier l'hypothèse de risques proportionnels pour les modèles Cox
Utiliser la validation croisée pour l'ajustement des hyperparamètres avec les scoreurs appropriés
Valider la qualité des données avant la modélisation (vérifier les temps négatifs, les événements suffisants par feature)
Comparer plusieurs types de modèles pour trouver la meilleure performance
Utiliser l'importance par permutation pour les Random Survival Forests (pas d'importance intégrée)
Considérer les risques concurrents quand plusieurs types d'événements existent
Documenter le mécanisme de censure et les taux dans l'analyse

Pièges courants à éviter

Utiliser le C-index de Harrell avec censure élevée → Utiliser le C-index d'Uno
Ne pas standardiser les features pour les SVM → Toujours standardiser
Oublier de passer y_train à concordance_index_ipcw → Requis pour le calcul IPCW
Traiter les événements concurrents comme censurés → Utiliser les méthodes de risques concurrents
Ne pas vérifier les événements suffisants par feature → Règle empirique : 10+ événements par feature
Utiliser l'importance de feature intégrée pour RSF → Utiliser l'importance par permutation
Ignorer l'hypothèse de risques proportionnels → Valider ou utiliser des modèles alternatifs
Ne pas utiliser les scoreurs appropriés en validation croisée → Utiliser as_concordance_index_ipcw_scorer()

Fichiers de référence

Cette skill inclut des fichiers de référence détaillés pour des sujets spécifiques :

references/cox-models.md : Guide complet des modèles de risques proportionnels de Cox, Cox pénalisé (CoxNet), IPCRidge, stratégies de régularisation et interprétation
references/ensemble-models.md : Random Survival Forests, Gradient Boosting, ajustement des hyperparamètres, importance des features et sélection du modèle
references/evaluation-metrics.md : Indice de concordance (Harrell vs Uno), AUC dépendant du temps, score de Brier, pipelines d'évaluation compréhensifs
references/data-handling.md : Chargement des données, workflows de prétraitement, gestion des données manquantes, encodage de features, vérifications de validation
references/svm-models.md : Machines à vecteurs de support pour la survie, sélection de noyau, transformée de noyau clinique, ajustement des hyperparamètres
references/competing-risks.md : Analyse des risques concurrents, fonctions d'incidence cumulée, modèles de risques spécifiques à la cause

Chargez ces fichiers de référence quand des informations détaillées sont nécessaires pour des tâches spécifiques.

Ressources supplémentaires

Documentation officielle : https://scikit-survival.readthedocs.io/
Dépôt GitHub : https://github.com/sebp/scikit-survival
Ensembles de données intégrés : Utiliser sksurv.datasets pour des ensembles de données de pratique (GBSG2, WHAS500, cancer du poumon des vétérans, etc.)
Référence API : Liste complète des classes et fonctions sur https://scikit-survival.readthedocs.io/en/stable/api/index.html

Référence rapide : Imports clés

# Modèles
from sksurv.linear_model import CoxPHSurvivalAnalysis, CoxnetSurvivalAnalysis, IPCRidge
from sksurv.ensemble import RandomSurvivalForest, GradientBoostingSurvivalAnalysis
from sksurv.svm import FastSurvivalSVM, FastKernelSurvivalSVM
from sksurv.tree import SurvivalTree

# Métriques d'évaluation
from sksurv.metrics import (
    concordance_index_censored,
    concordance_index_ipcw,
    cumulative_dynamic_auc,
    brier_score,
    integrated_brier_score,
    as_concordance_index_ipcw_scorer,
    as_integrated_brier_score_scorer
)

# Estimation non-paramétrique
from sksurv.nonparametric import (
    kaplan_meier_estimator,
    nelson_aalen_estimator,
    cumulative_incidence_competing_risks
)

# Gestion des données
from sksurv.util import Surv
from sksurv.preprocessing import OneHotEncoder, encode_categorical
from sksurv.datasets import load_gbsg2, load_breast_cancer, load_veterans_lung_cancer

# Noyaux
from sksurv.kernels import ClinicalKernelTransform