Régression Logistique : Guide complet — Principes, Exemples et Implémentation Python

Résumé — La régression logistique est l’un des algorithmes fondamentaux de la classification binaire en apprentissage supervisé. Elle estime la probabilité qu’une observation appartienne à une classe donnée en produisant une sortie comprise entre 0 et 1. Malgré sa simplicité apparente, elle reste l’un des modèles les plus utilisés en pratique grâce à son excellent compromis entre performance, interprétabilité et rapidité d’entraînement.

Principe mathématique

La fonction sigmoïde

Au cœur de la régression logistique se trouve la fonction sigmoïde (ou fonction logistique), notée $\sigma$ :

$$
\sigma(z) = \frac{1}{1 + e^{-z}}
$$

Cette fonction possède plusieurs propriétés qui la rendent idéale pour la classification :

• Plage de sortie : pour tout $z \in \mathbb{R}$, $\sigma(z) \in ]0, 1[$. Le résultat s’interprète naturellement comme une probabilité.
• Dérivée simple :
  $$
  \sigma’(z) = \sigma(z)\,(1 – \sigma(z))
  $$
  Cette forme compacte simplifie le calcul du gradient lors de l’optimisation.
• Comportement asymptotique : $\sigma(0)=0{,}5$, $\sigma(+\infty)\to1$ et $\sigma(-\infty)\to0$.

Le modèle

La régression logistique applique la fonction sigmoïde à une combinaison linéaire des variables d’entrée :

$$
p = P(Y=1 \mid X) = \sigma(w^\top X + b) = \frac{1}{1 + e^{-(w^\top X + b)}}
$$

où :

• $X$ est le vecteur des caractéristiques d’entrée ;
• $w$ est le vecteur des poids ;
• $b$ est le biais ;
• $w^\top X + b$ est appelé le logit.

En inversant la sigmoïde, on obtient l’équation fondamentale :

$$
\log\left(\frac{p}{1-p}\right) = w^\top X + b
$$

Cette équation montre pourquoi on parle de régression logistique : le modèle effectue une régression sur le log-odds de la probabilité, tout en étant utilisé pour un problème de classification.

Fonction de coût : l’entropie croisée binaire

Contrairement à la régression linéaire, la régression logistique n’utilise pas l’erreur quadratique moyenne. Elle maximise la log-vraisemblance, ce qui revient à minimiser la log-loss, aussi appelée entropie croisée binaire :

$$
J(w, b) = -\frac{1}{m}\sum_{i=1}^{m}\left[y_i \log(p_i) + (1-y_i)\log(1-p_i)\right]
$$

où :

• $m$ est le nombre d’échantillons ;
• $y_i \in {0,1}$ est l’étiquette réelle ;
• $p_i$ est la probabilité prédite pour l’échantillon $i$.

Cette fonction de coût est convexe, ce qui garantit qu’un algorithme d’optimisation bien paramétré converge vers un minimum global.

Elle pénalise fortement les erreurs confiantes :

• si $y_i = 1$ et $p_i \to 0$, le coût tend vers l’infini ;
• si $y_i = 0$ et $p_i \to 1$, le coût tend aussi vers l’infini.

Optimisation

Les paramètres $w$ et $b$ sont généralement appris à l’aide de la descente de gradient ou de solveurs plus avancés comme L-BFGS, Newton-CG ou SAGA.

Les gradients s’écrivent :

$$
\frac{\partial J}{\partial w} = \frac{1}{m} X^\top (p-y)
$$

$$
\frac{\partial J}{\partial b} = \frac{1}{m}\sum_{i=1}^{m}(p_i-y_i)
$$

En pratique, les bibliothèques comme scikit-learn gèrent automatiquement cette optimisation.

Intuition

Pourquoi ne pas utiliser la régression linéaire pour classifier ?

On pourrait être tenté d’utiliser une régression linéaire, puis de poser un seuil sur la sortie. Cette approche est pourtant inadaptée :

1. Sorties non bornées : une régression linéaire peut produire des valeurs négatives ou supérieures à 1, ce qui n’a pas de sens pour une probabilité.
2. Sensibilité aux valeurs extrêmes : une observation aberrante peut fortement déplacer la droite de régression.
3. Mauvaise modélisation de la probabilité : la relation entre les variables et la probabilité d’appartenance à une classe est rarement purement linéaire.

La sigmoïde comme compresseur

La sigmoïde agit comme un compresseur : elle transforme toute la droite réelle en une valeur comprise entre 0 et 1. Les valeurs très négatives sont rapprochées de 0, les valeurs très positives de 1, et la zone autour de 0 représente l’incertitude.

Le seuil de décision

Par défaut, on classe une observation dans la classe 1 si :

$$
p \ge 0{,}5
$$

et dans la classe 0 sinon.

Ce seuil de 0,5 n’est pas universel. En pratique, on l’ajuste selon le coût des erreurs :

• en médecine, on préfère souvent réduire les faux négatifs en abaissant le seuil ;
• en détection de fraude, on peut au contraire relever le seuil pour éviter trop de fausses alertes.

Implémentation Python

Installation des dépendances

pip install scikit-learn numpy matplotlib

Exemple complet avec scikit-learn

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    roc_auc_score,
    roc_curve,
    confusion_matrix,
    classification_report
)

