Python ile Makine Öğrenmesi: Başlangıçtan İleri Seviyeye

1. Python ve Makine Öğrenmesine Giriş

Makine öğrenmesi (Machine Learning), günümüzün en heyecan verici ve hızla gelişen teknoloji alanlarından biridir. Veriden öğrenebilen ve tahminler yapabilen algoritmalar geliştirmek, artık yalnızca akademik bir çalışma alanı olmaktan çıkarak endüstrinin her köşesine yayılmıştır. Bu devrimde en büyük rolü oynayan programlama dili ise hiç kuşkusuz Python'dur.

Python'un makine öğrenmesinde bu kadar popüler olmasının birçok nedeni vardır: okunabilir ve temiz sözdizimi, zengin kütüphane ekosistemi, büyük ve aktif topluluk desteği, hızlı prototipleme imkânı ve diğer dillerle kolay entegrasyon. Finans sektöründen sağlık bilimlerine, e-ticaretten otonom araçlara kadar her alanda Python tabanlı makine öğrenmesi çözümleri kullanılmaktadır.

Makine öğrenmesi temelde üç ana kategoriye ayrılır: denetimli öğrenme (supervised learning), denetimsiz öğrenme (unsupervised learning) ve pekiştirmeli öğrenme (reinforcement learning). Denetimli öğrenmede etiketlenmiş verilerle model eğitilirken, denetimsiz öğrenmede verinin içindeki gizli yapılar keşfedilir. Pekiştirmeli öğrenmede ise bir ajan, çevresiyle etkileşime girerek ödül ve ceza mekanizmasıyla öğrenir.

2. Python ML Ekosistemi: Temel Kütüphaneler

Python'un makine öğrenmesi ekosistemi, birbirleriyle uyumlu çalışan güçlü kütüphanelerden oluşur. Bu kütüphaneler, veri işleme, model oluşturma, değerlendirme ve dağıtım süreçlerinin tamamını kapsar.

Bu kütüphanelerin kurulumu için pip paket yöneticisini kullanabilirsiniz:

pip install numpy pandas scikit-learn matplotlib seaborn
pip install jupyter  # Notebook ortamı için

3. NumPy ile Sayısal Hesaplama

NumPy (Numerical Python), Python'daki bilimsel hesaplamanın temel taşıdır. Makine öğrenmesindeki tüm matematiksel işlemler — matris çarpımları, lineer cebir operasyonları, istatistiksel hesaplamalar — NumPy üzerine inşa edilmiştir. C dilinde yazılmış altyapısı sayesinde Python listelerine kıyasla onlarca kat hızlıdır.

NumPy Dizileri ve Temel İşlemler

import numpy as np

# Dizi oluşturma
veri = np.array([1, 2, 3, 4, 5])
matris = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Rastgele veri üretme (ML için çok kullanılır)
np.random.seed(42)  # Tekrarlanabilirlik için
X = np.random.randn(100, 5)  # 100 örnek, 5 özellik

# Temel istatistikler
print(f"Ortalama: {X.mean(axis=0)}")
print(f"Standart sapma: {X.std(axis=0)}")
print(f"Şekil: {X.shape}")

# Matris işlemleri
A = np.random.randn(3, 4)
B = np.random.randn(4, 2)
C = np.dot(A, B)  # Matris çarpımı
print(f"Sonuç şekli: {C.shape}")  # (3, 2)

# Broadcasting
normalizasyon = (X - X.mean(axis=0)) / X.std(axis=0)

NumPy'ın broadcasting özelliği, farklı boyutlardaki diziler arasında işlem yapabilmenizi sağlar. Bu, veri normalizasyonu gibi işlemleri tek satırda gerçekleştirmenize olanak tanır ve kodunuzu hem daha okunabilir hem de daha performanslı hale getirir.

4. Pandas ile Veri Manipülasyonu

