Projeler · Proje 2

Robot kol hedefe uzanır

Üç eklemli kolun ters kinematiğini küçük bir sinir ağı öğrenir

Senaryo. Masaya vidalı üç eklemli bir kol: taban sağa sola döner, omuz ve dirsek yukarı aşağı. Kamera bir parçanın yerini (x, y, z) söylüyor; kolun ucunu oraya götürmek için üç motorun hangi açıya döneceğini bulmamız gerek. Açılardan uç noktasını hesaplamak kolay (ileri kinematik), tersi zor. Formül türetmek yerine kolu rastgele açılarda gezdirip nereye vardığını kaydediyor ve tersini bir ağa öğretiyoruz.

Amaç. Kolun hiç görmediği 200 hedefte ortalama uzaklık 2 cm’nin altına inince eğitim biter.

3B sahne yükleniyor…

eğitim adımı 0 · ortalama hata 98,5 cm

Sürükle: döndür · iki parmak / tekerlek: yakınlaş

Gizli nöron (katman başına) 32Öğrenme oranı 0.01Eğitim örneği 2000Tohum 1

Eğitim paneli

Eğitim çalıştırılıyor…

Model bu sayfada, tarayıcında sıfırdan eğitilir (sabit tohum: aynı ayarlarla her seferinde aynı sonuç). Eğitim her karede küçük parçalar hâlinde yapılır; sekme ya da sahne görünmezken durur.

Adımlar

Veri: kol rastgele açılara getirilir, ileri kinematikle ucun vardığı nokta hesaplanır. Her örnek bir (nokta, açılar) çiftidir. Yalnız “dirsek yukarı” duruşlar kullanılır; aynı noktaya iki farklı duruşla varılabildiği için ağın kafası karışmasın.
Ağ ters yönde çalışır: nokta girer, açılar çıkar. Taban açısı doğrudan değil, kosinüs ve sinüsüyle öğrenilir; böylece −120° ile +120° arasında atlama olmaz.
Her adımda 32 örneklik bir mini grupta tahmin edilen açılar gerçek açılarla karşılaştırılır; ortalama kare hata geri yayılımla ağırlıklara paylaştırılır ve Adam küçük bir adım atar.
Asıl ölçüt açı hatası değil, ucun hedefe uzaklığıdır: ağın verdiği açılar ileri kinematikten geçirilir ve kolun hiç görmediği 200 hedefte ortalama uzaklık (cm) ölçülür.
Sahnede kol sekiz hedefe sırayla uzanır. Eğitimin başında uç hedefin çok uzağında kalır; hata düştükçe kıskaç hedefe oturur ve aradaki çizgi kırmızıdan yeşile döner.

Model

Çok katmanlı sinir ağı ile regresyon: 3 girdi (hedef), iki tanh gizli katman, 4 çıktı (taban açısının kosinüs ve sinüsü, omuz ve dirsek açısı). Kayıp ortalama kare hata, ağırlıklar geri yayılım ve Adam ile güncellenir; doğrusal regresyon, sinir ağı, gradyan inişi ve geri yayılım derslerindeki parçaların aynısı.

Kullanılan dersler: Doğrusal regresyon ve gradyan inişi · Küçük bir sinir ağı · Gradyan inişi: kayıp arazisinde yokuş aşağı · Geri yayılım: altı ağırlıktan hangisi suçlu? · Aşırı öğrenme ve doğrulama

Kendin dene

Gizli nöron sayısını 4’e indir. Ağ bu kadar az nöronla kolun eğri yüzeyini çizemez: hata 7 cm civarında takılır ve 24.000 adımlık bütçe hedefe ulaşmadan biter. 8 nöronla 3 cm civarında kalır; 32 nöron 7.600 adımda 2 cm’nin altına iner.
Öğrenme oranını 0,03’e çıkar. Adımlar büyüdüğü için hata düzgün inmez, zıplar: 3.000. adımdaki hata 1.000. adımdakinden kötüdür ve hedefe 7.600 yerine 18.800 adımda ulaşılır.
Eğitim örneğini 50’ye indir. Eğitim kaybı 2.000 örnektekinden bile düşer (0,00004), ama kolun görmediği hedeflerde hata 6–7 cm’de kalır: ağ 50 duruşu ezberlemiştir, aradaki boşlukları bilmez. Aşırı öğrenme dersindeki durumun aynısı.

