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

جلسه‌ی 26: نرخ یادگیری The Learning Rate

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

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

درس

جلسه‌ی قبل در فرمول w = w - lr * g یک عدد کوچک به اسم lr بود و گفتیم «کمی حرکت کن». امروز می‌بینیم این «کمی» چقدر مهم است. برگرد به تپه‌ی چشم‌بسته: lr اندازه‌ی قدم توست.

قدم خیلی کوچک: به پایین می‌رسی، ولی بعد از ده هزار قدم! در کد یعنی خطا هر بار فقط ذره‌ای کم می‌شود. برای فهمیدنش خطای هر قدم را در لیست history ذخیره می‌کنیم؛ به این لیست منحنی خطا می‌گوییم.

X = [[1], [2], [3], [4]]
y = [3, 5, 7, 9]           # the truth is y = 2x + 1

def run(lr, steps):
    w = b = 0.0
    history = []
    for s in range(steps):
        gw = gb = 0
        for i in range(len(X)):
            error = w * X[i][0] + b - y[i]
            gw += error * X[i][0]
            gb += error
        w = w - lr * gw / len(X)
        b = b - lr * gb / len(X)
        history.append(sum((w * X[i][0] + b - y[i]) ** 2 for i in range(len(X))) / len(X))
    return w, b, history

w, b, h = run(0.001, 50)
print(round(h[0], 2), round(h[-1], 2))   # 40.32 -> 17.73: still far from zero

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

w, b, h = run(0.5, 20)
print([round(e) for e in h[:6]])
# [413, 4166, 41998, 423404, ...]  -> exploding!

قدم مناسب: خطا تند پایین می‌آید و بعد صاف می‌شود (به همگرایی می‌رسد). با lr = 0.1 همین داده در ۵۰ قدم به خطای تقریباً صفر می‌رسد. نرخ درست را با امتحان کردن پیدا می‌کنند: چند نرخ مثل ۰.۰۰۱، ۰.۰۱، ۰.۱ را امتحان کن و منحنی‌ها را مقایسه کن.

for lr in [0.001, 0.01, 0.1, 0.5]:
    w, b, h = run(lr, 50)
    print(lr, "->", round(h[-1], 4))

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

if len(history) > 1 and history[-1] > history[-2]:
    lr = lr / 2
    print("too fast, lr is now", lr)

منحنی خطا را می‌شود با turtle هم کشید: محور افقی شماره‌ی قدم و محور عمودی خطا. چون خطای اول خیلی بزرگ است، آن را به بازه‌ی صفحه مقیاس می‌کنیم: -150 + 300 * e / history[0]. یک منحنی که تند پایین می‌آید و صاف می‌شود یعنی یادگیری خوب.

import turtle
t = turtle.Turtle()
t.speed(0)
t.penup()
for i, e in enumerate(history):
    x = -200 + i * 400 / len(history)
    yy = -150 + 300 * e / history[0]
    t.goto(x, yy)
    t.pendown()

اشتباه رایج: وقتی خطا inf یا nan می‌شود، فکر کنی کد خراب است. نه، نرخ یادگیری زیاد است! اشتباه دوم: نرخ خوبِ یک مسئله را برای مسئله‌ی دیگر استفاده کنی؛ اگر ویژگی‌ها عددهای بزرگ‌تری داشته باشند، نرخ باید کوچک‌تر شود. به همین دلیل نرمال‌سازی جلسه‌ی ۲۲ به اینجا هم کمک می‌کند.

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

چالش‌ها

  1. Record the Error (آسان)
  2. Too Slow (آسان)
  3. Spot the Explosion (متوسط)
  4. Try Several Rates (متوسط)
  5. Auto-Halving Rate (سخت)
  6. Draw the Error Curve (سخت)

بیشتر بخوان

← جلسه‌ی 25: رگرسیون با دو ویژگی جلسه‌ی 27: نورون سیگموید →