Bölüm 8 · Büyük dil modellerinin parçaları · Ders 37

Model damıtma

Büyük öğretmen sunucuda, küçük öğrenci robotun çipinde

Veri. Robot, titreşim (IMU) ve tekerlek kaymasından zeminin beton, çim ya da çakıl olduğunu anlamalı. Sunucuda 1500 etiketli sürüşle eğitilmiş büyük bir ağ var (64 gizli nöron, 387 sayı). Robotun mikrodenetleyicisine ise yalnız 4 gizli nöronlu, 27 sayılık bir ağ sığar ve elimizde onun için yalnız 24 etiketli örnek var. Zeminler birbirine karışır: aynı titreşim bazen çim, bazen çakıldır; tek tek etiketler gürültülüdür.

sunucuda 1500 etiketli sürüşöğretmen 387 sayı · öğrenci 27 sayı

1 / 63

Sıcaklık T 4Öğrencinin etiketli örneği 24

damitma.pypython

import numpy as np
M = np.array([[-1, -.5], [1, -.5], [0, 1]]) # beton, çim, çakıl
def data(n, g=np.random.default_rng(0)): # titreşim, kayma; sınıflar örtüşür
y = g.integers(0, 3, n)
return M[y] + g.normal(0, .7, (n, 2)), y
def sm(z, T=1): # sıcaklıklı softmax
e = np.exp((z - z.max(1, keepdims=True)) / T)
return e / e.sum(1, keepdims=True)
def train(X, P, h, T=1, steps=2000, lr=.75, snaps=None): # P: hedef olasılıklar
r = np.random.default_rng(1)
W1, W2 = r.normal(0, 1, (2, h)), r.normal(0, .5, (h, 3))
b1, b2 = np.zeros(h), np.zeros(3)
for i in range(steps + 1):
if snaps is not None and i % 40 == 0: snaps.append((W1.copy(), b1.copy(), W2.copy(), b2.copy())) # her 40 adımda ağırlıkları sakla
if i == steps: break
H = np.tanh(X @ W1 + b1)
G = (sm(H @ W2 + b2, T) - P) * T / len(X) # gradyan × T²
GH = G @ W2.T * (1 - H ** 2) # geri yayılım
W2 -= lr * H.T @ G; b2 -= lr * G.sum(0)
W1 -= lr * X.T @ GH; b1 -= lr * GH.sum(0)
return lambda X: np.tanh(X @ W1 + b1) @ W2 + b2
(A, a), (S, s), (X, y) = data(1500), data(24), data(1000) # büyük, küçük, test
big = train(A, np.eye(3)[a], 64, lr=.3) # öğretmen: 387 sayı
hs, ss = [], []
hard = train(S, np.eye(3)[s], 4, snaps=hs) # öğrenci, sert etiket: 27 sayı
soft = train(S, sm(big(S), 4), 4, T=4, snaps=ss) # öğrenci, yumuşak hedef
for f in big, hard, soft: print(np.mean(f(X).argmax(1)==y)) # test doğruluğu
f = lambda w, Z: np.tanh(Z @ w[0] + w[1]) @ w[2] + w[3]
Ps = sm(big(S), 4) # öğretmenin yumuşak hedefleri
history = {'step': [], 'hard_acc': [], 'soft_acc': [], 'hard_loss': [], 'soft_kl': []}
for i, (wh, ws) in enumerate(zip(hs, ss)): # test doğruluğu, sert kayıp, KL(öğretmen ‖ öğrenci)
row = (40 * i, np.mean(f(wh, X).argmax(1) == y), np.mean(f(ws, X).argmax(1) == y), -np.log(sm(f(wh, S))[np.arange(len(s)), s]).mean(), (Ps * np.log(Ps / sm(f(ws, S), 4))).sum(1).mean())
for k, v in zip(history, row): history[k].append(float(v))
for k in history: print(f'{k:<10}{history[k][-1]:>10.4f}') # son ölçümler tablosu
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as fh: # geçmişi CSV'ye yaz
csv.writer(fh).writerows([list(history), *zip(*history.values())]) # satır başına 40 adım
try:
import matplotlib.pyplot as plt # varsa grafik çiz
for k in ('hard_acc', 'soft_acc'): plt.plot(history['step'], history[k], label=k)
plt.xlabel('step'); plt.ylabel('test accuracy'); plt.legend(); plt.show()
except ImportError:
print('matplotlib yok: grafik atlandı')

Eğitim paneli

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

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.

damitma.pypython

import numpy as np
M = np.array([[-1, -.5], [1, -.5], [0, 1]])   # beton, çim, çakıl
def data(n, g=np.random.default_rng(0)):      # titreşim, kayma; sınıflar örtüşür
    y = g.integers(0, 3, n)
    return M[y] + g.normal(0, .7, (n, 2)), y
def sm(z, T=1):                               # sıcaklıklı softmax
    e = np.exp((z - z.max(1, keepdims=True)) / T)
    return e / e.sum(1, keepdims=True)
