Doğrusal regresyon

Bir evin kirasını ya da yarınki sıcaklığı tahmin etmek gibi, sonucu sürekli bir sayı olan işlere regresyon (regression) denir. Doğrusal regresyon bunu doğrusal bir modelle yapar. Tahmin $\hat{\mathbf{y}} = X\mathbf{w} + b$‘dir.

Model, parametre, kayıp dersinde dört evin en iyi çizgisinin $w = 0{,}19$ ve $b = 2{,}7$ olduğunu söyledik. Bu sayıları nasıl bulduğumuzu göstermedik.

Bu derste şunları yapacaksın:

• Ortalama kare hatanın (mean squared error, MSE)ortalama kare hata (mean squared error, MSE): Tahminlerle hedef değerler arasındaki farkların karelerinin ortalaması. Büyük hataları küçüklerden daha ağır cezalandırır. gradyanını çıkaracaksın.
• Gradyan inişiyle (gradient descent)gradyan inişi (gradient descent): Kaybı azaltmak için parametreleri gradyanın tersine küçük adımlarla güncelleyen yöntem. eğitim döngüsünü kuracaksın.
• Düz bir eğrinin neden minimuma varıldığını göstermediğini göreceksin.
• Özniteliklerin (feature)öznitelik (feature): Bir örneği tanımlayan ve modele girdi olarak verilen ölçülebilir değerlerden biri. ölçeğinin öğrenme oranına (learning rate)öğrenme oranı (learning rate): Gradyan inişinde atılan adımın büyüklüğü. Çok küçükse eğitim yavaşlar, çok büyükse kayıp büyür. nasıl sınır koyduğunu göreceksin.

Bir sonraki ders, Ölçekleme, mini-batch ve kapalı form, eğitimi hızlandırır ve aynı çizgiyi tek hamlede bulur.

MSE’nin gradyanı

Bir ağırlığın (weight)ağırlık (weight): Bir girdiyle çarpılarak onun çıktıya ne kadar katkıda bulunacağını belirleyen parametre. Doğrusal modelde her özniteliğin kendi ağırlığı vardır. gradyanı, hata çarpı öznitelik değerinin ortalamasının iki katıdır. Bunu çıkarmak için Gradyan inişi dersinden kısmi türevi (partial derivative)kısmi türev (partial derivative): Birden çok değişkenli bir fonksiyonun, öbür değişkenler sabit tutulup yalnızca bir değişkene göre alınan türevi. bilmen yeter: öbür parametreleri sabit sayıp yalnızca birine göre aldığın türev.

Tek bir örneğin türevi

Model, parametre, kayıp dersindeki A modelini ($w = 0{,}2$, $b = 2$) ve 80 metrekarelik evi alalım. Tahmin 18, gerçek kira 17. Hata $e = \hat{y} - y = 1$; kare hatası $\ell = (w \cdot 80 + b - 17)^2$.

$w$‘ye göre kısmi türev üç adımda çıkar:

1. Dıştaki karenin türevini al: $2e$.
2. İçteki $w \cdot 80 + b - 17$ ifadesinin $w$‘ye göre türevini al: 80, çünkü $b$ ve 17 sabittir.
3. İkisini çarp: $2 \cdot 1 \cdot 80 = 160$.

İç içe fonksiyonlarda türev böyle alınır: dıştakinin türevi çarpı içtekinin türevi. Geri yayılım dersinde bu kurala zincir kuralı diyeceğiz.

Yani $w$ biraz artarsa bu evin kare hatası, artışın 160 katı kadar artar. $b$, yani sapma (bias)sapma (bias): Girdilerle çarpılmadan çıktıya eklenen parametre. Doğrusal modelde bütün öznitelikler 0 iken modelin verdiği tahmindir. için içteki türev 1’dir; sonuç $2 \cdot 1 \cdot 1 = 2$.

