Aller au contenu
ELECTRONICS ENGINEERINGelectronics-engineering.com
Apprentissage automatique et réseaux de neurones

L'entraînement en pratique : données, initialisation de He, normalisation, dropout et métriques

Entraînement, validation et test, l'initialisation de He démontrée et mesurée sur 20 couches, normalisation par lot et par couche, dropout, quantité de données, précision, rappel et F1, recherche d'hyperparamètres, avec des expériences honnêtes.

https://www.electronics-engineering.com/fr/entrainement-en-pratique-initialisation-dropout-metriques/

Pas encore de vote : soyez le premier à noter cette page.

Entre la théorie des leçons précédentes et un réseau qui fonctionne vraiment, il y a de nombreux choix pratiques : comment répartir les données, comment initialiser les poids, comment normaliser, comment éviter le surapprentissage, comment mesurer le résultat. Cette leçon les présente avec leurs raisons mathématiques et avec des expériences mesurées, y compris celles qui ne confirment pas les attentes : dans l’entraînement des réseaux, de nombreuses « astuces » fonctionnent sur certains problèmes et pas sur d’autres, et le seul moyen de savoir est de mesurer.

La répartition des données

Les données se répartissent en trois parties : l’entraînement (pour les poids), la validation (pour les choix : taille du réseau, pas, régularisation, quand s’arrêter) et le test, utilisé une seule fois à la fin pour estimer la performance sur de nouvelles données. Si l’on fait des choix en regardant l’ensemble de test, le test devient une seconde validation et l’estimation est optimiste. Avec peu de données, on utilise la validation croisée : on divise l’ensemble en k parties, on entraîne k fois en laissant de côté une partie différente, et l’on fait la moyenne des résultats. Deux avertissements pratiques : la répartition doit être faite avant toute normalisation (moyenne et variance se calculent seulement sur l’ensemble d’entraînement), et pour des données dans le temps (séries de capteurs), le test doit venir après les données d’entraînement, pas mélangé à elles.

L’initialisation des poids

Si les poids initiaux sont trop petits, les activations (et les gradients) s’évanouissent couche après couche ; s’ils sont trop grands, ils explosent. La bonne initialisation maintient la variance constante.

Théorème (initialisation de He, 2015). Dans un réseau à activations ReLU, avec des poids indépendants de moyenne nulle et n entrées par neurone, la variance des sommes pondérées reste constante d’une couche à la suivante si \text{Var}(w) = \dfrac{2}{n}.

Démonstration. Pour un neurone z = \sum_{j=1}^nw_jh_j avec w_j indépendant de h_j et de moyenne nulle, \text{Var}(z) = n\,\text{Var}(w)\,\mathbb E[h^2]. Avec h = \max(0, z_{prev}) et z_{prev} symétrique autour de zéro, la ReLU laisse passer la moitié de la distribution : \mathbb E[h^2] = \frac{1}{2}\text{Var}(z_{prev}). Donc \text{Var}(z) = \frac{n}{2}\text{Var}(w)\,\text{Var}(z_{prev}), qui reste la même si \text{Var}(w) = 2/n. ∎

Pour des activations symétriques comme la tanh, le facteur 1/2 est absent et l’on obtient \text{Var}(w) = 1/n (Xavier ou Glorot, 2010). Expérience : 20 couches de 256 neurones ReLU, écart-type des activations :

poidsaprès 1 coucheaprès 5après 10après 20
\mathcal N(0;\ 0.01^2)0.0941.6\cdot 10^{-5}3\cdot 10^{-10}10^{-19}
\mathcal N(0;\ 1)9.351.8\cdot 10^53\cdot 10^{10}10^{21}
Xavier, 1/n0.580.150.0280.00067
He, 2/n0.830.860.800.76

Avec la ReLU, seule l’initialisation de He préserve le signal ; celle de Xavier le divise par deux (en variance) à chaque couche, exactement le facteur 1/2 de la démonstration.

Écart-type des activations à travers 20 couches ReLU
Sur une échelle logarithmique : avec des poids trop petits, en gris, le signal s’évanouit ; avec des poids trop grands, en rouge, il explose ; avec l’initialisation de Xavier, en orange, il décroît lentement ; avec celle de He, en bleu, il reste constant.

La normalisation

La normalisation par lot (batch normalization, 2015) normalise les sommes pondérées de chaque neurone sur le mini-lot (moyenne 0, variance 1) puis les remet à l’échelle avec deux paramètres appris. Elle rend l’entraînement bien moins sensible à l’initialisation et au pas, et permet des pas plus grands. Dans les transformers, on utilise la normalisation par couche (layer normalization), qui normalise sur les composantes d’un seul exemple au lieu de le faire sur le lot, et fonctionne même avec de petits lots et des séquences de longueur variable. Les entrées aussi doivent être normalisées : des variables d’échelles très différentes (une température en kelvins et une tension en millivolts) dégradent le conditionnement (leçon 1).

Contre le surapprentissage

  • Plus de données : le remède le plus efficace de tous, comme le montre l’expérience ci-dessous.
  • Augmentation de données : de nouvelles copies des exemples transformées de façons qui ne changent pas la réponse (décalages, rotations, bruit, changements d’éclairage).
  • Weight decay : la pénalité \lambda\|\mathbf w\|^2 de la leçon 1.
  • Dropout (Srivastava et al., 2014) : pendant l’entraînement, chaque neurone est éteint au hasard avec une probabilité p, et les neurones restants sont multipliés par 1/(1 - p). Ainsi, la valeur attendue de chaque sortie est la même avec et sans dropout : \mathbb E[\tilde h] = (1 - p)\cdot\frac{h}{1 - p} + p\cdot 0 = h, et à l’usage, tout le réseau est utilisé sans corrections. L’idée est d’empêcher les neurones de « s’appuyer » les uns sur les autres.
  • Arrêt précoce (early stopping) : on surveille l’erreur de validation pendant l’entraînement et l’on arrête quand elle commence à monter.

