Krok, paczka i optymalizator

Propagacja wsteczna z lekcji 5 daje gradient: dla każdej wagi kierunek, w którym strata rośnie. Zostają trzy decyzje. Krok uczenia η mówi, jak daleko pójść w przeciwną stronę. Paczka mówi, na ilu przykładach liczyć gradient przed jednym krokiem. Optymalizator mówi, jak z gradientów zrobić krok: wprost, z rozpędem albo z osobną skalą dla każdej wagi. Epoka to jedno przejście przez wszystkie przykłady treningowe.

Spróbuj

• Lab startuje z Adamem i krokiem 0,001: po 10 epokach 93,6% cyfr testowych.
• Wybierz SGD i znajdź krok, przy którym trafność przekracza 90%. To cel labu.
• Porównaj SGD z momentem przy kroku 0,01 i zwykły SGD przy 0,1: 93,6% i 94,2%.
• Wybierz Adama i krok 0,5. Zobacz, co się dzieje z krzywą trafności.

Pomysł w prostych słowach

Gradient z jednego przykładu jest tani, ale chwiejny: jedna cyfra ciągnie wagi w swoją stronę. Gradient z całego zbioru jest dokładny, ale drogi, i daje jeden krok na epokę. Paczka jest pośrodku: w labie 32 cyfry, czyli 45 kroków na epokę, 450 kroków w 10 epok. Na karcie graficznej przykłady z jednej paczki liczą się równolegle.

Krok uczenia to długość kroku. Za mały i wagi prawie stoją: zwykły SGD przy kroku 0,01 kończy z 73,8%. Za duży i wagi przeskakują dolinę straty, zamiast do niej zejść.

Moment dodaje rozpęd: krok to suma bieżącego gradientu i 0,9 poprzedniego kroku. Gdy kolejne gradienty wskazują podobnie, krok rośnie. Adam idzie dalej: każdą wagę przesuwa o krok podzielony przez typową wielkość jej gradientu, więc wagi z małym gradientem też się ruszają.

Dlaczego to działa

W przewidywaniu wygrała liczba kroków, nie dokładność gradientu. Przy równych 200 krokach paczka 16 kończy ze stratą 0,72, a cały zbiór 0,71, choć przeliczył ok. 32 razy więcej przykładów. Paczka po 1 przykładzie po 200 krokach ma 0,99, bo widziała tylko 200 cyfr. Mała paczka daje więc dużo tanich kroków, a duża dokładne i drogie.

Moment 0,9 sumuje mniej więcej 10 ostatnich gradientów. Dlatego SGD z momentem przy kroku 0,01 daje prawie to samo co zwykły SGD przy kroku 10 razy większym.

Adam dzieli krok przez wielkość gradientu, więc rusza wagę o ułamek η, prawie niezależnie od skali gradientu. W labie w 1. epoce przy kroku 0,001 waga przesuwała się średnio o 0,42·η na krok, a przy SGD o 0,012·η. Dlatego SGD potrzebuje kroku co najmniej 0,1, a Adam działa już przy 0,001.

import numpy as np

# kroki w 5 epokach na 499 cyfrach: im mniejsza paczka, tym więcej kroków
n = 499
for B in [1, 4, 16, 64, n]:
    steps = int(np.ceil(n / B))
    print(f"batch {B:3d}: {steps:3d} per epoch, {5 * steps:4d} steps in 5 epochs")

# wydłużona dolina: strata L(w) = (w1^2 + 10 w2^2) / 2, start (3, 1), 50 kroków
grad = lambda w: np.array([w[0], 10 * w[1]])
loss = lambda w: (w[0] ** 2 + 10 * w[1] ** 2) / 2

def run(rule, lr, steps=50):
    w, vel, m, v = np.array([3.0, 1.0]), np.zeros(2), np.zeros(2), np.zeros(2)
    for t in range(1, steps + 1):
        g = grad(w)
        if rule == "sgd":
            w = w - lr * g
        elif rule == "momentum":
            vel = 0.9 * vel - lr * g
            w = w + vel
        else:  # adam
            m = 0.9 * m + 0.1 * g
            v = 0.999 * v + 0.001 * g ** 2
            w = w - lr * (m / (1 - 0.9 ** t)) / (np.sqrt(v / (1 - 0.999 ** t)) + 1e-8)
    return loss(w)

print("loss after 50 steps (start 9.5)")
for rule in ["sgd", "momentum", "adam"]:
    print(f"{rule:8s}", "  ".join(f"lr {lr}: {run(rule, lr):9.3g}" for lr in [0.01, 0.1, 0.25]))

batch   1: 499 per epoch, 2495 steps in 5 epochs
batch   4: 125 per epoch,  625 steps in 5 epochs
batch  16:  32 per epoch,  160 steps in 5 epochs
batch  64:   8 per epoch,   40 steps in 5 epochs
batch 499:   1 per epoch,    5 steps in 5 epochs
loss after 50 steps (start 9.5)
sgd      lr 0.01:      1.65  lr 0.1:   0.00012  lr 0.25:  2.03e+18
momentum lr 0.01:    0.0376  lr 0.1:    0.0323  lr 0.25:    0.0154
adam     lr 0.01:      4.59  lr 0.1:    0.0144  lr 0.25:    0.0184