بتل کد Battle Codeدارد باز می‌شود…

جلسه‌ی 46: داده‌ی بزرگ‌تر ۲ Bigger Data 2

منحنی یادگیری می‌کشیم: خطا و دقت آموزش و آزمون را در هر دوره ثبت می‌کنیم، با # و با turtle رسمشان می‌کنیم، نرخ یادگیری و اندازه‌ی دسته را با منحنی‌ها مقایسه می‌کنیم، سکو (plateau) را می‌بینیم و یاد می‌گیریم کِی آموزش را متوقف کنیم.

در این جلسه یاد می‌گیری

درس

جلسه‌ی قبل بعد از هر دوره فقط یک خط چاپ می‌کردیم و رد می‌شدیم. ولی برای فهمیدن این‌که آموزش چطور پیش می‌رود، باید تاریخچه را نگه داریم؛ مثل کسی که برای مسابقه تمرین می‌کند و رکورد دوی هر هفته‌اش را در دفترچه می‌نویسد تا ببیند پیشرفت می‌کند یا درجا می‌زند. در هر دوره سه عدد ثبت می‌کنیم: خطای آموزش، دقت آموزش و دقت آزمون (روی Xt که شبکه هیچ‌وقت با آن آموزش نمی‌بیند). نمودار این عددها بر حسب دوره را منحنی یادگیری می‌گوییم.

import random
import numpy as np

SHAPES = """
.###. ..#.. .###. ####. #..#. ##### .###. ##### .###. .###.
#...# .##.. #...# ....# #..#. #.... #.... ....# #...# #...#
#...# ..#.. ..##. .###. ##### ####. ####. ...#. .###. .####
#...# ..#.. .#... ....# ...#. ....# #...# ..#.. #...# ....#
.###. .###. ##### ####. ...#. ####. .###. ..#.. .###. .###.
"""


def make_digits(copies, noise, seed):
    random.seed(seed)
    rows = SHAPES.strip().splitlines()
    X, y = [], []
    for c in range(copies):
        for d in range(10):
            pixels = [1.0 if ch == "#" else 0.0 for ch in "".join(r.split()[d] for r in rows)]
            for i in random.sample(range(25), noise):
                pixels[i] = 1.0 - pixels[i]
            X.append(pixels)
            y.append(d)
    return np.array(X), np.array(y)


X, y = make_digits(20, 2, 1)     # training set: 200 digits, 2 flipped pixels each
Xt, yt = make_digits(10, 2, 2)   # test set: 100 other noisy digits


def softmax(z):
    e = np.exp(z - z.max(axis=1, keepdims=True))
    return e / e.sum(axis=1, keepdims=True)


def rand_matrix(rows, cols):
    return np.array([[random.uniform(-0.5, 0.5) for _ in range(cols)] for _ in range(rows)])


def make_net():
    random.seed(0)
    return {"W1": rand_matrix(25, 16), "b1": np.zeros(16), "W2": rand_matrix(16, 10), "b2": np.zeros(10)}


def forward(net, X):
    h = np.maximum(0, X @ net["W1"] + net["b1"])
    return h, softmax(h @ net["W2"] + net["b2"])


def train_batch(net, xb, yb, lr):
    h, p = forward(net, xb)
    dz2 = (p - np.eye(10)[yb]) / len(xb)
    dh = dz2 @ net["W2"].T * (h > 0)
    net["W2"] -= lr * h.T @ dz2
    net["b2"] -= lr * dz2.sum(axis=0)
    net["W1"] -= lr * xb.T @ dh
    net["b1"] -= lr * dh.sum(axis=0)
    return float(-np.log(p[np.arange(len(yb)), yb]).mean())


def loss_acc(net, X, y):
    h, p = forward(net, X)
    loss = -np.log(p[np.arange(len(y)), y]).mean()
    return float(loss), float((p.argmax(axis=1) == y).mean())


net = make_net()
order = list(range(len(X)))
losses, train_acc, test_acc = [], [], []
for epoch in range(1, 11):
    random.shuffle(order)
    Xs, ys = X[order], y[order]
    for start in range(0, len(X), 20):
        train_batch(net, Xs[start:start + 20], ys[start:start + 20], 0.5)
    loss, acc = loss_acc(net, X, y)
    t_loss, t_acc = loss_acc(net, Xt, yt)
    losses.append(loss)
    train_acc.append(acc)
    test_acc.append(t_acc)
print(round(losses[-1], 3), round(train_acc[-1] * 100), round(test_acc[-1] * 100))   # 0.061 99 96

ساده‌ترین نمودار: یک میله از # برای هر دوره. "#" * 12 یعنی ۱۲ تا # پشت هم. طول میله را متناسب با خطا می‌گیریم (int(loss * 10)). حالا با یک نگاه شکل منحنی را می‌بینی: اول تند پایین می‌آید، بعد آرام‌تر، و گاهی کمی بالا می‌پرد (دوره‌ی ۷ و ۹)؛ این پرش‌ها به خاطر mini-batch و بُر زدن طبیعی‌اند.

for i in range(len(losses)):
    print(i + 1, "#" * int(losses[i] * 10), round(losses[i], 3))
# 1 ############## 1.458
# 2 ######### 0.93
# 3 ##### 0.529
# 4 #### 0.417
# 5 # 0.181
# 6 # 0.109
# 7 # 0.131
# 8  0.08
# 9 # 0.149
# 10  0.061