Pandas, yapılandırılmış verilerle çalışmak için en güçlü Python kütüphanesidir. DataFrame yapısı, SQL tablolarına benzer bir şekilde verinizi satır ve sütunlar halinde organize eder. Makine öğrenmesi projelerinin büyük bir bölümü veri hazırlama aşamasında geçtiğinden, Pandas'a hakimiyet kritik öneme sahiptir.

DataFrame Oluşturma ve Keşifsel Analiz

import pandas as pd

# CSV dosyasından veri okuma
df = pd.read_csv("musteri_verileri.csv")

# İlk bakış
print(df.head())           # İlk 5 satır
print(df.info())            # Sütun tipleri ve eksik değerler
print(df.describe())        # İstatistiksel özet
print(df.shape)             # Satır ve sütun sayısı

# Eksik değer analizi
print(df.isnull().sum())    # Her sütundaki eksik değer sayısı
print(df.isnull().mean())   # Eksik değer oranı

# Filtreleme ve seçim
yuksek_gelir = df[df['gelir'] > 50000]
secili_sutunlar = df[['isim', 'yas', 'gelir']]

# Gruplama ve toplama
kategori_ozet = df.groupby('kategori').agg({
    'gelir': ['mean', 'median', 'std'],
    'yas': 'mean',
    'satis': 'sum'
}).round(2)

print(kategori_ozet)

Veri Birleştirme ve Dönüştürme

# Veri birleştirme
df_merged = pd.merge(df_musteri, df_siparis, on='musteri_id', how='left')

# Pivot tablo
pivot = df.pivot_table(
    values='satis',
    index='bolge',
    columns='ay',
    aggfunc='sum'
)

# Tarih işlemleri
df['tarih'] = pd.to_datetime(df['tarih'])
df['yil'] = df['tarih'].dt.year
df['ay'] = df['tarih'].dt.month
df['gun_adi'] = df['tarih'].dt.day_name()

5. Veri Ön İşleme Teknikleri

Veri ön işleme, makine öğrenmesi sürecinin en kritik adımlarından biridir. Ham veri genellikle eksik değerler, tutarsızlıklar ve farklı ölçeklerdeki özellikler içerir. Modelin performansı büyük ölçüde verinin kalitesine bağlıdır; bu nedenle "Garbage In, Garbage Out" (Çöp Girer, Çöp Çıkar) prensibi makine öğrenmesinin temel kurallarından biridir.

Eksik Değer Yönetimi

from sklearn.impute import SimpleImputer, KNNImputer

# Basit doldurma stratejileri
imputer_mean = SimpleImputer(strategy='mean')
imputer_median = SimpleImputer(strategy='median')
imputer_mode = SimpleImputer(strategy='most_frequent')

# Sayısal sütunlar için ortalama ile doldurma
sayisal_sutunlar = df.select_dtypes(include=[np.number]).columns
df[sayisal_sutunlar] = imputer_mean.fit_transform(df[sayisal_sutunlar])

# KNN tabanlı gelişmiş doldurma
knn_imputer = KNNImputer(n_neighbors=5)
df[sayisal_sutunlar] = knn_imputer.fit_transform(df[sayisal_sutunlar])

# Kategorik sütunlar için mod ile doldurma
kategorik_sutunlar = df.select_dtypes(include=['object']).columns
df[kategorik_sutunlar] = imputer_mode.fit_transform(df[kategorik_sutunlar])

Ölçeklendirme ve Normalizasyon

Farklı ölçeklerdeki özellikler, birçok makine öğrenmesi algoritmasının performansını olumsuz etkiler. Örneğin, yaş (0-100) ve gelir (0-1.000.000) gibi farklı aralıklardaki özellikler standartlaştırılmalıdır.

from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# StandardScaler: ortalaması 0, std 1
scaler_standard = StandardScaler()
X_standard = scaler_standard.fit_transform(X)

# MinMaxScaler: 0-1 aralığına dönüştürme
scaler_minmax = MinMaxScaler()
X_minmax = scaler_minmax.fit_transform(X)

