Inventé par Frank Rosenblatt à la fin des années 1950, le perceptron est le premier neurone artificiel. Il additionne des entrées pondérées et corrige ses poids à chaque erreur. Rarement utilisé seul aujourd'hui, il reste la brique qui permet de comprendre les réseaux de neurones et l'apprentissage au fil de l'eau.
Un apprenti qui trie des pièces : à chaque erreur signalée par le chef, il ajuste un peu sa règle de tri, puis passe à la pièce suivante.
Chaque pixel reçoit un poids. La somme pondérée donne un score ; le signe du score, ou le score le plus élevé entre plusieurs classes, décide de la réponse.
Si la réponse est fausse, on ajoute l'exemple aux poids de la bonne classe et on le retire de ceux de la classe prédite à tort. Si elle est juste, on ne touche à rien.
On recommence plusieurs passes. Si une droite peut séparer parfaitement les classes, les erreurs finissent par disparaître ; sinon, les poids continuent d'osciller.
Chaque chiffre scanné est une image de 8 × 8 pixels. À chaque correction d'un opérateur, le modèle reçoit la bonne réponse et peut se mettre à jour sans tout réentraîner.
Sur le jeu d'exemple, le perceptron lit 87 % des chiffres mis de côté après une passe, 94 % après quatre. Les erreurs à l'entraînement ne baissent pas régulièrement : elles remontent parfois d'une passe à l'autre.
On suit l'exactitude sur un jeu mis de côté après chaque passe, pour arrêter quand elle plafonne. Le perceptron ne garantit pas que la dernière passe soit la meilleure.
Noms donnés pour Python (scikit-learn). En R, l'algorithme s'écrit directement en R base.
Combien de fois on parcourt les données. On s'arrête quand l'exactitude sur un jeu de validation ne progresse plus (early_stopping=True en Python).
Mélanger les exemples à chaque passe évite qu'une séquence particulière oriente les poids. Activé par défaut en Python.
Régularisation optionnelle des poids, désactivée par défaut. Elle limite le surapprentissage quand les données sont bruitées.
# Lecture de chiffres manuscrits : perceptron en R
# Pas de package R de référence : l'algorithme tient en quelques lignes de R base
chiffres <- read.csv("chiffres_manuscrits.csv")
X <- cbind(1, as.matrix(chiffres[, 1:64]) / 16) # 1re colonne = biais
y <- chiffres$chiffre + 1 # classes 1 à 10
set.seed(42)
idx <- sample(nrow(X), round(0.7 * nrow(X)))
W <- matrix(0, nrow = 10, ncol = ncol(X)) # un vecteur de poids par chiffre
for (passe in 1:5) {
erreurs <- 0
for (i in sample(idx)) {
predit <- which.max(W %*% X[i, ])
if (predit != y[i]) { # correction seulement en cas d'erreur
W[y[i], ] <- W[y[i], ] + X[i, ]
W[predit, ] <- W[predit, ] - X[i, ]
erreurs <- erreurs + 1
}
}
pred <- max.col(X[-idx, ] %*% t(W))
cat("Passe", passe, "| erreurs corrigées :", erreurs, "| exactitude test :", round(mean(pred == y[-idx]), 3), "\n")
}# Lecture de chiffres manuscrits : perceptron en Python
import numpy as np
import pandas as pd
from sklearn.linear_model import Perceptron
from sklearn.model_selection import train_test_split
chiffres = pd.read_csv("chiffres_manuscrits.csv")
X = chiffres.drop(columns="chiffre").to_numpy() / 16 # pixels entre 0 et 1
y = chiffres["chiffre"].to_numpy()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# Un perceptron par chiffre (un contre tous), corrigé à chaque erreur
modele = Perceptron(random_state=42)
for passe in range(1, 6):
# partial_fit = un seul passage sur les données, comme un flux
modele.partial_fit(X_train, y_train, classes=np.arange(10))
erreurs = (modele.predict(X_train) != y_train).sum()
print("Passe", passe, "| erreurs à l'entraînement :", erreurs, "| exactitude test :", round(modele.score(X_test, y_test), 3))C'est le modèle de neurone artificiel le plus simple : une somme pondérée des entrées, suivie d'un seuil qui donne une réponse oui ou non. Il apprend en corrigeant ses poids chaque fois qu'il se trompe. Frank Rosenblatt l'a présenté en 1958.
Parce qu'il ne trace qu'une frontière droite. Le XOR, « l'un ou l'autre mais pas les deux », demande deux droites. Il faut au moins une couche cachée, c'est-à-dire un réseau de neurones multicouche, pour le résoudre.
Un réseau de neurones empile plusieurs couches de neurones, avec des fonctions d'activation non linéaires, et s'entraîne par rétropropagation du gradient. Le perceptron est une seule couche avec un seuil : il ne sépare que ce qu'une droite peut séparer.
Des perceptrons empilés en couches, avec des fonctions d'activation : les frontières deviennent courbes.
Voir la fiche → la frontière la plus sûreFrontière droite aussi, mais placée au plus loin des deux classes. Plus stable.
Voir la fiche → la version probabilisteUne somme pondérée passée dans une courbe en S : on obtient une probabilité au lieu d'un oui ou non.
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