با turtle می‌شود منحنی واقعی کشید، مثل جلسه‌ی ۲۶: محور افقی دوره‌ها، محور عمودی خطا. هر دوره یک نقطه است و قلم از نقطه‌ای به نقطه‌ی بعد می‌رود. عددها را طوری بزرگ کن که در صفحه جا شوند: x = -200 + i * 40 و y = -150 + loss * 200.

import turtle

losses = [1.458, 0.93, 0.529, 0.417, 0.181, 0.109, 0.131, 0.08, 0.149, 0.061]
t = turtle.Turtle()
t.speed(0)
t.penup()
for i in range(len(losses)):
    t.goto(-200 + i * 40, -150 + losses[i] * 200)
    t.pendown()
    t.dot(6)

حالا می‌توانیم آزمایش کنیم! نرخ یادگیری (جلسه‌ی ۲۶) را عوض کن و منحنی‌ها را کنار هم بگذار. با 0.05 (خیلی کوچک) خطا بعد از ۲۰ دوره هنوز ۰.۴۸ است؛ مثل کسی که با قدم‌های مورچه‌ای از تپه پایین می‌رود. با 0.5 بعد از ۱۰ دوره ۰.۰۶. با 5.0 (خیلی بزرگ) خطا اول به ۵.۸ می‌پرد و بعد روی ۲.۳۳ گیر می‌کند: دقت ۱۰٪، یعنی مثل حدس زدن یکی از ده رقم! قدم‌ها آن‌قدر بزرگ بودند که نورون‌های ReLU «مُردند» (همیشه منفی، همیشه صفر).

# loss per epoch for three learning rates (batches of 20)
# lr 0.05: 2.331 2.143 1.999 1.865 1.736 ... 0.525 0.484   (20 epochs, too slow)
# lr 0.5:  1.458 0.93 0.529 0.417 0.181 ... 0.061          (10 epochs, good)
# lr 5.0:  5.757 2.366 2.388 2.331 2.378 ... 2.32          (stuck at 10%)

اندازه‌ی دسته هم منحنی را عوض می‌کند. با دسته‌ی ۱، هر دوره ۲۰۰ قدم داریم ولی هر قدم فقط به یک رقم واکنش نشان می‌دهد و شبکه بین رقم‌ها تلوتلو می‌خورد (بعد از ۵ دوره خطا هنوز حدود ۱.۴). با دسته‌ی ۲۰۰ (کل داده) قدم‌ها خیلی آرام و دقیق‌اند اما هر دوره فقط یک قدم است، پس خیلی کند است (۱.۷۵). دسته‌ی ۲۰ وسط این دوتاست: ۱۰ قدم در هر دوره و هر قدم میانگین ۲۰ رقم (۰.۱۸). برای همین شبکه‌های واقعی معمولاً دسته‌های ۳۲ تا ۲۵۶ تایی دارند.

سکو (plateau): جایی که منحنی تقریباً صاف می‌شود. اگر شبکه با lr = 0.5 را ۲۰ دوره آموزش دهی، از دوره‌ی ۱۰ به بعد خطا فقط بین ۰.۰۳ و ۰.۰۶ بالا و پایین می‌رود و دقت آزمون بین ۹۳ و ۹۶ درجا می‌زند. ادامه دادن فقط وقت (و برق!) هدر می‌دهد. پس یک قانون توقف می‌گذاریم: «وقتی خطا از یک هدف کمتر شد، break». قانون دیگر: «اگر دقت آزمون چند دوره بهتر نشد، بس است».

net = make_net()
order = list(range(len(X)))
for epoch in range(1, 31):
    random.shuffle(order)
    Xs, ys = X[order], y[order]
    for start in range(0, len(X), 20):
        train_batch(net, Xs[start:start + 20], ys[start:start + 20], 0.5)
    loss, acc = loss_acc(net, X, y)
    if loss < 0.1:
        print("good enough at epoch", epoch)     # good enough at epoch 8
        break

اشتباه‌های رایج: ۱) ثبت خطای یک دسته به جای کل داده؛ منحنی پر از پرش‌های بی‌معنی می‌شود. ۲) فراموش کردن make_net() تازه برای هر آزمایش؛ آن‌وقت آزمایش دوم از جایی که اولی تمام شد ادامه می‌دهد و مقایسه بی‌معنی است. ۳) نتیجه گرفتن از یک دوره؛ همیشه شکل کل منحنی را ببین.

⚠️ منحنی آموزش امروز خیلی قشنگ است: خطا به ۰.۰۳ و دقت آموزش به ۱۰۰٪ می‌رسد. اما به ستون آزمون نگاه کن: از دوره‌ی ۶ به بعد هیچ‌وقت از ۹۶٪ بالاتر نرفت. منحنی آموزش فقط می‌گوید شبکه داده‌ای را که دیده چقدر خوب یاد گرفته (یا حفظ کرده)؛ درباره‌ی دست‌خط جدید فقط عددهای آزمون حرف راست را می‌زنند. اگر روزی گزارش دادی «مدل من ۱۰۰٪ دقت دارد» و آن عدد آموزش بود، ناخواسته دروغ گفته‌ای. در جلسه‌ی ۴۸ می‌بینیم وقتی این دو منحنی از هم جدا می‌شوند (overfitting) چه اتفاقی می‌افتد.

مثال‌های این جلسه

چالش‌ها

  1. Bars of Loss (آسان)
  2. Draw the Curve (آسان)
  3. Keep a History (متوسط)
  4. Three Learning Rates (متوسط)
  5. Batch Size Race (سخت)
  6. Stop When Good Enough (سخت)

بیشتر بخوان

← جلسه‌ی 45: داده‌ی بزرگ‌تر ۱ جلسه‌ی 47: پروژه: شناسای کامل رقم →