Biyolojik bir nöron; sinyalleri dendritleriyle alır, hücre gövdesinde bir araya getirir ve yeterli uyarılma oluşursa akson üzerinden başka hücrelere iletir. Bu süreç birebir kopyalanmasa da temel fikir matematiksel bir modele dönüştürülebilir.
| Biyolojik yapı | Perceptrondaki karşılığı | Görevi |
|---|---|---|
| Dendrit | Girdi $x_i$ | Dışarıdan bilgi alır |
| Sinaps | Ağırlık $w_i$ | Sinyalin önemini belirler |
| Hücre gövdesi | Ağırlıklı toplam | Girdileri birleştirir |
| Ateşleme eşiği | Aktivasyon fonksiyonu | Çıkış kararını üretir |
| Akson | Tahmin $y$ | Sonucu sonraki birime taşır |
1943 yılında Warren McCulloch ve Walter Pitts, nöron davranışını mantıksal işlemlerle açıklayan ilk matematiksel modellerden birini geliştirdi. Frank Rosenblatt ise 1957’de bu fikri öğrenebilen bir yapıya dönüştürerek perceptronu tanıttı.
Perceptron, her girdiyi ilgili ağırlıkla çarpar, sonuçları toplar ve bias adı verilen ek değeri ekler:
\[z = w_1x_1 + w_2x_2 + \cdots + w_nx_n + b\]Ardından basamak aktivasyon fonksiyonu uygulanır:
\[y = \begin{cases} 1, & z \geq 0 \\ 0, & z < 0 \end{cases}\]Ağırlıklar girdilerin önemini, bias ise karar sınırının konumunu kontrol eder. Modelin yaptığı şey aslında şudur: “Toplam kanıt yeterince güçlüyse 1, değilse 0 de.” Bir e-postanın spam olup olmadığını düşünürsek “ücretsiz”, “ödül” ve “hemen tıkla” gibi özellikler girdileri temsil edebilir.
Perceptron başlangıçta doğru ağırlıkları bilmez. Her örnek için tahmin üretir ve hata yaptığında ağırlıklarını günceller:
\[w_i \leftarrow w_i + \eta(t-y)x_i\] \[b \leftarrow b + \eta(t-y)\]Burada $t$ gerçek etiket, $y$ tahmin ve $\eta$ öğrenme oranıdır. Öğrenme oranı, düzeltme adımlarının ne kadar büyük olacağını belirler. Model doğru tahmin yaptığında $t-y=0$ olur ve ağırlıklar değişmez.
Aşağıdaki Python kodu, AND mantık kapısını öğrenen basit bir perceptron kurar:
import numpy as np
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
t = np.array([0, 0, 0, 1])
w = np.zeros(2)
b = 0.0
learning_rate = 0.1
for epoch in range(10):
for x, target in zip(X, t):
z = np.dot(w, x) + b
prediction = 1 if z >= 0 else 0
error = target - prediction
w += learning_rate * error * x
b += learning_rate * error
print("Ağırlıklar:", w)
print("Bias:", b)
Kod, her eğitim örneğinde tahmin ile gerçek değer arasındaki farkı hesaplar. Hata varsa ağırlıklar ve bias, doğru sınıfa yaklaşacak yönde değiştirilir.
Perceptronun karar sınırı iki boyutta bir doğru, üç boyutta bir düzlem ve daha yüksek boyutlarda bir hiperdüzlemdir:
\[w_1x_1 + w_2x_2 + b = 0\]Sınıflar tek bir doğruyla birbirinden ayrılabiliyorsa veri doğrusal ayrılabilir kabul edilir.
| Mantık kapısı | Doğrusal ayrılabilir mi? | Tek perceptron öğrenebilir mi? |
|---|---|---|
| AND | Evet | Evet |
| OR | Evet | Evet |
| XOR | Hayır | Hayır |
XOR probleminde aynı sınıfa ait noktalar çapraz köşelerde bulunur; bu nedenle tek bir doğru yeterli olmaz. Bu sınırlama, yapay zekâ tarihinde büyük bir hayal kırıklığı yaratmış olsa da çözüm yeni bir kapı açtı: Birden fazla perceptronu katmanlar hâlinde birleştirmek. Gizli katmanlar ve doğrusal olmayan aktivasyonlar sayesinde çok katmanlı sinir ağları karmaşık karar sınırları öğrenebilir.
Kısacası perceptron küçük bir matematiksel hücredir; ancak ağırlık, bias, öğrenme ve karar sınırı gibi bugün hâlâ kullandığımız temel kavramları taşır. Modern derin öğrenme sistemleri çok daha gelişmiş olsa da onların aile albümündeki ilk ciddi fotoğraflardan biri kesinlikle perceptrondur.
]]>``
Bir biyometrik sistem ham görüntüleri doğrudan karşılaştırmak yerine genellikle şablon adı verilen sayısal temsiller üretir. Parmak izinde çizgi sonları ve çatallanmalar; iriste ise doku frekansları, halkalar ve yerel desenler özellik olarak kullanılabilir.
Tipik işlem hattı şöyledir:
| Aşama | Parmak izi örneği | İris örneği |
|---|---|---|
| Ön işleme | Çizgileri belirginleştirme | Göz bebeğini ayırma |
| Özellik | Minutiae noktaları | Doku kodları |
| Sorun | Parmağın kayması | Göz kapağı ve yansıma |
| Temsil | Nokta ve yön listesi | İkili veya sayısal vektör |
İki özellik vektörü arasındaki uzaklık için Öklid uzaklığı kullanılabilir. Kayıtlı şablon $x$, yeni örnek $y$ ise:
\[d(x,y)=\sqrt{\sum_{i=1}^{n}(x_i-y_i)^2}\]Uzaklık küçüldükçe örnekler birbirine daha çok benzer. Benzerlik puanını $[0,1]$ aralığına taşımak için basitçe şu dönüşüm uygulanabilir:
\[s(x,y)=\frac{1}{1+d(x,y)}\]Karar kuralımız $s \geq t$ olabilir. Buradaki $t$ eşik değeridir. Eşiği yükseltmek güvenliği artırabilir ancak gerçek kullanıcıların reddedilmesine de yol açabilir.
| Eşik tercihi | Avantaj | Dezavantaj |
|---|---|---|
| Düşük | Kullanım daha rahat | Yanlış kabul artabilir |
| Yüksek | Yetkisiz kabul azalabilir | Yanlış ret artabilir |
| Dengeli | İki hata türünü dengeler | Test verisi gerektirir |
Aşağıdaki kod gerçek görüntüler yerine sentetik biyometrik vektörler kullanır. Böylece kişisel veri toplamadan eşleştirme mekanizmasını deneyebiliriz.
import numpy as np
class BiometricMatcher:
def __init__(self, threshold=0.80):
self.threshold = threshold
self.templates = {}
def enroll(self, user_id, features):
vector = np.asarray(features, dtype=float)
norm = np.linalg.norm(vector)
if norm == 0:
raise ValueError("Sıfır vektörü kaydedilemez.")
self.templates[user_id] = vector / norm
def verify(self, user_id, sample):
if user_id not in self.templates:
return False, 0.0
sample = np.asarray(sample, dtype=float)
norm = np.linalg.norm(sample)
if norm == 0:
return False, 0.0
sample = sample / norm
template = self.templates[user_id]
distance = np.linalg.norm(template - sample)
score = 1 / (1 + distance)
return score >= self.threshold, score
matcher = BiometricMatcher(threshold=0.80)
matcher.enroll("kullanici_42", [0.12, 0.77, 0.31, 0.55, 0.18])
accepted, score = matcher.verify(
"kullanici_42",
[0.11, 0.75, 0.34, 0.53, 0.20]
)
print(f"Kabul: {accepted}, skor: {score:.3f}")
enroll metodu özellik vektörünü normalize ederek saklar. verify ise yeni örnekle kayıtlı şablonun uzaklığını hesaplar. Normalizasyon, ölçüm ölçeğindeki farklılıkların etkisini azaltır; fakat gerçek sistemlerde dönüş, konum ve sensör kalitesi için çok daha gelişmiş işlemler gerekir.
Sistemi yalnızca “çalıştı” diyerek değerlendirmek yeterli değildir. FAR yetkisiz örneklerin kabul oranını, FRR ise gerçek kullanıcıların reddedilme oranını gösterir:
\[FAR=\frac{yanlış\ kabuller}{yetkisiz\ denemeler}\] \[FRR=\frac{yanlış\ retler}{gerçek\ kullanıcı\ denemeleri}\]Eşiği farklı değerlerde deneyerek bu iki metriği karşılaştırabiliriz. Ayrıca farklı sensör koşulları, gürültü seviyeleri ve kullanıcı gruplarıyla test yapmak olası yanlılıkları ortaya çıkarır.
Son olarak biyometrik veri parola gibi kolayca değiştirilemez. Bu nedenle ham görüntü saklamak yerine şifrelenmiş veya iptal edilebilir şablonlar kullanılmalı; açık rıza, veri minimizasyonu, erişim kontrolü ve silme politikaları tasarımın merkezinde olmalıdır. Küçük dedektifimiz zeki olabilir, ama aynı zamanda mahremiyete saygılı olmak zorundadır.
]]>``
Multi-Layer Perceptron (MLP), birbirine bağlı yapay nöronlardan oluşan ileri beslemeli bir sinir ağıdır. “İleri beslemeli” denmesinin nedeni, verinin girişten çıkışa doğru tek yönde ilerlemesidir. Döngü veya geçmiş durumu saklayan bir bağlantı bulunmaz.
Bir MLP genellikle üç bölümden oluşur:
| Katman | Görevi | Örnek |
|---|---|---|
| Girdi katmanı | Ham özellikleri kabul eder | Yaş, gelir, ürün fiyatı |
| Gizli katmanlar | Özellikleri dönüştürür ve örüntüleri öğrenir | Fiyat-gelir ilişkisini keşfetmek |
| Çıktı katmanı | Tahmin veya sınıf üretir | “Satın alır” olasılığı |
Girdi katmanında hesaplama genellikle yapılmaz; değerler yalnızca ilk gizli katmana aktarılır. Asıl öğrenme, ağırlık ve sapma değerlerini kullanan gizli katmanlarda gerçekleşir.
Bir nöron, kendisine ulaşan değerleri ağırlıklandırır ve toplar. Katman $l$ için bu işlem şöyle gösterilebilir:
\[z^{(l)} = W^{(l)}a^{(l-1)} + b^{(l)}\]Burada $W$ ağırlık matrisini, $a$ önceki katmanın çıktısını, $b$ ise sapma değerini temsil eder. Elde edilen $z$ değeri doğrudan sonraki katmana gönderilmez; önce bir aktivasyon fonksiyonundan geçirilir:
\[a^{(l)} = f(z^{(l)})\]Bu küçük görünen $f$ fonksiyonu son derece önemlidir. Aktivasyon kullanılmazsa, art arda eklenen katmanlar matematiksel olarak tek bir doğrusal dönüşüme indirgenir. Başka bir ifadeyle ağ çok katlı görünür, ancak tek katlı bir hesap makinesi gibi davranır.
Aktivasyon fonksiyonları MLP’nin eğri karar sınırları ve karmaşık ilişkiler öğrenmesini sağlar.
| Aktivasyon | Özellik | Yaygın kullanım |
|---|---|---|
| ReLU | $f(x)=max(0,x)$, hızlı ve basit | Gizli katmanlar |
| Sigmoid | Değeri 0 ile 1 arasına sıkıştırır | İkili sınıflandırma çıktısı |
| Tanh | Değeri -1 ile 1 arasına taşır | Bazı gizli katmanlar |
| Softmax | Sınıflar için olasılık dağılımı üretir | Çok sınıflı çıktı |
Örneğin XOR problemi tek bir doğrusal çizgiyle ayrılamaz. Gizli katmana ve doğrusal olmayan aktivasyona sahip bir MLP ise girdileri yeni bir temsil uzayına taşıyarak bu problemi çözebilir. Gizli katmanların “temsil öğrenmesi” denilen yeteneği tam olarak budur.
İleri besleme sırasında eğitim yapılmaz; mevcut ağırlıklarla tahmin hesaplanır. Veri her katmanda şu yolculuğu gerçekleştirir:
Aşağıdaki NumPy örneği, tek gizli katmanlı bir ağın ileri beslemesini gerçekleştirir:
import numpy as np
def relu(x):
return np.maximum(0, x)
x = np.array([0.8, 0.2])
W1 = np.array([[0.5, -0.3],
[0.7, 0.4],
[-0.2, 0.9]])
b1 = np.array([0.1, 0.0, -0.1])
W2 = np.array([[0.6, -0.5, 0.8]])
b2 = np.array([0.2])
hidden = relu(W1 @ x + b1)
output = W2 @ hidden + b2
print(output)
Burada W1 @ x girişleri gizli nöronlarla birleştirir, relu doğrusal olmayan dönüşümü uygular ve W2 @ hidden gizli temsilden sonucu hesaplar. Gerçek bir eğitim sürecinde çıktı ile hedef arasındaki hata ölçülür; geri yayılım da ağırlıkları günceller.
MLP’ler tablo verileri, sınıflandırma ve regresyon problemleri için güçlü bir başlangıç noktasıdır. Ancak katman veya nöron sayısını rastgele artırmak başarı garantisi değildir. Uygun veri ölçekleme, aktivasyon seçimi ve aşırı öğrenmeye karşı düzenlileştirme gerekir. Kısacası MLP, bilgiyi katman katman işleyen matematiksel bir montaj hattıdır; ileri besleme ise bu hattın girişten tahmine uzanan tek yönlü üretim turudur.
]]>``
Bir veri kümesindeki her örnek, özellikler ve hedef etiketten oluşur. Özellik vektörünü $x$, etiketi $y$ ile gösterirsek eğitim kümesi şu biçimdedir:
\[D = \{(x_1,y_1),(x_2,y_2),\ldots,(x_n,y_n)\}\]Amaç, gerçek ilişkiyi mümkün olduğunca iyi temsil eden $f(x)$ fonksiyonunu öğrenmektir. Sınıflandırmada çıktı ayrık bir sınıftır: spam veya normal, hasta veya sağlıklı gibi. Regresyonda ise ev fiyatı gibi sürekli bir değer tahmin edilir.
Modelin yalnızca eğitim örneklerini ezberlemesi yeterli değildir. Asıl başarı, görülmemiş veriler üzerinde doğru tahmin yapabilmesidir. Eğitim başarısı yüksek fakat test başarısı düşükse aşırı öğrenme, model iki tarafta da zayıfsa yetersiz öğrenme gündemdedir.
| Algoritma | Temel fikir | Güçlü yönü | Dikkat edilmesi gereken |
|---|---|---|---|
| k-NN | En yakın komşular oy verir | Basit ve sezgiseldir | Ölçeklendirmeye duyarlıdır |
| Karar Ağacı | Sorularla veriyi dallara ayırır | Kolay açıklanabilir | Aşırı öğrenebilir |
| SVM | Sınıflar arasındaki marjı büyütür | Karmaşık sınırlarda etkilidir | Parametre seçimi önemlidir |
k-NN, yeni bir örneğin eğitim kümesindeki en yakın $k$ komşusunu bulur ve çoğunluğun etiketini seçer. Öklid uzaklığı yaygın bir ölçüdür:
\[d(x,z)=\sqrt{\sum_{j=1}^{m}(x_j-z_j)^2}\]$k=1$ seçimi gürültüye karşı hassas olabilir; çok büyük $k$ ise farklı sınıfları birbirine karıştırabilir. Ayrıca yaş ile gelir gibi farklı ölçeklerdeki özellikler kullanılacaksa standartlaştırma yapılmalıdır. Aksi hâlde büyük sayılara sahip özellik, mesafe hesabının megafonunu ele geçirir.
Karar ağacı, veriyi art arda sorularla böler. Örneğin “Gelir 40.000’den yüksek mi?” sorusu iki dal oluşturabilir. En faydalı bölünmeyi belirlemek için Gini safsızlığı kullanılabilir:
\[Gini = 1-\sum_{i=1}^{C}p_i^2\]Saf bir düğümde örneklerin tamamı aynı sınıftadır. Ağacın kontrolsüz büyümesi ezberlemeye yol açabileceğinden max_depth ve min_samples_split gibi sınırlar önemlidir.
SVM, sınıfları ayıran bir hiper düzlem bulur ve bu düzlemle en yakın örnekler arasındaki marjı en büyük yapmaya çalışır. Kararı belirleyen kritik örneklere destek vektörleri denir. Doğrusal ayrım mümkün değilse RBF gibi çekirdekler, veriyi açıkça dönüştürmeden daha karmaşık karar sınırları kurabilir. C parametresi hatalara verilen cezayı, gamma ise tek bir örneğin etki alanını kontrol eder.
Aşağıdaki kod, özellikleri standartlaştırır ve modelleri aynı test kümesinde değerlendirir:
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42
)
models = {
"k-NN": make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)),
"Karar Ağacı": DecisionTreeClassifier(max_depth=4, random_state=42),
"SVM": make_pipeline(StandardScaler(), SVC(kernel="rbf"))
}
for name, model in models.items():
model.fit(X_train, y_train)
print(name, model.score(X_test, y_test))
Doğruluk tek başına her zaman yeterli değildir. Dengesiz sınıflarda kesinlik, duyarlılık, F1 skoru ve karmaşıklık matrisi de incelenmelidir. Sonuçta en iyi algoritma diye evrensel bir şampiyon yoktur; veri yapısına, açıklanabilirlik ihtiyacına ve hata maliyetine en uygun yarışmacı vardır.
]]>Denetimli öğrenmede modele hem özellikler hem de doğru cevaplar verilir. Denetimsiz öğrenmede ise yalnızca $X = {x_1, x_2, …, x_n}$ gözlemleri bulunur. Algoritma, gözlemler arasındaki uzaklık veya benzerlik ilişkilerinden yararlanarak gizli yapıyı keşfetmeye çalışır.
| Özellik | Denetimli öğrenme | Denetimsiz öğrenme |
|---|---|---|
| Etiket | Vardır | Yoktur |
| Temel amaç | Tahmin yapmak | Yapı keşfetmek |
| Örnek görev | Spam sınıflandırma | Müşteri segmentasyonu |
| Değerlendirme | Accuracy, F1 | Silhouette, küme içi varyans |
Kümelemenin kalbi benzerlik ölçümüdür. Sayısal verilerde sık kullanılan Öklid uzaklığı iki nokta için şöyle hesaplanır:
\[d(x,y)=\sqrt{\sum_{j=1}^{m}(x_j-y_j)^2}\]Ölçekler farklıysa uzaklık yanıltıcı olabilir. Örneğin yaş 18–70, gelir ise binlerce birim aralığındaysa gelir özelliği hesaplamayı domine eder. Bu nedenle standardizasyon çoğu zaman zorunludur.
K-Means, veriyi önceden belirlenen $K$ adet kümeye ayırır. Önce rastgele merkezler seçer, her noktayı en yakın merkeze atar, ardından merkezleri yeniden hesaplar. Atamalar değişmeyene kadar bu döngü sürer.
Amaç fonksiyonu, noktaların kendi küme merkezlerine uzaklıklarının karelerini küçültmektir:
\[J=\sum_{k=1}^{K}\sum_{x_i \in C_k}\lVert x_i-\mu_k\rVert^2\]Aşağıdaki örnek müşterileri yıllık gelir ve harcama puanına göre gruplar:
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
X = customers[['annual_income', 'spending_score']]
X_scaled = StandardScaler().fit_transform(X)
model = KMeans(n_clusters=3, random_state=42, n_init=10)
customers['cluster'] = model.fit_predict(X_scaled)
print(model.cluster_centers_)
StandardScaler, özellikleri karşılaştırılabilir ölçeğe getirir. fit_predict modeli eğitir ve her müşteriye bir küme numarası atar. Ancak bu numaralar sıralama ifade etmez; “küme 2”, “küme 1”den daha iyi değildir.
Doğru $K$ değerini seçmek için dirsek yöntemi veya Silhouette skoru kullanılabilir. Silhouette değeri $-1$ ile $1$ arasındadır; değerin $1$’e yaklaşması, kümelerin daha belirgin ayrıldığını gösterir.
Hiyerarşik kümeleme, kümelerin iç içe geçmiş ilişkilerini bir dendrogram üzerinde gösterir. Birleştirici yaklaşımda her gözlem başlangıçta ayrı bir kümedir; en yakın kümeler adım adım birleşir. Bölücü yaklaşım ise tüm veriyi tek kümeden başlayarak parçalar.
from scipy.cluster.hierarchy import linkage, dendrogram
import matplotlib.pyplot as plt
Z = linkage(X_scaled, method='ward')
dendrogram(Z)
plt.ylabel('Birleşme uzaklığı')
plt.show()
Ward yöntemi, birleşmeler sonucunda oluşan küme içi varyans artışını düşük tutmaya çalışır. Dendrogramın uzun dikey boşluklarından yatay kesilmesi, makul küme sayıları hakkında görsel ipucu verir.
| Ölçüt | K-Means | Hiyerarşik kümeleme |
|---|---|---|
| Küme sayısı | Başta belirtilir | Sonradan seçilebilir |
| Çıktı | Düz küme etiketleri | Dendrogram ve etiketler |
| Hız | Büyük veride genellikle hızlı | Büyük veride maliyetli |
| Küme şekli | Küresel kümelerde başarılı | Bağlantı yöntemine bağlı |
| Aykırı değer | Hassas | Yönteme göre hassas |
Büyük, sayısal ve yaklaşık küresel gruplara sahip verilerde K-Means iyi bir başlangıçtır. Küme sayısı bilinmiyorsa veya gruplar arasındaki soy ağacı benzeri ilişki incelenecekse hiyerarşik kümeleme daha açıklayıcıdır. Yine de sonuçlar mutlak gerçek olarak görülmemelidir. Özellik seçimi, ölçekleme, uzaklık metriği ve alan bilgisi değiştiğinde kümeler de değişebilir. Denetimsiz öğrenme sihirli bir etiket makinesi değil; verinin fısıltılarını duyulur hâle getiren güçlü bir keşif aracıdır.
]]>Bir modelin amacı yalnızca eğitim hatasını küçültmek değil, daha önce görmediği örneklerde de başarılı olmaktır. Model gereğinden fazla karmaşıksa sınırlı sayıdaki eğitim verisine özel kurallar geliştirebilir. Örneğin çok derin bir karar ağacı, her yaprağa tek örnek düşene kadar dallanarak veriyi neredeyse ezberleyebilir.
Genelleme performansını anlamak için veri genellikle eğitim, doğrulama ve test kümelerine ayrılır. Eğitim kaybı azalırken doğrulama kaybının yükselmeye başlaması önemli bir alarmdır.
| Durum | Eğitim hatası | Doğrulama hatası | Yorum |
|---|---|---|---|
| Underfitting | Yüksek | Yüksek | Model fazla basit |
| İdeal öğrenme | Düşük | Düşük | Örüntüler genelleniyor |
| Overfitting | Çok düşük | Yüksek | Model ayrıntıları ezberliyor |
Bu problem, bias-variance dengesi ile de açıklanır. Basit modeller yüksek bias nedeniyle gerçek ilişkiyi kaçırırken aşırı karmaşık modeller yüksek variance nedeniyle veri değişikliklerine fazla duyarlı olur. Hedef, iki uç arasında uygun dengeyi bulmaktır.
Düzenlileştirme, standart kayıp fonksiyonuna büyük ağırlıkları cezalandıran bir terim ekler:
\[J = L(y, \hat{y}) + \lambda R(w)\]Burada $L$ tahmin hatası, $R(w)$ ceza fonksiyonu ve $\lambda$ cezanın gücüdür. Lambda büyüdükçe model daha sade davranır; ancak aşırı büyük bir değer underfitting yaratabilir.
| Yöntem | Ceza | Temel etkisi | ||
|---|---|---|---|---|
| L1 (Lasso) | $\lambda \sum_i | w_i | $ | Bazı ağırlıkları sıfırlar, özellik seçimi sağlar |
| L2 (Ridge) | $\lambda \sum_i w_i^2$ | Ağırlıkları küçültür, daha dengeli dağıtır |
L1, gereksiz özellikleri oyundan çıkaran sert bir teknik direktör gibidir. L2 ise oyuncuları kovmak yerine hepsinin egosunu küçültür. Birlikte kullanıldıklarında Elastic Net yaklaşımı ortaya çıkar.
Dropout, sinir ağlarında eğitim sırasında bazı nöronları rastgele geçici olarak devre dışı bırakır. Böylece ağ belirli nöronlara bağımlı olamaz ve farklı temsil yolları öğrenir. Bir nöronun tutulma olasılığı $p$ ise kabaca şu maske uygulanır:
\[h' = m \odot h, \quad m_i \sim Bernoulli(p)\]TensorFlow/Keras ile örnek bir ağ şöyle kurulabilir:
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout
model = Sequential([
Dense(128, activation="relu", input_shape=(50,)),
Dropout(0.4), # Eğitimde nöronların %40'ını geçici kapatır
Dense(64, activation="relu"),
Dropout(0.2),
Dense(1, activation="sigmoid")
])
Dropout yalnızca eğitim sırasında etkindir. Tahmin aşamasında tüm nöronlar kullanılır; kütüphane gerekli ölçeklemeyi otomatik olarak yönetir.
Erken durdurma, doğrulama kaybını izler ve iyileşme sona erdiğinde eğitimi durdurur. Böylece modelin eğitim verisini ezberlemeye başladığı bölgeye fazla ilerlenmez.
from tensorflow.keras.callbacks import EarlyStopping
stopper = EarlyStopping(
monitor="val_loss",
patience=5,
restore_best_weights=True
)
model.fit(
X_train, y_train,
validation_split=0.2,
epochs=100,
callbacks=[stopper]
)
patience=5, doğrulama kaybı beş dönem boyunca iyileşmezse eğitimi bitirir. restore_best_weights=True ise son ağırlıklar yerine en başarılı dönemin ağırlıklarını geri yükler.
Bu yöntemler rakip değil, takım arkadaşıdır. L1/L2 model ağırlıklarını sınırlar, Dropout nöron bağımlılığını azaltır, early stopping ise eğitim süresini kontrol eder. En iyi değerler doğrulama kümesi ve hiperparametre aramasıyla belirlenmelidir. Test kümesine sürekli bakmak ise test verisini de dolaylı biçimde ezberlemek demektir. Kısacası iyi model, sınav sorularını hatırlayan değil; konuyu öğrenip yeni soruları çözebilendir.
]]>``
Gerçek dünya verileri nadiren kullanıma hazır gelir. Yaş sütununda negatif değerler, şehir bilgisinde farklı yazımlar, sensör kayıtlarında boş hücreler veya gelir değişkeninde uç değerler bulunabilir. Veri ön işleme, bu sorunları model eğitilmeden önce sistematik biçimde düzeltme sürecidir.
Temel amaç, gözlenen veriyi gerçek olguyu daha iyi temsil eden bir forma dönüştürmektir. Bir ölçümün şu şekilde oluştuğunu düşünebiliriz:
\[x_{gözlenen} = x_{gerçek} + hata\]Temizleme işlemleri hata bileşenini azaltmaya çalışır. Ancak aşırı temizlik de bilgi kaybına yol açabilir. Örneğin yüksek tutarlı bir alışveriş kaydı veri hatası değil, gerçekten önemli bir müşteri davranışı olabilir.
| Sorun | Yaygın çözüm | Olası risk |
|---|---|---|
| Eksik değer | Ortalama, medyan veya modelle tahmin | Dağılımın bozulması |
| Uç değer | Sınırlandırma veya dönüşüm | Nadir olayların kaybedilmesi |
| Farklı ölçekler | Standardizasyon | Yorumlanabilirliğin azalması |
| Kategorik veri | One-hot encoding | Çok fazla sütun oluşması |
| Tutarsız metin | Normalleştirme | Anlamlı ayrımların silinmesi |
Eksik değerleri doğrudan silmek pratik görünse de veri azsa pahalı bir seçimdir. Sayısal değişkenlerde ortalama kullanılabilir; fakat uç değerlere karşı daha dayanıklı olduğu için medyan çoğu zaman güvenlidir. Kategorik alanlarda en sık sınıf veya Bilinmiyor gibi ayrı bir kategori tercih edilebilir.
Eksikliğin kendisi de bilgi taşıyabilir. Örneğin gelir bilgisini paylaşmayan müşterilerin davranışları farklı olabilir. Bu durumda hem değeri doldurmak hem de gelir_eksik_mi adlı ikili bir öznitelik oluşturmak yararlıdır.
import pandas as pd
veri['gelir_eksik_mi'] = veri['gelir'].isna().astype(int)
veri['gelir'] = veri['gelir'].fillna(veri['gelir'].median())
Bu kod, eksikliği işaretler ve gelir sütunundaki boşlukları medyanla doldurur. Böylece model hem sayısal değeri kullanabilir hem de eksiklik davranışını öğrenebilir.
Mesafe veya gradyan tabanlı algoritmalar değişken ölçeklerinden etkilenir. Bir sütun 0–1, diğeri 0–100.000 aralığındaysa büyük değerli değişken modele gereğinden fazla yön verebilir. Standardizasyon şu formülle yapılır:
\[z = (x - μ) / σ\]Burada $μ$ ortalama, $σ$ standart sapmadır. Sonuçta değişken yaklaşık sıfır ortalamaya ve birim standart sapmaya taşınır.
Kategorik veriler ise doğrudan sayısal sıraya çevrilmemelidir. İstanbul, Ankara ve İzmir’i 1, 2 ve 3 yapmak, modelde sahte bir büyüklük ilişkisi oluşturur. Sırasız kategoriler için one-hot encoding; doğal sırası bulunan eğitim seviyesi gibi alanlar için ordinal encoding daha uygundur.
Öznitelik mühendisliği, mevcut sütunlardan problemi daha iyi açıklayan yeni bilgiler üretmektir. Doğum tarihinden yaş, sipariş tarihinden hafta sonu bilgisi veya fiyat ve miktardan toplam harcama türetilebilir:
veri['toplam_harcama'] = veri['fiyat'] * veri['miktar']
veri['siparis_saati'] = veri['siparis_tarihi'].dt.hour
veri['hafta_sonu'] = veri['siparis_tarihi'].dt.dayofweek.isin([5, 6]).astype(int)
İyi bir öznitelik yalnızca matematiksel değil, alan bilgisine dayalıdır. Finans uygulamasında gelirden çok borç/gelir oranı anlamlı olabilir:
\[borç\ oranı = toplam\ borç / aylık\ gelir\]Ön işleme adımları yalnızca eğitim verisi üzerinde öğrenilmelidir. Tüm veri kümesinin ortalamasını kullanmak, test verisinden eğitim sürecine bilgi sızdırır. Bu nedenle önce eğitim-test ayrımı yapılmalı; doldurma, ölçekleme ve kodlama işlemleri bir pipeline içinde uygulanmalıdır.
Sonuç olarak kaliteli veri hazırlama; temizleme, eksik değer yönetimi, uygun dönüşüm ve yaratıcı öznitelik üretiminin birleşimidir. Modeli değiştirmeden önce veriye bakmak çoğu zaman en güçlü optimizasyondur: Çünkü iyi özellikler, algoritmanın dünyayı daha anlaşılır görmesini sağlar.
]]>Bir modelin tahminleri ile gerçek değerler arasındaki fark, kayıp fonksiyonu üzerinden ölçülür. Parametreleri $\theta$ ile gösterirsek amaç şu problemi çözmektir:
\[\theta^* = \arg\min_{\theta} J(\theta)\]Burada $J(\theta)$ hata yüzeyini, $\theta^*$ ise mümkün olan en düşük hatayı sağlayan parametreleri temsil eder. Gradyan, bu yüzeyde hatanın en hızlı arttığı yönü gösterir. Dolayısıyla hatayı azaltmak için gradyanın tersine ilerleriz:
\[\theta_{t+1} = \theta_t - \eta \nabla J(\theta_t)\]$\eta$ öğrenme oranıdır. Çok küçük seçilirse eğitim kaplumbağa hızına düşer; çok büyük seçilirse algoritma minimum noktanın üzerinden zıplayabilir.
Geleneksel Gradient Descent, her güncellemede bütün veri kümesini kullanır. Bu yöntem kararlı olsa da büyük veri kümelerinde pahalıdır. Stochastic Gradient Descent (SGD) her adımda tek örnek kullanır. Gürültülü hareket eder fakat yerel çukurlardan kaçmasına yardımcı olabilecek kadar hareketlidir. Mini-batch yaklaşımı ise küçük veri gruplarıyla çalışarak iki yöntemi dengeler.
| Yöntem | Güncelleme verisi | Avantaj | Dezavantaj |
|---|---|---|---|
| Batch Gradient Descent | Tüm veri | Kararlı gradyan | Yavaş ve bellek maliyetli |
| SGD | Tek örnek | Hızlı güncelleme | Fazla dalgalanma |
| Mini-batch SGD | Küçük grup | Paralelleştirmeye uygun | Batch boyutu ayarlanmalı |
Momentum, geçmiş gradyanları kullanarak güncellemelerin yönünü yumuşatır:
\[v_t = \beta v_{t-1} + (1-\beta)\nabla J(\theta_t)\] \[\theta_{t+1} = \theta_t - \eta v_t\]Bunu yokuş aşağı yuvarlanan bir top gibi düşünebiliriz. Top doğru yönde hız kazanırken sağa sola oluşan küçük salınımlar bastırılır. Özellikle uzun ve dar hata vadilerinde klasik SGD’den daha hızlı ilerler.
RMSprop, her parametre için gradyan karelerinin hareketli ortalamasını tutar:
\[s_t = \rho s_{t-1} + (1-\rho)g_t^2\]Güncelleme, $\theta_{t+1}=\theta_t-\eta g_t/(\sqrt{s_t}+\epsilon)$ biçimindedir. Sık ve büyük gradyan alan parametrelerin adımı küçülürken seyrek güncellenenlerin adımı görece büyür.
Adam, Momentum’un birinci moment tahminiyle RMSprop’un ikinci moment tahminini birleştirir. Ayrıca başlangıçtaki yanlılığı düzeltir. Böylece farklı ölçeklerdeki parametreler için otomatik uyarlanan adımlar üretir.
| Algoritma | Temel fikir | Güçlü olduğu durum | Dikkat edilmesi gereken |
|---|---|---|---|
| SGD | Sabit öğrenme oranı | İyi genelleme | Hassas ayar ister |
| Momentum | Geçmiş yönleri biriktirme | Dar hata vadileri | Ek momentum katsayısı |
| RMSprop | Kare gradyan ortalaması | Değişken ve gürültülü problemler | Öğrenme oranına duyarlı olabilir |
| Adam | Momentum + RMSprop | Hızlı başlangıç, seyrek gradyanlar | Her zaman en iyi genellemeyi sağlamaz |
Aşağıdaki PyTorch kodu, aynı model için optimizasyon algoritmasının nasıl değiştirileceğini gösterir:
import torch
model = torch.nn.Linear(10, 1)
loss_fn = torch.nn.MSELoss()
optimizers = {
"sgd": torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9),
"rmsprop": torch.optim.RMSprop(model.parameters(), lr=0.001),
"adam": torch.optim.Adam(model.parameters(), lr=0.001)
}
optimizer = optimizers["adam"]
for features, targets in data_loader:
optimizer.zero_grad()
predictions = model(features)
loss = loss_fn(predictions, targets)
loss.backward()
optimizer.step()
zero_grad() eski gradyanları temizler, backward() türevleri hesaplar, step() ise parametreleri seçilen algoritmaya göre günceller.
Adam çoğu derin öğrenme projesinde güçlü bir başlangıç seçeneğidir; hızlı yakınsar ve az ayar gerektirir. Bununla birlikte SGD ve Momentum, uygun öğrenme oranı zamanlamasıyla daha iyi genelleme sağlayabilir. RMSprop ise tekrarlayan sinir ağları ve gürültülü hedeflerde hâlâ kullanışlıdır. En doğru yaklaşım, doğrulama kaybını izlemek, birkaç algoritmayı aynı koşullarda denemek ve yalnızca eğitim hızına değil modelin görülmemiş verideki başarısına da bakmaktır.
]]>``
28×28 piksellik gri tonlamalı bir rakam resmi, ağ açısından resim değil, 784 sayıdan oluşan bir vektördür. Her pikseli 255’e bölerek değerleri $[0,1]$ aralığına taşırız:
\[x_i = \frac{piksel_i}{255}\]Çıkış katmanında ise 10 nöron bulunur. Örneğin doğru cevap 3 ise hedef vektörü $[0,0,0,1,0,0,0,0,0,0]$ olur. Buna one-hot kodlama denir.
| Katman | Nöron sayısı | Görevi |
|---|---|---|
| Giriş | 784 | Piksel değerlerini almak |
| Gizli | 64 | Çizgi, kıvrım ve kenar örüntülerini öğrenmek |
| Çıkış | 10 | 0-9 sınıflarını puanlamak |
Bir nöron önce ağırlıklı toplam hesaplar:
\[z_j = \sum_i x_i w_{ij} + b_j\]Ardından doğrusal olmayan sigmoid fonksiyonu uygulanır:
\[\sigma(z)=\frac{1}{1+e^{-z}}\]Doğrusal olmayan aktivasyon kullanılmazsa çok sayıda katman, matematiksel olarak tek bir doğrusal dönüşüme dönüşür. Başka bir deyişle ağ büyür, fakat zekâsı pek büyümez.
Aşağıdaki Python kodu matris kütüphanesi kullanmaz. Ağırlıkları üretmek için kendi basit sözde rastgele sayı üretecimizi bile yazıyoruz:
seed = 123456
def rnd():
global seed
seed = (1103515245 * seed + 12345) % (2 ** 31)
return seed / (2 ** 31) - 0.5
def sigmoid(x):
return 1.0 / (1.0 + 2.718281828 ** (-max(-30, min(30, x))))
def matrix(rows, cols):
return [[rnd() * 0.1 for _ in range(cols)] for _ in range(rows)]
INPUT, HIDDEN, OUTPUT = 784, 64, 10
w1 = matrix(HIDDEN, INPUT)
b1 = [0.0] * HIDDEN
w2 = matrix(OUTPUT, HIDDEN)
b2 = [0.0] * OUTPUT
def forward(x):
hidden = []
for j in range(HIDDEN):
z = b1[j] + sum(w1[j][i] * x[i] for i in range(INPUT))
hidden.append(sigmoid(z))
output = []
for k in range(OUTPUT):
z = b2[k] + sum(w2[k][j] * hidden[j] for j in range(HIDDEN))
output.append(sigmoid(z))
return hidden, output
forward fonksiyonu tahmin üretir; ancak öğrenme için hatayı ağırlıklara geri dağıtmamız gerekir. Ortalama karesel hata kullanırsak temel hedefimiz şudur:
def train(x, target, rate=0.1):
hidden, output = forward(x)
out_delta = [
(output[k] - target[k]) * output[k] * (1 - output[k])
for k in range(OUTPUT)
]
hid_delta = []
for j in range(HIDDEN):
error = sum(out_delta[k] * w2[k][j] for k in range(OUTPUT))
hid_delta.append(error * hidden[j] * (1 - hidden[j]))
for k in range(OUTPUT):
for j in range(HIDDEN):
w2[k][j] -= rate * out_delta[k] * hidden[j]
b2[k] -= rate * out_delta[k]
for j in range(HIDDEN):
for i in range(INPUT):
w1[j][i] -= rate * hid_delta[j] * x[i]
b1[j] -= rate * hid_delta[j]
Her eğitim resmi için piksel listesini normalize eder, doğru rakamın hedef değerini 1 yapar ve train fonksiyonunu çağırırız. Bu işlemin tüm veri üzerinde bir kez yapılmasına epoch denir. Eğitimden sonra tahmin, en yüksek çıkış değerinin indeksidir:
def predict(pixels):
x = [p / 255.0 for p in pixels]
_, scores = forward(x)
return max(range(10), key=lambda i: scores[i])
| Yaklaşım | Avantaj | Dezavantaj |
|---|---|---|
| Sıfırdan ağ | Matematiği görünür kılar | Yavaş çalışır |
| Hazır kütüphane | Hızlı ve optimize | Ayrıntıları gizleyebilir |
Bu ağ modern modellerle yarışmayacaktır; fakat ileri yayılım, geri yayılım, gradyan inişi ve sınıflandırmanın nasıl birleştiğini açıkça gösterir. Sonraki adım olarak mini-batch eğitimi, ReLU, softmax ve çapraz entropi eklenebilir. Artık sinir ağı gizemli bir kara kutu değil; bolca döngü, türev ve sabırdan oluşan anlaşılır bir makinedir.
]]>Klasik programlamada insan kuralları ve girdileri verir, bilgisayar sonucu üretir. Makine öğrenmesinde ise girdilerle birlikte örnek sonuçlar veya bir değerlendirme mekanizması sunulur; sistem uygun kuralları kendisi yaklaşık olarak çıkarır.
Bu süreç genellikle bir amaç fonksiyonunun iyileştirilmesidir. Bir modelin parametreleri $\theta$, tahmini $f_\theta(x)$ ve gerçek cevap $y$ olsun. Denetimli öğrenmede hedef çoğunlukla şu kaybı küçültmektir:
\[\theta^* = \arg\min_\theta \frac{1}{n}\sum_{i=1}^{n} L(f_\theta(x_i), y_i)\]Buradaki kritik fikir şudur: Sistem “gerçeği” doğrudan öğrenmez; verilen veri, hedef ve ölçüm yöntemi altında başarılı olan bir temsil öğrenir.
| Paradigma | Öğrenme sinyali | Temel soru | Tipik kullanım |
|---|---|---|---|
| Denetimli | Etiket veya doğru cevap | Bu girdi için sonuç nedir? | Sınıflandırma, regresyon |
| Denetimsiz | Yalnızca ham veri | Bu veride nasıl bir yapı var? | Kümeleme, boyut indirgeme |
| Pekiştirmeli | Ödül ve ceza | Uzun vadede hangi eylem daha iyi? | Robotik, oyunlar, kontrol |
Denetimli öğrenmede veri kümesi $(x_i, y_i)$ çiftlerinden oluşur. Örneğin bir e-postanın özellikleri $x$, “spam” etiketi ise $y$ olabilir. Model, tahminleriyle etiketler arasındaki hatayı azaltır.
Felsefi açıdan bu yaklaşım, bilginin dışarıdan sağlanan doğru örneklerle kazanıldığını varsayar. Güçlüdür; fakat öğretmenin hatalarını da miras alır. Etiketlerde önyargı varsa model bunu şaşırtıcı bir disiplinle öğrenebilir.
from sklearn.linear_model import LogisticRegression
# Özelliklerden ikili sınıf etiketini tahmin eden model
model = LogisticRegression()
model.fit(X_train, y_train)
tahminler = model.predict(X_test)
Lojistik regresyon, sınıf olasılığını sigmoid fonksiyonuyla modeller: $\sigma(z)=1/(1+e^{-z})$. Basit görünmesine rağmen metin sınıflandırma ve risk tahmini gibi alanlarda güçlü bir başlangıçtır.
Denetimsiz öğrenmede doğru cevap anahtarı yoktur. Algoritma benzerlik, yoğunluk veya istatistiksel bağımlılık gibi ölçütlerle yapılar arar. K-means, noktaları merkezlerine olan kareli uzaklığı küçülterek $k$ kümeye ayırır:
\[J = \sum_{j=1}^{k}\sum_{x_i \in C_j}\lVert x_i-\mu_j\rVert^2\]Burada “doğru küme” mutlak değildir. Müşteriler yaşa göre başka, alışveriş davranışına göre başka biçimde gruplanabilir. Dolayısıyla sonuç, seçilen özelliklerin ve benzerlik tanımının bir yorumudur.
from sklearn.cluster import KMeans
# Etiketsiz müşterileri üç davranış grubuna ayırır
model = KMeans(n_clusters=3, random_state=42)
kume_numaralari = model.fit_predict(musteri_ozellikleri)
Pekiştirmeli öğrenmede bir ajan, durum $s$ içinde eylem $a$ seçer; çevre yeni durum ve ödül üretir. Amaç anlık ödülü değil, indirgenmiş toplam getiriyi büyütmektir:
\[G_t = \sum_{k=0}^{\infty}\gamma^k r_{t+k+1}\]$\gamma$, gelecekteki ödüllere verilen önemi belirler. Bu paradigma davranışçı öğrenmeye benzer: Ajan hangi eylemin doğru olduğunu önceden bilmez, sonuçları deneyimler. En büyük ikilem keşif ve sömürüdür; yeni seçenekler mi denenmeli, yoksa bilinen iyi davranış mı tekrarlanmalıdır?
| Özellik | Denetimli | Denetimsiz | Pekiştirmeli |
|---|---|---|---|
| Geri bildirim | Anında ve açık | Doğrudan yok | Gecikmeli olabilir |
| Veri üretimi | Genellikle sabit | Genellikle sabit | Etkileşimle oluşur |
| Başlıca risk | Aşırı öğrenme | Anlamsız desenler | Yanlış ödül tasarımı |
Elinizde güvenilir etiketler varsa denetimli öğrenme, yapıyı keşfetmek istiyorsanız denetimsiz öğrenme, ardışık kararlar ve çevresel etkileşim söz konusuysa pekiştirmeli öğrenme uygundur. Gerçek sistemlerde bu sınırlar bulanıktır: Bir robot görüntüleri denetimli öğrenmeyle tanıyabilir, denetimsiz yöntemle temsil çıkarabilir ve hareketlerini pekiştirmeli öğrenmeyle geliştirebilir. Kısacası mesele en havalı algoritmayı seçmek değil, eldeki geri bildirim türünü doğru anlamaktır.
]]>