Descendre le gradient

On connaît la perte et sa pente. Il reste à s'en servir : à chaque étape, on déplace chaque paramètre à l'opposé de sa pente. C'est la descente de gradient :

nouveau paramètre = paramètre − η × pente

La pente est négative en w = 0 (−0,3333) : « moins une pente négative » fait augmenter w. Le pas η (lettre « êta », learning rate en anglais, lr dans PyTorch) règle la taille du saut. Avec η = 3 : w passe de 0 à 0 − 3 × (−0,3333) = 1.

def un_pas(w, pente, eta):
    return w ___ eta * pente

w1 = un_pas(0.0, -1 / 3, 3)

Une descente complète répète 20 fois les mêmes étapes (cours, partie 8) : prédire, mesurer l'erreur, effacer les anciennes pentes, calculer les pentes (backward()), faire un pas. Avec η = 3 depuis w = 0 et b = 0, on arrive au creux : w = 1,46 et b = 0. Les premières pertes sont 0,69, puis 0,50, puis 0,48.

Dans PyTorch, effacer les pentes est obligatoire (w.grad.zero_() ou optimizer.zero_grad()) : sinon il ajoute les nouvelles pentes aux anciennes. L'optimiseur torch.optim.SGD([w, b], lr=3) fait le pas pour tous les paramètres : même résultat, w = 1,46.

t = [1.5, 1.0, -0.5, -1.5, -1.0, 0.5]
y = [1, 1, 1, 0, 0, 0]

def sig(z):
    return 1 / (1 + math.exp(-z))

def perte(w, b):
    return -sum(math.log(sig(w * ti + b) if yi == 1 else 1 - sig(w * ti + b)) for ti, yi in zip(t, y)) / 6

def pentes(w, b):
    return (sum((sig(w * ti + b) - yi) * ti for ti, yi in zip(t, y)) / 6,
            sum(sig(w * ti + b) - yi for ti, yi in zip(t, y)) / 6)

def descente(eta, nb_pas):
    w, b = 0.0, 0.0
    pertes = []
    for pas in range(nb_pas):
        pertes.append(perte(w, b))
        pw, pb = pentes(w, b)
        w, b = w - eta * ___, b - eta * ___
    return pertes, w

pertes, w_final = descente(3, 20)

Le choix de η change tout. Avec 20 pas depuis w = 0 (les valeurs chiffrées ci-dessous sont recalculées avec la même perte ; le notebook ne donne que w = 1,45 à 100 pas pour η = 0,3) :

• η = 0,3 : trop petit. La perte baisse lentement (0,69, 0,66, 0,63, …) et w n'atteint que 1,02 ; après 100 pas, w = 1,45 : on arrive, mais très lentement.
• η = 3 : un bon pas. En 2 pas la perte est à 0,48, w = 1,46.
• η = 12 : trop grand. Au premier pas la perte monte (de 0,69 à 0,72) : le saut dépasse le creux et retombe de l'autre côté. Elle finit tout de même par se calmer (w ≈ 1,465 au bout de 20 pas), mais sur un problème moins gentil, un pas trop grand peut faire diverger la perte.

exemple = [0.6931, 0.7159, 0.5193, 0.4806, 0.4800]   # η = 12, les premiers pas

def a_remonte(pertes):
    return any(pertes[i + 1] ___ pertes[i] for i in range(len(pertes) - 1))

def diagnostic(pertes):
    if a_remonte(pertes):
        return "trop grand"
    if pertes[-1] > ___:
        return "trop petit"
    return "correct"