0Pricing
Python Academy · Leçon

Évaluation des modèles et validation croisée

Évaluez les modèles avec l’exactitude, le score F1, ROC-AUC et la CV k-fold.

Évaluation des modèles et validation croisée est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Séparation entraînement/validation/test

Utilisez une séparation en trois parties : l'entraînement pour ajuster le modèle, la validation pour régler les hyperparamètres et le test pour présenter les performances finales. N'utilisez jamais le jeu de test pendant le développement.

from sklearn.model_selection import train_test_split
import numpy as np

X = np.random.rand(1000, 10)
y = (X[:,0] > 0.5).astype(int)

X_tr, X_rest, y_tr, y_rest = train_test_split(X, y, test_size=0.3)
X_val, X_te, y_val, y_te = train_test_split(X_rest, y_rest, test_size=0.5)

Score de précision

accuracy_score correspond à la proportion de prédictions correctes. Utilisez-le pour des classes équilibrées ; pour des données déséquilibrées, préférez F1 ou AUC.

from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = LogisticRegression().fit(X_tr, y_tr)
print("Accuracy:", accuracy_score(y_te, model.predict(X_te)))

Précision, rappel, F1

Pour des classes déséquilibrées : précision = TP/(TP+FP), rappel = TP/(TP+FN), F1 = moyenne harmonique de la précision et du rappel.

from sklearn.metrics import precision_score, recall_score, f1_score, classification_report

# Use classification_report for a full summary:
print(classification_report(y_te, model.predict(X_te)))
# shows precision, recall, f1 for each class

Matrice de confusion

Une matrice de confusion présente les vrais positifs, les faux positifs, les vrais négatifs et les faux négatifs.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

cm = confusion_matrix(y_te, model.predict(X_te))
print(cm)
# [[TN FP]
#  [FN TP]]

Courbe ROC et AUC

roc_auc_score mesure l'aire sous la courbe ROC. Une AUC de 1.0 est parfaite ; 0.5 correspond à un résultat aléatoire.

from sklearn.metrics import roc_auc_score, roc_curve

y_prob = model.predict_proba(X_te)[:,1]
print("AUC:", roc_auc_score(y_te, y_prob))

fpr, tpr, thresholds = roc_curve(y_te, y_prob)
# plot fpr vs tpr for the full ROC curve

Métriques de régression

Utilisez mean_squared_error (MSE), root_mean_squared_error (RMSE) et r2_score pour les tâches de régression.

from sklearn.metrics import mean_squared_error, r2_score

y_pred = regression_model.predict(X_te)
mse = mean_squared_error(y_te, y_pred)
print("RMSE:", mse**0.5)
print("R²:", r2_score(y_te, y_pred))

Validation croisée k-fold

cross_val_score divise les données en k sous-ensembles, entraîne le modèle sur k-1 sous-ensembles, l'évalue sur le dernier, puis répète l'opération k fois. Cette méthode est plus robuste qu'une seule séparation.

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(random_state=0)
scores = cross_val_score(LogisticRegression(), X, y, cv=10, scoring="accuracy")
print(f"{scores.mean():.3f} ± {scores.std():.3f}")

StratifiedKFold

Utilisez StratifiedKFold pour garantir que chaque sous-ensemble possède la même distribution des classes — ce qui est essentiel pour les jeux de données déséquilibrés.

from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(weights=[0.9,0.1], random_state=0)
cv = StratifiedKFold(n_splits=5)
scores = cross_val_score(LogisticRegression(), X, y, cv=cv, scoring="f1")
print("Stratified F1:", scores.mean())

Compromis biais-variance

Un biais élevé signifie un sous-apprentissage (modèle trop simple). Une variance élevée signifie un surapprentissage (modèle trop complexe). La validation croisée révèle lequel de ces problèmes vous rencontrez.

# Underfitting: low train score AND low val score
# → increase model complexity, add features

# Overfitting: high train score, low val score
# → regularise, reduce complexity, get more data

from sklearn.model_selection import validation_curve
import numpy as np

train_sc, val_sc = validation_curve(DecisionTreeClassifier(), X, y, param_name="max_depth", param_range=range(1,10))

Validation croisée imbriquée

Pour régler et évaluer les hyperparamètres sans biais, utilisez une validation croisée imbriquée : la boucle interne effectue le réglage et la boucle externe l'évaluation.

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.svm import SVC
from sklearn.datasets import make_classification

X, y = make_classification(random_state=0)
gs = GridSearchCV(SVC(), {"C":[0.1,1,10]}, cv=5)
outer_scores = cross_val_score(gs, X, y, cv=5)
print("Nested CV accuracy:", outer_scores.mean())

Calibration

Les estimations de probabilité d'un classifieur peuvent être mal calibrées. Utilisez CalibratedClassifierCV pour obtenir de meilleures estimations de probabilité.

from sklearn.calibration import CalibratedClassifierCV
from sklearn.svm import SVC
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y)

cal = CalibratedClassifierCV(SVC(), cv=5).fit(X_tr, y_tr)
print(cal.predict_proba(X_te[:3]))

Vérification rapide

Pourquoi la validation croisée est-elle préférable à une seule séparation entraînement/test pour évaluer les modèles ?

Récapitulatif

Utilisez la précision pour les problèmes équilibrés, et F1/AUC pour les problèmes déséquilibrés. Évaluez les modèles avec cross_val_score en k-fold, utilisez StratifiedKFold pour les données déséquilibrées et une validation croisée imbriquée lors du réglage des hyperparamètres afin d'obtenir une estimation finale non biaisée. Ne consultez jamais le jeu de test pendant le développement.

Questions Fréquemment Posées

La leçon « Évaluation des modèles et validation croisée » est-elle gratuite ?

Oui — le texte complet de « Évaluation des modèles et validation croisée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Évaluation des modèles et validation croisée » ?

Évaluez les modèles avec l’exactitude, le score F1, ROC-AUC et la CV k-fold. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Évaluation des modèles et validation croisée » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. L’API scikit-learn : fit, transform, predict
  2. Modèles linéaires : régression et classification
  3. Modèles arborescents : arbres de décision et forêts aléatoires
  4. Évaluation des modèles et validation croisée
← Retour à Python Academy