# RobustScaler: Aykırı değerlere dayanıklı
scaler_robust = RobustScaler()
X_robust = scaler_robust.fit_transform(X)

Kategorik Değişken Kodlama

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
import pandas as pd

# Label Encoding (sıralı kategoriler için)
le = LabelEncoder()
df['egitim_encoded'] = le.fit_transform(df['egitim_durumu'])

# One-Hot Encoding (nominal kategoriler için)
df_encoded = pd.get_dummies(df, columns=['sehir', 'cinsiyet'], drop_first=True)

# Scikit-learn OneHotEncoder
ohe = OneHotEncoder(sparse_output=False, handle_unknown='ignore')
encoded_features = ohe.fit_transform(df[['sehir', 'cinsiyet']])

6. Feature Engineering (Özellik Mühendisliği)

Feature engineering, ham veriden modelin daha iyi öğrenebileceği yeni özellikler üretme sanatıdır. Deneyimli veri bilimcilerin en çok vakit harcadığı aşama burasıdır çünkü doğru özellikler, basit bir modeli bile son derece başarılı kılabilir.

Yeni Özellik Türetme Stratejileri

import pandas as pd
import numpy as np

# Matematiksel dönüşümler
df['gelir_log'] = np.log1p(df['gelir'])
df['yas_kare'] = df['yas'] ** 2
df['bmi'] = df['kilo'] / (df['boy'] / 100) ** 2

# Etkileşim özellikleri
df['gelir_yas_oran'] = df['gelir'] / (df['yas'] + 1)
df['deneyim_egitim'] = df['deneyim_yili'] * df['egitim_yili']

# Tarih tabanlı özellikler
df['tarih'] = pd.to_datetime(df['tarih'])
df['haftanin_gunu'] = df['tarih'].dt.dayofweek
df['ay'] = df['tarih'].dt.month
df['ceyrek'] = df['tarih'].dt.quarter
df['hafta_sonu'] = df['haftanin_gunu'].isin([5, 6]).astype(int)
df['yilin_gunu'] = df['tarih'].dt.dayofyear

# Binning (gruplama)
df['yas_grubu'] = pd.cut(df['yas'], 
    bins=[0, 25, 35, 50, 65, 100],
    labels=['Genç', 'Yetişkin', 'Orta Yaş', 'Olgun', 'Yaşlı']
)

# Aggregation tabanlı özellikler
df['musteri_ort_satis'] = df.groupby('musteri_id')['satis'].transform('mean')
df['musteri_toplam_siparis'] = df.groupby('musteri_id')['siparis_id'].transform('count')

Özellik Seçimi (Feature Selection)

from sklearn.feature_selection import SelectKBest, f_classif, mutual_info_classif
from sklearn.feature_selection import RFE
from sklearn.ensemble import RandomForestClassifier

# İstatistiksel test ile seçim
selector = SelectKBest(score_func=f_classif, k=10)
X_selected = selector.fit_transform(X, y)
secili_ozellikler = X.columns[selector.get_support()]
print("Seçilen özellikler:", list(secili_ozellikler))

# Recursive Feature Elimination (RFE)
model = RandomForestClassifier(n_estimators=100, random_state=42)
rfe = RFE(estimator=model, n_features_to_select=10, step=1)
rfe.fit(X, y)

# Önem sıralaması
onem_sirasi = pd.DataFrame({
    'ozellik': X.columns,
    'siralama': rfe.ranking_
}).sort_values('siralama')
print(onem_sirasi)

7. Scikit-learn ile Model Eğitimi

Scikit-learn, Python'daki en popüler makine öğrenmesi kütüphanesidir. Tutarlı API tasarımı sayesinde farklı algoritmaları aynı arayüzle kullanabilirsiniz: fit(), predict(), score() metodları tüm modellerde aynı şekilde çalışır.

Veri Bölme ve İlk Model

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# Veri bölme
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"Eğitim seti: {X_train.shape[0]} örnek")
print(f"Test seti: {X_test.shape[0]} örnek")