w, b = 0.2, 2.0       # A modelix, y = 80.0, 17.0     # 80 metrekarelik ev, gerçek kiray_hat = w * x + b     # tahmine = y_hat - y         # hataprint(y_hat, e)       # → 18.0 1.0print(2 * e * x)      # → 160.0print(2 * e)          # → 2.0

Dört evin gradyanı

$i$. örnek için hata $e_i = \hat{y}_i - y_i = w x_i + b - y_i$ olsun. Her örnek, hatasının iki katını gradyana ekler: $w$ için öznitelik değeriyle çarparak, $b$ için olduğu gibi. MSE kare hataların ortalamasıdır; ortalamanın türevi, türevlerin ortalamasıdır:

A modelinde dört evin hataları 0, −1, 1 ve 0; metrekareleri 40, 60, 80 ve 100:

Gradyan $(10;\ 0)$: $w$ yönünde eğim 10, $b$ yönünde 0. Bir gradient descent adımı $w$‘yi azaltır, $b$‘yi yerinde bırakır. Merkezi fark da aynı sayıyı verir ($b = 2$ iken):

import numpy as npx = np.array([40., 60., 80., 100.])    # metrekarey = np.array([10., 15., 17., 22.])     # kira, bin TLw, b = 0.2, 2.0                        # A modelie = w * x + b - y                      # dört evin hatasıprint(e)                               # → [ 0. -1.  1.  0.]print(2 * e * x)                       # → [   0. -120.  160.    0.]print(2 * np.mean(e * x), 2 * np.mean(e))    # → 10.0 0.0def loss_at(w, b):    return np.mean((w * x + b - y) ** 2)print(loss_at(0.25, 2.0), loss_at(0.15, 2.0))              # → 14.5 13.5print((loss_at(0.25, 2.0) - loss_at(0.15, 2.0)) / 0.1)     # → 10.0

Birden çok öznitelik için matris biçimi

Birden çok öznitelikte $\mathbf{w}$ bir vektördür. $X_{ij}$, $i$. örneğin $j$. özniteliğidir. $j$. ağırlığın kısmi türevi şudur:

$X^\top$‘nin (NumPy’da X.T) $j$. satırı, $X$‘in $j$. sütunudur. Bu satırın hata vektörüyle çarpımı, yukarıdaki toplamı verir. Böylece $d$ tane toplam tek bir matris çarpımına dönüşür:

Boyutlar uyuşur:

• $X^\top$ matrisi $d \times N$‘dir.
• Hata vektörü $N$ elemanlıdır.
• Sonuç $d$ elemanlıdır: $\mathbf{w}$ ile aynı boyut.

Gradyanın parametreyle aynı boyutta olması iyi bir kontroldür. $b$ için formül aynıdır, yalnızca öznitelik değeri yerine 1 vardır: $b$, değeri hep 1 olan bir özniteliğin ağırlığı gibi davranır.

import numpy as npdef mse_gradient(X, y, w, b):    n = X.shape[0]    error = X @ w + b - y              # y_hat - y    grad_w = 2 / n * (X.T @ error)     # w ile aynı boyutta    grad_b = 2 / n * np.sum(error)    return grad_w, float(grad_b)X = np.array([[40.], [60.], [80.], [100.]])    # (4, 1)y = np.array([10., 15., 17., 22.])grad_w, grad_b = mse_gradient(X, y, np.array([0.2]), 2.0)print(grad_w, grad_b)                  # → [10.] 0.0X2 = np.array([[1., 2.], [3., 4.], [5., 6.]])  # 3 örnek, 2 featurey2 = np.array([1., 2., 3.])grad_w, grad_b = mse_gradient(X2, y2, np.array([0.5, 0.5]), 0.0)print(X2.T.shape, grad_w.shape)        # → (2, 3) (2,)print(np.round(grad_w, 2))             # → [11.67 14.67]

Eğitim döngüsü

