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

جلسه‌ی 30: شبکه‌ی XOR با دست XOR Network by Hand

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

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

درس

جلسه‌ی قبل وزن‌های XOR را خودمان نوشتیم. حالا می‌خواهیم شبکه خودش پیدایشان کند. برای نورون خروجی آسان است: خطایش را می‌دانیم (output - target) و مثل جلسه‌ی ۲۷ تصحیحش می‌کنیم. ولی نورون‌های پنهان چه؟ آن‌ها «هدف» ندارند! کسی به ما نگفته نورون پنهان اول باید OR باشد.

ایده‌ی پس‌انتشار (backpropagation): خطای خروجی را بین نورون‌های پنهان تقسیم کن، به نسبت وزنی که به خروجی داده‌اند. اگر نورون پنهان با وزن بزرگ به خروجی وصل است، سهم بزرگی از تقصیر دارد. اگر وزنش کوچک است، تقصیر کمی دارد. مثل تیمی که باخته: بازیکنی که بیشتر بازی کرده، بیشتر مسئول است.

# output neuron error:
out_error = output - target
# blame of hidden neuron j:
hidden_error_j = out_error * output_weights[j]

یک جزء دقیق‌تر: شیب سیگموید. وقتی خروجی نورون نزدیک ۰ یا ۱ است، سیگموید صاف است و تغییر وزن تأثیر کمی دارد؛ وقتی حدود ۰.۵ است، شیب تند است. شیب سیگموید را خیلی ساده می‌شود حساب کرد: out * (1 - out). خطای هر نورون را در این شیب ضرب می‌کنیم و به آن دلتا می‌گوییم. (در جلسه‌ی ۲۷ این را حذف کرده بودیم؛ برای شبکه‌ی دو لایه لازم است.)

def slope(out):
    return out * (1 - out)

print(slope(0.5))    # 0.25  steep
print(slope(0.99))   # 0.0099  flat

همه‌ی قدم‌ها برای یک مثال: ۱) رو به جلو: h و out را حساب کن. ۲) دلتای خروجی: d_out = (out - target) * slope(out). ۳) دلتای هر نورون پنهان: d_h[j] = d_out * w_out[j] * slope(h[j]). ۴) به‌روزرسانی: وزن‌های خروجی با lr * d_out * h[j]، وزن‌های پنهان با lr * d_h[j] * inputs[i]، و هر بایاس با دلتای خودش.

def train_example(inputs, target, hidden, output, lr):
    h = [neuron(inputs, w, b) for w, b in hidden]
    w_out, b_out = output
    out = neuron(h, w_out, b_out)
    d_out = (out - target) * slope(out)
    d_h = [d_out * w_out[j] * slope(h[j]) for j in range(len(h))]
    for j in range(len(h)):
        w_out[j] -= lr * d_out * h[j]
    b_out -= lr * d_out
    for j in range(len(hidden)):
        w, b = hidden[j]
        for i in range(len(inputs)):
            w[i] -= lr * d_h[j] * inputs[i]
        hidden[j] = (w, b - lr * d_h[j])
    return hidden, (w_out, b_out)

نکته‌ی مهم: وزن‌های اولیه نباید همه صفر باشند! اگر دو نورون پنهان با وزن‌های یکسان شروع کنند، همیشه یک چیز را یاد می‌گیرند و شبکه عملاً یک نورون است. برای همین با عددهای تصادفی کوچک شروع می‌کنیم. با random.seed نتیجه هر بار یکی می‌شود تا بشود مقایسه کرد.

import random
random.seed(3)

def random_neuron(n_inputs):
    return ([random.uniform(-1, 1) for _ in range(n_inputs)], random.uniform(-1, 1))

hidden = [random_neuron(2), random_neuron(2)]
output = random_neuron(2)

آموزش: چند هزار دوره روی چهار مثال XOR با lr حدود ۲ (برای این مسئله‌ی کوچک نرخ بزرگ خوب کار می‌کند). هر چند صد دوره خطا را چاپ کن و ببین پایین می‌آید. در آخر شبکه چهار جواب درست می‌دهد؛ چیزی که یک نورون هرگز نتوانست. اگر با یک seed دیگر گیر کرد (خطا پایین نیامد)، seed را عوض کن؛ این هم در شبکه‌های واقعی پیش می‌آید.

for epoch in range(3000):
    for inputs, target in xor_data:
        hidden, output = train_example(inputs, target, hidden, output, 2.0)
for inputs, target in xor_data:
    print(inputs, round(forward(inputs, hidden, output), 2), target)

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

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

چالش‌ها

  1. Slope of the Sigmoid (آسان)
  2. Random Start (آسان)
  3. Output Delta (متوسط)
  4. Share the Blame (متوسط)
  5. One Backprop Step (سخت)
  6. Train XOR (سخت)

بیشتر بخوان

← جلسه‌ی 29: دو لایه می‌شود شبکه جلسه‌ی 31: رقم‌های ۰ تا ۹ →