Scikit-learn Pipeline Rehberi (2026)

Scikit-learn Pipeline Nedir ve Neden Kullanmalısınız?

Makine öğrenmesi projelerinde veri ön işleme, özellik dönüşümü ve model eğitimi gibi adımları ayrı ayrı yazmak oldukça yaygın bir alışkanlık. Küçük deneylerde bu yaklaşım idare eder, ama gerçek dünya projelerine geçtiğinizde işler karışmaya başlıyor: veri sızıntısı (data leakage), her yerde tekrar eden kod blokları, üretimde beklenmeyen sonuçlar... Scikit-learn'ün Pipeline sınıfı tam olarak bu baş ağrılarını ortadan kaldırmak için var.

Pipeline, birden fazla veri dönüşümü ve modelleme adımını tek bir nesne içinde zincirler. Eğitim ve tahmin süreçleri tutarlı kalır, çapraz doğrulama sırasında veri sızıntısı önlenir ve kodunuz çok daha okunabilir hale gelir.

Bu rehberde Scikit-learn 1.8 ile Pipeline'ların nasıl oluşturulacağını, ColumnTransformer ile karma veri tiplerini nasıl yöneteceğinizi, GridSearchCV ve HalvingGridSearchCV ile hiperparametre optimizasyonunu ve iç içe çapraz doğrulamayı adım adım göreceğiz.

Temel Pipeline Oluşturma

Pipeline oluşturmak aslında çok basit. Her adıma bir isim ve bir dönüştürücü (transformer) veya tahmin edici (estimator) atıyorsunuz. Ara adımların hepsinde fit() ve transform() metodları bulunmalı; son adım ise yalnızca fit() metoduna sahip olabilir — genellikle bu son adım modeliniz oluyor.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

# Temel pipeline: ölçekleme + sınıflandırma
pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", LogisticRegression(max_iter=1000))
])

# Eğitim ve tahmin — tek nesne üzerinden
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
score = pipeline.score(X_test, y_test)
print(f"Doğruluk: {score:.4f}")

Alternatif olarak, make_pipeline() fonksiyonu adım isimlerini otomatik oluşturarak daha kısa bir söz dizimi sunar:

from sklearn.pipeline import make_pipeline

pipeline = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))

Her iki yöntem de aynı sonucu verir. Ama isimli adımlar kullanmak, özellikle hiperparametre araması sırasında parametreleri referans etmeyi ciddi şekilde kolaylaştırır. İlerleyen bölümlerde bunun neden bu kadar önemli olduğunu göreceksiniz.

Pipeline Veri Sızıntısını Nasıl Önler?

Açıkçası, makine öğrenmesindeki en sinsi hatalardan biri veri sızıntısı. Çapraz doğrulama öncesinde veri setinin tamamı üzerinde ölçekleme veya eksik değer doldurma yaparsanız, test katmanının bilgisi eğitim sürecine sızar. Sonuç? Metrikleriniz gerçekçi olmaktan çıkar ve siz farkında bile olmazsınız.

# YANLIŞ — veri sızıntısı var
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # Tüm veri üzerinde ölçekleme!
scores = cross_val_score(SVC(), X_scaled, y, cv=5)
# Test verisinin istatistikleri eğitime sızdı

# DOĞRU — Pipeline ile sızıntı yok
from sklearn.pipeline import make_pipeline

pipeline = make_pipeline(StandardScaler(), SVC())
scores = cross_val_score(pipeline, X, y, cv=5)
# Her katlamada ölçekleme yalnızca eğitim verisine uygulanır

Pipeline kullandığınızda, her çapraz doğrulama katlamasında StandardScaler yalnızca eğitim kısmına fit edilir ve test kısmına yalnızca transform uygulanır. Bu basit mekanizma, gerçek dünya performansını doğru yansıtan metrikler elde etmenizi sağlar.

Kendi deneyimimden söyleyeyim: bu hatayı ilk projelerimde defalarca yaptım. Pipeline'a geçtikten sonra bu tür kaygılar tamamen ortadan kalktı.

ColumnTransformer ile Karma Veri Tiplerini Yönetme

