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

جلسه‌ی 42: numpy: ماتریس به جای حلقه ۲ numpy: Arrays Instead of Loops 2

ضرب داخلی همان جمع وزن‌دار یک نورون است و ضرب ماتریسی یعنی چند نورون روی چند مثال با هم. شبکه‌ی XOR جلسه‌های ۲۹ و ۳۰ را با چند خط ماتریسی دوباره می‌سازیم و آموزش می‌دهیم.

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

درس

رسید بوفه را تصور کن: ۲ ساندویچ ۴۰ تومانی، ۱ آبمیوه‌ی ۲۵ تومانی، ۳ کیک ۱۰ تومانی. جمع کل = 2*40 + 1*25 + 3*10. این «تعداد ضرب در قیمت، بعد همه را جمع کن» اسم دارد: ضرب داخلی (dot product). در numpy می‌نویسیم np.dot(qty, prices) یا کوتاه‌تر qty @ prices.

import numpy as np

qty = np.array([2, 1, 3])
prices = np.array([40, 25, 10])
print(np.dot(qty, prices))   # 135
print(qty @ prices)          # 135, the same

حالا جلسه‌های ۲۷ و ۲۹ را به یاد بیاور: نورون هر ورودی را در وزنش ضرب می‌کرد و همه را با بایاس جمع می‌کرد. این دقیقاً همان رسید است! ورودی‌ها جای تعداد، وزن‌ها جای قیمت. پس یک نورون = یک ضرب داخلی + بایاس. آن حلقه‌ی for i in range(len(inputs)) حالا یک @ است.

x = np.array([0, 1])       # one example
w = np.array([6, 6])       # the OR neuron of session 29
b = -3
z = x @ w + b
print(z)                   # 3
print(1 / (1 + np.exp(-z)))  # sigmoid, about 0.95

اگر وزن‌های چند نورون را ستون‌به‌ستون کنار هم بگذاریم، یک ماتریس W داریم: هر ستون یک نورون. x @ W ورودی را با هر ستون ضرب داخلی می‌کند، یعنی همه‌ی نورون‌های لایه با هم. و اگر مثال‌ها را هم سطربه‌سطر در ماتریس X بگذاریم، X @ W همه‌ی نورون‌ها را روی همه‌ی مثال‌ها با هم حساب می‌کند. خانه‌ی سطر i و ستون j جواب = نورون j روی مثال i.

X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])   # 4 examples, 2 inputs
W = np.array([[6, 6],
              [6, 6]])                          # 2 inputs, 2 neurons (OR, AND)
print(X @ W)
# [[ 0  0]
#  [ 6  6]
#  [ 6  6]
#  [12 12]]

قانون شکل: (n, k) @ (k, m) می‌شود (n, m). عددهای وسط (k) باید برابر باشند، چون هر سطر چپ با هر ستون راست ضرب داخلی می‌شود و طولشان باید یکی باشد؛ عددهای بیرونی شکل جواب‌اند. ۴ مثال با ۲ ورودی (4, 2) ضرب در ۲ ورودی به ۳ نورون (2, 3) می‌شود (4, 3). اگر وزن‌ها را برعکس نوشته باشی (3, 2)، پایتون خطای matmul ... mismatch می‌دهد. ترانهاده .T سطر و ستون را جابه‌جا می‌کند و درستش می‌کند.

W_wrong = np.array([[1, 2], [3, 4], [5, 6]])   # shape (3, 2)
print(W_wrong.T.shape)                          # (2, 3)
print((X @ W_wrong.T).shape)                    # (4, 3)
# X @ W_wrong  ->  ValueError: matmul: ... mismatch

یک لایه کامل = X @ W + b و بعد تابع فعال‌سازی. b یک بایاس برای هر نورون است (شکل (m,)) و broadcasting آن را به همه‌ی سطرها اضافه می‌کند؛ همان «همه یک نمره‌ی اضافه» جلسه‌ی قبل، این بار برای هر ستون یک عدد. سیگموید هم با np.exp روی کل ماتریس یک‌جا کار می‌کند. حالا شبکه‌ی XOR جلسه‌ی ۲۹، با همان وزن‌های دستی، برای هر چهار مثال با هم:

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