# Lojistik Regresyon modeli
model = LogisticRegression(max_iter=1000, random_state=42)
model.fit(X_train, y_train)

# Tahmin ve değerlendirme
y_pred = model.predict(X_test)
print(f"Doğruluk: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred))

Farklı Algoritmaların Karşılaştırılması

from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score

# Model listesi
modeller = {
    'Lojistik Regresyon': LogisticRegression(max_iter=1000),
    'Karar Ağacı': DecisionTreeClassifier(random_state=42),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'Gradient Boosting': GradientBoostingClassifier(random_state=42),
    'SVM': SVC(kernel='rbf', random_state=42),
    'KNN': KNeighborsClassifier(n_neighbors=5)
}

# Çapraz doğrulama ile karşılaştırma
sonuclar = {}
for isim, model in modeller.items():
    cv_scores = cross_val_score(model, X_train, y_train, cv=5, scoring='accuracy')
    sonuclar[isim] = {
        'ortalama': cv_scores.mean(),
        'std': cv_scores.std()
    }
    print(f"{isim}: {cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")

# En iyi modeli seçme
en_iyi = max(sonuclar, key=lambda x: sonuclar[x]['ortalama'])
print(f"\nEn iyi model: {en_iyi}")

Regresyon Modelleri

from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

# Ridge Regresyon (L2 düzenlileştirme)
ridge = Ridge(alpha=1.0)
ridge.fit(X_train, y_train)
y_pred_ridge = ridge.predict(X_test)

# Performans metrikleri
print(f"RMSE: {np.sqrt(mean_squared_error(y_test, y_pred_ridge)):.4f}")
print(f"MAE: {mean_absolute_error(y_test, y_pred_ridge):.4f}")
print(f"R² Skoru: {r2_score(y_test, y_pred_ridge):.4f}")

# Random Forest Regresyon
rf_reg = RandomForestRegressor(n_estimators=200, max_depth=10, random_state=42)
rf_reg.fit(X_train, y_train)

# Özellik önem dereceleri
onem = pd.DataFrame({
    'ozellik': feature_names,
    'onem': rf_reg.feature_importances_
}).sort_values('onem', ascending=False)
print(onem.head(10))

8. Model Değerlendirme ve Metrikler

Bir modelin başarılı olup olmadığını belirlemek için doğru metrikleri kullanmak hayati öneme sahiptir. Sınıflandırma ve regresyon problemleri için farklı metrikler kullanılır ve her metrik, modelin performansının farklı bir boyutunu ölçer.

from sklearn.metrics import (
    confusion_matrix, classification_report,
    roc_auc_score, roc_curve, precision_recall_curve
)
import matplotlib.pyplot as plt

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print("Karışıklık Matrisi:")
print(cm)

# Detaylı sınıflandırma raporu
print(classification_report(y_test, y_pred, target_names=['Negatif', 'Pozitif']))

# ROC-AUC hesaplama
y_prob = model.predict_proba(X_test)[:, 1]
auc_score = roc_auc_score(y_test, y_prob)
print(f"AUC-ROC Skoru: {auc_score:.4f}")

# Çapraz doğrulama ile güvenilir değerlendirme
from sklearn.model_selection import cross_val_score, StratifiedKFold

skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
cv_scores = cross_val_score(model, X, y, cv=skf, scoring='f1_weighted')
print(f"5-Fold CV F1: {cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")

9. Hyperparameter Tuning

Hiperparametre ayarı, bir modelin öğrenme sürecini kontrol eden parametrelerin en iyi kombinasyonunu bulma işlemidir. Doğru hiperparametre seçimi, model performansında önemli iyileştirmeler sağlayabilir. Scikit-learn bu süreç için güçlü araçlar sunar.

Grid Search ve Random Search

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from sklearn.ensemble import RandomForestClassifier
from scipy.stats import randint, uniform

# Grid Search - tüm kombinasyonları dener
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [5, 10, 15, 20, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4],
    'max_features': ['sqrt', 'log2']
}