Gerçek dünya veri setleri hiçbir zaman sadece sayısal sütunlardan oluşmaz. Sayısal, kategorik ve metin sütunları bir arada bulunur ve her tip için farklı ön işleme gerekir: sayısal sütunları ölçeklemek, kategorik sütunları kodlamak, eksik değerleri farklı stratejilerle doldurmak... İşte ColumnTransformer tam bu noktada devreye giriyor.

import pandas as pd
import numpy as np
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer

# Örnek veri seti
veri = pd.DataFrame({
    "yas": [25, 30, np.nan, 45, 35],
    "maas": [4500, 7200, 5100, np.nan, 6800],
    "departman": ["IT", "Pazarlama", "IT", "Finans", None],
    "egitim": ["Lisans", "Yüksek Lisans", "Lisans", "Doktora", "Lisans"]
})

# Sayısal sütunlar için alt pipeline
sayisal_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])

# Kategorik sütunlar için alt pipeline
kategorik_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
])

# ColumnTransformer ile birleştirme
preprocessor = ColumnTransformer(transformers=[
    ("sayisal", sayisal_pipeline, ["yas", "maas"]),
    ("kategorik", kategorik_pipeline, ["departman", "egitim"])
])

make_column_selector ile Otomatik Sütun Seçimi

Sütun isimlerini tek tek yazmak zahmetli olabilir (özellikle 50+ sütunlu bir veri setiniz varsa). make_column_selector fonksiyonu ile veri tipine göre otomatik seçim yapabilirsiniz.

from sklearn.compose import make_column_selector as selector

preprocessor = ColumnTransformer(transformers=[
    ("sayisal", sayisal_pipeline, selector(dtype_include="number")),
    ("kategorik", kategorik_pipeline, selector(dtype_include="object"))
])

make_column_selector sayesinde yeni sayısal veya kategorik sütunlar eklendiğinde kodunuzu güncellemenize gerek kalmaz. Seçici bunları otomatik olarak yakalar ve doğru pipeline'a yönlendirir.

Uçtan Uca Pipeline: Veri Yüklemeden Tahmine

Hadi tüm parçaları bir araya getirelim. Gerçekçi bir makine öğrenmesi projesi kuruyoruz — Titanic benzeri bir veri seti üzerinde sınıflandırma yapacağız.

import pandas as pd
import numpy as np
from sklearn.compose import ColumnTransformer, make_column_selector as selector
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score

# Veri seti oluşturma
np.random.seed(42)
n = 500
veri = pd.DataFrame({
    "yas": np.random.normal(35, 12, n).clip(18, 70).round(),
    "gelir": np.random.normal(6000, 2000, n).clip(2000, 15000).round(),
    "deneyim_yili": np.random.randint(0, 30, n),
    "departman": np.random.choice(["IT", "Pazarlama", "Finans", "IK", "Üretim"], n),
    "egitim": np.random.choice(["Lise", "Lisans", "Yüksek Lisans", "Doktora"], n, p=[0.2, 0.45, 0.25, 0.1]),
    "sehir": np.random.choice(["İstanbul", "Ankara", "İzmir", "Bursa", "Antalya"], n),
})
veri["terfi"] = ((veri["deneyim_yili"] > 5) & (veri["gelir"] > 5000)).astype(int)

# Rastgele eksik değerler ekleme
for col in ["yas", "gelir"]:
    veri.loc[veri.sample(frac=0.1, random_state=42).index, col] = np.nan
veri.loc[veri.sample(frac=0.05, random_state=42).index, "departman"] = None

# Hedef ve özellikler
X = veri.drop("terfi", axis=1)
y = veri["terfi"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# Ön işleme pipeline'ları
sayisal_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])

kategorik_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(handle_unknown="ignore", sparse_output=False))
])

preprocessor = ColumnTransformer(transformers=[
    ("sayisal", sayisal_pipeline, selector(dtype_include="number")),
    ("kategorik", kategorik_pipeline, selector(dtype_include="object"))
])

# Tam pipeline
full_pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", RandomForestClassifier(n_estimators=200, random_state=42))
])

