כל חומר הקורס, מסודר כצינור אחד: מקוד, לנתונים, למודלים, לענן

import pandas as pd
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

df = pd.read_csv("diamonds.csv")
X = pd.get_dummies(df.drop(columns="price"), drop_first=True).astype(float)
y = df["price"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42)
for name, reg in [("Linear", LinearRegression()), ("Ridge a=10", Ridge(alpha=10)),
                  ("Lasso a=50", Lasso(alpha=50, max_iter=5000)),
                  ("ElasticNet a=0.1 r=0.5", ElasticNet(alpha=0.1, l1_ratio=0.5, max_iter=5000))]:
    m = make_pipeline(StandardScaler(), reg).fit(X_tr, y_tr)
    coefs = m[-1].coef_
    print(f"{name:<21} R2={m.score(X_te, y_te):.4f}  zero coefs={int((abs(coefs) < 1e-8).sum())}/{len(coefs)}")

import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline

rng = np.random.default_rng(0)
X = rng.normal(size=(100, 5000))      # pure noise features
y = rng.integers(0, 2, size=100)      # random labels -> true accuracy is ~0.5

# WRONG: select the 20 "best" features on ALL data, then cross-validate
X_sel = SelectKBest(f_classif, k=20).fit_transform(X, y)
leaky = cross_val_score(LogisticRegression(max_iter=1000), X_sel, y, cv=5)
print("leaky CV accuracy :", leaky.mean().round(3))

# RIGHT: selection lives inside the pipeline, refit on each training fold only
pipe = make_pipeline(SelectKBest(f_classif, k=20), LogisticRegression(max_iter=1000))
clean = cross_val_score(pipe, X, y, cv=5)
print("pipeline CV accuracy:", clean.mean().round(3))

import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB

X, y = load_breast_cancer(return_X_y=True)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
models = {
    "LogReg":   make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)),
    "KNN":      make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)),
    "KNN (no scaling)": KNeighborsClassifier(n_neighbors=5),
    "SVM":      make_pipeline(StandardScaler(), SVC(kernel="rbf", C=1)),
    "SVM (no scaling)": SVC(kernel="rbf", C=1),
    "Tree":     DecisionTreeClassifier(max_depth=5, random_state=42),
    "RF":       RandomForestClassifier(n_estimators=300, random_state=42),
    "GradBoost": GradientBoostingClassifier(n_estimators=200, learning_rate=0.05,
                                            max_depth=3, random_state=42),
    "GaussianNB": GaussianNB(),
}
for name, model in models.items():
    s = cross_val_score(model, X, y, cv=cv, scoring="f1")
    print(f"{name:<17} F1 = {s.mean():.3f} ± {s.std():.3f}")

from sklearn.metrics import confusion_matrix, recall_score
y_true = [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
y_pred = [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
print("sklearn layout [[TN FP] [FN TP]]:\n", confusion_matrix(y_true, y_pred))
print("Recall / Sensitivity (TPR):", round(tp / (tp + fn), 3))
print("Specificity (TNR)         :", round(tn / (tn + fp), 3))
print("same via recall_score(pos_label=0):", round(recall_score(y_true, y_pred, pos_label=0), 3))
print("FPR = 1 - specificity     :", round(fp / (fp + tn), 3))

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

X, y = load_breast_cancer(return_X_y=True)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)
path = DecisionTreeClassifier(random_state=42).cost_complexity_pruning_path(X_tr, y_tr)
for a in [0.0, 0.002, 0.005, 0.01, 0.02, 0.05]:
    t = DecisionTreeClassifier(ccp_alpha=a, random_state=42).fit(X_tr, y_tr)
    print(f"ccp_alpha={a:<6} leaves={t.get_n_leaves():>2}  train={t.score(X_tr, y_tr):.3f}  test={t.score(X_te, y_te):.3f}")
print("number of candidate alphas on the path:", len(path.ccp_alphas))

from sklearn.ensemble import GradientBoostingClassifier
model = GradientBoostingClassifier(n_estimators=200, learning_rate=0.05,
                                   max_depth=3, random_state=42)

from sklearn.neighbors import KNeighborsRegressor
knn_reg = KNeighborsRegressor(n_neighbors=5, weights="distance")

from sklearn.naive_bayes import MultinomialNB   # word counts / frequencies
nb_text = MultinomialNB(alpha=1.0)