Sieć wielowarstwowa na cyfrach

W lekcji 1 jeden neuron rysował jedną prostą i na tym kończyły się jego możliwości. Odręcznie napisana cyfra to coś więcej niż dwa pomiary kwiatu: 64 piksele i 10 możliwych odpowiedzi. Sieć wielowarstwowa ma między wejściem a wyjściem warstwę ukrytą: wiele neuronów, z których każdy robi to samo co neuron z lekcji 1. Sprawdźmy, ile to daje.

Spróbuj

• Kliknij „trenuj 10 epok” i patrz, jak rośnie trafność na teście: od 8,4% przed treningiem do 95,3% po 10 epokach.
• Przeczytaj macierz pomyłek: w każdym wierszu dodaj liczby poza przekątną. Kliknij cyfrę, w której wierszu ta suma jest największa. To cel labu.
• Porównaj ten wiersz z kolumną tej samej cyfry. Wiersz mówi, ile razy sieć nie poznała cyfry, a kolumna, ile razy wskazała ją bez powodu.
• Kliknij „od nowa” i wytrenuj jeszcze raz. Nowe wagi początkowe dają inne pomyłki, ale podobną trafność.

Pomysł w prostych słowach

Każdy z 32 neuronów ukrytych liczy ważoną sumę 64 pikseli, dodaje bias i przepuszcza wynik przez funkcję aktywacji (tu tanh). Tak jak neuron z lekcji 1 odpowiada na jedno proste pytanie, na przykład „czy jest tusz w lewej górnej części, a nie ma go pośrodku?”. Odpowiedź nie jest twarda: tanh daje liczbę od −1 do 1, czyli „raczej tak” albo „raczej nie”.

Warstwa wyjściowa dostaje te 32 odpowiedzi. Każdy z 10 neuronów wyjściowych liczy z nich własną ważoną sumę, a sieć wybiera cyfrę z najwyższym wynikiem. Decyzja „to trójka” nie jest jedną prostą, tylko głosowaniem wielu prostych pytań o piksele. Żadnego z tych pytań nikt nie wpisał ręcznie: wagi ustawia spadek gradientu na 1438 cyfrach treningowych.

Na płaszczyźnie widać to najlepiej. Jedna prosta dzieli płaszczyznę na dwie części. Trzy neurony ukryte to trzy proste, a neuron wyjściowy, który mówi „tak” tylko wtedy, gdy wszystkie trzy się zgadzają, rysuje trójkąt. Pokazuje to kod niżej, w warstwie „W kodzie”.

Dlaczego to działa

Złożenie prostych to stary wynik matematyki. Twierdzenie o uniwersalnej aproksymacji (Cybenko, 1989) mówi: jedna warstwa ukryta z dostatecznie wieloma neuronami przybliży dowolnie dokładnie każdą ciągłą funkcję na ograniczonym i domkniętym obszarze. Twierdzenie nie mówi jednak, ilu neuronów trzeba ani czy spadek gradientu je znajdzie. To sprawdza się w praktyce, na danych.

Sieć z labu ma 2410 wag: 64 · 32 + 32 w warstwie ukrytej i 32 · 10 + 10 w wyjściowej. Tyle wystarcza, żeby rozpoznać 95,3% cyfr testowych.

Trafność to jedna liczba. Macierz pomyłek pokazuje, skąd się bierze. Wiersz to prawdziwa cyfra, kolumna to odpowiedź sieci, a przekątna to trafienia. Na pierwszym starcie po 10 epokach najwięcej pomyłek mają trójka i ósemka, po 4. Każdą z czterech ósemek sieć wzięła za inną cyfrę. Za to w kolumnie „8” stoi 5 pomyłek: ósemka jest najczęstszą błędną odpowiedzią. Sieć wskazała ją na dwie trójki, szóstkę, siódemkę i dziewiątkę. Na pięciu pierwszych startach labu najczęściej mylona cyfra to zawsze 3 albo 8, a zero i dwójka nie są pomylone ani razu.

import numpy as np

relu = lambda z: np.maximum(0, z)

# warstwa ukryta: trzy neurony, każdy to jedna prosta (wiersz = wagi x i y)
W1 = np.array([[-1, 1], [1, 1], [0, -1]])
b1 = np.array([0, -12, 1])  # proste: y = x, x + y = 12, y = 1
xs, ys = np.meshgrid(np.arange(13), np.arange(6, -1, -1))
P = np.stack([xs.ravel(), ys.ravel()], axis=1)
H = relu(P @ W1.T + b1)          # jak daleko punkt leży po złej stronie każdej prostej
inside = 0.5 - H.sum(axis=1) > 0  # neuron wyjściowy: „tak”, gdy żaden neuron ukryty nie protestuje
for row in inside.reshape(xs.shape):
    print("".join("#" if v else "." for v in row))
print("points inside:", inside.sum())

# macierz pomyłek z labu: pierwszy start, 10 epok; wiersz = prawdziwa cyfra, kolumna = odpowiedź sieci
cm = np.array([
    [36, 0, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 35, 0, 0, 0, 0, 0, 0, 0, 1],
    [0, 0, 35, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 33, 0, 1, 0, 0, 2, 0],
    [1, 1, 0, 0, 34, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 35, 0, 0, 0, 1],
    [0, 0, 0, 0, 0, 0, 35, 0, 1, 0],
    [0, 0, 0, 0, 0, 0, 0, 35, 1, 0],
    [0, 1, 1, 0, 0, 1, 1, 0, 31, 0],
    [0, 0, 0, 0, 1, 1, 0, 0, 1, 33],
])
off = cm - np.diag(np.diag(cm))  # same pomyłki
missed, said = off.sum(axis=1), off.sum(axis=0)
print(f"accuracy: {np.trace(cm)}/{cm.sum()} = {np.trace(cm) / cm.sum():.1%}")
print("missed per true digit:", missed)
print("most missed:", np.flatnonzero(missed == missed.max()), "with", missed.max(), "errors each")
print("wrong answers per digit:", said)
a, b = np.unravel_index(off.argmax(), off.shape)
print(f"most common pair: true {a} -> answer {b}, {off[a, b]} times")

......#......
.....###.....
....#####....
...#######...
..#########..
.###########.
.............
points inside: 36
accuracy: 342/359 = 95.3%
missed per true digit: [0 1 0 4 2 1 1 1 4 3]
most missed: [3 8] with 4 errors each
wrong answers per digit: [1 2 2 0 1 3 1 0 5 2]
most common pair: true 3 -> answer 8, 2 times