# ---------------------------------------------------------
# 1. Génération d'un jeu de données binaire
# ---------------------------------------------------------
X, y = make_classification(
    n_samples=1000,
    n_features=2,        # 2 variables pour faciliter la visualisation
    n_informative=2,
    n_redundant=0,
    n_clusters_per_class=1,
    class_sep=1.5,
    random_state=42
)

# Séparation entraînement / test
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.25,
    stratify=y,
    random_state=42
)

# ---------------------------------------------------------
# 2. Pipeline : standardisation + régression logistique
# ---------------------------------------------------------
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("model", LogisticRegression(
        penalty="l2",
        C=1.0,
        solver="lbfgs",
        max_iter=1000,
        random_state=42
    ))
])

pipeline.fit(X_train, y_train)

# Prédictions
y_pred = pipeline.predict(X_test)
y_proba = pipeline.predict_proba(X_test)[:, 1]

# ---------------------------------------------------------
# 3. Évaluation
# ---------------------------------------------------------
print("=== Métriques de classification ===")
print(f"Accuracy  : {accuracy_score(y_test, y_pred):.4f}")
print(f"Précision : {precision_score(y_test, y_pred):.4f}")
print(f"Rappel    : {recall_score(y_test, y_pred):.4f}")
print(f"F1-score  : {f1_score(y_test, y_pred):.4f}")
print(f"ROC-AUC   : {roc_auc_score(y_test, y_proba):.4f}")

print("\n=== Rapport détaillé ===")
print(classification_report(y_test, y_pred, target_names=["Classe 0", "Classe 1"]))

print("=== Matrice de confusion ===")
print(confusion_matrix(y_test, y_pred))

Visualisation de la frontière de décision

def tracer_frontiere(modele, X, y, titre="Frontière de décision"):
    h = 0.02
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1

    xx, yy = np.meshgrid(
        np.arange(x_min, x_max, h),
        np.arange(y_min, y_max, h)
    )

    grille = np.c_[xx.ravel(), yy.ravel()]
    Z = modele.predict(grille)
    Z = Z.reshape(xx.shape)

    plt.figure(figsize=(10, 6))
    plt.contourf(xx, yy, Z, alpha=0.3, cmap="RdBu")
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap="RdBu", edgecolor="k", s=40)
    plt.xlabel("Caractéristique 1")
    plt.ylabel("Caractéristique 2")
    plt.title(titre)
    plt.tight_layout()
    plt.show()

tracer_frontiere(
    pipeline,
    X_test,
    y_test,
    "Frontière de décision — Régression logistique"
)

Courbe ROC

fpr, tpr, seuils = roc_curve(y_test, y_proba)
auc = roc_auc_score(y_test, y_proba)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, lw=2, label=f"ROC (AUC = {auc:.4f})")
plt.plot([0, 1], [0, 1], linestyle="--", lw=2, label="Aléatoire")
plt.xlabel("Taux de faux positifs")
plt.ylabel("Taux de vrais positifs")
plt.title("Courbe ROC — Régression logistique")
plt.legend(loc="lower right")
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

