Machine Learning Academy · Leçon

Régression logistique et fonction sigmoïde

Appliquez la sigmoïde pour produire des probabilités, interprétez la sortie comme le degré de confiance dans la classe et entraînez un modèle logistique avec scikit-learn.

Leçon 2 sur 413 étapes

Régression logistique et fonction sigmoïde est une leçon Machine Learning Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 Machine Learning Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Machine Learning Academy comprend 4 leçons au total.

Régression logistique : un classifieur probabiliste

La régression logistique est l'algorithme de référence pour la classification binaire. Malgré son nom, il s'agit d'un classifieur et non d'un modèle de régression. Elle étend le modèle linéaire en faisant passer la sortie par une fonction spéciale appelée sigmoid, ce qui garantit que les prédictions sont toujours des probabilités valides comprises entre 0 et 1.

La régression logistique est l'un des modèles d'apprentissage automatique les plus largement déployés en production. Elle est rapide à entraîner, interprétable et fournit des estimations de probabilités calibrées. Il s'agit souvent du premier classifieur à essayer sur un nouveau problème de classification binaire avant de recourir à des méthodes plus complexes.

La fonction sigmoid

La fonction sigmoid (également appelée fonction logistique) associe tout nombre réel à l'intervalle (0, 1) :

σ(z) = 1 / (1 + e^(-z))

Propriétés essentielles : σ(0) = 0.5, σ(+∞) → 1, σ(-∞) → 0. La courbe en S passe progressivement de 0 à 1. Lorsque z est un grand nombre positif (signal fort en faveur de la classe 1), la sortie se rapproche de 1. Lorsque z est un grand nombre négatif (signal fort en faveur de la classe 0), la sortie se rapproche de 0.

import numpy as np
import matplotlib.pyplot as plt

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

z = np.linspace(-10, 10, 200)
y = sigmoid(z)

plt.plot(z, y, 'b-', linewidth=2)
plt.axhline(y=0.5, color='red', linestyle='--', alpha=0.5, label='threshold=0.5')
plt.axvline(x=0, color='gray', linestyle='--', alpha=0.5)
plt.xlabel('z (linear score)')
plt.ylabel('sigmoid(z) = probability')
plt.title('The Sigmoid Function')
plt.legend()
plt.show()

print('sigmoid(0):', sigmoid(0))   # 0.5
print('sigmoid(5):', sigmoid(5))   # ~0.993
print('sigmoid(-5):', sigmoid(-5)) # ~0.007

Comment la régression logistique calcule une probabilité

La régression logistique calcule d'abord la même combinaison linéaire que la régression linéaire (z = w₁x₁ + w₂x₂ + ... + b), puis la fait passer par la fonction sigmoid pour obtenir une probabilité :

P(y=1|x) = σ(wᵀx + b) = 1 / (1 + e^(-(wᵀx+b)))

Le modèle produit la probabilité que l'entrée appartienne à la classe 1. Si cette probabilité dépasse 0.5, le modèle prédit la classe 1 ; sinon, la classe 0. Les poids w sont appris pendant l'entraînement afin de maximiser la vraisemblance des étiquettes observées — un processus appelé estimation du maximum de vraisemblance.

import numpy as np

def logistic_predict_proba(X, weights, bias):
    z = X @ weights + bias  # linear score
    probability = 1 / (1 + np.exp(-z))  # sigmoid
    return probability

# Example: spam classification
# Features: word_count, exclamation_marks, capital_ratio
weights = np.array([0.05, 0.3, 2.0])
bias = -3.0

new_email = np.array([50, 5, 0.6])  # 50 words, 5 '!', 60% capitals
prob_spam = logistic_predict_proba(new_email, weights, bias)
print(f'P(spam): {prob_spam:.3f}')
print('Predicted label:', 1 if prob_spam >= 0.5 else 0)

Log Loss : la fonction de coût appropriée

La régression logistique n'utilise pas MSE comme fonction de coût. Elle utilise plutôt l'entropie croisée binaire (perte logarithmique) :

Loss = -(y × log(ŷ) + (1-y) × log(1-ŷ))

Cette fonction pénalise extrêmement sévèrement les prédictions erronées faites avec une grande confiance. Si la véritable étiquette est 1 et que le modèle prédit une probabilité de 0.001, la perte logarithmique vaut -log(0.001) ≈ 6.9 — une valeur énorme. Si le modèle prédit 0.99, la perte vaut -log(0.99) ≈ 0.01 — une valeur infime. Cette pénalisation asymétrique est exactement adaptée au calibrage des probabilités.

import numpy as np