Les expériences. Réseau dense 64 → 1024 → 1024 → 10 sur les chiffres 8×8, entraîné pendant 300 pas sur des sous-ensembles de taille croissante, précision sur les 450 chiffres de test (moyenne sur 3 graines) :

exemples d’entraînement501002004001347
précision en test76,4 %89,5 %91,9 %95,5 %97,0 %

Le dropout (p = 0,5), sur le même réseau avec 100 exemples, a donné 89,5 % contre 89,1 % sans (moyenne sur 5 graines) : aucune différence mesurable ; avec 50 exemples, 77,8 % contre 77,9 %. Le weight decay avec \lambda = 10^{-2} l’a légèrement dégradé (86,0 %). Sur ce problème, petit et déjà facile, la régularisation compte peu et la quantité de données compte beaucoup. Sur de très grands réseaux et des problèmes plus difficiles (images ImageNet, modèles de langage), le dropout et le weight decay donnent en revanche des bénéfices mesurables. La morale est celle de la leçon : il faut essayer les techniques sur son propre problème, avec une validation honnête.

Les métriques

La précision globale (accuracy, la fraction de bonnes réponses) est trompeuse quand les classes sont déséquilibrées : si une panne survient dans 1 % des cas, un classifieur qui dit toujours « pas de panne » a 99 % de précision globale et est inutile. Pour une classe « positive », avec TP, FP, FN les vrais positifs, les faux positifs et les faux négatifs :

    \[ \text{precision} = \frac{TP}{TP + FP},\qquad \text{recall} = \frac{TP}{TP + FN},\qquad F_1 = \frac{2\cdot\text{precision}\cdot\text{recall}}{\text{precision} + \text{recall}} \]

La précision (precision) dit combien d’alarmes sont vraies, le rappel (recall) combien de cas vrais sont trouvés. Déplacer le seuil de décision échange l’un contre l’autre ; ce qui compte le plus dépend de l’application (dans un système de freinage d’urgence, un faux négatif est bien plus grave qu’un faux positif, dans un filtre antispam, c’est l’inverse). La matrice de confusion, utilisée dans la dernière leçon, montre toutes les erreurs classe par classe.

Le choix des hyperparamètres

Le pas, les tailles, la régularisation, la taille de lot sont des hyperparamètres : ils ne sont pas appris par le gradient, on les choisit en comparant les résultats sur l’ensemble de validation. La recherche aléatoire (Bergstra et Bengio, 2012) est en général meilleure que la recherche en grille : si seuls quelques hyperparamètres comptent vraiment, essayer des valeurs aléatoires explore beaucoup plus de valeurs différentes des importants. Le pas se cherche sur une échelle logarithmique (10^{-4}, 3\cdot 10^{-4}, 10^{-3}, …).

import numpy as np, torch, torch.nn as nn
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

# 1) initialisation: standard deviation of the activations through 20 ReLU layers
g = np.random.default_rng(0)
h0 = g.normal(0, 1, (1000, 256))
for name, std in (("N(0, 0.01^2)", lambda n: 0.01), ("N(0, 1)", lambda n: 1.0),
                  ("Xavier 1/n", lambda n: np.sqrt(1 / n)), ("He 2/n", lambda n: np.sqrt(2 / n))):
    h, values = h0.copy(), []
    for layer in range(20):
        h = np.maximum(h @ g.normal(0, std(256), (256, 256)), 0)
        values.append(h.std())
    print(f"{name:13s}: after 1, 5, 10, 20 layers {values[0]:.3g}, {values[4]:.3g}, {values[9]:.3g}, {values[19]:.3g}")

# 2) amount of data: the same network trained on larger and larger subsets
d = load_digits()
Xa, Xp, ya, yp = train_test_split(d.data / 16.0, d.target, test_size=0.25, random_state=0, stratify=d.target)
Xa, Xp = torch.tensor(Xa, dtype=torch.float32), torch.tensor(Xp, dtype=torch.float32)
ya, yp = torch.tensor(ya), torch.tensor(yp)

def trial(n, seed, dropout=0.0):
    torch.manual_seed(seed)
    layers = [nn.Linear(64, 1024), nn.ReLU()] + ([nn.Dropout(dropout)] if dropout else []) \
           + [nn.Linear(1024, 1024), nn.ReLU()] + ([nn.Dropout(dropout)] if dropout else []) + [nn.Linear(1024, 10)]
    net = nn.Sequential(*layers)
    opt = torch.optim.Adam(net.parameters(), lr=1e-3)
    idx = torch.randperm(len(Xa), generator=torch.Generator().manual_seed(seed))[:n]
    for _ in range(300):                                   # 300 steps on the whole subset
        net.train()
        loss = nn.functional.cross_entropy(net(Xa[idx]), ya[idx])
        opt.zero_grad(); loss.backward(); opt.step()
    net.eval()                                             # dropout is off in use
    with torch.no_grad():
        return float((net(Xp).argmax(1) == yp).float().mean())

for n in (50, 100, 200, 400, 1347):
    print(f"{n:4d} examples: test accuracy {np.mean([trial(n, s) for s in range(3)]):.3f}")
S’abonner
Notifier de
guest
1 commentaire
Le plus ancien
Plus récent Les plus votés
1
0
Vous avez apprécié cet article ? Merci de laisser un commentaire.x