Machine Learning

Machine Learning Nedir?

Machine Learning, bilgisayarların açık bir şekilde programlanmadan deneyimlerden öğrenmeleri ve gelecekteki kararları vermelerini sağlayan yapay zeka dalıdır. Verilerden desenler çıkararak tahminlerde bulunur ve sürekli kendini geliştirir.

Linear Regression Varsayımları

Linearity: X ve y arasında doğrusal ilişki
Independence: Gözlemler birbirinden bağımsız
Homoscedasticity: Hata terimlerinin varyansı sabit
Normality: Hata terimleri normal dağılım gösterir

Dikkat: Multicollinearity (bağımsız değişkenler arası yüksek korelasyon) model performansını olumsuz etkileyebilir. VIF (Variance Inflation Factor) ile kontrol edin.

Polynomial Regression

Polynomial Regression, doğrusal olmayan ilişkileri modellemek için kullanılan bir regresyon tekniğidir. Bağımsız değişkenlerin yüksek dereceli terimlerini ekleyerek karmaşık eğrileri fit edebilir.

# Polynomial Regression Implementation
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import mean_squared_error, r2_score

# Veri hazırlama
X = np.array([[val] for val in range(1, 11)])
y = np.array([1, 4, 9, 16, 25, 36, 49, 64, 81, 100])

# Farklı dereceler için polynomial regression
degrees = [1, 2, 3, 4]
results = {}

for degree in degrees:
# Pipeline ile polynomial features ve linear regression birleştirme
poly_reg = Pipeline([
    ('poly', PolynomialFeatures(degree=degree)),
    ('linear', LinearRegression())
])

# Model eğitimi
poly_reg.fit(X, y)

# Tahmin
y_pred = poly_reg.predict(X)

# Performans değerlendirme
mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)

results[degree] = {'mse': mse, 'r2': r2}

print(f"Degree {degree}: MSE = {mse:.4f}, R² = {r2:.4f}")

# En iyi polynomial derecesini bulma
from sklearn.model_selection import validation_curve

param_range = range(1, 11)
train_scores, test_scores = validation_curve(
Pipeline([('poly', PolynomialFeatures()), ('linear', LinearRegression())]),
X, y, param_name='poly__degree', param_range=param_range,
cv=5, scoring='r2'
)

# Overfitting kontrolü
train_mean = np.mean(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)

# En iyi degree'yi seç (test score'u maksimize eden)
best_degree = param_range[np.argmax(test_mean)]
print(f"En iyi polynomial derecesi: {best_degree}")

# Final model
final_model = Pipeline([
('poly', PolynomialFeatures(degree=best_degree)),
('linear', LinearRegression())
])
final_model.fit(X, y)

Polynomial Degree Selection

Under-fitting (Low Degree): Model çok basit, bias yüksek
Over-fitting (High Degree): Model çok karmaşık, variance yüksek
Sweet Spot: Bias-variance trade-off'u dengelenmiş
Validation: Cross-validation ile optimal degree seçimi

Support Vector Machines (SVM)

Support Vector Machines, hem sınıflandırma hem de regresyon problemleri için kullanılan güçlü bir algoritmadır. Veri noktalarını ayıran en iyi hiper düzlemi bularak karar sınırını oluşturur.

# SVM Classification
from sklearn.svm import SVC, SVR
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix

# Veri hazırlama
X = df.drop('target', axis=1)
y = df['target']

# Feature scaling (SVM için kritik!)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
X_scaled, y, test_size=0.2, random_state=42
)

# Linear SVM
svm_linear = SVC(kernel='linear', random_state=42)
svm_linear.fit(X_train, y_train)
y_pred_linear = svm_linear.predict(X_test)

print("Linear SVM Results:")
print(classification_report(y_test, y_pred_linear))

# RBF (Radial Basis Function) SVM
svm_rbf = SVC(kernel='rbf', random_state=42)
svm_rbf.fit(X_train, y_train)
y_pred_rbf = svm_rbf.predict(X_test)

print("\nRBF SVM Results:")
print(classification_report(y_test, y_pred_rbf))

# Hyperparameter tuning
param_grid = {
'C': [0.1, 1, 10, 100],
'gamma': ['scale', 'auto', 0.1, 1],
'kernel': ['linear', 'rbf', 'poly']
}

grid_search = GridSearchCV(
SVC(random_state=42), param_grid, cv=5, 
scoring='accuracy', n_jobs=-1
)

grid_search.fit(X_train, y_train)

print(f"\nEn iyi parametreler: {grid_search.best_params_}")
print(f"En iyi CV score: {grid_search.best_score_:.4f}")

# En iyi model ile final prediction
best_svm = grid_search.best_estimator_
y_pred_best = best_svm.predict(X_test)