grid_search = GridSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,
    scoring='f1_weighted',
    n_jobs=-1,
    verbose=1
)
grid_search.fit(X_train, y_train)

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

# Random Search - rastgele örnekleme (daha hızlı)
param_dist = {
    'n_estimators': randint(50, 500),
    'max_depth': randint(3, 30),
    'min_samples_split': randint(2, 20),
    'min_samples_leaf': randint(1, 10),
    'max_features': uniform(0.1, 0.9)
}

random_search = RandomizedSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=100,
    cv=5,
    scoring='f1_weighted',
    n_jobs=-1,
    random_state=42
)
random_search.fit(X_train, y_train)

print(f"En iyi parametreler: {random_search.best_params_}")
print(f"En iyi skor: {random_search.best_score_:.4f}")

# En iyi model ile test setinde değerlendirme
best_model = random_search.best_estimator_
y_pred_best = best_model.predict(X_test)
print(f"Test doğruluğu: {accuracy_score(y_test, y_pred_best):.4f}")

10. İleri Seviye Konular ve Pipeline

Gerçek dünya projelerinde, veri ön işleme ve model eğitimini tekrarlanabilir bir pipeline yapısında organize etmek büyük önem taşır. Scikit-learn Pipeline'ları, tüm adımları sıralı bir şekilde birleştirerek veri sızıntısını önler ve kodu temiz tutar.

ML Pipeline Oluşturma

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import GradientBoostingClassifier

# Sayısal ve kategorik sütunları ayırt etme
sayisal_ozellikler = ['yas', 'gelir', 'deneyim_yili']
kategorik_ozellikler = ['sehir', 'egitim', 'meslek']

# Sayısal pipeline
sayisal_pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# Kategorik pipeline
kategorik_pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(handle_unknown='ignore'))
])

# Sütun dönüştürücü
preprocessor = ColumnTransformer(transformers=[
    ('sayisal', sayisal_pipeline, sayisal_ozellikler),
    ('kategorik', kategorik_pipeline, kategorik_ozellikler)
])

# Tam pipeline
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', GradientBoostingClassifier(
        n_estimators=200,
        learning_rate=0.1,
        max_depth=5,
        random_state=42
    ))
])

# Eğitim ve tahmin
full_pipeline.fit(X_train, y_train)
y_pred = full_pipeline.predict(X_test)
print(f"Pipeline doğruluğu: {accuracy_score(y_test, y_pred):.4f}")

Modeli Kaydetme ve Yükleme

import joblib

# Modeli kaydetme
joblib.dump(full_pipeline, 'ml_model_v1.joblib')

# Modeli yükleme
loaded_model = joblib.load('ml_model_v1.joblib')
yeni_tahmin = loaded_model.predict(yeni_veri)
print(f"Tahmin: {yeni_tahmin}")

Ensemble Yöntemler ve Stacking

from sklearn.ensemble import VotingClassifier, StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

# Voting Classifier
voting_clf = VotingClassifier(
    estimators=[
        ('rf', RandomForestClassifier(n_estimators=200, random_state=42)),
        ('gb', GradientBoostingClassifier(n_estimators=200, random_state=42)),
        ('svc', SVC(probability=True, random_state=42))
    ],
    voting='soft'
)
voting_clf.fit(X_train, y_train)

# Stacking Classifier
stacking_clf = StackingClassifier(
    estimators=[
        ('rf', RandomForestClassifier(n_estimators=200, random_state=42)),
        ('gb', GradientBoostingClassifier(n_estimators=200, random_state=42)),
        ('svc', SVC(probability=True, random_state=42))
    ],
    final_estimator=LogisticRegression(),
    cv=5
)
stacking_clf.fit(X_train, y_train)
print(f"Stacking doğruluğu: {stacking_clf.score(X_test, y_test):.4f}")

Sık Sorulan Sorular (SSS)