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

جلسه‌ی 45: داده‌ی بزرگ‌تر ۱ Bigger Data 1

از ۳۰ نقطه به ۲۰۰ رقم دست‌نویس ۵×۵ می‌رسیم. داده را مشترک می‌سازیم، رقم را با # و . می‌کشیم و یاد می‌گیریم با دسته‌های کوچک (mini-batch)، دوره‌ها و بُر زدن هر دوره، شبکه‌ی ۲۵ → ۱۶ → ۱۰ را آموزش دهیم.

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

درس

۳۰ نقطه‌ی جلسه‌ی قبل اسباب‌بازی بود. حالا داده‌ی بزرگ‌تر: ده رقم ۰ تا ۹، هر کدام روی یک جدول ۵×۵ کشیده شده (# یعنی جوهر، . یعنی کاغذ سفید). make_digits از هر رقم چند نسخه می‌سازد و در هر نسخه چند پیکسل تصادفی را برعکس می‌کند، مثل دست‌خطی که کمی کج و لرزان است. این کد را از این جلسه تا جلسه‌ی ۴۹ بدون تغییر استفاده می‌کنیم؛ بالای همه‌ی برنامه‌ها همین است.

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

هر رقم یک سطر ۲۵ تایی از ۰ و ۱ است: ۵ پیکسل ردیف اول، بعد ۵ پیکسل ردیف دوم و همین‌طور (همان «صاف کردن» جلسه‌ی ۳۱). برای دیدنش، هر ۵ پیکسل را یک خط چاپ می‌کنیم. pixels[r * 5:r * 5 + 5] ردیف r است.

def show(pixels):
    for r in range(5):
        row = pixels[r * 5:r * 5 + 5]
        print("".join("#" if v == 1 else "." for v in row))


print("label", y[3])
show(X[3])
# label 3
# ####.
# ....#
# .###.
# #...#
# #####

شکل داده را همیشه اول چک کن: X.shape می‌شود (200, 25)، یعنی ۲۰۰ مثال و ۲۵ ویژگی (پیکسل). y ۲۰۰ برچسب دارد که به ترتیب 0, 1, 2, ..., 9, 0, 1, ... تکرار می‌شوند. داده‌ی آزمون Xt جداست: ۱۰۰ رقم دیگر با نویز دیگر که شبکه هیچ‌وقت در آموزش نمی‌بیند.

print(X.shape, y.shape)     # (200, 25) (200,)
print(y[:12])               # [0 1 2 3 4 5 6 7 8 9 0 1]
print(Xt.shape)             # (100, 25)

تا حالا در هر قدم آموزش همه‌ی مثال‌ها را با هم می‌دادیم (full-batch). با ۲۰۰ رقم (و در دنیای واقعی میلیون‌ها عکس) این کند است: برای هر قدم کوچک باید کل داده را بخوانی. راه بهتر: mini-batch. داده را به دسته‌های ۲۰تایی ببُر و بعد از هر دسته وزن‌ها را کمی درست کن. مثل خواندن ۲۰۰ فلش‌کارت: به جای این‌که همه را بخوانی و فقط آخرش خودت را تصحیح کنی، بعد از هر ۲۰ کارت چک می‌کنی. هر قدم کمی «نویزی» است، اما جهتش درست است و خیلی زودتر یاد می‌گیری.

for start in range(0, len(X), 20):
    xb = X[start:start + 20]
    yb = y[start:start + 20]
    print(start, xb.shape, yb.shape)
# 0 (20, 25) (20,)
# 20 (20, 25) (20,)
# ... 10 batches up to 180

یک دوره (epoch) یعنی یک بار رد شدن از کل داده. با ۲۰۰ مثال و دسته‌های ۲۰تایی، هر دوره ۱۰ قدم آموزش است. ۱۰ دوره یعنی ۱۰۰ قدم، و شبکه هر مثال را ۱۰ بار دیده است. (در جلسه‌های قبل یک دوره = یک قدم بود، چون همه‌ی داده یک دسته بود.)

بُر زدن (shuffle): چرا ترتیب مهم است؟ فرض کن داده مرتب بود: اول همه‌ی صفرها، بعد همه‌ی یک‌ها. دسته‌ی اول فقط صفر دارد و شبکه یاد می‌گیرد «همیشه بگو ۰»؛ دسته‌ی بعد فقط یک دارد و همه را عوض می‌کند. مثل کسی که شب امتحان فقط فصل ۱ را بخواند، بعد فقط فصل ۲ و فصل ۱ را فراموش کند. پس اول هر دوره ترتیب را بُر می‌زنیم تا هر دسته مخلوط باشد و دسته‌ها هر دوره فرق کنند. نکته‌ی حیاتی: X و y باید با یک ترتیب بُر بخورند (جلسه‌ی ۲۳)؛ وگرنه عکس ۳ برچسب ۷ می‌گیرد! X[order] با یک لیست شماره، سطرها را به همان ترتیب برمی‌دارد.

order = list(range(len(X)))
random.seed(7)
random.shuffle(order)
print(order[:5])                # [28, 4, 41, 168, 81]
Xs, ys = X[order], y[order]     # the same order for both!
print(ys[:5])                   # [8 4 1 8 1]

حالا همه با هم. برای این‌که توابع بتوانند وزن‌ها را عوض کنند، آن‌ها را در دیکشنری net نگه می‌داریم (مثل جلسه‌ی ۴۲). train_batch همان قدم آموزش جلسه‌ی ۴۴ است برای یک دسته و خطای آن دسته را برمی‌گرداند. loss_acc خطا و دقت را روی هر داده‌ای می‌دهد. این چهار تابع را در جلسه‌ی بعد هم استفاده می‌کنیم.

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)))
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)
    print(epoch, round(loss, 3), round(acc * 100))
# 1 1.458 46
# 2 0.93 68
# ...
# 10 0.061 99

اشتباه‌های رایج: ۱) بُر زدن X و y با دو ترتیب جدا (دو بار random.shuffle روی دو لیست). ۲) X[start:20] به جای X[start:start + 20]؛ دسته‌ی دوم خالی می‌شود. ۳) ساختن net داخل حلقه‌ی دوره‌ها؛ آن‌وقت هر دوره از صفر شروع می‌شود و هیچ‌وقت چیزی یاد نمی‌گیرد. ۴) نگاه کردن به خطای یک دسته و نتیجه گرفتن؛ خطای دسته‌ها بالا و پایین می‌پرد، خطای کل دوره را ببین.

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

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

چالش‌ها

  1. Show Sample 13 (آسان)
  2. Cut into Batches (آسان)
  3. Shuffle Together (متوسط)
  4. Loss of an Epoch (متوسط)
  5. Shuffle Every Epoch (سخت)
  6. Test Digits It Gets Wrong (سخت)

بیشتر بخوان

← جلسه‌ی 44: شبکه‌ی چندلایه با numpy ۲ جلسه‌ی 46: داده‌ی بزرگ‌تر ۲ →