# Eğitim ve değerlendirme
full_pipeline.fit(X_train, y_train)
print(f"Test Doğruluğu: {full_pipeline.score(X_test, y_test):.4f}")

# Çapraz doğrulama
cv_scores = cross_val_score(full_pipeline, X, y, cv=5, scoring="f1")
print(f"CV F1 Skoru: {cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")

Dikkat edin: tüm ön işleme ve model eğitimi tek bir full_pipeline nesnesi üzerinden yönetiliyor. Yeni veri geldiğinde tek yapmanız gereken full_pipeline.predict(yeni_veri) çağrısı — ön işleme adımları otomatik uygulanır. Bu kadar temiz bir iş akışı, projenizi aylarca sürdürülebilir kılar.

GridSearchCV ile Hiperparametre Optimizasyonu

Pipeline'ın en güçlü yanlarından biri, GridSearchCV ve RandomizedSearchCV ile doğrudan entegre çalışabilmesi. Hem ön işleme hem de model hiperparametrelerini aynı anda arayabilirsiniz — başka bir araç kullanmaya gerek yok.

Parametre isimlerinde adımlar arasında çift alt çizgi (__) kullanılır. Mesela "classifier__n_estimators" ifadesi, "classifier" adımındaki n_estimators parametresine erişir. Biraz garip görünebilir ilk başta, ama alıştıktan sonra çok mantıklı geliyor.

from sklearn.model_selection import GridSearchCV

param_grid = {
    "preprocessor__sayisal__imputer__strategy": ["mean", "median"],
    "classifier__n_estimators": [100, 200, 300],
    "classifier__max_depth": [5, 10, 20, None],
    "classifier__min_samples_split": [2, 5, 10]
}

