Classical ML
Scikit-learn Derinlemesine.

from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
import numpy as np

# ─── Her estimator aynı API'yi paylaşır ──────────────────────
X_train = np.random.randn(100, 5)
y_train = np.random.randint(0, 2, 100)
X_test  = np.random.randn(20, 5)

# Transformer — fit ile istatistik öğren, transform ile uygula
scaler = StandardScaler()
scaler.fit(X_train)               # mean ve std hesapla
X_scaled = scaler.transform(X_train)
print(f"mean_: {scaler.mean_[:3]}")
print(f"scale_: {scaler.scale_[:3]}")

# Predictor — fit ile eğit, predict ile tahmin
clf = LogisticRegression(max_iter=200)
clf.fit(X_scaled, y_train)
preds = clf.predict(scaler.transform(X_test))
proba = clf.predict_proba(scaler.transform(X_test))

# get_params / set_params — hiperparametre yönetimi
print(clf.get_params())
clf.set_params(C=0.5, solver='saga')

# clone — aynı parametrelerle yeni nesne (fit durumu olmadan)
from sklearn.base import clone
clf_copy = clone(clf)   # coef_ gibi öğrenilmiş nitelikler yok

# check_estimator — sklearn uyumluluk doğrulaması
from sklearn.utils.estimator_checks import check_estimator
# check_estimator(MyCustomEstimator())  # kendi estimator'ınız için

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

# ─── Örnek veri ───────────────────────────────────────────────
df = pd.DataFrame({
    'age':        [25, 32, np.nan, 45, 28],
    'income':     [40000, np.nan, 75000, 90000, 55000],
    'education':  ['HS', 'BSc', 'MSc', 'PhD', 'BSc'],
    'city':       ['İstanbul', 'Ankara', 'İzmir', 'İstanbul', 'Ankara'],
    'target':     [0, 1, 1, 1, 0]
})
X = df.drop('target', axis=1)
y = df['target']

numeric_cols     = ['age', 'income']
nominal_cols     = ['city']
ordinal_cols     = ['education']
education_order  = [['HS', 'BSc', 'MSc', 'PhD']]

# ─── Alt pipeline'lar ─────────────────────────────────────────
numeric_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler',  StandardScaler()),
])

nominal_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('ohe',     OneHotEncoder(handle_unknown='ignore', sparse_output=False)),
])

ordinal_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('ord',     OrdinalEncoder(categories=education_order)),
])

# ─── ColumnTransformer ────────────────────────────────────────
preprocessor = ColumnTransformer([
    ('num', numeric_transformer, numeric_cols),
    ('nom', nominal_transformer, nominal_cols),
    ('ord', ordinal_transformer, ordinal_cols),
], remainder='drop')

# ─── Tam Pipeline ─────────────────────────────────────────────
full_pipeline = Pipeline([
    ('prep', preprocessor),
    ('clf',  LogisticRegression(max_iter=1000)),
])

full_pipeline.fit(X, y)
print("Tahminler:", full_pipeline.predict(X))
print("Olasılıklar:", full_pipeline.predict_proba(X)[:, 1])

# ─── Pipeline adına göre parametre erişimi ────────────────────
# prep__num__scaler__with_mean, clf__C gibi çift alt çizgi ile
full_pipeline.set_params(clf__C=0.1)
print(full_pipeline.get_params().keys())

import numpy as np
from sklearn.linear_model import Ridge, Lasso, ElasticNet, RidgeCV, LassoCV
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# ─── Veri oluştur ─────────────────────────────────────────────
X, y = make_regression(n_samples=500, n_features=50,
                       n_informative=10, noise=25, random_state=42)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)

# ─── Ridge — L2 regularization ───────────────────────────────
ridge = Ridge(alpha=1.0)
ridge.fit(X_tr, y_tr)
rmse_ridge = mean_squared_error(y_te, ridge.predict(X_te), squared=False)
print(f"Ridge RMSE: {rmse_ridge:.2f}")
print(f"Sıfır katsayı sayısı: {(ridge.coef_ == 0).sum()}")  # 0

