Des couches de neurones empilées : chacune fait des sommes pondérées de la précédente, puis les passe dans une fonction non linéaire. Le perceptron multicouche (MLP) apprend ainsi des relations qu'une droite ne capte pas. C'est la brique de base du deep learning, utile sur des données numériques denses comme des pixels ou des signaux.
Une chaîne de comités. Le premier regarde les pixels et vote sur des traits simples (une barre, une boucle). Le suivant combine ces votes pour décider quel chiffre est écrit.
Il multiplie chaque entrée par un poids, additionne, ajoute un biais. Seul, c'est une régression linéaire.
ReLU (garder le positif, mettre le négatif à zéro) ou tanh casse la linéarité. Sans elle, empiler des couches ne servirait à rien : le tout resterait une simple régression linéaire.
Entrée (64 pixels), couche cachée (64 neurones), sortie (10 chiffres). La sortie passe dans un softmax qui donne une probabilité par classe.
La rétropropagation calcule comment chaque poids a contribué à l'erreur, un optimiseur (Adam, descente de gradient) les ajuste. On répète sur toutes les données, plusieurs passes.
1 797 chiffres scannés en 8 × 8 pixels, soit 64 niveaux de gris par ligne, issus de formulaires remplis à la main. La colonne à prédire : le chiffre écrit, de 0 à 9.
Sur le jeu d'exemple, le MLP lit correctement 97,8 % des chiffres jamais vus, contre 96,7 % pour une régression logistique : 12 erreurs sur 540. Les chiffres lus avec une probabilité faible partent en vérification humaine.
L'exactitude donne la part de chiffres bien lus. La matrice de confusion montre les confusions : ici, les 8 lus comme des 1 sont l'erreur la plus fréquente. C'est elle qui dit où placer le contrôle humain.
Noms donnés pour R (nnet) et Python (scikit-learn). nnet ne gère qu'une couche cachée.
Le nombre de neurones et de couches cachées. Commencer avec une couche de la taille de l'entrée ; ajouter des couches seulement si la validation progresse.
La pénalité sur les poids (régularisation L2). Elle freine le surapprentissage : à augmenter si l'écart entre entraînement et test se creuse.
Le nombre de passes. En Python, early_stopping=True met de côté 10 % des données et arrête quand la validation ne progresse plus.
Obligatoire : un MLP apprend mal si une variable va de 0 à 1 et une autre de 0 à 100 000. Ici, les pixels sont divisés par 16 ; sur un tableau, StandardScaler ou scale().
# Formulaires manuscrits : réseau de neurones (MLP) en R
library(nnet)
chiffres <- read.csv("chiffres_manuscrits.csv")
chiffres[, 1:64] <- chiffres[, 1:64] / 16 # pixels ramenés entre 0 et 1
chiffres$chiffre <- factor(chiffres$chiffre)
set.seed(42)
idx <- sample(nrow(chiffres), round(0.7 * nrow(chiffres)))
train <- chiffres[idx, ]
test <- chiffres[-idx, ]
# 64 pixels -> 32 neurones cachés -> 10 chiffres (sortie softmax)
mlp <- nnet(chiffre ~ ., data = train, size = 32, decay = 0.01, maxit = 300,
MaxNWts = 5000, trace = FALSE)
pred <- predict(mlp, test, type = "class")
cat("Exactitude MLP :", round(mean(pred == test$chiffre), 3), "\n")
cat("Formulaires mal lus :", sum(pred != test$chiffre), "sur", nrow(test), "\n")
print(table(reel = test$chiffre, predit = pred))# Formulaires manuscrits : réseau de neurones (MLP) en Python
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, confusion_matrix
chiffres = pd.read_csv("chiffres_manuscrits.csv")
X = chiffres.drop(columns="chiffre") / 16 # pixels ramenés entre 0 et 1
y = chiffres["chiffre"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
# Référence linéaire : une régression logistique multiclasse
reference = LogisticRegression(max_iter=2000).fit(X_train, y_train)
print("Exactitude régression logistique :", round(accuracy_score(y_test, reference.predict(X_test)), 3))
# MLP : 64 pixels -> 64 neurones cachés -> 10 chiffres
mlp = MLPClassifier(hidden_layer_sizes=(64,), alpha=1e-4, max_iter=500, random_state=42)
mlp.fit(X_train, y_train)
pred = mlp.predict(X_test)
print("Exactitude MLP :", round(accuracy_score(y_test, pred), 3))
print("Formulaires mal lus sur", len(y_test), ":", (pred != y_test).sum())
print(pd.DataFrame(confusion_matrix(y_test, pred)))Le MLP est le réseau de neurones le plus simple : des couches entièrement connectées. On parle de deep learning quand on empile beaucoup de couches, souvent spécialisées : convolutions pour les images, attention pour le texte. Un MLP à une ou deux couches cachées est un réseau peu profond.
Il n'y a pas de formule. Un point de départ courant est un nombre proche du nombre de variables d'entrée, puis on compare quelques tailles en validation croisée. Au-delà d'une certaine taille, la performance plafonne et le risque de surapprentissage augmente.
Sur des tableaux de type clients ou contrats, le gradient boosting l'emporte le plus souvent, avec moins de préparation et de réglages. Le réseau prend l'avantage sur les données non structurées (images, son, texte) ou quand il faut combiner un tableau avec ce type de données.
Un MLP sans couche cachée. Lisible et rapide : si l'écart est faible, elle suffit.
Voir la fiche → le spécialiste des imagesDes filtres qui glissent sur l'image et exploitent la proximité des pixels. Nettement plus fort sur de vraies photos.
Voir la fiche → l'ancêtreUn seul neurone, une seule frontière droite. Le MLP en empile des couches pour tracer des frontières courbes.
Voir la fiche →Dataistudio forme les équipes au machine learning et à l'IA, sur des cas concrets.
Nous utilisons des cookies de mesure d'audience et de suivi publicitaire pour comprendre la fréquentation du site et l'efficacité de nos annonces. Rien n'est déposé sans votre accord. En savoir plus