grid_search = GridSearchCV(
    full_pipeline,
    param_grid,
    cv=5,
    scoring="f1",
    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 CV F1 skoru: {grid_search.best_score_:.4f}")
print(f"Test F1 skoru: {grid_search.score(X_test, y_test):.4f}")

RandomizedSearchCV ile Daha Hızlı Arama

GridSearchCV tüm kombinasyonları deniyor, yani parametre uzayı büyüdükçe süre katlanarak artıyor. Hızlıca bir hesap yapalım: 4 parametrenin her birinde 10 olası değer varsa, 10.000 kombinasyon demek. 5 katlı çapraz doğrulamayla birlikte 50.000 model eğitimi gerekiyor. Ciddi bir süre.

RandomizedSearchCV ise rastgele örnekleme yaparak çok daha kısa sürede iyi sonuçlar üretir.

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint, uniform

param_distributions = {
    "classifier__n_estimators": randint(50, 500),
    "classifier__max_depth": [3, 5, 10, 20, None],
    "classifier__min_samples_split": randint(2, 20),
    "classifier__min_samples_leaf": randint(1, 10),
    "classifier__max_features": ["sqrt", "log2", None]
}

random_search = RandomizedSearchCV(
    full_pipeline,
    param_distributions,
    n_iter=50,
    cv=5,
    scoring="f1",
    n_jobs=-1,
    random_state=42,
    verbose=1
)

random_search.fit(X_train, y_train)
print(f"En iyi parametreler: {random_search.best_params_}")
print(f"En iyi CV F1 skoru: {random_search.best_score_:.4f}")

HalvingGridSearchCV: Scikit-learn 1.8'in Hızlı Alternatifi

Scikit-learn 1.8 ile daha stabil hale gelen HalvingGridSearchCV, ardışık yarılama (successive halving) stratejisi kullanır. Mantığı şöyle: ilk turda tüm adaylar küçük bir veri alt kümesiyle değerlendirilir, her turda kötü performans gösterenler elenir ve kalanlara daha fazla kaynak ayrılır.

Büyük parametre uzaylarında GridSearchCV'den kat kat daha hızlı.

from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV

param_grid = {
    "classifier__n_estimators": [50, 100, 200, 300, 500],
    "classifier__max_depth": [3, 5, 10, 20, None],
    "classifier__min_samples_split": [2, 5, 10],
}

halving_search = HalvingGridSearchCV(
    full_pipeline,
    param_grid,
    cv=5,
    scoring="f1",
    factor=3,
    resource="n_samples",
    random_state=42,
    n_jobs=-1
)

halving_search.fit(X_train, y_train)
print(f"En iyi parametreler: {halving_search.best_params_}")
print(f"En iyi CV skoru: {halving_search.best_score_:.4f}")

İç İçe Çapraz Doğrulama (Nested Cross-Validation)

Bu kısım biraz teknik ama çok önemli. Hiperparametre optimizasyonu ve model değerlendirmesini aynı veri üzerinde yaparsanız, sonuçlarınız iyimser çıkar — yani gerçekte olduğundan daha iyi görünür.

İç içe çapraz doğrulama bu sorunu çözer: iç döngü hiperparametre optimizasyonu yapar, dış döngü ise modelin gerçek genelleme performansını ölçer.

from sklearn.model_selection import cross_val_score, GridSearchCV, StratifiedKFold

# İç döngü: hiperparametre optimizasyonu
inner_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

param_grid = {
    "classifier__n_estimators": [100, 200],
    "classifier__max_depth": [5, 10, None]
}

grid_search = GridSearchCV(
    full_pipeline,
    param_grid,
    cv=inner_cv,
    scoring="f1",
    n_jobs=-1
)

# Dış döngü: gerçek performans tahmini
outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
nested_scores = cross_val_score(grid_search, X, y, cv=outer_cv, scoring="f1")

print(f"İç içe CV F1 skoru: {nested_scores.mean():.4f} (+/- {nested_scores.std():.4f})")

Evet, hesaplama maliyeti yüksek. Ama model seçimi veya karşılaştırması yapıyorsanız, bu en güvenilir değerlendirme yöntemi. Akademik yayınlarda ve ciddi raporlarda model performansını bildirirken bu yaklaşımı kullanmanızı tavsiye ederim.

Farklı Modelleri Pipeline ile Karşılaştırma

Pipeline yapısının çok sevdiğim bir avantajı daha var: ön işleme adımlarını sabit tutarak farklı modelleri kolayca karşılaştırabiliyorsunuz. Tek değişen şey son adımdaki model.

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

modeller = {
    "Lojistik Regresyon": LogisticRegression(max_iter=1000),
    "Random Forest": RandomForestClassifier(n_estimators=200, random_state=42),
    "Gradient Boosting": GradientBoostingClassifier(n_estimators=200, random_state=42),
    "SVM": SVC(kernel="rbf")
}

sonuclar = {}
for isim, model in modeller.items():
    pipeline = Pipeline([
        ("preprocessor", preprocessor),
        ("classifier", model)
    ])
    scores = cross_val_score(pipeline, X, y, cv=5, scoring="f1")
    sonuclar[isim] = scores
    print(f"{isim}: F1 = {scores.mean():.4f} (+/- {scores.std():.4f})")

# Sonuçları görselleştirme
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(10, 6))
ax.boxplot(sonuclar.values(), labels=sonuclar.keys())
ax.set_ylabel("F1 Skoru")
ax.set_title("Model Karşılaştırması")
plt.xticks(rotation=15)
plt.tight_layout()
plt.savefig("model_karsilastirma.png", dpi=150)
plt.show()

Pipeline'ı Kaydetme ve Üretim Ortamına Taşıma

Eğitilmiş pipeline'ı diske kaydettiğinizde tüm ön işleme parametreleri ve model ağırlıkları birlikte saklanır. Üretim ortamında tek yapmanız gereken pipeline'ı yükleyip predict() çağırmak — gerçekten bu kadar basit.

import joblib

# Kaydetme
joblib.dump(full_pipeline, "terfi_tahmini_pipeline.joblib")

# Yükleme ve tahmin
yuklenen_pipeline = joblib.load("terfi_tahmini_pipeline.joblib")

yeni_calisan = pd.DataFrame({
    "yas": [32],
    "gelir": [7500],
    "deneyim_yili": [8],
    "departman": ["IT"],
    "egitim": ["Yüksek Lisans"],
    "sehir": ["Ankara"]
})