# ─── Lasso — L1 regularization, sparse ───────────────────────
lasso = Lasso(alpha=0.5, max_iter=5000)
lasso.fit(X_tr, y_tr)
rmse_lasso = mean_squared_error(y_te, lasso.predict(X_te), squared=False)
print(f"Lasso RMSE: {rmse_lasso:.2f}")
print(f"Sıfır katsayı sayısı: {(lasso.coef_ == 0).sum()}")  # ~40

# ─── ElasticNet — L1 + L2 mix ────────────────────────────────
enet = ElasticNet(alpha=0.5, l1_ratio=0.5, max_iter=5000)
enet.fit(X_tr, y_tr)

# ─── CV ile alpha seçimi ──────────────────────────────────────
ridge_cv = RidgeCV(alphas=np.logspace(-3, 3, 100), cv=5)
ridge_cv.fit(X_tr, y_tr)
print(f"En iyi alpha: {ridge_cv.alpha_:.4f}")

lasso_cv = LassoCV(cv=5, max_iter=10000)
lasso_cv.fit(X_tr, y_tr)
print(f"Lasso en iyi alpha: {lasso_cv.alpha_:.4f}")

# ─── Regularization path görselleştirme ───────────────────────
import matplotlib.pyplot as plt
alphas  = np.logspace(-2, 3, 50)
coefs   = [Lasso(alpha=a, max_iter=5000).fit(X_tr, y_tr).coef_ for a in alphas]
plt.figure(figsize=(10, 4))
plt.semilogx(alphas, coefs)
plt.xlabel("Alpha (Regularization Strength)")
plt.ylabel("Katsayı Değerleri")
plt.title("Lasso Regularization Path")
plt.axvline(lasso_cv.alpha_, color='red', linestyle='--', label='CV Alpha')
plt.legend()
plt.tight_layout()
plt.savefig('lasso_path.png', dpi=150)

from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.inspection import permutation_importance
import pandas as pd
import numpy as np

X, y = make_classification(n_samples=1000, n_features=20,
                            n_informative=8, random_state=42)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)

# ─── Decision Tree ────────────────────────────────────────────
dt = DecisionTreeClassifier(
    max_depth=4,
    min_samples_split=20,
    min_samples_leaf=10,
    criterion='gini',           # 'entropy' da kullanılabilir
    random_state=42
)
dt.fit(X_tr, y_tr)
print(f"DT Accuracy: {dt.score(X_te, y_te):.3f}")
print("Ağaç yapısı:")
print(export_text(dt, max_depth=3))

# ─── Random Forest ────────────────────────────────────────────
rf = RandomForestClassifier(
    n_estimators=200,
    max_depth=None,             # tam derinlik — bootstrap kurtarır
    max_features='sqrt',        # sınıflandırmada sqrt(n_features)
    min_samples_leaf=5,
    n_jobs=-1,
    random_state=42
)
rf.fit(X_tr, y_tr)
print(f"RF Accuracy: {rf.score(X_te, y_te):.3f}")

# ─── Feature Importance (MDI — Mean Decrease Impurity) ───────
fi = pd.Series(rf.feature_importances_,
               index=[f"feat_{i}" for i in range(20)])
print(fi.nlargest(5))

# ─── Permutation Importance — daha güvenilir ─────────────────
perm = permutation_importance(rf, X_te, y_te, n_repeats=20,
                               n_jobs=-1, random_state=42)
perm_df = pd.DataFrame({
    'mean': perm.importances_mean,
    'std':  perm.importances_std
}).nlargest(5, 'mean')
print(perm_df)

from sklearn.ensemble import GradientBoostingClassifier, HistGradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import xgboost as xgb
import lightgbm as lgb

X, y = make_classification(n_samples=5000, n_features=30,
                            n_informative=15, random_state=42)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2)

# ─── Sklearn HistGradientBoosting (hızlı, native NaN desteği) ─
hgb = HistGradientBoostingClassifier(
    max_iter=300,
    learning_rate=0.05,
    max_depth=5,
    l2_regularization=0.1,
    early_stopping=True,
    validation_fraction=0.1,
    random_state=42
)
hgb.fit(X_tr, y_tr)
print(f"HGB Accuracy: {hgb.score(X_te, y_te):.3f}, iter: {hgb.n_iter_}")

