Dersler

View on GitHub

Eğitim - Doğrulama - Test setleri (Train - Validation - Test)

Makine öğrenmesinde veri seti genellikle üçe ayrılır:

Amaç: Modelin sadece veriyi ezberlemesini (overfitting) engelleyerek genelleme yeteneğini ölçmek.

Neden Veri Bölme Yapılır?

from sklearn.model_selection import train_test_split
# %80 train, %20 test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42)

Gradient Descent (Gradyan İnişi) Nedir?

Gradient Descent, bir makine öğrenimi modelinin hata oranını en aza indirmek için kullanılan optimizasyon algoritmasıdır.

Amaç: Modelin tahmin hatasını düşürmek için ağırlıkları güncelleyerek en düşük kayıp fonksiyonunu bulmak. Nasıl çalışır?

Adam (Adaptive Moment Estimation) Nedir?

Adam, derin öğrenme modellerinde yaygın olarak kullanılan, adaptif öğrenme oranına sahip bir optimizasyon algoritmasıdır.

Amaç: Her parametre için öğrenme oranını dinamik olarak ayarlayarak daha hızlı ve kararlı bir şekilde en düşük kayıp değerine ulaşmak.

Batch Gradient Descent (Veri Kümesi Gradyan İnişi)

Stochastic Gradient Descent (SGD - Tekil Örnekli Gradyan İnişi)

Mini-Batch Gradient Descent (Küçük Veri Kümesi Gradyan İnişi)

Hangi Yöntemi Kullanmalıyız?

Epoch

Batch vs Mini-Batch vs SGD

# Batch Gradient Descent
model.fit(X, y, epochs=10, batch_size=len(X))

# Stochastic Gradient Descent (SGD)
model.fit(X, y, epochs=10, batch_size=1)

# Mini-Batch Gradient Descent
model.fit(X, y, epochs=10, batch_size=32)

Parametre - Hiperparametre

Sınıflandırmada Aktivasyon ve Kayıp Fonksiyonları

Sigmoid Aktivasyon Fonksiyonu

# Binary classification
model = models.Sequential([
    layers.Dense(1, activation='sigmoid')
])

Lineer Aktivasyon Fonksiyonu

ReLU (Rectified Linear Unit) Aktivasyon Fonksiyonu

# Binary classification
model = models.Sequential([
    layers.Dense(10, activation='relu'),
    layers.Dense(1, activation='linear')  # regresyon
])

Softmax Aktivasyon Fonksiyonu

$S_i = \frac{e^{x_i}}{\sum_{j} e^{x_j}}$

# Multi-class classification
model = models.Sequential([
    layers.Dense(3, activation='softmax')
])

Binary Crossentropy (İkili Çapraz Entropi )

$L = - (y \log(p) + (1 - y) \log(1 - p))$

Categorical Crossentropy (Kategorik Çapraz Entropi Kayıp Fonksiyonu)

$L = -\sum_{i} y_i \log(p_i)$

Regresyon Kayıp Fonksiyonları

Ortalama Kare Hata (Mean Squared Error, MSE)

Kayıp Fonksiyonları

# Binary classification
model.compile(
    optimizer='adam',
    loss='binary_crossentropy'
)

# Multi-class classification
model.compile(
    optimizer='adam',
    loss='categorical_crossentropy'
)

# Regression
model.compile(
    optimizer='adam',
    loss='mse'
)

Ortalama mutlak hata (Mean Absolute Error, MAE)

\[MAE = \frac{1}{N} \sum_{i=1}^{N} \lvert y_i - \hat{y}_i \rvert\]

Ortalama Mutlak Yüzde Hata (Mean Absolute Percentage Error, MAPE)

\[MAPE = \frac{100}{N} \sum_{i=1}^{N} \left\lvert \frac{y_i - \hat{y}_i}{y_i} \right\rvert\]

MSE, MAE, MAPE Hesaplama

import numpy as np

y_true = np.array([10, 20, 30, 40, 50])
y_pred = np.array([12, 18, 33, 37, 55])

mse = np.mean((y_true - y_pred)**2)
mae = np.mean(np.abs(y_true - y_pred))
mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100

print("MSE:", mse)
print("MAE:", mae)
print("MAPE:", mape)

Sınıflandırma Metrikleri ve Formülleri

TP, TN, FP, FN Kavramları

Bir sınıflandırma modelinin performansını değerlendirmek için kullanılan temel terimler:

Gerçek \ Tahmin Pozitif (P) Negatif (N)
Pozitif (P) ✅ TP (True Positive) ❌ FN (False Negative)
Negatif (N) ❌ FP (False Positive) ✅ TN (True Negative)

Örnek | Durum | TP | TN | FP | FN | |——-|—-|—-|—-|—-| | Spam Filtresi | Spam e-postayı “Spam” olarak işaretlemek | Normal e-postayı “Normal” olarak bırakmak | Normal e-postayı “Spam” olarak yanlış işaretlemek | Spam e-postayı “Normal” olarak kaçırmak |

Metrikler

Doğruluk (Accuracy)

Doğru tahmin edilen örneklerin, toplam örnek sayısına oranıdır.

\[Accuracy = \frac{TP + TN}{TP + TN + FP + FN}\]

Kesinlik (Precision)

Bir sınıfa ait olarak tahmin edilen örneklerin, gerçekten o sınıfa ait olma oranıdır.

\[Precision = \frac{TP}{TP + FP}\]

Duyarlılık (Recall)

Gerçekten pozitif olan örneklerin, model tarafından doğru tahmin edilme oranıdır.

\[Recall = \frac{TP}{TP + FN}\]

F1-Skoru

Kesinlik ve duyarlılığın harmonik ortalamasıdır. Dengesiz veri kümelerinde kullanışlıdır.

\[F1 = 2 \times \frac{Precision \times Recall}{Precision + Recall}\] 
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

y_true = [1,0,1,1,0,1,0,0,1,1]
y_pred = [1,0,1,0,0,1,1,0,1,0]

print("Accuracy:", accuracy_score(y_true, y_pred))
print("Precision:", precision_score(y_true, y_pred))
print("Recall:", recall_score(y_true, y_pred))
print("F1 Score:", f1_score(y_true, y_pred))

Karışıklık Matrisi (Confusion Matrix)

Her sınıfın gerçek ve tahmin edilen değerleri arasındaki ilişkileri gösteren matristir.

Gerçek \ Tahmin Pozitif ( P ) Negatif ( N )
Pozitif ( P ) TP (True Positive) FN (False Negative)
Negatif ( N ) FP (False Positive) TN (True Negative)

Karışıklık Matrisi Örnek

# Confusion Matrix (4 Sınıf) - Örnek Kod
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Gerçek sınıflar (0,1,2,3)
y_true = np.array([0,1,2,3,0,1,2,3,0,1,2,3])
# Tahminler
y_pred = np.array([0,2,1,3,0,1,2,2,0,0,2,3])

# Confusion Matrix hesaplama
cm = confusion_matrix(y_true, y_pred)
# Görselleştirme
disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                              display_labels=[0,1,2,3])

disp.plot(cmap='Blues')
plt.title("4 Sınıflı Confusion Matrix")
plt.show()

Örnek Hesaplama

Eğer bir model:

için hesaplamalar:

\[Accuracy = \frac{90 + 50}{90 + 50 + 30 + 20} = 0.74\]
\[Precision = \frac{90}{90 + 30} = 0.75\] \[Recall = \frac{90}{90 + 20} = 0.818\] \[F1 = 2 \times \frac{0.75 \times 0.818}{0.75 + 0.818} = 0.783\]