def log_loss_single(y_true, y_pred_proba, epsilon=1e-9):
    # Clip to avoid log(0)
    p = np.clip(y_pred_proba, epsilon, 1 - epsilon)
    return -(y_true * np.log(p) + (1 - y_true) * np.log(1 - p))

# True label = 1 (spam)
print('P(spam)=0.95, loss:', log_loss_single(1, 0.95).round(3))  # small
print('P(spam)=0.5,  loss:', log_loss_single(1, 0.50).round(3))  # moderate
print('P(spam)=0.05, loss:', log_loss_single(1, 0.05).round(3))  # large!
print('P(spam)=0.001,loss:', log_loss_single(1, 0.001).round(3)) # very large!

Entraîner une régression logistique avec scikit-learn

La LogisticRegression de scikit-learn utilise un optimiseur fondé sur le gradient (LBFGS par défaut) pour minimiser la perte logarithmique et trouver les poids optimaux. L'API est identique à celle de LinearRegression : instancier, ajuster, prédire.

Les paramètres importants comprennent C (inverse de la force de régularisation — une valeur de C plus petite signifie une régularisation plus forte) et max_iter (nombre maximal d'étapes d'optimisation). Si vous voyez un avertissement de convergence, augmentez max_iter ou mettez d'abord vos caractéristiques à l'échelle.

from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

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)

# Scale features (important for logistic regression)
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

model = LogisticRegression(C=1.0, max_iter=1000)
model.fit(X_train_s, y_train)
print('Test accuracy:', model.score(X_test_s, y_test).round(3))

Sorties de probabilités et degré de confiance

La régression logistique est l'un des rares classifieurs à produire des estimations de probabilités bien calibrées. Une probabilité de 0.85 pour la classe 1 signifie qu'environ 85 % des prédictions ayant ce niveau de confiance devraient effectivement appartenir à la classe 1. Ce calibrage est précieux dans les applications de gestion des risques (évaluation du risque de crédit, diagnostic médical), où la probabilité elle-même compte, et pas seulement l'étiquette binaire.

Utilisez predict_proba() pour récupérer le vecteur complet des probabilités. Les deux colonnes représentent P(classe 0) et P(classe 1). Leur somme vaut toujours 1.0.

import numpy as np

# Get class probabilities
probas = model.predict_proba(X_test_s[:8])
labels = model.predict(X_test_s[:8])

print('Sample | P(benign) | P(malignant) | Predicted')
for i, (proba, label) in enumerate(zip(probas, labels)):
    print(f'  {i+1}    |   {proba[0]:.3f}   |    {proba[1]:.3f}     | {label}')

print('\nClass names:', model.classes_)  # [0, 1] or ['benign', 'malignant']

Interpréter les coefficients de la régression logistique

Les coefficients de la régression logistique sont moins directement interprétables que ceux de la régression linéaire, mais ils contiennent tout de même des informations significatives. Le coefficient w associé à une caractéristique représente la variation des log-chances de la classe positive pour une augmentation d'une unité de cette caractéristique :

log(P(y=1)/P(y=0)) = wᵀx + b

Le rapport de cotes d'une caractéristique est exp(w). Si exp(w) = 2, cette caractéristique double les chances de la classe positive. Les grands coefficients positifs indiquent des caractéristiques qui prédisent fortement la classe 1 ; les grands coefficients négatifs prédisent fortement la classe 0.

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer

data = load_breast_cancer()
feature_names = data.feature_names

# Coefficient table with odds ratios
coef_df = pd.DataFrame({
    'Feature': feature_names,
    'Coefficient': model.coef_[0],
    'Odds_Ratio': np.exp(model.coef_[0])
}).sort_values('Coefficient', key=abs, ascending=False)

print(coef_df.head(5).to_string(index=False))
# Features with largest |coef| drive predictions most strongly

Régularisation de la régression logistique

La régression logistique de scikit-learn applique par défaut une régularisation L2, contrôlée par le paramètre C. Contrairement à la plupart des paramètres de régularisation, C est l'inverse de la force de régularisation : une valeur de C plus petite signifie une régularisation plus forte (un rétrécissement plus important des poids), tandis qu'une valeur de C plus grande signifie une régularisation plus faible.

Utilisez penalty='l1' et le solveur 'liblinear' pour une régularisation L1, qui effectue automatiquement une sélection des caractéristiques en mettant à zéro les poids des caractéristiques non pertinentes. La régression logistique L1 est particulièrement utile lorsque vous disposez de nombreuses caractéristiques et soupçonnez que la plupart sont sans intérêt.

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