# ─── XGBoost ──────────────────────────────────────────────────
xgb_clf = xgb.XGBClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=5,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,       # L1
    reg_lambda=1.0,      # L2
    early_stopping_rounds=20,
    eval_metric='auc',
    random_state=42,
    n_jobs=-1
)
xgb_clf.fit(X_tr, y_tr,
           eval_set=[(X_te, y_te)],
           verbose=False)
print(f"XGB Accuracy: {xgb_clf.score(X_te, y_te):.3f}")

# ─── LightGBM ─────────────────────────────────────────────────
lgb_clf = lgb.LGBMClassifier(
    n_estimators=500,
    learning_rate=0.05,
    num_leaves=31,       # leaf-wise büyüme kontrolü
    min_child_samples=20,
    subsample=0.8,
    colsample_bytree=0.8,
    random_state=42,
    n_jobs=-1
)
lgb_clf.fit(X_tr, y_tr,
           eval_set=[(X_te, y_te)],
           callbacks=[lgb.early_stopping(20), lgb.log_evaluation(100)])
print(f"LGB Accuracy: {lgb_clf.score(X_te, y_te):.3f}")

from sklearn.model_selection import cross_val_score, StratifiedKFold, cross_validate
from sklearn.metrics import (confusion_matrix, classification_report,
                               roc_auc_score, roc_curve,
                               precision_recall_curve, average_precision_score)
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=2000, n_features=20,
                            weights=[0.85, 0.15], random_state=42)

# ─── Stratified K-Fold CV ─────────────────────────────────────
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
clf = RandomForestClassifier(n_estimators=100, random_state=42)

cv_scores = cross_val_score(clf, X, y, cv=skf, scoring='roc_auc', n_jobs=-1)
print(f"ROC-AUC: {cv_scores.mean():.3f} ± {cv_scores.std():.3f}")

# ─── Çoklu metrik ─────────────────────────────────────────────
results = cross_validate(clf, X, y, cv=skf, n_jobs=-1,
    scoring=['roc_auc', 'f1', 'precision', 'recall'])
for metric in ['roc_auc', 'f1', 'precision', 'recall']:
    vals = results[f"test_{metric}"]
    print(f"{metric:12s}: {vals.mean():.3f} ± {vals.std():.3f}")

# ─── Confusion matrix + classification report ─────────────────
from sklearn.model_selection import train_test_split
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, stratify=y)
clf.fit(X_tr, y_tr)
y_pred  = clf.predict(X_te)
y_proba = clf.predict_proba(X_te)[:, 1]

cm = confusion_matrix(y_te, y_pred)
print("Confusion Matrix:\n", cm)
print(classification_report(y_te, y_pred, target_names=['Negatif', 'Pozitif']))

# ─── ROC-AUC ve Precision-Recall ─────────────────────────────
auc = roc_auc_score(y_te, y_proba)
ap  = average_precision_score(y_te, y_proba)
print(f"ROC-AUC: {auc:.3f}, Average Precision: {ap:.3f}")

fpr, tpr, _ = roc_curve(y_te, y_proba)
prec, rec, thresholds = precision_recall_curve(y_te, y_proba)
# Eşik optimizasyonu: F1 maksimum
f1_scores = 2 * (prec * rec) / (prec + rec + 1e-9)
best_thr  = thresholds[np.argmax(f1_scores)]
print(f"En iyi threshold (F1 max): {best_thr:.3f}")

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

X, y = make_classification(n_samples=2000, n_features=20, random_state=42)

# ─── GridSearchCV ─────────────────────────────────────────────
param_grid = {
    'n_estimators':   [100, 200, 300],
    'max_depth':       [3, 5, 7, None],
    'min_samples_leaf': [1, 5, 10],
}
grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid, cv=5, scoring='roc_auc', n_jobs=-1
)
grid_search.fit(X, y)
print(f"Grid Best: {grid_search.best_params_}, AUC: {grid_search.best_score_:.3f}")

# ─── RandomizedSearchCV ───────────────────────────────────────
param_dist = {
    'n_estimators':    randint(50, 500),
    'max_depth':        randint(2, 15),
    'min_samples_leaf': randint(1, 20),
    'max_features':     uniform(0.2, 0.8),
}
rand_search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42),
    param_dist, n_iter=50, cv=5, scoring='roc_auc',
    n_jobs=-1, random_state=42
)
rand_search.fit(X, y)
print(f"Random Best: {rand_search.best_params_}, AUC: {rand_search.best_score_:.3f}")