Python karşılığı

robot_kol.pypython

import numpy as np
h0, L1, L2 = 0.2, 0.5, 0.4 # omuz yüksekliği, üst kol, ön kol (m)
lo = np.radians([-120, 15, -140]); hi = np.radians([120, 100, -20]) # eklem sınırları, dirsek yukarı
def fk(q): # ileri kinematik
r = L1 * np.cos(q[:, 1]) + L2 * np.cos(q[:, 1] + q[:, 2])
z = h0 + L1 * np.sin(q[:, 1]) + L2 * np.sin(q[:, 1] + q[:, 2])
return np.c_[r * np.cos(q[:, 0]), r * np.sin(q[:, 0]), z]
rng = np.random.default_rng(1)
q = rng.uniform(lo, hi, (2000, 3)) # rastgele duruşlar
X = fk(q) / 0.9; X[:, 2] -= h0 / 0.9 # girdi: uç noktası
mid, half = (lo + hi) / 2, (hi - lo) / 2
Y = np.c_[np.cos(q[:, 0]), np.sin(q[:, 0]), ((q - mid) / half)[:, 1:]] # çıktı: açılar
sizes = [3, 32, 32, 4]
W = [rng.normal(0, 1 / np.sqrt(a), (a, b)) for a, b in zip(sizes, sizes[1:])]
B = [np.zeros(b) for b in sizes[1:]]
def net(A): # ileri hesap: her katmanın çıktısı
a = [A]
for k in range(3): z = a[-1] @ W[k] + B[k]; a.append(np.tanh(z) if k < 2 else z)
return a
def ik(P): # ters kinematik: ağın cevabı
o = net((P - [0, 0, h0]) / 0.9)[-1]
return np.c_[np.arctan2(o[:, 1], o[:, 0]), mid[1:] + o[:, 2:] * half[1:]]
qt = rng.uniform(lo, hi, (200, 3)); test = fk(qt) # kolun hiç görmediği 200 hedef
Yt = np.c_[np.cos(qt[:, 0]), np.sin(qt[:, 0]), ((qt - mid) / half)[:, 1:]]
hata = lambda P: np.linalg.norm(fk(ik(P)) - P, axis=1).mean() * 100 # ucun hedefe ortalama uzaklığı (cm)
history = {'step': [], 'loss': [], 'val_loss': [], 'test_err_cm': []} # eğitim geçmişi
kayip = []
for step in range(1, 20001):
i = rng.integers(0, len(X), 32) # mini grup
a = net(X[i]) # ileri
kayip.append(((a[-1] - Y[i]) ** 2).mean()) # ortalama kare hata
d = 2 * (a[-1] - Y[i]) / a[-1].size # ortalama kare hatanın türevi
for k in (2, 1, 0): # geri yayılım
gW, gB = a[k].T @ d, d.sum(0)
if k: d = (d @ W[k].T) * (1 - a[k] ** 2)
W[k] -= 0.01 * gW; B[k] -= 0.01 * gB # basitlik için düz adım (projede Adam)
if step % 1000 == 0: # her 1000 adımda geçmişe bir satır
val = ((net((test - [0, 0, h0]) / 0.9)[-1] - Yt) ** 2).mean() # doğrulama kaybı: saklı hedefler
for k, v in zip(history, (step, np.mean(kayip), val, hata(test))): history[k].append(v if isinstance(v, int) else float(v))
kayip = []
for k in history: print(f'{k:<12}{history[k][-1]:>12.5f}') # son ölçümler tablosu
print(hata(test), 'cm') # saklı hedeflerde ortalama uzaklık
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as f: # geçmişi CSV'ye yaz
csv.writer(f).writerows([list(history), *zip(*history.values())])
try:
import matplotlib.pyplot as plt # varsa grafik çiz
for k in ('loss', 'val_loss'): plt.plot(history['step'], history[k], label=k)
plt.yscale('log'); plt.xlabel('step'); plt.ylabel('MSE'); plt.legend(); plt.show()
except ImportError:
print('matplotlib yok: grafik atlandı')

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.

robot_kol.pypython