# Compare regularisation strengths
for C in [0.01, 0.1, 1.0, 10.0, 100.0]:
    model_c = LogisticRegression(C=C, max_iter=1000)
    scores = cross_val_score(model_c, X_train_s, y_train, cv=5)
    print(f'C={C:6}: CV Accuracy = {scores.mean():.3f} (+/- {scores.std():.3f})')

Rapport de classification

Un seul nombre de précision masque des informations importantes. La fonction classification_report() de scikit-learn affiche la valeur prédictive positive, le rappel et le score F1 pour chaque classe, ainsi que les moyennes macro et pondérée. C'est la méthode standard pour présenter les performances d'une classification dans la recherche et l'industrie.

Pour lire le rapport : la colonne « support » indique combien d'exemples de chaque classe se trouvent dans l'ensemble de test. Si les supports sont très inégaux (déséquilibre des classes), examinez le rappel par classe plutôt que la précision globale afin de comprendre où le modèle échoue.

from sklearn.metrics import classification_report

y_pred = model.predict(X_test_s)
print(classification_report(y_test, y_pred, target_names=['benign', 'malignant']))
# Shows for each class:
#   precision: of all predicted positive, how many were actually positive
#   recall: of all actual positive, how many did we catch
#   f1-score: harmonic mean of precision and recall
#   support: number of true instances of each class in test set

Comparaison entre régression logistique et régression linéaire

Voici une comparaison claire des cas d'utilisation de chacune :

Type de cible : régression linéaire → nombre continu ; régression logistique → probabilité / étiquette binaire.
Plage de sortie : linéaire → (-∞, +∞) ; logistique → (0, 1).
Fonction de perte : linéaire → MSE ; logistique → entropie croisée binaire (perte logarithmique).
Évaluation : linéaire → RMSE, R² ; logistique → précision, F1, AUC-ROC.
Propriété commune : ce sont deux modèles linéaires — la frontière de décision est un hyperplan et tous deux bénéficient de la mise à l'échelle des caractéristiques et de la régularisation.

Régression logistique multiclasse

Pour les problèmes comportant plus de deux classes, la régression logistique se généralise en régression Softmax (également appelée régression logistique multinomiale). Au lieu d'une seule sigmoïde, elle calcule un score linéaire pour chaque classe, puis les fait tous passer par la fonction softmax, ce qui produit une distribution de probabilités sur l'ensemble des classes.

Dans scikit-learn, définissez multi_class='multinomial' et utilisez le solveur 'lbfgs' ou 'saga'. Le modèle produit une probabilité pour chaque classe, et la classe prédite est celle dont la probabilité est la plus élevée.

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

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)
X_train_s = StandardScaler().fit_transform(X_train)
X_test_s = StandardScaler().fit_transform(X_test)

# Multinomial for 3 classes
model = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=1000)
model.fit(X_train_s, y_train)
print('Test accuracy:', model.score(X_test_s, y_test).round(3))
print('Proba shape:', model.predict_proba(X_test_s[:1]).shape)  # (1, 3)

Vérification rapide

Testez votre compréhension des concepts d'apprentissage automatique avec Python abordés dans cette leçon.

Réponds-y dans la leçon interactive

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que la fonction sigmoïde ramène tout score linéaire à une probabilité valide comprise entre 0 et 1, que la régression logistique utilise une fonction de perte d'entropie croisée binaire qui pénalise fortement les prédictions erronées faites avec confiance, et que les coefficients représentent des variations des log-cotes, le rapport de cotes exp(w) offrant une interprétation plus intuitive et indépendante de l'échelle. Ensuite, nous construirons une matrice de confusion à partir des prédictions et des valeurs réelles, afin d'obtenir une analyse détaillée des réussites et des échecs du classifieur.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 30
Leçons: 120

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Régression logistique et fonction sigmoïde » est-elle gratuite ?

Oui — le texte complet de « Régression logistique et fonction sigmoïde » 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 Machine Learning Academy, passe à CoddyKit PRO. Le cours Machine Learning Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Régression logistique et fonction sigmoïde » ?

Appliquez la sigmoïde pour produire des probabilités, interprétez la sortie comme le degré de confiance dans la classe et entraînez un modèle logistique avec scikit-learn. Tu pratiques Machine Learning 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 Machine Learning Academy ?

Aucune expérience préalable n'est requise. Machine Learning 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 2 sur 4.

Combien de temps prend la leçon « Régression logistique et fonction sigmoïde » ?

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 Machine Learning Academy ?

Oui. Chaque leçon Machine Learning 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

De la régression à la classification : décisions fondées sur un seuil
Régression logistique et fonction sigmoïde
La matrice de confusion expliquée
Précision, rappel et score F1 en pratique

← Retour à Machine Learning Academy