Deep Learning 2 — Classification

:::tip Notebook Kaggle Le code complet et exécutable de ce chapitre est sur Kaggle : Ouvrir →

Versions anglaise et chinoise disponibles depuis la page d'accueil. :::

Au chapitre précédent, nous avons fait de la régression — prédire un nombre. Ici nous attaquons la classification — prédire une catégorie. La grande surprise du chapitre, et c'est sa beauté : passer de l'un à l'autre ne demande quasiment rien. Le gradient garde la même forme.

Pourquoi ce chapitre ?

Vous y voyez :

• le neurone logistique (régression linéaire + sigmoïde) ;
• l'explication intuitive de la cross-entropy et sa dérivation depuis la loi de Bernoulli ;
• le fait que le gradient garde la même forme $\frac{1}{n} X^T (u - y)$ ;
• les pièges PyTorch : BCELoss vs BCEWithLogitsLoss vs CrossEntropyLoss ;
• la classification multiclasse : softmax + CrossEntropyLoss.

Du linéaire au logistique

Pour la classification binaire, la cible est $y \in \{0, 1\}$. On veut une probabilité $\hat{p} = P(y = 1 \mid X)$, donc une sortie dans $(0, 1)$.

Solution : on applique la fonction sigmoïde à la sortie linéaire.

$z = X w + b, \quad u = \sigma(z) = \frac{1}{1 + e^{-z}}$

$\sigma(z)$ écrase n'importe quel réel dans $(0, 1)$. C'est le neurone logistique.

La cross-entropy comme « surprise »

La fonction de coût pour la classification est la cross-entropy :

$E_i = -\big[ y_i \log u_i + (1 - y_i) \log(1 - u_i) \big]$

L'intuition : la cross-entropy mesure la « surprise » du modèle face à la vérité.

• Si $y_i = 1$ et $u_i \to 1$ : aucune surprise, $E_i = -\log 1 = 0$.
• Si $y_i = 1$ et $u_i \to 0$ : énorme surprise, $E_i \to +\infty$.
• Symétrique si $y_i = 0$.

Plus le modèle est confiant dans la bonne réponse, plus la loss est petite. Plus il est confiant dans la mauvaise réponse, plus la loss explose. C'est cette asymétrie qui pousse le modèle à apprendre des probabilités calibrées.

Dérivation depuis Bernoulli

Pourquoi cette formule précise ? Elle vient du maximum de vraisemblance. Si on modélise $y$ comme une variable de Bernoulli de paramètre $p$ :

$P(y \mid p) = p^y (1-p)^{1-y}$

La vraisemblance des observations est le produit. On prend le log négatif (pour avoir une fonction à minimiser) et on retombe exactement sur la cross-entropy.

Le gradient garde la même forme

C'est le moment magique du chapitre. Pour le neurone linéaire :

$\frac{\partial E}{\partial w} = \frac{1}{n} X^T (u - y)$

Pour le neurone logistique, après calcul :

$\frac{\partial E}{\partial w} = \frac{1}{n} X^T (u - y)$

Strictement la même formule. La seule différence est dans la définition de $u$ :

• linéaire : $u = X w + b$
• logistique : $u = \sigma(X w + b)$

Conséquence pratique : pour transformer un LinearNeuron en LogisticNeuron, il suffit de changer forward() pour appliquer la sigmoïde. Tout le reste reste identique.

Version PyTorch

model = nn.Linear(m, 1)             # juste les logits, pas de Sigmoid
criterion = nn.BCEWithLogitsLoss()  # applique la sigmoïde + cross-entropy
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

Pièges classiques

PyTorch propose plusieurs combinaisons modèle + loss qui se ressemblent mais ne sont pas équivalentes :

Si la loss est...	Le modèle doit sortir...
nn.BCELoss	une probabilité (avec Sigmoid à la fin)
nn.BCEWithLogitsLoss	un logit (sans Sigmoid)
nn.CrossEntropyLoss (multiclasse)	un vecteur de logits (sans Softmax)

:::warning Le piège n°1 Ne jamais mettre Sigmoid dans le modèle ET utiliser BCEWithLogitsLoss. La sigmoïde s'appliquerait deux fois, le modèle n'apprend rien. :::

BCEWithLogitsLoss est recommandé : numériquement plus stable que la combinaison Sigmoid + BCELoss.

Prédire la classe

Après l'entraînement, pour passer du logit à la classe :

model.eval()
with torch.no_grad():
    logits = model(X_test_t)
    proba  = torch.sigmoid(logits)         # logit → probabilité
    y_hat  = (proba >= 0.5).float()        # probabilité → classe

Multiclasse : softmax + CrossEntropyLoss

Pour $C$ classes, la dernière couche a $C$ neurones et produit un vecteur de logits :

$z = (z_0, z_1, \dots, z_{C-1})$

La généralisation de la sigmoïde est la softmax :

$P(y = c \mid X) = \frac{e^{z_c}}{\sum_k e^{z_k}}$

Toutes les probabilités sont positives et somment à 1.

La cross-entropy multiclasse est simplement :

$E_i = -\log P(y = y_i \mid X_i)$

Moins le log de la probabilité prédite pour la vraie classe.

model = nn.Sequential(
    nn.Linear(m, 64),
    nn.ReLU(),
    nn.Linear(64, C),     # logits multiclasse
)
criterion = nn.CrossEntropyLoss()  # applique LogSoftmax + cross-entropy

Forme attendue de y

Tâche	Forme du modèle	Forme de y	Type	Loss
Régression	(n, 1)	(n, 1)	float32	MSELoss
Classification binaire	(n, 1)	(n, 1)	float32	BCEWithLogitsLoss
Classification multiclasse	(n, C)	(n,)	long	CrossEntropyLoss

:::warning y multiclasse Pour CrossEntropyLoss, $y$ est un vecteur 1D d'entiers (pas one-hot). Type long, pas float. :::

Prédire la classe

with torch.no_grad():
    logits = model(X_test_t)
    y_hat  = torch.argmax(logits, dim=1)   # classe la plus probable

argmax sur la dimension des classes — pas besoin d'appliquer la softmax explicitement, l'ordre est préservé.

---

Notebook complet sur Kaggle (forkable) →