# SVR for Regression
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error

# Regression için SVR
svr_model = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
svr_model.fit(X_train, y_train_reg)  # continuous target için
y_pred_svr = svr_model.predict(X_test)

mse_svr = mean_squared_error(y_test_reg, y_pred_svr)
print(f"SVR MSE: {mse_svr:.4f}")

SVM Kernel Fonksiyonları

Linear: K(x,y) = x·y - Doğrusal ayrılabilir veriler için
RBF: K(x,y) = exp(-γ||x-y||²) - En popüler, non-linear
Polynomial: K(x,y) = (γx·y + r)^d - Polynomial ilişkiler
Sigmoid: K(x,y) = tanh(γx·y + r) - Neural network benzeri

SVM Hiperparametreleri:

C: Regularization parameter, yüksek değer overfitting riski
gamma: RBF kernel için, decision boundary'nin şeklini etkiler
epsilon: SVR için, error tube genişliği
degree: Polynomial kernel için polinom derecesi

K-Means Clustering

K-Means, verileri K adet kümeye ayıran unsupervised learning algoritmasıdır. Her veri noktasını en yakın centroid'e atayarak kümeleri oluşturur ve centroid'leri iteratif olarak günceller.

# K-Means Clustering Implementation
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score, adjusted_rand_score

# Veri hazırlama
X = df[['feature1', 'feature2']]  # İki özellik seçelim

# Feature scaling (K-means distance-based olduğu için önemli)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Elbow Method ile optimal K değerini bulma
wcss = []  # Within-Cluster Sum of Squares
k_range = range(1, 11)

for k in k_range:
kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
kmeans.fit(X_scaled)
wcss.append(kmeans.inertia_)

# Silhouette Score ile optimal K bulma
silhouette_scores = []
for k in range(2, 11):
kmeans = KMeans(n_clusters=k, random_state=42)
cluster_labels = kmeans.fit_predict(X_scaled)
silhouette_avg = silhouette_score(X_scaled, cluster_labels)
silhouette_scores.append(silhouette_avg)

# En iyi K değeri (silhouette score'a göre)
best_k = silhouette_scores.index(max(silhouette_scores)) + 2
print(f"En iyi K değeri: {best_k}")

# Final K-means model
final_kmeans = KMeans(n_clusters=best_k, random_state=42)
cluster_labels = final_kmeans.fit_predict(X_scaled)

# Cluster centers
centers = final_kmeans.cluster_centers_
print(f"Cluster merkezleri:\n{centers}")

# Her cluster'daki nokta sayısı
unique, counts = np.unique(cluster_labels, return_counts=True)
for cluster, count in zip(unique, counts):
print(f"Cluster {cluster}: {count} veri noktası")

# Advanced K-Means: K-Means++
kmeans_plus = KMeans(
n_clusters=best_k, 
init='k-means++',  # Daha iyi initialization
max_iter=300,
n_init=10,
random_state=42
)
labels_plus = kmeans_plus.fit_predict(X_scaled)

# Model performans değerlendirme
inertia = final_kmeans.inertia_
silhouette_avg = silhouette_score(X_scaled, cluster_labels)

print(f"Inertia (WCSS): {inertia:.4f}")
print(f"Silhouette Score: {silhouette_avg:.4f}")

# Yeni veri noktası için cluster tahmini
new_data = np.array([[1.0, 2.0]])
new_data_scaled = scaler.transform(new_data)
predicted_cluster = final_kmeans.predict(new_data_scaled)
print(f"Yeni veri noktası cluster: {predicted_cluster[0]}")

K-Means Algorithm Steps

1. Initialize: K adet centroid rastgele yerleştir
2. Assign: Her noktayı en yakın centroid'e ata
3. Update: Centroid'leri cluster ortalamalarına taşı
4. Repeat: Convergence'a kadar 2-3 adımlarını tekrarla

K-Means Evaluation Metrics

Inertia/WCSS: Cluster içi mesafe kareler toplamı
Silhouette Score: Cluster kalitesi [-1, 1] arası
Elbow Method: WCSS grafiğindeki dirsek noktası
Calinski-Harabasz: Cluster ayrım kalitesi

K-Means Limitations: Spherical cluster varsayımı, outlier'lara duyarlılık, K değerini önceden belirleme zorunluluğu.

XGBoost: Extreme Gradient Boosting

XGBoost, gradient boosting framework'ün optimize edilmiş ve scalable implementasyonudur. Kaggle yarışmalarında ve endüstride en popüler algoritmalardan biridir.

# XGBoost Implementation
import xgboost as xgb
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.metrics import accuracy_score, classification_report
import pandas as pd

# Veri hazırlama
X = df.drop('target', axis=1)
y = df['target']

X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)

