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

Résumé — La régression logistique est l’algorithme de classification par excellence. Elle modélise la probabilité d’appartenance à une classe via une fonction sigmoïde appliquée à une combinaison linéaire des features. Simple, interprétable, régularisable et efficace, elle reste le point de départ incontournable de tout problème de classification supervisée, malgré l’essor des méthodes plus complexes.

Principe mathématique

La régression logistique repose sur quatre piliers mathématiques :

1. Fonction sigmoïde : La fonction logistique (ou sigmoïde) transforme une valeur réelle $z$ en une probabilité entre 0 et 1 :

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

Propriétés clés : $\sigma(0) = 0.5$, $z \to +\infty \Rightarrow \sigma(z) \to 1$, $z \to -\infty \Rightarrow \sigma(z) \to 0$, et $\sigma’(z) = \sigma(z)(1-\sigma(z))$.

2. Modèle linéaire probabiliste : On pose $z = w \cdot x + b$ (combinaison linéaire), puis la probabilité d’appartenance à la classe positive est :

$$P(y=1 | x) = \sigma(w \cdot x + b) = \frac{1}{1 + e^{-(w \cdot x + b)}}$$

La probabilité complémentaire est $P(y=0 | x) = 1 – P(y=1 | x)$.

3. Log-vraisemblance et fonction de coût : La vraisemblance de l’ensemble des données est le produit des probabilités individuelles :

$$L(w) = \prod_{i=1}^{n} p_i^{y_i} (1-p_i)^{1-y_i}$$

On maximise la log-vraisemblance (numériquement plus stable) :

$$\ell(w) = \sum_{i=1}^{n} [y_i \log(p_i) + (1-y_i) \log(1-p_i)]$$

C’est l’équivalent négatif de la binary cross-entropy. La fonction de coût à minimiser est :

$$J(w) = -\frac{1}{n} \sum_{i=1}^{n} [y_i \log(p_i) + (1-y_i) \log(1-p_i)]$$

4. Gradient et optimisation : Le gradient a une forme remarquablement simple :

$$\frac{\partial \ell}{\partial w} = \sum_{i=1}^{n} (p_i – y_i) x_i$$

C’est la même structure que la régression linéaire, mais avec $p_i = \sigma(w \cdot x_i + b)$ au lieu de $w \cdot x_i + b$. L’optimisation se fait généralement par des méthodes de quasi-Newton (L-BFGS) ou la descente de gradient.

5. Régularisation :
– L2 (Ridge) : ajoute $\frac{\lambda}{2} ||w||^2$ à la fonction de coût — pénalise les poids élevés, évite le surapprentissage.
– L1 (Lasso) : ajoute $\lambda ||w||_1$ — force certains coefficients à zéro, effectuant automatiquement la sélection de variables.
– ElasticNet : combinaison linéaire des deux : $\lambda_1 ||w||_1 + \frac{\lambda_2}{2} ||w||^2$.

Extension multinomiale : Pour $K$ classes, on utilise la fonction softmax :

$$P(y=k | x) = \frac{e^{w_k \cdot x + b_k}}{\sum_{j=1}^{K} e^{w_j \cdot x + b_j}}$$

Intuition

Imaginez un médecin qui doit diagnostiquer une maladie à partir de la température du patient. Une régression linéaire dirait : « à 39°C, la valeur prédite est 0,84 ». Mais qu’est-ce que ça veut dire, 0,84 ? Ce n’est pas une température, ni un diagnostic clair.

La régression logistique, elle, dit : « à 39°C, il y a 84% de chances que le patient soit malade ». C’est une réponse directement utilisable. Avec un seuil à 50%, on classe comme malade ; en baissant le seuil à 30%, on devient plus prudent et on hospitalise plus de patients par sécurité.

L’analogie du vote : Chaque feature contribue proportionnellement à sa valeur et à son poids. Si « fumer » a un poids positif de +3, un fumeur voit sa probabilité de maladie augmenter. Si « faire du sport » a un poids négatif de -1,5, un sportif voit sa probabilité diminuer. Le résultat final est une probabilité synthétique qui combine toutes ces contributions.

Pourquoi c’est si populaire ? : La régression logistique est au machine learning ce que le tournevis est à la boîte à outils — simple, fiable, et étonnamment utile. Son plus grand atout est l’interprétabilité : chaque coefficient quantifie exactement l’impact de sa feature sur la probabilité cible, ce qui est crucial dans des domaines réglementés comme la finance ou la santé.

Implémentation Python

Exemple 1 : Classification binaire avec scikit-learn

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, roc_curve, roc_auc_score
import matplotlib.pyplot as plt
import numpy as np

