🚀 ML Master Pipeline Handbook

Running dataset for the whole handbook: Titanic Survival Prediction. Every concept below is demonstrated on this same dataset — you'll watch it evolve from raw CSV to a deployable model. Target: Survived (0/1) — a binary classification problem.

1. The Complete ML Pipeline

Step-by-step: What / Why / Input / Output / Mistakes

2. Understanding the Dataset (Titanic)

Before any modeling: know your columns, their types, and what's missing. This is where you set up everything downstream.

Key checks to run first

import pandas as pd
df = pd.read_csv("titanic.csv")

df.info()               # dtypes + non-null counts
df.isnull().sum()      # missing values per column
df.duplicated().sum()   # duplicate rows
df['Survived'].value_counts(normalize=True)  # class balance

3. Exploratory Data Analysis (EDA)

Class Imbalance & Skewness

• Class imbalance: Titanic target is ~62% died / ~38% survived — mild imbalance. Not extreme, but enough that accuracy alone is a misleading metric (a model predicting "always died" gets 62% accuracy for free).
• Skewness: Fare is right-skewed (long tail of expensive tickets) — check with df['Fare'].skew(); |skew| > 1 typically flags a transform-worthy feature.

4. Data Preprocessing

4.1 Missing Values

# BEFORE: Age 177 missing, Embarked 2 missing, Cabin 687 missing (of 891 rows)
df['Age'] = df.groupby('Title')['Age'].transform(lambda x: x.fillna(x.median()))
df['Embarked'] = df['Embarked'].fillna(df['Embarked'].mode()[0])
df['HasCabin'] = df['Cabin'].notna().astype(int)
df.drop(columns=['Cabin'], inplace=True)
# AFTER: 0 missing values across all remaining columns

4.2 Outliers

4.3 Encoding Categorical Variables

4.4 Scaling

# BEFORE: Fare — skew ≈ 4.8, range 0 to 512
df['Fare_log'] = np.log1p(df['Fare'])
# AFTER: skew ≈ 0.4 — much closer to symmetric, ready for linear models

5. Feature Engineering

Feature Creation (the Titanic gold mine)

# Title extraction — classic Titanic feature engineering move
df['Title'] = df['Name'].str.extract(r' ([A-Za-z]+)\.')
df['Title'] = df['Title'].replace(
    ['Lady','Countess','Capt','Col','Don','Dr','Major','Rev','Sir','Jonkheer'], 'Rare')

df['FamilySize'] = df['SibSp'] + df['Parch'] + 1
df['IsAlone'] = (df['FamilySize'] == 1).astype(int)
df['Fare_per_Person'] = df['Fare'] / df['FamilySize']

Feature Selection

6. Model Selection

Titanic → categorical target → Classification branch.

(Clustering, PCA, and Time Series algorithms are covered in depth in Part 2 — they're listed above for the full decision tree but Titanic itself is a classification task, so Sections 7 onward focus there.)

— end of Part 1. Part 2 continues: Training the models → Evaluation → Overfitting/Underfitting → Hyperparameter Tuning → Ensemble Learning → Time Series — same Titanic thread continues. ✦ —

🚀 ML Master Pipeline Handbook

Picking up right where Part 1 left off — we now have a cleaned, feature-engineered Titanic dataset (Title, FamilySize, IsAlone, Fare_per_Person, one-hot encoded Sex/Embarked) split into train/test. Time to train.

7. Training the Models

We train several candidate models on the same processed Titanic train set and compare — this is the "bake-off" every real project does before committing to one model.

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)  # stratify keeps 38/62 split intact