tahmin = yuklenen_pipeline.predict(yeni_calisan)
print(f"Terfi tahmini: {'Evet' if tahmin[0] == 1 else 'Hayır'}")

Bu yaklaşımın güzel tarafı, modeli bir REST API veya web uygulamasına entegre etmeyi son derece kolaylaştırması. Tüm ön işleme adımları pipeline içinde kapsüllendiği için ayrıca dönüşüm kodu yazmanıza gerek yok. Flask, FastAPI, Django — hangisini kullanırsanız kullanın, pipeline'ı yükleyip doğrudan tahmin yapabilirsiniz.

Pipeline ile Özel Dönüştürücü Yazma

Scikit-learn'ün hazır dönüştürücüleri çoğu durumu karşılasa da bazen yeterli olmuyor. Kendi özel dönüştürücünüzü yazarak pipeline'a entegre edebilirsiniz. BaseEstimator ve TransformerMixin sınıflarından türetmeniz yeterli.

from sklearn.base import BaseEstimator, TransformerMixin

class YasGrubuEkleyici(BaseEstimator, TransformerMixin):
    """Yaş sütunundan yaş grubu özelliği türetir."""

    def __init__(self, yas_sutunu="yas"):
        self.yas_sutunu = yas_sutunu

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        X = X.copy()
        X["yas_grubu"] = pd.cut(
            X[self.yas_sutunu],
            bins=[0, 25, 35, 45, 100],
            labels=["Genç", "Orta", "Kıdemli", "Deneyimli"]
        )
        return X

# Pipeline'a ekleme
pipeline_ozel = Pipeline([
    ("yas_grubu", YasGrubuEkleyici(yas_sutunu="yas")),
    ("preprocessor", preprocessor),
    ("classifier", RandomForestClassifier(n_estimators=200, random_state=42))
])

Özel dönüştürücüler; özellik mühendisliği, veri doğrulama veya alana özgü dönüşümler için biçilmiş kaftan. BaseEstimator sayesinde get_params() ve set_params() metodlarını otomatik olarak kazanırlar, dolayısıyla GridSearchCV ile de sorunsuz çalışırlar.

Scikit-learn 1.8 ile Pipeline'lardaki Yenilikler

Aralık 2025'te yayınlanan Scikit-learn 1.8, Pipeline'larla doğrudan ilgili birkaç önemli yenilik getirdi. İşte öne çıkanlar:

Array API Desteği: StandardScaler, RidgeCV, PolynomialFeatures ve birçok metrik artık PyTorch ve CuPy dizileriyle doğrudan çalışabiliyor. Pipeline'ları GPU üzerinde çalıştırmak artık mümkün — ve bu gerçekten heyecan verici.
L1 Cezalı Tahmin Edicilerde Hız Artışı: Lasso, ElasticNet ve varyantlarının eğitim süresi gap-safe tarama kuralları sayesinde ciddi ölçüde azaldı.
Karar Ağacı Performansı: Mutlak hata kriterli karar ağaçlarında bölünme süresi ~20 saniyeden ~100 milisaniyeye düştü. Bu dramatik bir fark.
HTML Gösterim İyileştirmesi: Jupyter notebook'larda Pipeline'ların HTML gösteriminde hiperparametreler artık belgelere bağlantı içeriyor — hata ayıklamayı epey kolaylaştırıyor.

# Scikit-learn 1.8 — GPU destekli pipeline (PyTorch)
import torch
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import RidgeCV

# PyTorch tensörleri ile çalışma
X_torch = torch.tensor(X_train.values, dtype=torch.float32, device="cuda")
y_torch = torch.tensor(y_train.values, dtype=torch.float32, device="cuda")

# Pipeline GPU üzerinde çalışır
gpu_pipeline = make_pipeline(StandardScaler(), RidgeCV())
# Not: Array API desteği set_config ile etkinleştirilmelidir
from sklearn import config_context
with config_context(array_api_dispatch=True):
    gpu_pipeline.fit(X_torch, y_torch)

Sık Yapılan Hatalar ve Çözümleri