W1 = np.array([[6, 6], [6, 6]])     # columns: OR neuron, AND neuron
b1 = np.array([-3, -9])
W2 = np.array([[8], [-8]])          # output: "OR and not AND"
b2 = np.array([-4])

h = sigmoid(X @ W1 + b1)            # (4, 2)
out = sigmoid(h @ W2 + b2)          # (4, 1)
print(np.round(out[:, 0], 2))       # [0.03 0.96 0.96 0.03]

آموزش هم ماتریسی می‌شود. همان قدم‌های جلسه‌ی ۳۰، فقط برای همه‌ی مثال‌ها با هم: دلتای خروجی d2 = (out - y) * out * (1 - out) (خطا ضرب در شیب سیگموید). سهم تقصیر لایه‌ی پنهان d1 = (d2 @ W2.T) * h * (1 - h)؛ @ W2.T همان «تقسیم تقصیر به نسبت وزن» است. تغییر وزن‌ها h.T @ d2 و X.T @ d1: ترانهاده‌ها کاری می‌کنند که سهم هر چهار مثال با هم جمع شود. بایاس‌ها با sum(axis=0).

import random
random.seed(1)

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

y = np.array([[0], [1], [1], [0]])
W1 = rand_matrix(2, 2); b1 = np.zeros(2)
W2 = rand_matrix(2, 1); b2 = np.zeros(1)
for epoch in range(3000):
    h = sigmoid(X @ W1 + b1)
    out = sigmoid(h @ W2 + b2)
    d2 = (out - y) * out * (1 - out)
    d1 = (d2 @ W2.T) * h * (1 - h)
    W2 -= 1.0 * h.T @ d2
    b2 -= 1.0 * d2.sum(axis=0)
    W1 -= 1.0 * X.T @ d1
    b1 -= 1.0 * d1.sum(axis=0)
print(np.round(out[:, 0], 2))   # [0.03 0.96 0.96 0.03]

مقایسه کن: تابع train_example جلسه‌ی ۳۰ حدود ۱۵ خط بود با سه حلقه‌ی تودرتو و فقط یک مثال را در هر بار حساب می‌کرد. این‌جا ۸ خط داخل حلقه، بدون هیچ حلقه‌ی داخلی، و هر بار هر چهار مثال. اگر به جای ۲ نورون پنهان ۱۰۰ تا بخواهی، فقط عدد را در rand_matrix(2, 100) عوض می‌کنی؛ کد همان است. شبکه‌های واقعی دقیقاً همین‌طور نوشته می‌شوند.

اشتباه‌های رایج: ۱) * به جای @. * خانه‌به‌خانه است و ضرب داخلی نمی‌کند؛ اگر شکل‌ها جور باشند خطا هم نمی‌دهد و فقط جواب غلط می‌گیری. ۲) فراموش کردن .T و گرفتن خطای mismatch. وقتی گیر کردی، print(a.shape, b.shape) بزن و قانون (n,k) @ (k,m) را چک کن. ۳) y به شکل [0, 1, 1, 0] (یک‌بعدی) به جای ستون [[0], [1], [1], [0]]؛ آن‌وقت out - y یک ماتریس ۴×۴ عجیب می‌شود!

⚠️ شبکه‌ی امروز روی XOR صددرصد درست جواب داد. ولی فقط ۴ مثال وجود داشت و شبکه همان ۴ را دید! این مثل این است که کسی جواب ۴ سؤال امتحان را از قبل حفظ کند؛ ۱۰۰ گرفتن ثابت نمی‌کند درس را «فهمیده». وقتی مدلی را روی همان داده‌ای می‌سنجی که با آن آموزش دیده، عدد قشنگ ممکن است فقط حفظ کردن باشد (overfitting، جلسه‌ی ۲۳). از جلسه‌ی ۴۵ داده‌ی آزمون جدا داریم تا این را واقعاً بسنجیم.

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

چالش‌ها

  1. Receipt Total (آسان)
  2. Fix the Shape (آسان)
  3. A Layer Function (متوسط)
  4. XOR, All at Once (متوسط)
  5. One Backprop Step (سخت)
  6. Three-Input Parity (سخت)

بیشتر بخوان

← جلسه‌ی 41: numpy: ماتریس به جای حلقه ۱ جلسه‌ی 43: شبکه‌ی چندلایه با numpy ۱ →