Eğitim, aynı güncelleme kuralını tekrar tekrar uygulamaktır. Her parametre, kendi kısmi türevinin tersine, $\eta$ ile ölçeklenmiş bir adım atar. Buradaki $\eta$, Gradyan inişi dersinden bildiğin öğrenme oranıdıröğrenme oranı (learning rate): Gradyan inişinde atılan adımın büyüklüğü. Çok küçükse eğitim yavaşlar, çok büyükse kayıp büyür..

Güncelleme kuralı

Bu iki satır eğitimin tamamıdır; gerisi tekrardır. Bir tur dört adımdan oluşur:

1. Mevcut $\mathbf{w}$ ve $b$ ile bütün örneklerin tahminini yap.
2. Hataları hesapla.
3. Gradyanı çıkar.
4. Parametreleri güncelle.

Dört evde $w = 0$, $b = 0$ ve $\eta = 0{,}0001$ ile başlayalım. Tahminlerin hepsi 0 olduğundan hatalar $-y$ olur; yani $-10,\ -15,\ -17,\ -22$. Gradyan ve güncelleme:

Kayıp (loss) 274,5’ten 2,88’e düşer.

$w$ ilk adımda 0,243’e sıçrar, $b$ ise 0,0032’de kalır. Gradyan $w$ yönünde $b$ yönünden yaklaşık 76 kat büyüktür; ilk adım neredeyse yalnızca $w$‘yi değiştirir. Learning rate bu kadar küçük, çünkü büyüğü ıraksar. Nedenini aşağıda göreceksin.

Epoch

Veri kümesinin (dataset)veri kümesi (dataset): Her biri öznitelikler ve bir hedef değerden oluşan örneklerin tamamı. tamamı üzerinden bir tura epochepoch: Eğitimde veri kümesinin tamamı üzerinden bir tur; her örnek bir kez kullanılmış olur. denir. Her güncelleme bütün örnekleri kullandığı için şimdilik bir güncelleme bir epoch’tur.

Döngü, dört adımı epoch sayısı kadar tekrarlar:

import numpy as npdef train(X, y, lr=0.1, epochs=100):    n, d = X.shape    w = np.zeros(d)    b = 0.0    for _ in range(epochs):        y_hat = X @ w + b                  # 1. tahmin        error = y_hat - y                  # 2. hata        grad_w = 2 / n * (X.T @ error)     # 3. gradyan        grad_b = 2 / n * np.sum(error)        w = w - lr * grad_w                # 4. güncelleme        b = b - lr * grad_b    return w, float(b)X = np.array([[40.], [60.], [80.], [100.]])y = np.array([10., 15., 17., 22.])w, b = train(X, y, lr=0.0001, epochs=1)print(w, b)                                # → [0.243] 0.0032print(round(np.mean((X @ w + b - y) ** 2), 2))    # → 2.88

Tek epoch’un çıktısı, yukarıda elle bulduğumuz 0,243 ve 0,0032’dir.

Öğrenme eğrisi

Her epoch’un sonunda loss’u kaydet. Yatay eksende epoch, dikey eksende loss olan bir öğrenme eğrisi (learning curve) elde edersin. Eğriyi şöyle oku:

• Hızla düşüp düzleşiyorsa eğitim ilerliyordur. Ama düzleşme, minimuma varıldığını kanıtlamaz; aşağıda göreceksin.
• Yükseliyorsa learning rate büyüktür ve eğitim ıraksıyordur.

Durma koşulları Gradyan inişi dersindeki gibidir: loss’un değişimi küçüldüğünde ya da epoch sınırına ulaştığında dur.

Bizim eğitimimizde loss ikinci epoch’ta 1,13’e iner. Sonra eğri düzleşir; 100 epoch sonunda 1,12, 1000 epoch sonunda 1,10 olur. Eğri yakınsamış gibi görünür; oysa bu veride loss 0,45’e inebilir.