def train(X, P, h, T=1, steps=2000, lr=.75, snaps=None):  # P: hedef olasılıklar
    r = np.random.default_rng(1)
    W1, W2 = r.normal(0, 1, (2, h)), r.normal(0, .5, (h, 3))
    b1, b2 = np.zeros(h), np.zeros(3)
    for i in range(steps + 1):
        if snaps is not None and i % 40 == 0: snaps.append((W1.copy(), b1.copy(), W2.copy(), b2.copy()))  # her 40 adımda ağırlıkları sakla
        if i == steps: break
        H = np.tanh(X @ W1 + b1)
        G = (sm(H @ W2 + b2, T) - P) * T / len(X)  # gradyan × T²
        GH = G @ W2.T * (1 - H ** 2)          # geri yayılım
        W2 -= lr * H.T @ G; b2 -= lr * G.sum(0)
        W1 -= lr * X.T @ GH; b1 -= lr * GH.sum(0)
    return lambda X: np.tanh(X @ W1 + b1) @ W2 + b2
(A, a), (S, s), (X, y) = data(1500), data(24), data(1000)  # büyük, küçük, test
big = train(A, np.eye(3)[a], 64, lr=.3)       # öğretmen: 387 sayı
hs, ss = [], []
hard = train(S, np.eye(3)[s], 4, snaps=hs)    # öğrenci, sert etiket: 27 sayı
soft = train(S, sm(big(S), 4), 4, T=4, snaps=ss)  # öğrenci, yumuşak hedef
for f in big, hard, soft: print(np.mean(f(X).argmax(1)==y))  # test doğruluğu
f = lambda w, Z: np.tanh(Z @ w[0] + w[1]) @ w[2] + w[3]
Ps = sm(big(S), 4)                            # öğretmenin yumuşak hedefleri
history = {'step': [], 'hard_acc': [], 'soft_acc': [], 'hard_loss': [], 'soft_kl': []}
for i, (wh, ws) in enumerate(zip(hs, ss)):    # test doğruluğu, sert kayıp, KL(öğretmen ‖ öğrenci)
    row = (40 * i, np.mean(f(wh, X).argmax(1) == y), np.mean(f(ws, X).argmax(1) == y), -np.log(sm(f(wh, S))[np.arange(len(s)), s]).mean(), (Ps * np.log(Ps / sm(f(ws, S), 4))).sum(1).mean())
    for k, v in zip(history, row): history[k].append(float(v))
for k in history: print(f'{k:<10}{history[k][-1]:>10.4f}')  # son ölçümler tablosu
import csv
with open('egitim_gecmisi.csv', 'w', newline='') as fh:  # geçmişi CSV'ye yaz
    csv.writer(fh).writerows([list(history), *zip(*history.values())])  # satır başına 40 adım
try:
    import matplotlib.pyplot as plt           # varsa grafik çiz
    for k in ('hard_acc', 'soft_acc'): plt.plot(history['step'], history[k], label=k)
    plt.xlabel('step'); plt.ylabel('test accuracy'); plt.legend(); plt.show()
except ImportError:
    print('matplotlib yok: grafik atlandı')

Kendi CSV’ni yükle

Çıktı

Çıktı burada görünecek.

Nasıl çalışır

Sert etiket: "bu örnek çim" (1, 0, 0 gibi). Yumuşak hedef: öğretmenin olasılıkları, ör. çim 0,6, çakıl 0,3, beton 0,1. İkincisi "ne kadar emin" ve "neye benziyor" bilgisini de taşır.
Sıcaklık T: öğretmenin çıktıları softmax(z / T) ile yumuşatılır. T büyüdükçe küçük olasılıklar görünür olur; öğrenci aynı T ile eğitilir, gradyan T² ile ölçeklenir.
İki öğrenci aynı 24 noktayı, aynı başlangıç ağırlıklarını ve aynı 2000 adımı kullanır; tek fark hedeftir. Doğruluk, 1000 yeni sürüşte ölçülür.
Sert etiketli öğrenci gürültülü 24 noktayı ezberler ve sınırı büker; damıtılmış öğrenci öğretmenin düzgün sınırını kopyalar.
Şunu dene: örnek sayısını 120 yap; fark küçülür, çünkü bol veri gürültüyü kendisi ortalar. T’yi 1 ile 8 arasında değiştir: bu basit problemde T’nin etkisi küçüktür.

Neden önemli

Büyük dil modellerinin küçük ve hızlı sürümleri (ör. DeepSeek’in damıtılmış modelleri, telefonlarda çalışan asistanlar) böyle eğitilir: büyük model öğretmen olur, küçük model onun çıktılarını taklit eder. Robotikte sunucudaki ağır algı modelleri, mikrodenetleyici ya da gömülü GPU’ya sığan küçük ağlara bu yolla aktarılır; enerji, gecikme ve bellek kazanılır.

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