Machine Learning Algorithms

• Rapid baselines that guide feature engineering and data collection.
• Strong model selection skills for classification, regression, and clustering tasks.
• Practical tuning to reach reliable performance with limited time and compute.
• Clear communication of model behavior, limitations, and risks to stakeholders.

Do quick refreshers on: arrays and broadcasting (NumPy), data wrangling (Pandas), and the scikit-learn estimator API (fit/predict/transform, pipelines).

• Can train and evaluate at least one model from each major family.
• Uses proper CV and reports uncertainty (mean ± std across folds).
• Understands when to prefer linear vs. tree-based vs. margin-based models.
• Can reduce dimensionality safely and explain the trade-offs.

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import roc_auc_score

X, y = make_classification(n_samples=3000, n_features=20, n_informative=5,
                           weights=[0.7, 0.3], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("clf", LogisticRegression(C=1.0, penalty="l2", solver="liblinear", max_iter=200))
])

pipe.fit(X_train, y_train)
proba = pipe.predict_proba(X_test)[:, 1]
print("ROC AUC:", roc_auc_score(y_test, proba))

# Tip: Lower C -> stronger regularization (simpler model, less variance)

from sklearn.datasets import make_regression
from sklearn.model_selection import cross_val_score
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
import numpy as np

X, y = make_regression(n_samples=3000, n_features=30, noise=10, random_state=0)
rf = RandomForestRegressor(n_estimators=300, random_state=0)
gb = GradientBoostingRegressor(random_state=0)

rf_scores = cross_val_score(rf, X, y, cv=5, scoring="neg_mean_absolute_error")
gb_scores = cross_val_score(gb, X, y, cv=5, scoring="neg_mean_absolute_error")

print("RF MAE:", -np.mean(rf_scores))
print("GB MAE:", -np.mean(gb_scores))

# Heuristic: RF handles many noisy features robustly; GB often wins with careful tuning.

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

X, y = load_breast_cancer(return_X_y=True)
pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("svm", SVC(kernel="rbf", probability=True))
])

param_grid = {
    "svm__C": [0.1, 1, 10],
    "svm__gamma": ["scale", 0.1, 0.01]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
search = GridSearchCV(pipe, param_grid, cv=cv, scoring="roc_auc", n_jobs=-1)
search.fit(X, y)
print("Best params:", search.best_params_)
print("Best AUC:", search.best_score_)

# Larger C -> narrower margin (can overfit); larger gamma -> more local decision boundary.

from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
import numpy as np

X, y = load_iris(return_X_y=True)
pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("knn", KNeighborsClassifier(n_neighbors=5, weights="distance"))
])

scores = cross_val_score(pipe, X, y, cv=5)
print("CV accuracy:", np.mean(scores))

# Always scale for distance-based models; try odd k in small datasets to reduce ties.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score

texts = [
    "great product loved it", "bad quality not recommended",
    "excellent value would buy again", "terrible broken on arrival",
    "works perfectly as expected", "waste of money"
]
labels = [1, 0, 1, 0, 1, 0]

X_train, X_test, y_train, y_test = train_test_split(texts, labels, test_size=0.33, random_state=42, stratify=labels)
model = make_pipeline(CountVectorizer(), MultinomialNB())
model.fit(X_train, y_train)
preds = model.predict(X_test)
print("F1:", f1_score(y_test, preds))

# NB is fast and strong with bag-of-words; assumes feature independence.

from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA
from sklearn.metrics import silhouette_score
import numpy as np

X, y_true = make_blobs(n_samples=1000, centers=4, cluster_std=1.0, random_state=0)

# PCA (for visualization or speed)
pca = PCA(n_components=2, random_state=0)
X2 = pca.fit_transform(X)

# KMeans with k=4
kmeans = KMeans(n_clusters=4, n_init=10, random_state=0)
labels_k = kmeans.fit_predict(X)
print("KMeans silhouette:", silhouette_score(X, labels_k))

# DBSCAN (density-based; discovers non-spherical clusters, can mark noise)
db = DBSCAN(eps=0.8, min_samples=10)
labels_d = db.fit_predict(X)
mask = labels_d != -1
if np.any(mask):
    print("DBSCAN silhouette:", silhouette_score(X[mask], labels_d[mask]))
else:
    print("DBSCAN found only noise with these params.")

# Heuristic: scale features before clustering; tune eps/min_samples for DBSCAN.

• Symptom: unrealistically high CV, low production performance.
• Fix: wrap preprocessing in Pipelines; split before scaling/encoding/selection.

• Symptom: accuracy looks great but minority class suffers.
• Fix: for imbalance, prefer ROC AUC, PR AUC, or F1; monitor class-wise recall.

• Symptom: best CV score is from extreme hyperparameters.
• Fix: use nested CV or a validation split; constrain search ranges; inspect learning curves.

• Symptom: kNN/SVM unstable across runs.
• Fix: standardize/normalize features; check outliers; use robust scalers if needed.

• Symptom: single number reported as performance.
• Fix: report mean ± std across folds; add confidence intervals for key metrics.

• Reproducible code with fixed random_state where applicable.
• No leakage (all transforms inside Pipelines).
• Report mean ± std across folds and final test metrics.
• Brief note on risks and failure modes (e.g., drift, imbalance).

• Add calibration (Platt scaling or isotonic) and compare Brier score.
• Use SHAP or permutation importance to validate feature influence (if available).
• Try Gradient Boosting or XGBoost-style alternatives and compare compute vs. gains.