Accueil › Glossaire › Régression Logistique

Régression Logistique (Logistic Regression)

La régression logistique est un algorithme de classification supervisée qui modélise la probabilité qu’un événement se produise en appliquant la fonction sigmoïde à une combinaison linéaire des variables d’entrée. Malgré son nom, ce n’est pas un algorithme de régression : il prédit des classes, pas des valeurs continues.

Pourquoi « régression » pour un classifieur ?

Le nom prête à confusion, et c’est historique. La régression logistique modélise une variable continue : la probabilité p d’un événement (comprise entre 0 et 1). C’est un modèle de régression sur cette probabilité. Mais en pratique, on s’en sert presque toujours pour classer : si p > 0.5, on prédit la classe 1 ; sinon, la classe 0.

C’est l’algorithme de classification le plus simple qui fonctionne réellement bien. Il devrait être votre premier réflexe sur tout nouveau problème de classification : rapide à entraîner, facile à interpréter, et souvent étonnamment compétitif face à des méthodes plus complexes.

Comment ça fonctionne

Du modèle linéaire à la classification

La régression logistique part d’un modèle linéaire classique. Elle calcule une combinaison linéaire z des features d’entrée :

z = β₀ + β₁x₁ + β₂x₂ + ... + βₚxₚ

Le problème : z peut prendre n’importe quelle valeur de -∞ à +∞, alors qu’une probabilité doit être comprise entre 0 et 1. C’est là qu’intervient la fonction sigmoïde (ou fonction logistique).

La fonction sigmoïde

La fonction sigmoïde transforme n’importe quel nombre réel en une valeur entre 0 et 1 :

σ(z) = 1 / (1 + e⁻ᶻ)

Son comportement est intuitif : quand z est très positif, σ(z) tend vers 1 (haute probabilité). Quand z est très négatif, σ(z) tend vers 0 (faible probabilité). Quand z = 0, σ(z) = 0.5 (incertitude maximale).

La probabilité prédite est donc :

P(y=1|x) = σ(β₀ + β₁x₁ + β₂x₂ + ... + βₚxₚ)

Odds, log-odds et logit

Pour comprendre l’interprétation des coefficients, il faut passer par les odds (cotes) et les log-odds.

Les odds d’un événement sont le rapport entre la probabilité qu’il se produise et la probabilité qu’il ne se produise pas : odds = p / (1-p). Si la probabilité de réussite est 0.8, les odds sont 0.8/0.2 = 4 (4 chances pour, 1 contre).

Les log-odds (ou logit) sont le logarithme naturel des odds : logit(p) = ln(p / (1-p)). La transformation logit a une propriété fondamentale : elle transforme une probabilité (bornée entre 0 et 1) en une valeur non bornée (-∞ à +∞), ce qui permet de la modéliser par une équation linéaire.

La régression logistique modélise donc les log-odds comme une fonction linéaire des features :

ln(p / (1-p)) = β₀ + β₁x₁ + β₂x₂ + ... + βₚxₚ

C’est cette formulation qui rend les coefficients interprétables : chaque βⱼ représente le changement des log-odds pour une augmentation d’une unité de xⱼ, toutes les autres variables étant constantes.

Interprétation des coefficients

Les coefficients de la régression logistique ne s’interprètent pas comme ceux d’une régression linéaire. Il y a trois niveaux de lecture :

En log-odds : le coefficient β₁ = 0.5 signifie qu’une augmentation d’une unité de x₁ augmente les log-odds de 0.5, toutes choses égales par ailleurs.

En odds ratio : en prenant l’exponentielle, exp(0.5) ≈ 1.65 signifie que les odds sont multipliés par 1.65 pour chaque unité supplémentaire de x₁. C’est l’interprétation la plus courante en épidémiologie et en sciences sociales.

En probabilité : l’effet sur la probabilité dépend du point de départ (la relation n’est pas linéaire). Une augmentation d’une unité de x₁ a un effet plus important sur la probabilité quand on part de p = 0.5 que quand on part de p = 0.01.

Fonction de coût : cross-entropy

La régression logistique est optimisée par maximisation de la vraisemblance, ce qui revient à minimiser la cross-entropy loss (ou log-loss) :

L = -1/n × Σ [yᵢ ln(p̂ᵢ) + (1-yᵢ) ln(1-p̂ᵢ)]

