Bölüm 1 · Temeller · Ders 6

Aynı kod, üç ürün

Tek bir learn() fonksiyonu: sayı tahmini, evet/hayır, bölge çitleme

Veri. Bir depo robotunda üç ayrı soru var. (1) Taşıdığı yük (0–5 kg) motorun kaç amper çekeceğini söyler mi? 24 ölçüm. (2) Kızılötesi yansıma ve sonar yankısı (ikisi de 0–10) birlikte "önde engel var" der mi? 60 an. (3) Arenadaki 160 konumdan hangileri ortadaki güvenli bölgede? Üçünü de aynı learn() fonksiyonu öğreniyor; her işte örneklerin dörtte biri saklanır ve model en sonda bu hiç görmediği örneklerle sınanır.

iş 1 · 24 ölçüm: yük → motor akımı18 eğitim · 6 gizli

1 / 106

Bölge işinde gizli nöron 6Öğrenme oranı 1

ayni_kod.pypython

import numpy as np
rng = np.random.default_rng(7)
def learn(X, y, H=0, lr=1.0, steps=2000): # tek öğrenme fonksiyonu
m, s = X.mean(0), X.std(0); S = (X - m) / s # ölçekle
W1, b1 = rng.normal(size=(len(m), H)), np.zeros(H) # gizli katman (H nöron)
w, b, sig = np.full(H or len(m), .1), 0, y.dtype == bool # cevap evet/hayır mı?
def f(Z):
h = np.tanh(Z @ W1 + b1) if H else Z; o = h @ w + b # ağırlıklı toplam
return h, 1 / (1 + np.exp(-o)) if sig else o # evet/hayır ise sigmoid
for _ in range(steps):
h, p = f(S); g = (p - y) / len(y) # tahmin ve hata
if H: gh = np.outer(g, w) * (1 - h ** 2) # hata geriye akar
w -= lr * h.T @ g; b -= lr * g.sum() # küçük adım
if H: W1 -= lr * S.T @ gh; b1 -= lr * gh.sum(0)
return lambda Z: f((Z - m) / s)[1] # eğitilmiş model
kg = rng.uniform(0, 5, (24, 1)) # 1) yük (kg)
amp = .3 + .42 * kg[:, 0] + rng.normal(0, .05, 24) # motor akımı (A)
ir = rng.uniform(0, 10, (60, 2)) # 2) IR ve sonar
see = ir @ [.6, .4] + rng.normal(0, .5, 60) > 5 # engel var mı
xy = rng.uniform(-2, 2, (160, 2)) # 3) arena konumu (m)
ok = (xy ** 2).sum(1) < 1.2 # ortadaki güvenli bölge
for X, y, H in (kg, amp, 0), (ir, see, 0), (xy, ok, 6): # aynı kod, üç iş
k = len(y) * 3 // 4; p = learn(X[:k], y[:k], H)(X[k:]) # dörtte biri gizli
e = abs(p - y[k:]); print(e.mean(), (e < .5).mean()) # gizli: ort. hata, isabet

Sahnedeki her sayı, aynı algoritmanın tarayıcında yapılan gerçek çalıştırmasından gelir (sabit tohum, her seferinde aynı sonuç). Python kodunu kendi bilgisayarında çalıştırırsan rastgele başlangıçlar farklı olacağı için sayılar biraz değişebilir.

Veri seti

Tüm veri setleri →

Bu dersin kodu verisini kendi içinde üretir; indirilecek dosya yok. Kodu yine de aşağıda tarayıcında çalıştırabilirsin.

Kodu tarayıcıda çalıştırPython · NumPy · matplotlib · Pyodide

Python ve NumPy bu sayfada, tarayıcında çalışır (Pyodide). Kodu değiştirip yeniden çalıştırabilirsin; dersin veri setleri çalışma klasöründe hazır. Kod matplotlib kullanırsa grafikler çıktının altında görünür, yazdığı dosyalar (ör. egitim_gecmisi.csv) indirilebilir.

ayni_kod.pypython

import numpy as np
rng = np.random.default_rng(7)
def learn(X, y, H=0, lr=1.0, steps=2000):     # tek öğrenme fonksiyonu
    m, s = X.mean(0), X.std(0); S = (X - m) / s  # ölçekle
    W1, b1 = rng.normal(size=(len(m), H)), np.zeros(H)  # gizli katman (H nöron)
    w, b, sig = np.full(H or len(m), .1), 0, y.dtype == bool  # cevap evet/hayır mı?
    def f(Z):
        h = np.tanh(Z @ W1 + b1) if H else Z; o = h @ w + b  # ağırlıklı toplam
        return h, 1 / (1 + np.exp(-o)) if sig else o  # evet/hayır ise sigmoid
    for _ in range(steps):
        h, p = f(S); g = (p - y) / len(y)     # tahmin ve hata
        if H: gh = np.outer(g, w) * (1 - h ** 2)  # hata geriye akar
        w -= lr * h.T @ g; b -= lr * g.sum()  # küçük adım
        if H: W1 -= lr * S.T @ gh; b1 -= lr * gh.sum(0)
    return lambda Z: f((Z - m) / s)[1]        # eğitilmiş model
kg = rng.uniform(0, 5, (24, 1))               # 1) yük (kg)
amp = .3 + .42 * kg[:, 0] + rng.normal(0, .05, 24)  # motor akımı (A)
ir = rng.uniform(0, 10, (60, 2))              # 2) IR ve sonar
see = ir @ [.6, .4] + rng.normal(0, .5, 60) > 5  # engel var mı
xy = rng.uniform(-2, 2, (160, 2))             # 3) arena konumu (m)
ok = (xy ** 2).sum(1) < 1.2                   # ortadaki güvenli bölge
for X, y, H in (kg, amp, 0), (ir, see, 0), (xy, ok, 6):  # aynı kod, üç iş
    k = len(y) * 3 // 4; p = learn(X[:k], y[:k], H)(X[k:])  # dörtte biri gizli
    e = abs(p - y[k:]); print(e.mean(), (e < .5).mean())  # gizli: ort. hata, isabet

Kendi CSV’ni yükle

Çıktı

Çıktı burada görünecek.

Nasıl çalışır

learn() hep aynı döngüdür: örnekleri al, tahmin et, hatayı bul, ağırlıkları hataya karşı küçük bir adım oynat, tekrar et.
Sayı tahmininde çıktı düz toplamdır (doğru). Evet/hayır işinde üstüne sigmoid eğrisi gelir: çıktı 0–1 arası güven olur.
Bölge işinde tek bir doğru yetmez: gizli nöronların her biri bir doğru çizer, hata geriye doğru onlara dağıtılır (geri yayılım) ve birlikte bölgeyi çitlerler.
Her model, canlıya çıkmadan önce hiç görmediği örneklerle notlanır: ezber değil, genelleme ölçülür.
Şunu dene: gizli nöron sayısını 0 yap; üçüncü iş tek nörona kalır ve bölgeyi çitleyemez, doğruluk belirgin düşer.

Neden önemli

Gerçek ürünlerin çoğu bu üç kalıptan birine oturur: bir sayı tahmin et (akım, sıcaklık, varış süresi), evet/hayır de (engel, arıza, spam), bir bölgeyi tanı (güvenli çalışma alanı, beğenilen içerik). Robotikte de aynı öğrenme kodu, yalnız veri değiştirilerek motor modeline, sensör füzyonuna ve güvenli bölge sınırına dönüşür.

ESOF 323, 11. hafta: robotlarda derin öğrenme →