import numpy as npx = np.array([40., 60., 80., 100.])y = np.array([10., 15., 17., 22.])w, b, lr, tol = 0.0, 0.0, 0.0001, 1e-3losses = [np.mean((w * x + b - y) ** 2)]        # epoch 0: başlangıçfor epoch in range(1, 1001):                    # epoch sınırı    error = w * x + b - y    w = w - lr * 2 * np.mean(error * x)    b = b - lr * 2 * np.mean(error)    losses.append(np.mean((w * x + b - y) ** 2))    # epoch sonunda kaydet    if abs(losses[-2] - losses[-1]) < tol:      # değişim küçüldü: dur        breakprint(epoch)                                    # → 4print(np.round(losses, 2).tolist())             # → [274.5, 2.88, 1.13, 1.12, 1.12]

Bu toleransla eğitim 4. epoch’ta durur. Loss o anda 1,12’dir; minimum ise 0,45.

Düzleşen eğri ve loss yüzeyi

Düzleşen bir learning curve, minimuma varıldığı anlamına gelmez. Nedenini aşağıdaki grafikte gör.

Grafikte topun her konumu bir $(w, b)$ çiftidir, yani bir çizgi. Yüzey, o çizginin MSE’sidir. Küçük iç grafik dört evi ve topun çizgisini gösterir.

Metrekareler $100\text{ m}^2$ biriminde yazıldı ($x = 0{,}4;\ 0{,}6;\ 0{,}8;\ 1{,}0$).

Grafikte iki görünüm var: “Ölçeksiz” ve “Ölçekli feature”. İkisi de aynı learning rate’i ($\eta = 0{,}55$) ve 60 adımı kullanır. Başta “Ölçeksiz” seçili; “Ölçekli feature” görünümünü bir sonraki derste kullanacaksın.

Değiştireceğin şey başlangıç noktasıdır. Topu sürükle ya da grafikte bir yere dokun; yolun tamamı yeniden çizilir. Şunları dene:

• Topu yalnızca $b$ yönünde kaydır: çizgi eğimini korur, yukarı ya da aşağı kayar. Yalnızca $w$ yönünde kaydırırsan eğim değişir.
• Topu çanağın dibinden uzak bir yere koy ve yolu izle. Top önce zikzak çizerek kesikli çizgiyle gösterilen vadi tabanına çabucak iner, sonra taban boyunca küçük adımlarla sürünür.
• İç grafikteki çizgi veriye yaklaşır ama 60 adımda tam oturmaz.

Eğitimin 1000. epoch’ta bıraktığı nokta ile çanağın dibi arasındaki farkı loss’tan oku:

import numpy as npdef mse_loss(X, y, w, b):    return np.mean((X @ w + b - y) ** 2)# train: Epoch bölümündeki fonksiyonX = np.array([[40.], [60.], [80.], [100.]])y = np.array([10., 15., 17., 22.])w, b = train(X, y, lr=0.0001, epochs=1000)print(np.round(w, 4), round(b, 4))                  # → [0.2243] 0.0524print(round(mse_loss(X, y, w, b), 2))               # → 1.1best = mse_loss(X, y, np.array([0.19]), 2.7)        # çanağın dibiprint(round(best, 2))                               # → 0.45

Dar vadi ve learning rate

Eğri düzleşir, çünkü çanak $w$ yönünde $b$ yönünden binlerce kat daha diktir.

Çanağın biçimi

Dört ev için MSE’yi açarsak nedeni görürsün:

$w = 0{,}2$ ve $b = 2$ (A modeli) için $L = 0{,}5$ çıkar. Kare terimlerine bak:

• $w^2$‘nin katsayısı 5400’dür: metrekarelerin karelerinin ortalaması. Metrekareler 40 ile 100 arasında olduğundan kareleri binlere ulaşır.
• $b^2$‘nin katsayısı 1’dir, çünkü $b$ değeri hep 1 olan bir özniteliğin ağırlığıdır.

Bu, Gradyan inişi dersindeki uzun çanağın çok daha aşırı hâlidir.