models = {
    "LogReg": LogisticRegression(max_iter=1000),
    "RandomForest": RandomForestClassifier(n_estimators=300, random_state=42),
    "XGBoost": XGBClassifier(n_estimators=300, learning_rate=0.05, max_depth=4)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    print(name, model.score(X_test, y_test))

8. Model Evaluation

Classification metrics (Titanic = classification)

Regression metrics (for context/comparison)

9. Overfitting & Underfitting

Learning Curves & Validation Curves

• Learning curve: plot train vs validation score against training set size. Both low & converged → underfitting (need a better model/features). Big gap between train (high) and val (low) → overfitting (need more data/regularization).
• Validation curve: plot train vs validation score against a single hyperparameter (e.g., Decision Tree's max_depth). Reveals the sweet spot before validation score starts dropping while train score keeps climbing.

Tools to fight overfitting

• Regularization: L1 (Lasso, drives some coefficients to exactly 0 — implicit feature selection) / L2 (Ridge, shrinks coefficients smoothly) for linear models; reg_lambda/reg_alpha for boosting.
• Cross-validation: more reliable performance estimate than one train/test split — see Section 10.
• Feature selection: fewer, more relevant features → less room to memorize noise.
• Early stopping: stop boosting/neural net training once validation loss stops improving — directly prevents the model from continuing to fit noise.

10. Hyperparameter Tuning

Cross-Validation strategies (the engine behind tuning)

from sklearn.model_selection import GridSearchCV, StratifiedKFold

param_grid = {
    'n_estimators': [200, 300, 500],
    'max_depth': [3, 4, 6],
    'learning_rate': [0.01, 0.05, 0.1]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)  # keeps 38/62 ratio per fold
grid = GridSearchCV(XGBClassifier(), param_grid, cv=cv, scoring='f1')
grid.fit(X_train, y_train)
print(grid.best_params_, grid.best_score_)

11. Ensemble Learning

Bagging vs Boosting vs Voting vs Stacking

Random Forest (Bagging)

• Each tree: bootstrap sample of rows + random subset of features per split.
• Feature randomness decorrelates trees — this is why variance drops more than plain bagging (averaging correlated trees doesn't cancel noise nearly as well).
• Titanic: naturally captures "Sex AND Pclass AND Age" interactions without manual feature crosses.

AdaBoost & Gradient Boosting (Boosting)

• AdaBoost: reweights misclassified samples upward each round; final prediction = weighted vote of weak learners (stumps), weighted by each stump's accuracy.
• Gradient Boosting: each new tree fits the residual/negative gradient of the loss — generalizes AdaBoost to any differentiable loss function.
• XGBoost/LightGBM/CatBoost: engineering-optimized gradient boosting — regularized objectives, histogram-based splits (LightGBM), native categorical handling (CatBoost).

12. Time Series (brief)

Titanic has no temporal ordering, so this section is a compact standalone reference — included because "explain time series basics" is a very common interview follow-up even in a classification-heavy round.

— end of Part 2. Part 3 continues: Model Debugging → Model Comparison Dashboard → Deployment Pipeline → 100 Interview Q&A → Master Cheat Sheets → One-Page Ultimate Revision. ✦ —

🚀 ML Master Pipeline Handbook

Final stretch. Same Titanic thread — our tuned XGBoost/RF models are ready; now we debug, compare, ship, and revise.

13. Model Debugging

How an ML engineer actually thinks when a model underperforms — a systematic checklist, not guesswork.

14. Model Comparison Dashboard

One reference table spanning everything mentioned across this handbook — regression, classification, clustering, dimensionality reduction, boosting variants, and time series.

*Accuracy is a relative, qualitative rating for typical tabular problems — always validate empirically per dataset.

15. Deployment Pipeline

# minimal serving sketch
import joblib
pipeline = joblib.load("titanic_pipeline.pkl")  # preprocessing + model bundled together

def predict(passenger_json):
    df = pd.DataFrame([passenger_json])
    proba = pipeline.predict_proba(df)[:, 1][0]
    return {"survived_probability": float(proba)}

16. 100 Most Asked ML Interview Questions

Grouped by topic, crisp answers, ready for rapid-fire revision. Follow-ups are folded into the answer where a natural next question exists.

A. EDA & Data Understanding (1–10)

B. Preprocessing (11–25)

C. Feature Engineering & Selection (26–35)

D. Algorithms & Assumptions (36–55)

E. Model Evaluation (56–65)

F. Overfitting, Underfitting & Regularization (66–75)

G. Hyperparameter Tuning & Cross-Validation (76–85)

H. Ensemble Learning (86–93)

I. Time Series & Business/Process Questions (94–100)

17. Master Cheat Sheets

18. One-Page Ultimate Revision

If you only have one hour before the interview — read just this section.

— end of the handbook (Parts 1–3 complete). Good luck with the interviews! ✦ —