Une règle que personne n’a écrite
Une application de réservation annonce au loueur que samedi sera plein. Personne chez l’éditeur n’a écrit « s’il fait chaud et sec le week-end ». L’application est partie de nombres qui ne voulaient rien dire. Elle les a corrigés, un jour passé après l’autre.
Pour un réseau de neurones, « apprendre » veut dire cela. C’est un calcul que vous pouvez suivre à la main.
À la fin de cette leçon
Remarque
Je peux expliquer comment apprend un petit réseau de neurones.
Mots clés
| Mot | Ce que ça veut dire | Exemple |
|---|---|---|
| Neurone | additionne ses entrées pondérées et un biais, puis décide | |
| Poids | combien une entrée compte | |
| Biais | un nombre ajouté qui déplace la décision | |
| Taux d’apprentissage | la taille de chaque correction | 0.1 |
| Époque | un passage sur toutes les lignes d’entraînement | |
| Couche cachée | des neurones placés entre les entrées et la réponse |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Un perceptron additionne, puis décide
Un perceptron est un seul neurone. Il multiplie chaque entrée par son poids, additionne le tout, puis ajoute le biais.
Si le total dépasse 0, il répond 1, ici « plein ». Sinon il répond 0, « calme ». Un grand poids positif pousse vers plein. Un poids négatif pousse vers calme.
Exemple travaillé : deux jours dans un neurone
| Jour | Entrées : temp, pluie, week-end | Poids 0,5, -0,9, 0,6 et biais -1 | Total | Réponse |
|---|---|---|---|---|
| Samedi chaud | 2,0, 0,0, 1 | 1,0 + 0 + 0,6 - 1 | 0,6 | 1, plein |
| Mercredi froid et pluvieux | 0,5, 1,0, 0 | 0,25 - 0,9 + 0 - 1 | -1,65 | 0, calme |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Une correction à la main
# Un jour plein : température en dizaines de degrés, pluie en cm, week-end.
jour = [2.0, 0.0, 1]
cible = 1
poids = [0.0, 0.0, 0.0]
biais = 0.0
taux = 0.1
total = biais
for n in range(3):
total = total + poids[n] * jour[n]
reponse = 0
if total > 0:
reponse = 1
erreur = cible - reponse
for n in range(3):
poids[n] = round(poids[n] + taux * erreur * jour[n], 2)
biais = round(biais + taux * erreur, 2)
print("réponse :", reponse, "erreur :", erreur)
print("poids :", poids, "biais :", biais)
# Recopiez les nouveaux poids et le biais aux lignes 4 et 5.
# Relancez. L'erreur vaut-elle maintenant 0 ?
Apprendre, c’est corriger les poids
L’entraînement part de poids nuls. Pour chaque ligne, le perceptron répond. L’erreur est la vraie réponse moins la sienne : 1, 0 ou -1.
Chaque poids bouge alors du taux d’apprentissage fois l’erreur fois son entrée. Un passage sur toutes les lignes est une époque. On s’arrête après un nombre d’époques fixé, ou quand une époque ne change presque plus rien.
Entraîner un perceptron sur l’année
docker exec jupyter python3 steps/perceptron.pyAffichée ici, non exécutée. Créez un compte gratuit pour appuyer sur Exécuter et la saisir dans le terminal de votre propre labo.
Une seule droite ne suffit pas toujours
Un perceptron sépare ses entrées par une seule frontière droite. Certains motifs ne se séparent pas ainsi.
Le plus connu est le XOR, le « ou exclusif » : la réponse vaut 1 quand une seule des deux entrées vaut 1. Aucune droite ne met les deux 1 d’un côté et les deux 0 de l’autre. Le bloc du carnet ci-dessous essaie quand même.
Exemple travaillé : OU et XOR
| Première entrée | Seconde entrée | OU | XOR |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 1 | 1 |
| 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 0 |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
À taper dans votre carnet : OU et XOR
from sklearn.linear_model import Perceptron
from sklearn.neural_network import MLPClassifier
X = [[0, 0], [0, 1], [1, 0], [1, 1]]
ou = [0, 1, 1, 1]
xor = [0, 1, 1, 0]
print(Perceptron(random_state=0).fit(X, ou).score(X, ou))
print(Perceptron(random_state=0).fit(X, xor).score(X, xor))
# Une couche cachée de 4 neurones.
reseau = MLPClassifier(hidden_layer_sizes=(4,), solver="lbfgs", max_iter=1000, random_state=1).fit(X, xor)
print(reseau.score(X, xor))
Des couches et beaucoup de petites corrections
Une couche cachée est une rangée de neurones entre les entrées et la réponse. Chacun trace sa propre frontière, et le dernier neurone les combine. C’est ainsi que le XOR est résolu.
Un réseau prend des décisions lisses plutôt qu’une marche brutale. Chaque poids peut alors être poussé un peu dans le sens qui baisse l’erreur. L’erreur remonte de la réponse vers chaque couche : c’est la rétropropagation.
Trois tailles de réseau sur l’année
docker exec jupyter python3 steps/network.pyAffichée ici, non exécutée. Créez un compte gratuit pour appuyer sur Exécuter et la saisir dans le terminal de votre propre labo.
Une erreur fréquente
Attention
Beaucoup pensent qu’un réseau plus gros est toujours meilleur. Ici, 2, 8 et 32 neurones cachés font tous 0,87, car le motif de trois entrées est simple. Des neurones en trop coûtent du temps et peuvent apprendre le bruit. Commencez petit, et grandissez seulement si un jeu de test dit que cela aide.
Pour aller plus loin
Dans votre carnet, entraînez le perceptron de perceptron.py avec trois taux d’apprentissage : eta0=0.01, eta0=1 et eta0=10. Notez chaque fois les passages et l’exactitude.
Expliquez ensuite en deux phrases pourquoi le taux compte plus pour certains modèles que pour d’autres. Indice : que devient la décision si l’on multiplie tous les poids et le biais par un même nombre ?