Cette fonction de coût pénalise fortement les prédictions confiantes mais fausses. Si le modèle prédit p = 0.99 pour une observation qui est en réalité classe 0, la pénalité est énorme. C’est ce qui pousse le modèle vers des probabilités bien calibrées.

Contrairement à la régression linéaire (résolution analytique via les moindres carrés), la cross-entropy n’a pas de solution fermée. On utilise des algorithmes d’optimisation itératifs pour trouver les coefficients optimaux.

Implémentation avec scikit-learn

scikit-learn (version 1.8.0) propose LogisticRegression avec plusieurs solveurs optimisés pour différents cas d’usage.

Classification binaire

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, roc_auc_score
from sklearn.datasets import load_breast_cancer
import numpy as np

# Charger les données
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Pipeline : normalisation + régression logistique
model = make_pipeline(
    StandardScaler(),
    LogisticRegression(C=1.0, max_iter=1000, random_state=42)
)
model.fit(X_train, y_train)

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

# Évaluation
print(classification_report(y_test, y_pred))
print(f"AUC-ROC : {roc_auc_score(y_test, y_proba):.4f}")

# Odds ratios
lr = model.named_steps['logisticregression']
odds_ratios = np.exp(lr.coef_[0])
print("Top 5 odds ratios :")
feature_names = load_breast_cancer().feature_names
for idx in np.argsort(odds_ratios)[-5:]:
    print(f"  {feature_names[idx]}: OR = {odds_ratios[idx]:.3f}")

Classification multiclasse

La régression logistique s’étend naturellement à plus de deux classes via la régression logistique multinomiale (softmax regression). Au lieu d’une seule sigmoïde, le modèle utilise la fonction softmax pour produire une distribution de probabilité sur K classes.

from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# multi_class='multinomial' est le défaut avec lbfgs
model = make_pipeline(
    StandardScaler(),
    LogisticRegression(
        multi_class='multinomial',  # ou 'ovr' pour one-vs-rest
        solver='lbfgs',
        max_iter=1000
    )
)
model.fit(X_train, y_train)
print(f"Accuracy : {model.score(X_test, y_test):.4f}")

Régularisation

La régularisation est essentielle pour éviter le surapprentissage, surtout quand le nombre de features est élevé. scikit-learn applique une régularisation L2 par défaut.

Le paramètre C est l’inverse de la force de régularisation : un C petit signifie une régularisation forte (coefficients contraints), un C grand signifie une régularisation faible. C’est l’opposé de la convention λ utilisée en statistiques (C = 1/λ).

# Sélection de features avec L1
model_l1 = make_pipeline(
    StandardScaler(),
    LogisticRegression(penalty='l1', solver='saga', C=0.1, max_iter=5000)
)
model_l1.fit(X_train, y_train)

# Compter les features avec coefficient non nul
lr_l1 = model_l1.named_steps['logisticregression']
n_features = (lr_l1.coef_ != 0).sum()
print(f"Features sélectionnées : {n_features} sur {X_train.shape[1]}")

Les solveurs : quel algorithme choisir

scikit-learn 1.8.0 propose six solveurs. Le choix dépend de la taille du dataset, du type de régularisation et du nombre de classes.

Hyperparamètres et tuning

scikit-learn propose LogisticRegressionCV, qui intègre la validation croisée directement dans le modèle pour optimiser C automatiquement :

from sklearn.linear_model import LogisticRegressionCV

model_cv = make_pipeline(
    StandardScaler(),
    LogisticRegressionCV(
        Cs=10,           # teste 10 valeurs de C
        cv=5,            # validation croisée 5-fold
        penalty='l2',
        max_iter=1000,
        random_state=42
    )
)
model_cv.fit(X_train, y_train)

lr_cv = model_cv.named_steps['logisticregressioncv']
print(f"Meilleur C : {lr_cv.C_[0]:.4f}")
print(f"Score : {model_cv.score(X_test, y_test):.4f}")

Forces et limites

Pourquoi la régression logistique reste incontournable

Rapidité : l’entraînement prend quelques millisecondes à quelques secondes, même sur des datasets volumineux. C’est des ordres de grandeur plus rapide que les méthodes ensemblistes ou le deep learning.

Interprétabilité : chaque coefficient a une signification directe (odds ratio). En santé, finance ou droit, pouvoir expliquer pourquoi le modèle a pris une décision est souvent une obligation réglementaire.

Probabilités calibrées : contrairement aux SVM ou aux arbres de décision, la régression logistique produit des probabilités intrinsèquement bien calibrées. Quand le modèle dit « probabilité de 70% », c’est réellement 70% des cas qui se réalisent.