# Jeu de données
X, y = make_classification(
    n_samples=1000, n_features=10, n_informative=5,
    n_redundant=3, n_classes=2, random_state=42
)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Modèle
model = LogisticRegression(
    penalty='l2',
    C=1.0,
    solver='lbfgs',
    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(f"Accuracy : {model.score(X_test, y_test):.3f}")
print(f"AUC-ROC  : {roc_auc_score(y_test, y_proba):.3f}")
print("\nRapport de classification :")
print(classification_report(y_test, y_pred))
print("\nMatrice de confusion :")
print(confusion_matrix(y_test, y_pred))

Exemple 2 : Interprétation des coefficients

import pandas as pd
import numpy as np

# Features nommées pour l'interprétation
feature_names = [f"feature_{i}" for i in range(X.shape[1])]
coefficients = model.coef_[0]
intercept = model.intercept_[0]

# Tableau des coefficients
coef_df = pd.DataFrame({
    'Feature': feature_names,
    'Coefficient': coefficients,
    'Odds Ratio (exp(β))': np.exp(coefficients),
    'Abs(Coeff)': np.abs(coefficients)
}).sort_values('Abs(Coeff)', ascending=False)

print("\nImportance des features (triées par impact) :")
print(coef_df[['Feature', 'Coefficient', 'Odds Ratio (exp(β))']].to_string(index=False))

# Visualisation
plt.figure(figsize=(10, 5))
sorted_idx = np.argsort(coefficients)
colors = ['red' if c < 0 else 'green' for c in coefficients[sorted_idx]]
plt.barh(range(len(feature_names)), coefficients[sorted_idx], color=colors)
plt.yticks(range(len(feature_names)), [feature_names[i] for i in sorted_idx])
plt.axvline(x=0, color='black', linestyle='-', linewidth=0.5)
plt.title('Coefficients de la régression logistique')
plt.xlabel('Coefficient (positive = augmente la probabilité)')
plt.tight_layout()
plt.savefig('logistic_coefficients.png', dpi=150)
print("Graphique des coefficients sauvegardé")

Exemple 3 : Courbe ROC et optimisation du seuil

from sklearn.metrics import roc_curve, precision_recall_curve

# Courbe ROC
fpr, tpr, thresholds = roc_curve(y_test, y_proba)
roc_auc = roc_auc_score(y_test, y_proba)

plt.figure(figsize=(8, 5))
plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.3f}', linewidth=2)
plt.plot([0, 1], [0, 1], 'k--', label='Hasard')
plt.xlabel('Taux de faux positifs')
plt.ylabel('Taux de vrais positifs')
plt.title('Courbe ROC — Régression Logistique')
plt.legend()
plt.grid(True, alpha=0.3)
plt.savefig('logistic_roc.png', dpi=150)

# Optimisation du seuil
precision, recall, pr_thresholds = precision_recall_curve(y_test, y_proba)
f1_scores = 2 * (precision * recall) / (precision + recall + 1e-8)
best_threshold = pr_thresholds[np.argmax(f1_scores)]
print(f"\nSeuil optimisé (F1 max) : {best_threshold:.3f}")
print(f"F1 score seuil 0.50 : {f1_scores[np.argmin(np.abs(pr_thresholds - 0.5))]:.3f}")
print(f"F1 score seuil optimal : {f1_scores.max():.3f}")

Exemple 4 : Classification multinomiale

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Iris : 3 classes
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Classification multinomiale
model_multi = LogisticRegression(
    penalty='l2',
    C=1.0,
    solver='lbfgs',
    multi_class='multinomial',  # softmax pour K > 2 classes
    max_iter=1000,
    random_state=42
)
model_multi.fit(X_train, y_train)

print(f"Accuracy (multiclasse) : {model_multi.score(X_test, y_test):.3f}")
print(f"Classes : {model_multi.classes_}")
print(f"Forme des coefficients : {model_multi.coef_.shape}")

# Matrice des coefficients (3 classes × 4 features)
for k, coef_k in enumerate(model_multi.coef_):
    print(f"Classe {model_multi.classes_[k]}: coefficients = {coef_k.round(3)}")

Hyperparamètres

Avantages de la Régression Logistique

1. Interprétabilité maximale : Chaque coefficient est directement lisible comme une contribution à la probabilité via les odds ratios. Dans des domaines réglementés (banque, santé, assurance), cette transparence est souvent une exigence légale.
2. Rapidité d’entraînement : L’optimisation de la log-vraisemblance converge en quelques secondes, même sur des millions de points. C’est de loin l’algorithme le plus rapide de la liste pour un problème de classification.
3. Probabilités calibrées : Contrairement à SVM ou KNN qui nécessitent un recalibrage post-hoc (Platt scaling), les scores de la régression logistique sont déjà des probabilités bien calibrées.
4. Régularisation intégrée : L1, L2 et ElasticNet font partie du modèle nativement, permettant de contrôler le surapprentissage et de sélectionner automatiquement les variables pertinentes (avec L1).
5. Baseline incontestable : C’est le point de départ de tout problème de classification. Si un modèle complexe n’arrive pas à battre une simple régression logistique, le problème est probablement mal posé ou les données ne contiennent pas assez de signal.