import numpy as np
h0, L1, L2 = 0.2, 0.5, 0.4                    # omuz yüksekliği, üst kol, ön kol (m)
lo = np.radians([-120, 15, -140]); hi = np.radians([120, 100, -20])  # eklem sınırları, dirsek yukarı
def fk(q):                                    # ileri kinematik
    r = L1 * np.cos(q[:, 1]) + L2 * np.cos(q[:, 1] + q[:, 2])
    z = h0 + L1 * np.sin(q[:, 1]) + L2 * np.sin(q[:, 1] + q[:, 2])
    return np.c_[r * np.cos(q[:, 0]), r * np.sin(q[:, 0]), z]
rng = np.random.default_rng(1)
q = rng.uniform(lo, hi, (2000, 3))            # rastgele duruşlar
X = fk(q) / 0.9; X[:, 2] -= h0 / 0.9          # girdi: uç noktası
mid, half = (lo + hi) / 2, (hi - lo) / 2
Y = np.c_[np.cos(q[:, 0]), np.sin(q[:, 0]), ((q - mid) / half)[:, 1:]]  # çıktı: açılar
sizes = [3, 32, 32, 4]
W = [rng.normal(0, 1 / np.sqrt(a), (a, b)) for a, b in zip(sizes, sizes[1:])]
B = [np.zeros(b) for b in sizes[1:]]
def net(A):                                   # ileri hesap: her katmanın çıktısı
    a = [A]
    for k in range(3): z = a[-1] @ W[k] + B[k]; a.append(np.tanh(z) if k < 2 else z)
    return a
def ik(P):                                    # ters kinematik: ağın cevabı
    o = net((P - [0, 0, h0]) / 0.9)[-1]
    return np.c_[np.arctan2(o[:, 1], o[:, 0]), mid[1:] + o[:, 2:] * half[1:]]
qt = rng.uniform(lo, hi, (200, 3)); test = fk(qt)  # kolun hiç görmediği 200 hedef
Yt = np.c_[np.cos(qt[:, 0]), np.sin(qt[:, 0]), ((qt - mid) / half)[:, 1:]]
hata = lambda P: np.linalg.norm(fk(ik(P)) - P, axis=1).mean() * 100  # ucun hedefe ortalama uzaklığı (cm)
history = {'step': [], 'loss': [], 'val_loss': [], 'test_err_cm': []}  # eğitim geçmişi
kayip = []
for step in range(1, 20001):
    i = rng.integers(0, len(X), 32)           # mini grup
    a = net(X[i])                             # ileri
    kayip.append(((a[-1] - Y[i]) ** 2).mean())  # ortalama kare hata
    d = 2 * (a[-1] - Y[i]) / a[-1].size       # ortalama kare hatanın türevi
    for k in (2, 1, 0):                       # geri yayılım
        gW, gB = a[k].T @ d, d.sum(0)
        if k: d = (d @ W[k].T) * (1 - a[k] ** 2)
        W[k] -= 0.01 * gW; B[k] -= 0.01 * gB  # basitlik için düz adım (projede Adam)
    if step % 1000 == 0:                      # her 1000 adımda geçmişe bir satır
        val = ((net((test - [0, 0, h0]) / 0.9)[-1] - Yt) ** 2).mean()  # doğrulama kaybı: saklı hedefler
        for k, v in zip(history, (step, np.mean(kayip), val, hata(test))): history[k].append(v if isinstance(v, int) else float(v))
        kayip = []
for k in history: print(f'{k:<12}{history[k][-1]:>12.5f}')  # son ölçümler tablosu
print(hata(test), 'cm')                       # saklı hedeflerde ortalama uzaklık
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as f:  # geçmişi CSV'ye yaz
    csv.writer(f).writerows([list(history), *zip(*history.values())])
try:
    import matplotlib.pyplot as plt           # varsa grafik çiz
    for k in ('loss', 'val_loss'): plt.plot(history['step'], history[k], label=k)
    plt.yscale('log'); plt.xlabel('step'); plt.ylabel('MSE'); plt.legend(); plt.show()
except ImportError:
    print('matplotlib yok: grafik atlandı')

Kendi CSV’ni yükle

Çıktı

Çıktı burada görünecek.