Baseline indispensable : c’est le premier modèle à tester sur tout nouveau problème de classification. Si un modèle plus complexe ne bat pas significativement la régression logistique, ce modèle complexe ne se justifie pas.

Fonctionne en haute dimension : avec une régularisation L1, la régression logistique gère bien les datasets avec beaucoup de features (texte TF-IDF, génomique), en sélectionnant automatiquement les features pertinentes.

Les limites à connaître

Frontière de décision linéaire : la régression logistique ne capture que les relations linéaires entre les features et les log-odds. Si la véritable frontière entre les classes est une courbe ou un cercle, le modèle sera sous-performant. On peut contourner cette limite en créant des features polynomiales ou d’interaction, mais cela devient vite laborieux.

Hypothèse de linéarité des log-odds : le modèle suppose que la relation entre chaque feature et le logit est linéaire. Si cette hypothèse est violée, les prédictions et les coefficients sont biaisés.

Sensible à la multicolinéarité : si deux features sont très corrélées, les coefficients deviennent instables et difficiles à interpréter. La régularisation L2 atténue ce problème mais ne l’élimine pas.

Pas adaptée aux données non structurées : images, audio, texte brut nécessitent des architectures spécialisées (CNN, RNN, Transformers). La régression logistique peut être utilisée comme couche finale, mais pas comme modèle complet.

Régression logistique vs les alternatives

Verdict

La régression logistique n’est pas un modèle « ancien » qu’on utilise par nostalgie. C’est le point de départ obligatoire de tout projet de classification. Si votre problème est linéairement séparable, si l’interprétabilité compte, ou si vous avez besoin de probabilités fiables, elle peut être votre modèle final. Si les performances ne suffisent pas, passez à XGBoost, LightGBM ou CatBoost pour les données tabulaires, ou au deep learning pour les données non structurées.

Cas d’usage concrets

Scoring crédit et risque financier : la régression logistique reste le modèle dominant dans le scoring bancaire. Les régulateurs exigent des modèles interprétables, et les odds ratios répondent parfaitement à cette exigence. Un odds ratio de 2.5 sur le ratio dette/revenu signifie que doubler ce ratio multiplie par 2.5 les chances de défaut.

Diagnostic médical : prédire la probabilité d’une maladie en fonction de symptômes et de résultats de tests. L’interprétabilité est cruciale : un médecin doit comprendre pourquoi le modèle recommande un examen complémentaire.

Détection de spam : historiquement, la régression logistique sur des features TF-IDF était l’approche standard. Elle reste compétitive comme baseline et entraîne en quelques secondes sur des millions d’emails.

Marketing et churn : prédire la probabilité qu’un client résilie son abonnement. Les coefficients identifient directement les facteurs de risque (ancienneté, fréquence d’utilisation, nombre de contacts support).

A/B testing : la régression logistique permet d’analyser l’impact d’une modification (changement de design, prix, fonctionnalité) sur un taux de conversion binaire, en contrôlant les variables confondantes.

Couche finale de réseaux de neurones : dans un réseau de classification, la dernière couche est souvent une régression logistique (binaire) ou une softmax (multiclasse) appliquée aux features extraites par les couches précédentes. Le deep learning ne remplace pas la régression logistique, il l’encapsule.

Bonnes pratiques

Commencez toujours par la régression logistique. Elle sert de baseline : tout modèle plus complexe doit justifier sa complexité en la battant significativement.

Normalisez vos features si vous utilisez les solveurs sag ou saga. Pour les autres solveurs, la normalisation n’est pas strictement nécessaire pour la convergence, mais elle facilite la comparaison des coefficients.

Augmentez max_iter si vous obtenez un avertissement de non-convergence. La valeur par défaut (100) est souvent insuffisante. Passez à 1000 ou 5000.

Utilisez class_weight='balanced' pour les datasets déséquilibrés (fraude, maladies rares). Cette option ajuste automatiquement les poids en fonction de la fréquence des classes.

Vérifiez la calibration. Même si la régression logistique produit des probabilités généralement bien calibrées, utilisez un diagramme de fiabilité (CalibrationDisplay dans scikit-learn) pour le vérifier, surtout après régularisation forte.

Utilisez L1 pour la sélection de features. Si vous avez des centaines de features et que vous soupçonnez que beaucoup sont inutiles, la régularisation L1 les élimine automatiquement en mettant leurs coefficients à zéro.