Limites de la Régression Logistique

1. Linéarité : La frontière de décision est intrinsèquement linéaire. Si les classes ne sont pas linéairement séparables (XOR, cercles concentriques), le modèle échouera — à moins d’ajouter manuellement des features non linéaires (interactions, polynômes).
2. Feature engineering nécessaire : Pour capturer des relations non linéaires, il faut créer manuellement des interactions entre features ou des transformations polynomiales, ce qui peut être fastidieux et sujet au surapprentissage si trop de combinaisons sont testées.
3. Sensibilité à la multicollinéarité : Quand deux features sont fortement corrélées, les coefficients deviennent instables et leurs signes peuvent être contre-intuitifs. La régularisation L2 atténue ce problème mais ne le résout pas.
4. Hypothèse de linéarité du log-odds : Le modèle suppose que le logarithme des odds est linéaire par rapport aux features. Si cette hypothèse est violée, les prédictions seront faussées, même avec de nombreux données.
5. Outliers influents : Les points extrêmes peuvent avoir un impact disproportionné sur les coefficients, surtout sans régularisation forte. Un outlier peut “tirer” la frontière vers lui.

4 cas d’usage concrets

1. Scoring de crédit bancaire

Les banques utilisent la régression logistique pour évaluer la probabilité de défaut de paiement d’un emprunteur. Chaque feature (revenu, nombre d’incidents de paiement, âge, durée du prêt) a un coefficient qui traduit son poids dans le risque de défaut. Les odds ratios permettent d’expliquer au client pourquoi sa demande a été refusée — une exigence réglementaire européenne (droit à l’explication).

2. Diagnostic médical (dépistage)

En santé publique, la régression logistique modélise la probabilité qu’un patient développe une maladie à partir de ses facteurs de risque (IMC, tabagisme, hérédité, âge). L’interprétabilité des coefficients permet aux médecins de comprendre quels facteurs pèsent le plus et d’adapter les recommandations. De plus, les probabilités calibrées permettent de fixer des seuils de dépistage adaptés au coût des faux positifs vs faux négatifs.

3. Prédiction d’attrition (churn) en télécoms

Les opérateurs télécoms utilisent la régression logistique pour prédire quels clients sont susceptibles de résilier leur abonnement. Chaque coefficient identifie un facteur de churn (prix trop élevé, nombre d’appels au service client, ancienneté). Cela permet des actions ciblées : offrir une réduction aux clients à fort risque de départ, plutôt que de dépenser du budget sur tous les clients indiscriminément.

4. Analyse de résultats de campagnes marketing

En marketing digital, la régression logistique évalue l’impact de chaque facteur (canal d’acquisition, heure d’envoi, segment démographique, offre promotionnelle) sur la probabilité de conversion. Les odds ratios permettent de quantifier précisément : “Les clients reçus par email convertissent 2,3 fois plus que ceux reçus par SMS, toutes choses égales par ailleurs.” C’est un outil d’analyse causale puissant quand les données d’AB testing ne sont pas disponibles.

Bonnes pratiques

• Toujours normaliser les features avant une régression logistique avec régularisation (StandardScaler), sinon les pénalités L1/L2 affectent disproportionnellement les features à grande échelle.
• Commencer par C=1.0 puis faire varier de 0.01 à 100 via cross-validation pour trouver le bon niveau de régularisation.
• Interpréter les odds ratios (exp(coef)) plutôt que les coefficients bruts — un odds ratio de 1,4 se lit “40% de chances en plus par unité de feature”.
• Vérifier la calibration des probabilités avec un reliability diagram (CalibrationDisplay) — surtout important si les probabilités sont utilisées pour la prise de décision.
• Gérer le déséquilibre de classes avec class_weight='balanced' ou le ré-échantillonnage (SMOTE) si la classe positive représente moins de 10% des données.

Conclusion

La régression logistique est sans doute l’algorithme le plus utilisé en production dans l’industrie, devant même lesRandom Forests et les réseaux de neurones. Sa modestie est sa force : elle ne prétend pas tout résoudre, mais offre un compromis inégalé entre performance, interprétabilité et simplicité.

Pour choisir entre les classifieurs linéaires :
– Perceptron : quand les données sont linéairement séparables et qu’on veut un modèle ultra-simple.
– SVM linéaire : quand la marge maximale est importante (SVM gère mieux les outliers proches de la frontière).
– Régression logistique : dans TOUS les autres cas — c’est le choix par défaut le plus sûr.

Voir aussi

• Maîtriser la Logique Circulaire en Python : Guide Complet pour Débutants et Experts
• Maîtriser les Arrangements Maximaux en Python : Guide Complet et Astuces pour Développeurs