import numpy as npx = np.array([40., 60., 80., 100.])y = np.array([10., 15., 17., 22.])print(np.mean(x ** 2))         # → 5400.0print(2 * np.mean(x))          # → 140.0print(-2 * np.mean(x * y))     # → -2430.0print(-2 * np.mean(y))         # → -32.0print(np.mean(y ** 2))         # → 274.5w, b = 0.2, 2.0                # A modeliL = 5400 * w**2 + 140 * w * b + b**2 - 2430 * w - 32 * b + 274.5print(round(L, 2))             # → 0.5

Sırayla $w^2$, $wb$, $w$ ve $b$ katsayıları ile sabit terim çıktı.

Learning rate’in üst sınırı

Dar yön, learning rate’e üst sınır koyar. $w$ yönünde loss kabaca $5400\,w^2$ gibi davranır. Üst sınır üç adımda çıkar:

1. Gradyan $2 \cdot 5400\,w$ olur. Bir adım $w$‘yi $w - \eta \cdot 2 \cdot 5400\,w$ yapar: dipten uzaklık $1 - 2 \cdot 5400\,\eta$ ile çarpılır.
2. Çarpanın mutlak değerini 1’den küçük tut.
3. Sınırı bul: $\eta < 1/5400 \approx 0{,}000185$.

$\eta = 0{,}0001$ sınırın içindedir, $0{,}0002$ ise ıraksar. Bu küçük learning rate dar yöne uyar, ama uzun yönde, yani vadinin boyunca, çok küçük adımlar attırır. Bunun çaresi, vadiyi yuvarlamaktır: bir sonraki derste öznitelikleri ölçekleyeceksin.

import numpy as npprint(1 / 5400)    # → 0.00018518518518518518multipliers = [1 - 2 * 5400 * lr for lr in (0.0001, 0.0002)]print(np.round(multipliers, 2).tolist())   # → [-0.08, -1.16]# train ve mse_loss: önceki bloklardanX = np.array([[40.], [60.], [80.], [100.]])y = np.array([10., 15., 17., 22.])lrs = (0.0001, 0.0002)curve = [mse_loss(X, y, *train(X, y, lr=lr, epochs=10)) for lr in lrs]print(np.round(curve, 2).tolist())         # → [1.12, 5354.63]

$\eta = 0{,}0002$ için çarpan $-1{,}16$‘dır. Mutlak değeri 1’i aştığından loss 10 epoch’ta yaklaşık 5355’e çıkar.

Vadi doğrusu

$140\,wb$ terimi vadiyi eğik yapar. $b$‘ye göre kısmi türevi sıfıra eşitle:

Vadi kabaca bu doğru boyunca uzanır. Doğrunun üzerindeki her $(w, b)$ çifti, verinin ortalama noktası $(70;\ 16)$‘dan geçen ve hatalarının ortalaması 0 olan bir çizgidir.

import numpy as npx = np.array([40., 60., 80., 100.])y = np.array([10., 15., 17., 22.])w = 0.3b = y.mean() - w * x.mean()        # 16 - 70 we = w * x + b - yprint(round(b, 2), e)              # → -5.0 [-3. -2.  2.  3.]print(np.mean(e))                  # → 0.0print(w * x.mean() + b)            # → 16.0

Son satır, çizginin ortalama noktadan geçtiğini gösterir: $x = 70$ için tahmin 16.

Özet

• MSE’nin $\mathbf{w}$ gradyanı, $X^\top(\hat{\mathbf{y}} - \mathbf{y})$ çarpımının $2/N$ katıdır; $b$ gradyanı hataların ortalamasının iki katıdır.
• Gradyan, parametreyle aynı boyuttadır.
• Eğitim döngüsü tahmin, hata, gradyan ve güncellemeyi epoch epoch tekrarlar.
• Düz bir learning curve, minimuma varıldığını kanıtlamaz.
• Ölçeksiz öznitelikler çanağı uzun ve eğik yapar; learning rate dar yöne göre küçük kalır.

Terimler