Pipeline kullanırken karşılaşılan en yaygın hataları ve çözümlerini bir araya getirdim. Bunların çoğunu ben de yaşadım, bu yüzden listeyi kişisel deneyimle de şekillendirdim diyebilirim.

1. Parametre İsimlendirme Hataları

GridSearchCV ile parametre ararken en sık yapılan hata, adım isimlerini yanlış yazmak. Küçük bir yazım hatası bütün aramayı bozabiliyor.

# YANLIŞ — adım ismi hatalı
param_grid = {"model__n_estimators": [100, 200]}

# DOĞRU — pipeline'daki adım ismiyle eşleşmeli
param_grid = {"classifier__n_estimators": [100, 200]}

# İpucu: mevcut parametreleri görmek için
print(full_pipeline.get_params().keys())

2. ColumnTransformer'da Sütun Sırası Karışıklığı

ColumnTransformer çıktısında sütun sırası, tanımlanan dönüştürücü sırasına göre belirlenir. Özellik önemliliklerini yorumlarken buna dikkat etmezseniz yanlış sütunu önemli sanabilirsiniz.

# Dönüştürülmüş özellik isimlerini almak için
feature_names = full_pipeline.named_steps["preprocessor"].get_feature_names_out()
print(feature_names)

3. Pandas DataFrame Uyumluluğu

Pipeline varsayılan olarak NumPy dizileri çıktısı verir. DataFrame çıktısı almak istiyorsanız set_output kullanmanız gerekiyor.

# Pipeline çıktısını DataFrame olarak almak
full_pipeline.set_output(transform="pandas")

# Veya global ayar olarak
from sklearn import set_config
set_config(transform_output="pandas")

Sıkça Sorulan Sorular

Scikit-learn Pipeline ne işe yarar?

Pipeline, veri ön işleme (ölçekleme, eksik değer doldurma, kategorik kodlama gibi) ve model eğitimi adımlarını tek bir nesnede zincirler. Kod tekrarı azalır, veri sızıntısı önlenir ve üretim ortamına taşıma kolaylaşır. Bir de GridSearchCV ile birlikte kullanıldığında hem ön işleme hem model parametrelerini aynı anda optimize edebilirsiniz.

Pipeline ile ColumnTransformer arasındaki fark nedir?

Pipeline adımları sıralı olarak zincirler — her adımın çıktısı bir sonraki adımın girdisi olur. ColumnTransformer ise farklı sütunlara farklı dönüşümler uygulayarak sonuçları yan yana birleştirir. Pratikte ColumnTransformer genellikle bir Pipeline'ın adımlarından biri olarak kullanılır.

GridSearchCV ve RandomizedSearchCV arasında hangisini seçmeliyim?

Parametre uzayınız küçükse (toplam 50-100 kombinasyon) GridSearchCV tüm olasılıkları deneyerek en iyisini garanti eder. Parametre sayısı veya değer aralıkları büyükse RandomizedSearchCV çok daha hızlı ve pratikte GridSearch kadar iyi sonuçlar verir. Çok büyük uzaylar için ise HalvingGridSearchCV'yi deneyin.

Pipeline'ı üretim ortamına nasıl taşıyabilirim?

joblib.dump() ile eğitilmiş pipeline'ı diske kaydedin. Üretim ortamında joblib.load() ile yükleyip doğrudan predict() çağırın. Tüm ön işleme adımları pipeline içinde kapsüllendiği için ayrıca dönüşüm kodu yazmanız gerekmez. Flask, FastAPI veya Django gibi web çerçeveleriyle kolayca entegre edebilirsiniz.

Veri sızıntısı (data leakage) nedir ve Pipeline bunu nasıl önler?

Veri sızıntısı, test verisinin bilgisinin eğitim sürecine karışmasıdır. Örneğin, veri setinin tamamı üzerinde ölçekleme yapıp ardından çapraz doğrulama uygulamak tipik bir sızıntı hatasıdır. Pipeline, her çapraz doğrulama katlamasında dönüşümlerin yalnızca eğitim kısmına uygulanmasını garanti eder ve bu sorunu tamamen ortadan kaldırır.