# ─── Optuna — Bayesian Optimization ──────────────────────────
from sklearn.model_selection import cross_val_score, StratifiedKFold

def objective(trial):
    params = {
        'n_estimators':    trial.suggest_int('n_estimators', 50, 500),
        'max_depth':        trial.suggest_int('max_depth', 2, 15),
        'min_samples_leaf': trial.suggest_int('min_samples_leaf', 1, 20),
        'max_features':     trial.suggest_float('max_features', 0.2, 1.0),
    }
    clf = RandomForestClassifier(**params, n_jobs=-1, random_state=42)
    cv  = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)
    scores = cross_val_score(clf, X, y, cv=cv, scoring='roc_auc', n_jobs=1)
    return scores.mean()

optuna.logging.set_verbosity(optuna.logging.WARNING)
study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50, n_jobs=1)
print(f"Optuna Best: {study.best_params}, AUC: {study.best_value:.3f}")

from sklearn.feature_selection import (SelectKBest, f_classif,
                                          mutual_info_classif, RFE, RFECV)
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
import shap
import pandas as pd

X, y = make_classification(n_samples=1000, n_features=30,
                            n_informative=8, n_redundant=5, random_state=42)
feat_names = [f"f{i}" for i in range(30)]

# ─── SelectKBest ──────────────────────────────────────────────
selector_f = SelectKBest(f_classif, k=10)
selector_f.fit(X, y)
mask_f = selector_f.get_support()
print("ANOVA seçilen:", [feat_names[i] for i, m in enumerate(mask_f) if m])

selector_mi = SelectKBest(mutual_info_classif, k=10)
selector_mi.fit(X, y)
mask_mi = selector_mi.get_support()
print("MI seçilen:", [feat_names[i] for i, m in enumerate(mask_mi) if m])

# ─── RFE ──────────────────────────────────────────────────────
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rfe = RFE(rf, n_features_to_select=10, step=3)
rfe.fit(X, y)
print("RFE seçilen:", [feat_names[i] for i, m in enumerate(rfe.support_) if m])

# ─── RFECV — CV ile otomatik k ────────────────────────────────
rfecv = RFECV(RandomForestClassifier(n_estimators=50, random_state=42),
              step=2, cv=3, scoring='roc_auc', n_jobs=-1)
rfecv.fit(X, y)
print(f"RFECV optimum özellik sayısı: {rfecv.n_features_}")

# ─── SHAP Feature Importance ──────────────────────────────────
rf.fit(X, y)
explainer   = shap.TreeExplainer(rf)
shap_values = explainer.shap_values(X[:, ...])
# Global importance: |SHAP| ortalaması
mean_abs_shap = pd.Series(
    shap_values[1].mean(axis=0).__abs__(),  # pozitif sınıf SHAP
    index=feat_names
).sort_values(ascending=False)
print(mean_abs_shap.head(10))
# shap.summary_plot(shap_values[1], X, feature_names=feat_names)

from imblearn.over_sampling import SMOTE, SMOTENC
from imblearn.under_sampling import RandomUnderSampler
from imblearn.combine import SMOTETomek
from imblearn.pipeline import Pipeline as ImbPipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import StratifiedKFold, cross_validate
from sklearn.datasets import make_classification
import numpy as np

X, y = make_classification(n_samples=5000, n_features=20,
                            weights=[0.9, 0.1], random_state=42)
print(f"Sınıf 0: {(y==0).sum()}, Sınıf 1: {(y==1).sum()}")

# ─── SMOTE ────────────────────────────────────────────────────
smote = SMOTE(sampling_strategy=0.5, k_neighbors=5, random_state=42)
X_res, y_res = smote.fit_resample(X, y)
print(f"SMOTE sonrası — Sınıf 0: {(y_res==0).sum()}, Sınıf 1: {(y_res==1).sum()}")

# ─── SMOTETomek — oversample + temizleme ─────────────────────
smt = SMOTETomek(random_state=42)
X_smt, y_smt = smt.fit_resample(X, y)

# ─── class_weight='balanced' — en basit yol ───────────────────
clf_balanced = RandomForestClassifier(
    n_estimators=200, class_weight='balanced', random_state=42
)