# Basic XGBoost Model
xgb_model = xgb.XGBClassifier(
random_state=42,
eval_metric='logloss'
)

xgb_model.fit(X_train, y_train)
y_pred = xgb_model.predict(X_test)

print(f"Basic XGBoost Accuracy: {accuracy_score(y_test, y_pred):.4f}")

# Hyperparameter Tuning
param_grid = {
'n_estimators': [100, 200, 300],
'max_depth': [3, 4, 5, 6],
'learning_rate': [0.01, 0.1, 0.2],
'subsample': [0.8, 0.9, 1.0],
'colsample_bytree': [0.8, 0.9, 1.0]
}

# Grid search (küçük grid kullan, çok zaman alır)
grid_search = GridSearchCV(
estimator=xgb.XGBClassifier(random_state=42, eval_metric='logloss'),
param_grid={
    'n_estimators': [100, 200],
    'max_depth': [3, 4],
    'learning_rate': [0.1, 0.2]
},
scoring='accuracy',
cv=3,
n_jobs=-1
)

grid_search.fit(X_train, y_train)

print(f"En iyi parametreler: {grid_search.best_params_}")
print(f"En iyi CV score: {grid_search.best_score_:.4f}")

# En iyi model ile final prediction
best_xgb = grid_search.best_estimator_
y_pred_best = best_xgb.predict(X_test)
final_accuracy = accuracy_score(y_test, y_pred_best)

print(f"Final XGBoost Accuracy: {final_accuracy:.4f}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred_best))

# Feature Importance
feature_importance = best_xgb.feature_importances_
feature_names = X.columns

importance_df = pd.DataFrame({
'feature': feature_names,
'importance': feature_importance
}).sort_values('importance', ascending=False)

print("\nTop 10 Features:")
print(importance_df.head(10))

# Early Stopping ile overfitting önleme
xgb_early = xgb.XGBClassifier(
random_state=42,
eval_metric='logloss',
early_stopping_rounds=10
)

# Validation set ile early stopping
X_train_split, X_val, y_train_split, y_val = train_test_split(
X_train, y_train, test_size=0.2, random_state=42
)

xgb_early.fit(
X_train_split, y_train_split,
eval_set=[(X_val, y_val)],
verbose=False
)

XGBoost Key Features

Gradient Boosting: Sequential learning from mistakes
Regularization: L1/L2 penalty terms
Parallel Processing: Multi-threaded tree construction
Missing Values: Automatic handling
Feature Importance: Built-in feature selection

XGBoost Hyperparameters:

n_estimators: Boosting rounds sayısı
max_depth: Tree derinliği (overfitting kontrol)
learning_rate: Shrinkage parameter (0.01-0.3)
subsample: Row sampling ratio
colsample_bytree: Feature sampling ratio
reg_alpha/reg_lambda: L1/L2 regularization

Doğal Dil İşleme (NLP)

Natural Language Processing, bilgisayarların insan dilini anlayıp işleyebilmesini sağlayan yapay zeka dalıdır. Metin madenciliği, sentiment analizi ve dil modelleme gibi uygulamalarda kullanılır.

# NLP Pipeline with Scikit-learn
import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, accuracy_score
import re
import nltk
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer

# Veri hazırlama (örnek: film yorumları)
# df['text'] = film yorumları, df['sentiment'] = pozitif/negatif

# Text preprocessing function
def preprocess_text(text):
# Küçük harfe dönüştür
text = text.lower()

# Özel karakterleri kaldır
text = re.sub(r'[^a-zA-Z\s]', '', text)

# Stopwords kaldır
stop_words = set(stopwords.words('english'))
words = text.split()
words = [word for word in words if word not in stop_words]

# Stemming
stemmer = PorterStemmer()
words = [stemmer.stem(word) for word in words]

return ' '.join(words)

# Metinleri önişle
df['cleaned_text'] = df['text'].apply(preprocess_text)

# Feature extraction - Bag of Words
vectorizer = CountVectorizer(max_features=5000, ngram_range=(1, 2))
X_bow = vectorizer.fit_transform(df['cleaned_text'])

# TF-IDF Vectorization
tfidf_vectorizer = TfidfVectorizer(max_features=5000, ngram_range=(1, 2))
X_tfidf = tfidf_vectorizer.fit_transform(df['cleaned_text'])

# Target variable
y = df['sentiment']

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
X_tfidf, y, test_size=0.2, random_state=42
)

# Naive Bayes Classifier
nb_model = MultinomialNB()
nb_model.fit(X_train, y_train)
nb_pred = nb_model.predict(X_test)

print("Naive Bayes Results:")
print(f"Accuracy: {accuracy_score(y_test, nb_pred):.4f}")
print(classification_report(y_test, nb_pred))