Modifier le seuil de décision

Par défaut, predict() utilise un seuil de 0,5. Voici comment tester un autre seuil :

seuil = 0.3
y_pred_custom = (y_proba >= seuil).astype(int)

print(f"=== Évaluation avec seuil = {seuil} ===")
print(f"Précision : {precision_score(y_test, y_pred_custom):.4f}")
print(f"Rappel    : {recall_score(y_test, y_pred_custom):.4f}")
print(f"F1-score  : {f1_score(y_test, y_pred_custom):.4f}")

Interprétation des coefficients

L’un des grands atouts de la régression logistique est son interprétabilité.

Pour récupérer les coefficients du modèle dans scikit-learn :

coefficients = pipeline.named_steps["model"].coef_[0]
intercept = pipeline.named_steps["model"].intercept_[0]

print("Intercept :", intercept)
print("Coefficients :", coefficients)

Comment les lire ?

• un coefficient positif augmente le logit, donc la probabilité d’appartenir à la classe 1 ;
• un coefficient négatif la diminue ;
• plus la valeur absolue du coefficient est grande, plus l’effet est fort.

Attention toutefois : l’interprétation devient plus délicate si les variables sont très corrélées entre elles.

Hyperparamètres

Remarques pratiques

• lbfgs est un bon choix général pour la classification binaire.
• liblinear est souvent utilisé pour de petits jeux de données et pour la pénalité l1.
• saga est adapté aux grands jeux de données et à elasticnet.
• class_weight="balanced" est très utile lorsque la classe positive est rare.
• C est souvent l’hyperparamètre le plus important à régler via validation croisée.

Avantages et limites

Avantages

• Interprétable : chaque coefficient a une signification claire.
• Rapide : entraînement et prédiction sont efficaces même sur de grands volumes.
• Robuste comme baseline : excellent modèle de référence avant de tester des approches plus complexes.
• Probabiliste : produit des probabilités exploitables pour ajuster les seuils de décision.
• Bien adapté aux problèmes linéairement séparables ou presque.

Limites

• Frontière de décision linéaire : le modèle ne capture pas directement des relations non linéaires complexes.
• Sensibilité au déséquilibre de classes : sans ajustement, il peut négliger la classe minoritaire.
• Sensibilité aux variables corrélées : les coefficients peuvent devenir instables.
• Dépendance au prétraitement : la standardisation est souvent recommandée, surtout avec régularisation.

Cas d’usage concrets

1. Détection de fraude bancaire

Les transactions sont classées en frauduleuses ou légitimes à partir de variables comme le montant, l’heure, la localisation ou l’historique du client. La régression logistique est appréciée pour sa rapidité et pour la possibilité d’ajuster le seuil de décision selon la politique de risque.

2. Diagnostic médical assisté

En santé, elle permet d’estimer la probabilité qu’un patient présente une maladie à partir de facteurs cliniques : âge, IMC, glycémie, tension, antécédents, etc. Son interprétabilité est un atout majeur dans les environnements réglementés.

3. Scoring de crédit

Les banques utilisent la régression logistique pour évaluer le risque de défaut d’un emprunteur. Ce modèle reste populaire car il est performant, rapide, et surtout explicable auprès des régulateurs.

4. Filtrage de spam

La classification d’e-mails en spam ou non-spam est un usage historique. En représentation sac de mots ou TF-IDF, la régression logistique fonctionne très bien et fournit une baseline solide.

Conclusion

La régression logistique est souvent le premier modèle à essayer pour un problème de classification binaire, et très souvent l’un des meilleurs points de départ. Elle combine une base mathématique solide, une optimisation efficace, une grande interprétabilité et de très bonnes performances sur de nombreux cas pratiques.

Même à l’ère des modèles complexes, elle reste incontournable : non seulement comme baseline, mais aussi comme modèle final dans de nombreux systèmes industriels, financiers et médicaux.

Voir aussi

• Optimisez Votre Python : Maximiser le Produit de Partition D’un Entier en Python
• La Cryptomonnaie selon l’intelligence artificielle