# ─── imbalanced-learn Pipeline (SMOTE sadece train'de) ────────
pipe = ImbPipeline([
    ('smote', SMOTE(random_state=42)),
    ('clf',   RandomForestClassifier(n_estimators=200, random_state=42)),
])
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_validate(pipe, X, y, cv=cv, scoring=['f1', 'roc_auc'], n_jobs=-1)
print(f"SMOTE+RF F1:  {scores['test_f1'].mean():.3f}")
print(f"SMOTE+RF AUC: {scores['test_roc_auc'].mean():.3f}")

# ─── Threshold tuning ─────────────────────────────────────────
from sklearn.model_selection import train_test_split
from sklearn.metrics import precision_recall_curve
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, stratify=y)
clf_balanced.fit(X_tr, y_tr)
proba = clf_balanced.predict_proba(X_te)[:, 1]
prec, rec, thr = precision_recall_curve(y_te, proba)
f1  = 2 * prec * rec / (prec + rec + 1e-9)
opt = thr[np.argmax(f1[:-1])]
print(f"Varsayılan eşik (0.5) F1: {f1[np.searchsorted(thr, 0.5)]:.3f}")
print(f"Optimal eşik ({opt:.2f}) F1: {f1.max():.3f}")

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
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
from sklearn.metrics import classification_report, roc_auc_score
import shap, joblib

# ─── 1. Veri Yükleme ──────────────────────────────────────────
url = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
cols = ['age', 'workclass', 'fnlwgt', 'education', 'education-num',
        'marital-status', 'occupation', 'relationship', 'race',
        'sex', 'capital-gain', 'capital-loss', 'hours-per-week',
        'native-country', 'income']
df = pd.read_csv(url, header=None, names=cols,
                  skipinitialspace=True, na_values='?')

# ─── 2. Target ve Feature ayrımı ─────────────────────────────
df['income'] = (df['income'].str.strip() == '>50K').astype(int)
X = df.drop(['income', 'fnlwgt'], axis=1)  # fnlwgt kaldır
y = df['income']

num_cols  = ['age', 'education-num', 'capital-gain',
             'capital-loss', 'hours-per-week']
cat_cols  = ['workclass', 'education', 'marital-status',
             'occupation', 'relationship', 'race', 'sex', 'native-country']

X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

# ─── 3. Preprocessing ─────────────────────────────────────────
num_pipe = Pipeline([
    ('imp',   SimpleImputer(strategy='median')),
    ('scale', StandardScaler()),
])
cat_pipe = Pipeline([
    ('imp', SimpleImputer(strategy='most_frequent')),
    ('ohe', OneHotEncoder(handle_unknown='ignore', sparse_output=False)),
])
prep = ColumnTransformer([
    ('num', num_pipe, num_cols),
    ('cat', cat_pipe, cat_cols),
])

# ─── 4. Model Pipeline ────────────────────────────────────────
pipeline = Pipeline([
    ('prep', prep),
    ('clf',  GradientBoostingClassifier(
        n_estimators=300, learning_rate=0.05,
        max_depth=4, subsample=0.8, random_state=42
    )),
])

# ─── 5. Eğitim ve Değerlendirme ───────────────────────────────
pipeline.fit(X_tr, y_tr)
y_pred  = pipeline.predict(X_te)
y_proba = pipeline.predict_proba(X_te)[:, 1]
print(classification_report(y_te, y_pred, target_names=['<=50K', '>50K']))
print(f"ROC-AUC: {roc_auc_score(y_te, y_proba):.3f}")

# ─── 6. SHAP Interpretability ─────────────────────────────────
X_tr_prep = pipeline['prep'].transform(X_tr)
ohe_cats  = pipeline['prep'].named_transformers_['cat']['ohe'].get_feature_names_out(cat_cols)
feat_names = list(num_cols) + list(ohe_cats)

explainer   = shap.TreeExplainer(pipeline['clf'])
shap_values = explainer.shap_values(X_tr_prep[:500])
shap.summary_plot(shap_values, X_tr_prep[:500],
                  feature_names=feat_names, show=False)

# ─── 7. Model Kaydetme ────────────────────────────────────────
joblib.dump(pipeline, 'adult_income_pipeline.joblib')
print("Model kaydedildi: adult_income_pipeline.joblib")