Makine öğrenmesinin temel kavramları

Bakü'deki bir dairenin fiyatını alanına, oda sayısına ve semtine göre tahmin eden bir program yazman gerektiğini düşün. Bütün kuralları elle yazmak imkânsızdır: “semt Nesimi ise ve alan 80 m²'den büyükse...” gibi koşulların sonu gelmez. Makine öğrenmesi başka bir yol sunar: bilgisayara satılmış binlerce dairenin örneğini veririz, o da kuralı verilerden kendisi öğrenir. Bu ders, modülün tamamının matematiksel temelidir: sinir ağları, CNN'ler ve transformerlar hep bunun üzerine kuruludur.

Öğrenme türleri, öznitelikler ve etiketler

Her örnek bir öznitelik (feature) vektörü x ile tanımlanır: bir daire için alan, oda sayısı, kat. Tahmin etmek istediğimiz büyüklük etikettir (label) y: fiyat. n örnek ve d öznitelik olduğunda veri, n × d boyutlu bir X matrisi ve n uzunluğunda bir y vektörü olarak saklanır. Etiket bir sayıysa görev regresyon, bir sınıfsa (spam / spam değil) sınıflandırma adını alır.

Verinin bölünmesi: eğitim, doğrulama ve test kümeleri

Bir modelin gerçek sınavı, hiç görmediği verilerdir. Bu yüzden veriyi rastgele karıştırıp üç parçaya böleriz (tipik oran 70/15/15 ya da 80/10/10):

• Eğitim kümesi — parametreler yalnızca bu veriyle öğrenilir.
• Doğrulama kümesi — hiperparametreleri (öğrenme oranı, model boyutu) seçmek ve eğitimi ne zaman durduracağımıza karar vermek için.
• Test kümesi — en sonda, bir kez: modelin gerçek dünyadaki başarısının yansız bir tahmini.

import numpy as np

rng = np.random.default_rng(42)
idx = rng.permutation(10)
train, val, test = idx[:6], idx[6:8], idx[8:]
print('train:', train)
print('val:  ', val)
print('test: ', test)

train: [5 6 0 7 3 2]
val:   [4 9]
test:  [1 8]

Kayıp fonksiyonları

Modelin ne kadar yanıldığını tek bir sayıyla ölçmemiz gerekir; bu sayıyı kayıp fonksiyonu L verir. Öğrenme, kaybı en küçük yapan parametreleri aramaktır. Regresyonda genellikle ortalama karesel hata, sınıflandırmada ise çapraz entropi kullanılır.

import numpy as np

y = np.array([3.0, 5.0, 2.5])
y_hat = np.array([2.5, 5.0, 3.5])
mse = np.mean((y - y_hat) ** 2)
print(f'MSE = {mse:.4f}')

p = np.array([0.7, 0.2, 0.1])
print(f'CE (true class 0) = {-np.log(p[0]):.4f}')
print(f'CE (true class 2) = {-np.log(p[2]):.4f}')

MSE = 0.4167
CE (true class 0) = 0.3567
CE (true class 2) = 2.3026

Gradyan inişi ve öğrenme oranı

Sisli bir dağdan indiğini düşün: uzağı göremiyorsun ama ayağının altındaki eğimi hissediyorsun. En dik iniş yönünde küçük bir adım atıyor ve bunu tekrarlıyorsun. Gradyan ∇L, kaybın en hızlı arttığı yönü gösterir; bu yüzden onun tersine gideriz. Adımın uzunluğunu öğrenme oranı η belirler.

Doğrusal regresyonda ŷᵢ = w · xᵢ + b ve L = MSE'dir. Zincir kuralıyla (ŷᵢ − yᵢ)² ifadesinin w'ye göre türevi 2(ŷᵢ − yᵢ) · xᵢ, b'ye göre türevi ise 2(ŷᵢ − yᵢ) olur. Tüm örnekler üzerinden ortalama alırsak:

Şimdi aynı fikri 50 sentetik noktaya uygulayalım. Veri, y = 3x + 4 doğrusuna gürültü eklenerek üretildi; model w ve b'yi hiçbir şey bilmeden, sıfırdan başlayarak bulmalı. Kodu çalıştır; kayıp grafiği otomatik olarak gösterilecek.

import numpy as np
import matplotlib.pyplot as plt

rng = np.random.default_rng(42)
x = rng.uniform(0, 5, size=50)
y = 3 * x + 4 + rng.normal(0, 1, size=50)

w, b, lr = 0.0, 0.0, 0.05
losses = []
for epoch in range(500):
    error = (w * x + b) - y
    losses.append(np.mean(error ** 2))
    dw = 2 * np.mean(error * x)
    db = 2 * np.mean(error)
    w -= lr * dw
    b -= lr * db
    if epoch % 100 == 0:
        print(f'epoch {epoch:3d}  loss {losses[-1]:.4f}')

print(f'w = {w:.3f}, b = {b:.3f}')
plt.plot(losses)
plt.yscale('log')
plt.xlabel('epoch')
plt.ylabel('MSE loss')
plt.show()

epoch   0  loss 158.9249
epoch 100  loss 0.6019
epoch 200  loss 0.5740
epoch 300  loss 0.5735
epoch 400  loss 0.5735
w = 3.024, b = 3.769

Uygulamada gradyan her adımda verinin tamamı üzerinden değil, B boyutunda küçük bir mini yığın (mini-batch, örneğin B = 32) üzerinden hesaplanır. Buna stokastik gradyan inişi (SGD) denir: adımlar daha gürültülü ama çok daha ucuzdur; gürültü bazen kötü yerel minimumlardan kaçmaya bile yardım eder.

Aşırı öğrenme, eksik öğrenme ve yanlılık–varyans dengesi

Çok basit bir model verideki örüntüyü yakalayamaz; buna eksik öğrenme (underfitting) denir. Çok karmaşık bir model ise örüntüyle birlikte rastgele gürültüyü de ezberler: eğitim hatası neredeyse sıfırdır ama yeni verideki hatası büyüktür; buna aşırı öğrenme (overfitting) denir. Aşağıdaki kod, sin(2πx) fonksiyonundan alınmış 15 gürültülü noktaya farklı dereceli polinomlar uydurur:

import numpy as np
from numpy.polynomial import Polynomial

rng = np.random.default_rng(1)
x_train = np.sort(rng.uniform(0, 1, 15))
x_val = np.sort(rng.uniform(0, 1, 15))
f = lambda x: np.sin(2 * np.pi * x)
y_train = f(x_train) + rng.normal(0, 0.2, 15)
y_val = f(x_val) + rng.normal(0, 0.2, 15)

for deg in [1, 3, 9, 12]:
    model = Polynomial.fit(x_train, y_train, deg)
    train_mse = np.mean((model(x_train) - y_train) ** 2)
    val_mse = np.mean((model(x_val) - y_val) ** 2)
    print(f'degree {deg:2d}: train {train_mse:.3f}, validation {val_mse:.3f}')

degree  1: train 0.264, validation 0.235
degree  3: train 0.032, validation 0.037
degree  9: train 0.008, validation 1.894
degree 12: train 0.005, validation 67.532