# Logistic Regression
lr_model = LogisticRegression(random_state=42)
lr_model.fit(X_train, y_train)
lr_pred = lr_model.predict(X_test)

print("\nLogistic Regression Results:")
print(f"Accuracy: {accuracy_score(y_test, lr_pred):.4f}")

NLP Pipeline Steps

1. Text Cleaning: Lowercase, punctuation removal
2. Tokenization: Split into words/sentences
3. Stop Words: Remove common words (the, and, is)
4. Stemming/Lemmatization: Root form extraction
5. Vectorization: Convert to numerical features
6. Model Training: Apply ML algorithms

Reinforcement Learning

Reinforcement Learning, bir ajanın çevre ile etkileşim kurarak deneme-yanılma yoluyla optimal davranış stratejilerini öğrendiği makine öğrenmesi dalıdır.

# Upper Confidence Bound (UCB) Implementation
import numpy as np
import matplotlib.pyplot as plt
import math

class UCBBandit:
def __init__(self, n_arms):
    self.n_arms = n_arms
    self.reset()

def reset(self):
    self.counts = np.zeros(self.n_arms)
    self.values = np.zeros(self.n_arms)
    self.total_count = 0

def select_arm(self, confidence_level=2):
    if self.total_count < self.n_arms:
        # İlk turda her kolu bir kez dene
        return self.total_count
    
    # UCB hesapla
    ucb_values = []
    for arm in range(self.n_arms):
        confidence_interval = math.sqrt(
            (confidence_level * math.log(self.total_count)) / self.counts[arm]
        )
        ucb_value = self.values[arm] + confidence_interval
        ucb_values.append(ucb_value)
    
    return np.argmax(ucb_values)

def update(self, chosen_arm, reward):
    self.counts[chosen_arm] += 1
    n = self.counts[chosen_arm]
    value = self.values[chosen_arm]
    
    # Incremental average update
    self.values[chosen_arm] = ((n - 1) / float(n)) * value + (1 / float(n)) * reward
    self.total_count += 1

# Thompson Sampling Implementation
class ThompsonSampling:
def __init__(self, n_arms):
    self.n_arms = n_arms
    self.reset()

def reset(self):
    # Beta distribution parameters
    self.alpha = np.ones(self.n_arms)  # Success count + 1
    self.beta = np.ones(self.n_arms)   # Failure count + 1

def select_arm(self):
    # Her arm için beta dağılımından sample al
    samples = []
    for arm in range(self.n_arms):
        sample = np.random.beta(self.alpha[arm], self.beta[arm])
        samples.append(sample)
    
    return np.argmax(samples)

def update(self, chosen_arm, reward):
    if reward > 0:
        self.alpha[chosen_arm] += 1
    else:
        self.beta[chosen_arm] += 1

# Multi-Armed Bandit Simülasyonu
def simulate_bandit(bandit_algorithm, true_rewards, n_rounds=1000):
# true_rewards: her kolun gerçek ödül oranı
chosen_arms = []
rewards = []
cumulative_reward = 0

for round_num in range(n_rounds):
    chosen_arm = bandit_algorithm.select_arm()
    
    # Bernoulli reward (0 or 1)
    reward = 1 if np.random.random() < true_rewards[chosen_arm] else 0
    
    bandit_algorithm.update(chosen_arm, reward)
    
    chosen_arms.append(chosen_arm)
    rewards.append(reward)
    cumulative_reward += reward

return chosen_arms, rewards, cumulative_reward

# Örnek simülasyon
true_rewards = [0.1, 0.5, 0.3, 0.8]  # 4 kollu bandit
n_arms = len(true_rewards)

# UCB test
ucb_bandit = UCBBandit(n_arms)
ucb_arms, ucb_rewards, ucb_total = simulate_bandit(ucb_bandit, true_rewards)

# Thompson Sampling test
ts_bandit = ThompsonSampling(n_arms)
ts_arms, ts_rewards, ts_total = simulate_bandit(ts_bandit, true_rewards)

print(f"UCB Total Reward: {ucb_total}")
print(f"Thompson Sampling Total Reward: {ts_total}")
print(f"Optimal Strategy Total: {1000 * max(true_rewards):.0f}")

Exploration vs Exploitation

Exploration: Yeni seçenekleri deneme, bilgi toplama
Exploitation: Mevcut en iyi seçeneği kullanma
UCB: Confidence interval ile denge kurma
Thompson Sampling: Bayesian yaklaşımla probabilistic seçim

RL Uygulama Alanları:

Oyunlar: Chess, Go, video games (AlphaGo)
Robotik: Autonomous navigation, manipulation
Finans: Algorithmic trading, portfolio optimization
Reklam: Online advertising, recommendation systems
Sağlık: Treatment planning, drug discovery