Model, parametre, kayıp

Düz bir çizgiden büyük bir dil modeline kadar, parametreleri veriden öğrenilen her model aynı iskeleti taşır. İskelet üç parçadan oluşur:

• Bir kural: girdiye bakıp tahmin (prediction) üretir.
• Kuralın ayarlanabilir sayıları: bunlara parametre (parameter)parametre (parameter): Modelin tahminini belirleyen ve eğitimde ayarlanan sayılardan her biri. denir.
• Bir ölçüt: parametrelerin ne kadar iyi seçildiğini gösterir.

Tahminlerin ne kadar yanlış olduğunu tek bir sayıyla ölçen fonksiyona kayıp fonksiyonu (loss function)kayıp fonksiyonu (loss function): Modelin tahminlerinin ne kadar yanlış olduğunu tek bir sayıyla ölçen fonksiyon. denir. Çıkan sayıya ise kayıp (loss) denir.

Bu derste şunları yapacaksın:

• Düz bir çizgiyi model olarak kuracaksın.
• Çizginin hatalarını tek bir sayıya indireceksin.
• Öğrenmenin neden bir optimizasyon problemi olduğunu göreceksin.

Veri nasıl görünür?

Veri, her satırı bir örnek (sample) olan bir tablodur.

Örnek, öznitelik ve hedef değer

Bir evin kirasını tahmin etmek istediğini düşün. Elinde dört evin metrekaresi ve gerçekte ödenen kirası (bin TL cinsinden) var:

Dört satırın hepsi birlikte bir veri kümesi (dataset)veri kümesi (dataset): Her biri öznitelikler ve bir hedef değerden oluşan örneklerin tamamı. oluşturur. İki sütunun birer adı var:

• Sol sütun modelin girdisidir ve örneği tanımlar. Ona öznitelik (feature)öznitelik (feature): Bir örneği tanımlayan ve modele girdi olarak verilen ölçülebilir değerlerden biri. denir.
• Sağ sütun tahmin etmek istediğimiz gerçek sonuçtur. Ona hedef değer (target) denir. Kitaplarda ve kütüphanelerde target değerine etiket (label) de denir.

Bu dataset’te tek bir feature var: metrekare. Gerçek veride oda sayısı, bina yaşı ve semt gibi onlarca feature olabilir.

X matrisi ve y vektörü

Dataset’i bir $X$ matrisi ve bir $\mathbf{y}$ vektörüyle yazarız. $N$ örnekli ve $d$ feature’lı bir dataset’te boyutlar şöyledir:

• $X$, $N \times d$ boyutlu bir matristir. Her satırı bir örneğin feature’larıdır.
• $\mathbf{y}$, $N$ elemanlı bir vektördür. Her elemanı bir örneğin target değeridir.

Bizim dataset’imizde $N = 4$ ve $d = 1$. NumPy’da şöyle yazarız:

import numpy as npX = np.array([[40.0], [60.0], [80.0], [100.0]])  # 4 örnek, 1 featurey = np.array([10.0, 15.0, 17.0, 22.0])           # her örneğin target değerin, d = X.shapeprint(n, d)         # → 4 1print(y.shape)      # → (4,)print(X[2], y[2])   # → [80.] 17.0

X[2] üçüncü örneği verir, çünkü indeks 0’dan başlar. X’in shape’i (n, d), y’nin shape’i (n,) olur.

Bu derste ve problemlerde y hep tek boyutlu bir array’dir. Onu (n, 1) biçiminde bir sütunla karıştırma.

Parametreli bir fonksiyon

Bir model, parametrelerine bağlı bir fonksiyondur.

Model ve parametreler

Bir tahmin kuralıyla başlayalım: her metrekare için 0,2 bin TL, üstüne 2 bin TL.

80 metrekarelik bir ev için bu kural $0{,}2 \cdot 80 + 2 = 18$ bin TL der. Gerçek kira 17 bin TL. Kural biraz yanılıyor ama kötü sayılmaz.

Kuralın iki parçası var:

• Biçim sabittir: bir çarpma, bir toplama.
• Sayılar değişebilir: 0,2 ve 2. Bunlar modelin parametreleridir.

Başka iki sayı seçersek aynı ev için başka bir tahmin alırız.

Bunu genel biçimde yazalım. Model, $x$ girdisini ve parametreleri alıp tahmin üreten bir $f$ fonksiyonudur. Parametreleri $\theta$ (teta) ile gösteririz.

Noktalı virgülden sonra gelenler ayarlanabilir sayılardır. $x$ aynı kalırken $\theta$ değişirse tahmin de değişir. $\hat{y}$ “y şapka” diye okunur ve tahmini gerçek $y$‘den ayırır.

Kodda $f$, girdiyi ve parametreleri alan bir fonksiyondur:

def f(x, w, b):    return w * x + b   # biçim sabit, w ve b değişebilirprint(f(80, 0.2, 2))   # → 18.0print(f(80, 0.3, 1))   # → 25.0 (aynı ev, başka parametre, başka tahmin)

Doğrusal model

En basit seçim düz bir çizgidir. Bu durumda $\theta$ iki sayıdan oluşur, $w$ ve $b$:

Formül, girdiyi $w$ ile çarpar ve sonuca $b$ ekler. İki parametrenin birer adı var:

• $w$, yani ağırlık (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.: $x$ bir birim artınca tahmin $w$ kadar değişir. Bu, feature’ın tahmin üzerindeki etkisidir. Örneğimizde $w$, her ek metrekarenin kirayı kaç bin TL artırdığıdır.
• $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.: feature 0 iken modelin verdiği tahmindir. Sıfır metrekarelik bir ev olmaz. $b$ burada çizgiyi yukarı ya da aşağı kaydıran bir ayardır.

Dört evin metrekaresine üç farklı çizgi uygulayalım:

# np, X ve y: ilk bloktaki dört evx = X[:, 0]               # metrekare sütunuprint(x)                  # → [ 40.  60.  80. 100.]print(0.2 * x + 2)        # → [10. 14. 18. 22.]  w = 0.2, b = 2print(0.3 * x + 2)        # → [14. 20. 26. 32.]  w büyüdü: çizgi dikleştiprint(0.2 * x + 5)        # → [13. 17. 21. 25.]  b büyüdü: çizgi yukarı kaydı

Birden çok feature

Birden çok feature’da her feature’ın kendi weight’i olur. Metrekareye oda sayısını da ekleyelim ve $w_1 = 0{,}2$, $w_2 = 1$, $b = 2$ seçelim. İki evin tahmini şöyle çıkar:

• 80 metrekare, 3 oda: $0{,}2 \cdot 80 + 1 \cdot 3 + 2 = 21$ bin TL.
• 50 metrekare, 1 oda: $0{,}2 \cdot 50 + 1 \cdot 1 + 2 = 13$ bin TL.

Bütün örnekleri tek seferde yazmanın yolu matris biçimidir. $X$‘in her satırını weight vektörü $\mathbf{w}$ ile çarpıp toplarız. Sonuca $b$‘yi ekleriz:

İki evimiz için bu, yukarıdaki iki hesabın aynısıdır:

Boyutlar uyuşur:

• $X$ matrisi $N \times d$‘dir.
• $\mathbf{w}$ vektörü $d$ elemanlıdır.
• Sonuç, her örnek için bir tahmin içeren $N$ elemanlı $\hat{\mathbf{y}}$ vektörüdür.

$b$ tek bir sayıdır ve her tahmine eklenir.

Matris biçimi tek bir fonksiyona sığar:

# np ve X: ilk bloktandef predict(X: np.ndarray, w: np.ndarray, b: float) -> np.ndarray:    return X @ w + b   # her örnek için bir tahminX_rooms = np.array([[80.0, 3.0],    # 80 metrekare, 3 oda                    [50.0, 1.0]])   # 50 metrekare, 1 odaw = np.array([0.2, 1.0])b = 2.0print(X_rooms @ w)              # → [19. 11.]print(predict(X_rooms, w, b))   # → [21. 13.]print(X_rooms.shape, w.shape)   # → (2, 2) (2,)# Tek feature'da w, bir elemanlı bir vektördür.print(predict(X, np.array([0.2]), 2.0))   # → [10. 14. 18. 22.]

Modelin hatası

Bir örnekteki hata

Bir örnekteki hata, tahmin eksi gerçek değerdir: $\hat{y}_i - y_i$. Hatanın işareti iki durumdan birini gösterir:

• Tahmin gerçek değerin üstündeyse hata pozitiftir.
• Tahmin gerçek değerin altındaysa hata negatiftir.

Farkı hep bu sırayla alırız.

Kuralımıza A modeli diyelim: $w = 0{,}2$ ve $b = 2$. Dört evin tahmini ve hatası şöyle:

Tahminler gerçek kiralara yakın ve hatalar küçük: 0, −1, 1 ve 0 bin TL.

# x ve y: önceki bloklardany_hat_a = 0.2 * x + 2     # A modelinin tahminlerierror_a = y_hat_a - y     # tahmin eksi gerçek değerprint(y_hat_a)            # → [10. 14. 18. 22.]print(error_a)            # → [ 0. -1.  1.  0.]

Hataların toplamı neden yetmez

Bir de metrekareye hiç bakmayan bir model deneyelim. Bu model, ev ne kadar büyük olursa olsun hep aynı kirayı söyler. Ona B modeli diyelim.

B için $w = 0$ ve $b = 16$; 16, dört kiranın ortalamasıdır.

Hataların toplamı iki modeli ayıramaz. B, A’dan açıkça daha kötüdür: en büyük iki hatası 6 ve −6 bin TL.

Yine de hataları toplarsak ikisi de aynı sonucu verir:

• A için $0 - 1 + 1 + 0 = 0$.
• B için $6 + 1 - 1 - 6 = 0$.

Pozitif ve negatif hatalar birbirini götürür. Hataların kendisinin ortalaması bu iki modeli birbirinden ayıramaz.

# x, y ve error_a: önceki bloklardany_hat_b = 0.0 * x + y.mean()   # B modeli: w = 0, b = dört kiranın ortalamasıerror_b = y_hat_b - yprint(y.mean())                # → 16.0print(error_b)                 # → [ 6.  1. -1. -6.]print(error_a.sum(), error_b.sum())     # → 0.0 0.0print(error_a.mean(), error_b.mean())   # → 0.0 0.0

Loss: hataları tek bir sayıya indirmek

Bir modele iyi ya da kötü diyebilmek için tek bir sayı gerekir. Bu sayı dört hatanın hepsini özetler. Ona loss diyoruz ve $L$ ile gösteriyoruz.

Loss küçüldükçe model bu veriye daha iyi uyar. Geriye hataları nasıl özetleyeceğimizi seçmek kalıyor.

Neden kare?

Yaygın çözüm, hatayı toplamadan önce karesini almaktır. Böylece hataların işaretleri birbirini götürmez.

Ortalama kare hata

Kare hataların ortalamasını iki model için alalım:

Bu hesabın adı ortalama kare hata (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.:

Formül üç adım söyler:

1. Her örneğin hatasının karesini al.
2. Kareleri topla.
3. Toplamı $N$‘ye böl.

Toplam sembolü ($\Sigma$), $i$ 1’den $N$‘ye kadar giderken yanındaki ifadeyi toplar.

MSE’nin değeri şunu söyler:

• Küçük MSE: tahminler bu veride gerçek değerlere yakındır.
• MSE 0: her tahmin tam isabettir.

A’nın loss’u 0,5, B’nin 18,5’tir. Artık iki modeli açıkça ayırabiliriz.

B modeli için üç adım kodda şöyle görünür:

# y ve error_b: önceki bloktansquares = error_b ** 2      # 1. her hatanın karesitotal = squares.sum()       # 2. kareleri toplaloss = total / len(y)       # 3. toplamı N'ye bölprint(squares)              # → [36.  1.  1. 36.]print(total)                # → 74.0print(loss)                 # → 18.5

Aynı üç adım tek bir fonksiyona sığar:

# y_hat_a, y_hat_b ve y: önceki bloklardandef mse(y_hat: np.ndarray, y: np.ndarray) -> float:    return float(np.mean((y_hat - y) ** 2))print(mse(y_hat_a, y))   # → 0.5print(mse(y_hat_b, y))   # → 18.5

Ortalama mutlak hata

İşareti ortadan kaldırmanın bir yolu daha var: mutlak değer. Ortalama mutlak hata (mean absolute error, MAE), hataların mutlak değerinin ortalamasıdır.

MAE de iki modeli ayırır. Büyük hataları MSE kadar ağır cezalandırmaz. Bu yüzden aykırı değerlerin (outlier) çok olduğu verilerde tercih edilebilir.

# y_hat_a, y_hat_b ve y: önceki bloklardandef mae(y_hat: np.ndarray, y: np.ndarray) -> float:    return float(np.mean(np.abs(y_hat - y)))print(mae(y_hat_a, y))   # → 0.5print(mae(y_hat_b, y))   # → 3.5

Doğruyu iki tutamaçla sürükle, karelerin alanını ve MSE ile MAE’nin nasıl değiştiğini izle.

Karenin üç özelliği

Kare almanın işimize yarayan üç özelliği var:

• İşaretler birbirini götürmez. Kare hiçbir zaman negatif değildir; 6 ile −6, ikisi de 36 verir. Mutlak değer de bunu sağlar. Kareyi tercih ettiren, aşağıdaki iki özelliktir.
• Büyük hatalar daha ağır sayılır. Hata iki katına çıkınca kare hata dört katına çıkar. B’nin 6 bin TL’lik hatası, 1 bin TL’lik hatasından altı kat büyüktür. Kare hata olarak 36 kat sayılır. Toplam 74’ün 72’si bu iki büyük hatadan gelir.
• Loss eğrisi düzgündür. $(\hat{y} - y)^2$, hata sıfıra yaklaşırken yumuşakça azalır. Her noktada bir eğimi vardır. $|\hat{y} - y|$ ise sıfırda keskin bir köşe yapar. Bir sonraki derste parametreleri eğime bakarak ayarlayacağız. Bu yüzden düzgün bir eğri işimizi kolaylaştırır.

İkinci özelliği B’nin kare hatalarında görebilirsin:

# squares: B modelinin kare hataları, MSE bloğundanerrors = np.array([1.0, 2.0, 3.0, 6.0])print(errors ** 2)               # → [ 1.  4.  9. 36.]  ceza, hatanın karesi kadarprint(squares[[0, 3]].sum())     # → 72.0  B'nin iki büyük hatasıprint(squares.sum())             # → 74.0  bütün hataların toplamı

Öğrenme bir arama işidir

Öğrenme, loss’u en küçük yapan parametreleri aramaktır. Önceki bölümlerde parametreleri biz seçtik ve loss’u hesapladık. Burada veri sabit kalır, parametreler değişir.

Parametreyi değiştirmek

$b = 2$‘yi sabit tutup yalnızca $w$‘yi değiştirelim. Her değer için dört evin MSE’sini hesaplayalım.

$w$ değişirken MSE bir çanak çizer. Tablodaki en düşük değer 0,2’dedir. İki yana gidildikçe MSE hızla yükselir.

Tablonun tamamı kısa bir döngüyle çıkar:

# x, y ve mse: önceki bloklardanfor w in [0.1, 0.15, 0.2, 0.25, 0.3]:    y_hat = w * x + 2                # b = 2 sabit    print(w, round(mse(y_hat, y), 2))# → 0.1 53.5# → 0.15 13.5# → 0.2 0.5# → 0.25 14.5# → 0.3 55.5

Loss, parametrelerin fonksiyonudur

Burada $b$ de değişebilirdi. İki parametreyle loss $L(w, b)$ olur ve çanak biçimli bir yüzeye dönüşür. $\theta$ bütün parametreleri birden gösteriyorsa loss $L(\theta)$ olur.

Veri ve model sabitken loss yalnızca parametrelere bağlıdır:

Formüldeki iki terim veriden gelir ve değişmez:

• $\mathbf{x}_i$, $X$‘in $i$. satırıdır: $i$. örneğin feature’ları.
• $y_i$, aynı örneğin target değeridir.

Ayarlayabileceğimiz tek şey $\theta$‘dır. Kodda bu, X ve y’yi sabit tutan, yalnızca w ve b’yi alan bir fonksiyondur:

# X, y, predict ve mse: önceki bloklardandef loss(w: np.ndarray, b: float) -> float:    return mse(predict(X, w, b), y)   # X ve y sabit, yalnızca w ve b değişirprint(round(loss(np.array([0.2]), 2.0), 2))    # → 0.5   A modeliprint(round(loss(np.array([0.0]), 16.0), 2))   # → 18.5  B modeliprint(round(loss(np.array([0.19]), 2.7), 2))   # → 0.45  en iyi parametreler

Bu veri için en iyi parametreler $w = 0{,}19$ ve $b = 2{,}7$ olur. MSE 0,45’e iner. A modeli (0,5) buna çok yakındır ama en iyisi değildir.

$b$ de serbest kalınca en iyi $w$ biraz küçülür. Bu değerlerin nasıl bulunduğunu Doğrusal regresyon dersinde göreceksin.

Gerçek modellerde

Gerçek modellerde loss bu kadar basit değildir. Parametreler milyonlarca olabilir. Loss’un parametrelere bağlı biçimi çok daha karmaşıktır.

Fikir yine aynıdır. Bir loss function seçersin ve parametreleri onu küçültecek biçimde ayarlarsın. Parametreleri rastgele denemek bu ölçekte işe yaramaz.

Bunun yerine bir yöntem kullanırız: gradyan inişi (gradient descent)gradyan inişi (gradient descent): Kaybı azaltmak için parametreleri gradyanın tersine küçük adımlarla güncelleyen yöntem.. Bu yöntem loss’un eğimine bakar ve çanağın dibine doğru küçük adımlar atar.

Bir sonraki ders olan Gradyan inişi onu sıfırdan kuruyor.

Özet

• Bir dataset örneklerden oluşur. $X$‘in her satırı bir örneğin feature’larını, $\mathbf{y}$‘nin her elemanı bir örneğin target değerini taşır.
• Model, parametrelerine bağlı bir $f(x;\, \theta)$ fonksiyonudur. Doğrusal modelde tahmin $\hat{y} = wx + b$ olur. Birden çok feature’da $\hat{\mathbf{y}} = X\mathbf{w} + b$ olur.
• Hataların kendisinin ortalaması, işaretler birbirini götürdüğü için yanıltır. MSE hataların karesinin ortalamasını alır. Büyük hataları daha ağır sayar ve düzgün bir eğri verir.
• Veri sabitken loss yalnızca parametrelere bağlıdır. Öğrenmek, loss’u en küçük yapan parametreleri aramaktır.

Terimler