# What is Machine Learning?

You've heard the buzzword everywhere. But what actually IS machine learning?

## The Simple Answer

Machine Learning is teaching computers to learn from examples instead of giving them exact rules.

**Traditional Programming:**
```
Rules + Data → Output
```

**Machine Learning:**
```
Data + Output → Rules (learned automatically)
```

## A Real Example

Say you want to filter spam emails.

**Traditional approach:** Write rules like "if email contains 'FREE MONEY', mark as spam"

**ML approach:** Show the computer 10,000 spam emails and 10,000 normal emails. It learns the patterns itself.

The ML approach is better because:
- It catches patterns you never thought of
- It adapts when spammers change tactics
- It improves with more data

## Three Types of Machine Learning

### 1. Supervised Learning
You give labeled examples: "This is a cat, this is a dog"
The model learns to predict labels for new data.

### 2. Unsupervised Learning
No labels. The model finds hidden patterns itself.
Example: Grouping customers by shopping behavior.

### 3. Reinforcement Learning
Learning by trial and error with rewards.
Example: A game-playing AI that gets points for winning.

## When to Use ML?

Use ML when:
- You have lots of data
- The problem is too complex for manual rules
- Patterns might change over time

Don't use ML when:
- Simple rules work fine
- You can't get enough data
- You need 100% explainable decisions

## Quick Vocabulary

- **Model**: The thing that learns and makes predictions
- **Training**: Teaching the model with data
- **Features**: Input variables (like age, income)
- **Label**: What you're trying to predict
- **Prediction**: The model's output

## What's Next?

Machine Learning isn't magic—it's math and statistics applied cleverly. In upcoming tutorials, we'll build actual models and see how they work inside.

The key insight: ML finds patterns in data that humans might miss. That's its superpower.

Understand what Machine Learning actually is, how it differs from traditional programming, and why it matters today.

What is Machine Learning? A Simple Introduction

# Supervised vs Unsupervised Learning

These are the two main flavors of ML. Let's break them down simply.

## Supervised Learning = Learning with Answers

Think of a teacher showing flashcards:
- Shows picture of cat → "This is a cat"
- Shows picture of dog → "This is a dog"

After enough examples, the student can identify new animals.

**The key:** You provide labeled data (input + correct answer).

### Supervised Learning Examples:

| Task | Input | Label |
|------|-------|-------|
| Spam detection | Email text | Spam/Not spam |
| House prices | Size, location | Price |
| Disease diagnosis | Symptoms | Disease type |
| Image recognition | Photo | Object name |

### Two Types of Supervised Learning:

**Classification** - Predicting categories
```python
# Is this email spam?
prediction = "spam" or "not_spam"
```

**Regression** - Predicting numbers
```python
# What's this house worth?
prediction = 450000  # dollars
```

## Unsupervised Learning = Finding Hidden Patterns

No labels. No right answers. The algorithm explores data on its own.

Like giving someone a box of Legos without instructions—they'll naturally group similar pieces together.

### Unsupervised Learning Examples:

| Task | What it does |
|------|--------------|
| Customer segmentation | Groups similar customers |
| Anomaly detection | Finds unusual transactions |
| Topic modeling | Discovers themes in documents |
| Recommendation | Finds similar items |

### Main Types:

**Clustering** - Grouping similar items
```python
# Which customers are similar?
groups = [[user1, user4], [user2, user5], [user3]]
```

**Dimensionality Reduction** - Simplifying data
```python
# Reduce 100 features to 10 important ones
simplified_data = reduce(complex_data)
```

## Quick Comparison

| Aspect | Supervised | Unsupervised |
|--------|------------|--------------|
| Has labels? | Yes | No |
| Goal | Predict specific output | Find patterns |
| Evaluation | Easy (compare to answers) | Harder (subjective) |
| Data prep | More work (need labels) | Less work |
| Examples | Spam filter, price prediction | Customer groups, anomaly detection |

## Which Should You Use?

**Use Supervised when:**
- You know what you want to predict
- You have labeled examples
- You need measurable accuracy

**Use Unsupervised when:**
- You want to explore data
- Labeling is expensive/impossible
- You're looking for unknown patterns

## Real World Scenario

**E-commerce website:**

Supervised task: "Will this user buy?" (Yes/No labels from history)

Unsupervised task: "What types of shoppers do we have?" (No labels, find natural groups)

Both work together! Use unsupervised to find customer segments, then supervised to predict behavior within each segment.

## Key Takeaway

- **Supervised** = "Here's the answer, learn to predict it"
- **Unsupervised** = "Find interesting patterns yourself"

Most real projects use both. Start with supervised if you have clear goals and labeled data.

Clear explanation of the two main types of machine learning with real examples and when to use each.

Supervised vs Unsupervised Learning Explained

# Training, Validation, and Test Sets

Why split your data? Because you need to know if your model actually works on NEW data, not just the data it learned from.

## The Problem

Imagine studying for an exam by memorizing all the practice questions.

If the exam has the SAME questions → You ace it
If the exam has DIFFERENT questions → You might fail

This is exactly what happens with ML models. We need to test on unseen data.

## The Three Splits

### Training Set (60-80% of data)
- Model learns from this
- Like the textbook you study from

### Validation Set (10-20% of data)
- Used to tune the model
- Like practice tests
- Helps you decide model settings

### Test Set (10-20% of data)
- Final evaluation only
- Like the actual exam
- NEVER touch until the very end

## Why Three Sets? Why Not Two?

With just train/test:

```python
# Bad approach
train_model(training_data)
if accuracy_on_test < 90%:
    tweak_settings()  # Oops! Now test set influenced your choices
    train_again()
```

The test set gets "leaked" into your decisions. You need a separate validation set for tuning.

## How to Split

```python
from sklearn.model_selection import train_test_split

# First split: separate test set
train_val, test = train_test_split(data, test_size=0.2)

# Second split: separate validation from training
train, val = train_test_split(train_val, test_size=0.2)

# Result: 64% train, 16% val, 20% test
```

## Common Splits

| Dataset Size | Train | Validation | Test |
|-------------|-------|------------|------|
| Small (<1K) | 60% | 20% | 20% |
| Medium (1K-100K) | 70% | 15% | 15% |
| Large (>100K) | 80% | 10% | 10% |

With big data, you can afford smaller validation/test percentages.

## Important Rules

### 1. Shuffle Before Splitting
```python
# Data might be ordered (all cats first, then dogs)
data = shuffle(data)  # Randomize first!
```

### 2. Keep Test Set Sacred
Never use test set for:
- Choosing features
- Tuning hyperparameters
- Deciding which model to use

### 3. Split BEFORE Any Processing
```python
# Wrong - data leakage!
normalized_data = normalize(all_data)
train, test = split(normalized_data)

# Right
train, test = split(raw_data)
train_normalized = normalize(train)  # Learn stats from train only
test_normalized = apply_same_normalization(test)
```

## Cross-Validation

When data is limited, use k-fold cross-validation:

```
Fold 1: [VAL][TRAIN][TRAIN][TRAIN][TRAIN]
Fold 2: [TRAIN][VAL][TRAIN][TRAIN][TRAIN]
Fold 3: [TRAIN][TRAIN][VAL][TRAIN][TRAIN]
Fold 4: [TRAIN][TRAIN][TRAIN][VAL][TRAIN]
Fold 5: [TRAIN][TRAIN][TRAIN][TRAIN][VAL]
```

Each data point gets to be in validation once. Average the results.

## Quick Summary

| Set | Purpose | When Used |
|-----|---------|-----------|
| Training | Learn patterns | During training |
| Validation | Tune settings | While developing |
| Test | Final score | Once, at the end |

## The Golden Rule

Your test set score should represent real-world performance. If you peek at it during development, you're fooling yourself about how good your model really is.

Learn why we split data into training, validation, and test sets, and how to do it correctly.

Understanding Training, Validation, and Test Sets

# Features and Labels: ML Building Blocks

Every ML problem boils down to: given these **features**, predict this **label**.

## What Are Features?

Features are the input variables—the information you give the model to make predictions.

**Example: Predicting house prices**

Features might be:
- Square footage
- Number of bedrooms
- Location
- Year built
- Has garage?

Each feature is a piece of information that might help predict the price.

## What Are Labels?

Labels are what you're trying to predict—the output.

| Problem | Label |
|---------|-------|
| House price prediction | Price ($) |
| Email spam detection | Spam or Not Spam |
| Disease diagnosis | Disease type |
| Customer churn | Will leave? Yes/No |

## Features vs Labels

```
Features (X)              Label (y)
─────────────            ─────────
[sqft, beds, location] → [price]
[email_text, sender]   → [spam/not_spam]
[age, symptoms, tests] → [diagnosis]
```

In code:
```python
X = data[['sqft', 'bedrooms', 'location']]  # Features
y = data['price']  # Label

model.fit(X, y)  # Learn: features → label
```

## Good Features Matter More Than Fancy Algorithms

A simple model with great features beats a complex model with poor features.

**Feature Engineering** = Creating good features from raw data

Example - Predicting flight delays:
- Raw data: departure_time = "2025-03-15 14:30:00"
- Better features:
  - hour_of_day = 14
  - day_of_week = Saturday
  - is_holiday = False
  - month = March

## Types of Features

### Numerical
Numbers that have mathematical meaning.
```python
age = 25
temperature = 72.5
income = 50000
```

### Categorical
Categories or groups.
```python
color = "red"
country = "USA"
size = "medium"
```

### Binary
Yes/No, True/False.
```python
is_member = True
has_insurance = False
```

## What Makes a Good Feature?

### 1. Predictive Power
Does it actually help predict the label?
- Height probably helps predict basketball skill
- Shoe size probably doesn't

### 2. Available at Prediction Time
You need the feature when making predictions!
- Predicting "will customer buy?" 
- Can't use "did customer buy" as a feature 😅

### 3. Not Too Many Missing Values
Features with 50% missing data cause problems.

### 4. Not Redundant
Don't include both "age" and "birth_year"—same information.

## Common Mistakes

### Mistake 1: Data Leakage
```python
# Predicting if patient has diabetes
# BAD: insulin_dosage as feature (reveals the answer!)
# GOOD: age, weight, family_history
```

### Mistake 2: Using Future Information
```python
# Predicting tomorrow's stock price
# BAD: tomorrow's trading volume (you don't have it yet!)
# GOOD: historical prices, today's volume
```

## Quick Vocab

- **Feature Matrix (X)**: All features for all samples
- **Target Vector (y)**: All labels
- **Feature Engineering**: Creating new features
- **Feature Selection**: Choosing which features to use

## Summary

| Term | What It Is | Example |
|------|-----------|---------|
| Feature | Input variable | Age, income, location |
| Label | Output to predict | Price, category |
| Sample | One data point | One house, one customer |

Remember: **Garbage features in = Garbage predictions out**

Spend time on your features. They're often more important than which algorithm you choose.

Understand features and labels - the fundamental concepts you need before building any ML model.

Features and Labels: The Building Blocks of ML

# Linear Regression: Your First ML Model

Linear Regression is the "Hello World" of machine learning. Simple, powerful, and teaches you core concepts.

## What Is Linear Regression?

Finding the best straight line through your data points.

```
Price
  │    
  │         ∙  ∙
  │      ∙ ───────  ← Best fit line
  │   ∙  ∙
  │ ∙
  └────────────── Size
```

The line lets you predict: "If house is X sqft, price is probably Y."

## The Math (Keep It Simple)

The equation of a line:
```
y = mx + b
```

In ML terms:
```
prediction = (weight × feature) + bias
```

- **weight (m)**: How much the feature affects the prediction
- **bias (b)**: The baseline value

## Multiple Features

With more features, we just add more weights:

```
price = (w1 × sqft) + (w2 × bedrooms) + (w3 × age) + bias
```

The model learns the best weights automatically.

## How Does It Learn?

### Step 1: Start with random weights
```python
weights = [0.5, 0.3, -0.1]  # Random guess
```

### Step 2: Make predictions
```python
predicted_price = weights[0]*sqft + weights[1]*beds + weights[2]*age + bias
```

### Step 3: Calculate error
```python
error = actual_price - predicted_price
```

### Step 4: Adjust weights to reduce error
This is called **gradient descent** (more on this later).

### Step 5: Repeat until error is small

## Code Example

```python
from sklearn.linear_model import LinearRegression
import numpy as np

# Training data
X = np.array([[1400, 3], [1600, 3], [1700, 2], [1875, 3], [1100, 2]])  # sqft, beds
y = np.array([245000, 312000, 279000, 308000, 199000])  # prices

# Create and train model
model = LinearRegression()
model.fit(X, y)

# See what it learned
print(f"Weights: {model.coef_}")      # How much each feature matters
print(f"Bias: {model.intercept_}")    # Baseline

# Make prediction
new_house = [[1500, 3]]  # 1500 sqft, 3 beds
predicted = model.predict(new_house)
print(f"Predicted price: ${predicted[0]:,.0f}")
```

Output:
```
Weights: [156.2, 8432.1]    # sqft matters a lot!
Bias: -18432.5
Predicted price: $268,756
```

## Interpreting the Weights

If weight for sqft = 156.2:
"Each additional square foot adds ~$156 to the price"

If weight for bedrooms = 8432.1:
"Each additional bedroom adds ~$8,432 to the price"

**This interpretability is Linear Regression's superpower!**

## Measuring Performance

### Mean Squared Error (MSE)
```python
errors = predictions - actual_values
mse = mean(errors ** 2)
```
Lower is better. Penalizes big errors heavily.

### R² Score
```python
from sklearn.metrics import r2_score
score = r2_score(y_true, y_pred)
```
- R² = 1.0: Perfect predictions
- R² = 0.0: No better than guessing the average
- R² < 0: Worse than guessing!

## When Linear Regression Works Well

✅ Relationship is actually linear
✅ Features are independent (not too correlated)
✅ No extreme outliers
✅ You need interpretable results

## When It Fails

❌ Non-linear relationships (use polynomial or other models)
❌ Classification problems (use Logistic Regression instead)
❌ Complex patterns (use decision trees, neural networks)

## Assumptions to Know

1. **Linearity**: Relationship is roughly linear
2. **Independence**: Data points are independent
3. **Homoscedasticity**: Error spread is constant
4. **Normality**: Errors are normally distributed (for inference)

Don't worry too much about these for predictions. They matter more for statistical analysis.

## Quick Summary

| Aspect | Linear Regression |
|--------|------------------|
| Type | Supervised, Regression |
| Output | Continuous number |
| Formula | y = w₁x₁ + w₂x₂ + ... + b |
| Learns | Optimal weights |
| Pro | Simple, interpretable |
| Con | Only linear relationships |

Linear Regression is your foundation. Even if you use complex models later, understanding this helps you understand them all.

Learn Linear Regression from scratch - the simplest and most important ML algorithm to understand.

Your First ML Model: Linear Regression Explained

# Logistic Regression: Classification Basics

Despite the confusing name, Logistic Regression is for **classification**, not regression. It predicts categories.

## The Problem

Linear Regression predicts numbers. But what if you need:
- Spam or Not Spam?
- Will customer churn? Yes/No
- Is transaction fraud? Yes/No

You need probabilities and categories, not raw numbers.

## The Solution: Sigmoid Function

Logistic Regression uses the sigmoid function to squash any number into 0-1 range:

```
         1
σ(x) = ─────────
       1 + e^(-x)
```

```
Output
  1 │          ════════
    │        ╱
0.5 │──────╋──────────
    │    ╱
  0 │════
    └──────────────── x
```

Now we can interpret the output as probability!

## How It Works

### Step 1: Linear combination (like linear regression)
```python
z = w1*x1 + w2*x2 + ... + bias
```

### Step 2: Sigmoid to get probability
```python
probability = sigmoid(z) = 1 / (1 + exp(-z))
```

### Step 3: Threshold for final prediction
```python
prediction = 1 if probability >= 0.5 else 0
```

## Code Example

```python
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import numpy as np

# Sample data: study hours, previous score -> pass/fail
X = np.array([[2, 50], [3, 55], [5, 65], [6, 70], [8, 85], [10, 90],
              [1, 45], [2, 48], [4, 60], [7, 78]])
y = np.array([0, 0, 1, 1, 1, 1, 0, 0, 1, 1])  # 0=fail, 1=pass

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Train model
model = LogisticRegression()
model.fit(X_train, y_train)

# Predict
new_student = [[5, 62]]  # 5 hours study, 62 previous score
probability = model.predict_proba(new_student)
prediction = model.predict(new_student)

print(f"Probability of passing: {probability[0][1]:.2%}")
print(f"Prediction: {'Pass' if prediction[0] == 1 else 'Fail'}")
```

Output:
```
Probability of passing: 73.45%
Prediction: Pass
```

## Understanding the Output

```python
model.predict_proba([[5, 62]])
# Returns: [[0.2655, 0.7345]]
#           ↑ Prob(Fail)  ↑ Prob(Pass)
```

Probabilities always sum to 1.

## Multiclass Classification

What if you have more than 2 classes? (Cat, Dog, Bird)

```python
model = LogisticRegression(multi_class='multinomial')
model.fit(X, y)  # y can be [0, 1, 2] for three classes

# Predictions
model.predict_proba([[features]])
# Returns: [[0.15, 0.75, 0.10]]  # Probabilities for each class
```

## Evaluation Metrics

### Accuracy
```python
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_true, y_pred)  # % correct
```

### Confusion Matrix
```
                 Predicted
                 0    1
Actual    0    [TN,  FP]
          1    [FN,  TP]
```

- **TN**: Correctly predicted negative
- **TP**: Correctly predicted positive
- **FP**: False alarm (predicted positive, was negative)
- **FN**: Missed it (predicted negative, was positive)

### Precision & Recall
```python
precision = TP / (TP + FP)  # Of predicted positives, how many correct?
recall = TP / (TP + FN)     # Of actual positives, how many found?
```

## Choosing the Threshold

Default threshold is 0.5, but you can change it:

```python
# Lower threshold = more positive predictions
threshold = 0.3
predictions = (model.predict_proba(X)[:, 1] >= threshold).astype(int)
```

**When to lower threshold:** When missing positives is costly (disease detection)
**When to raise threshold:** When false alarms are costly (spam filter)

## Logistic vs Linear Regression

| Aspect | Linear Regression | Logistic Regression |
|--------|------------------|---------------------|
| Output | Any number | Probability (0-1) |
| Use case | Predict values | Predict categories |
| Function | Straight line | S-curve (sigmoid) |
| Example | House price | Spam/Not spam |

## Pros and Cons

**Pros:**
- Simple and fast
- Gives probabilities, not just predictions
- Interpretable coefficients
- Works well for linearly separable data

**Cons:**
- Assumes linear decision boundary
- Can't capture complex patterns
- Struggles with highly correlated features

## Key Takeaway

Logistic Regression is the go-to algorithm for classification. It's simple, interpretable, and often works surprisingly well. Even when you use fancier models, Logistic Regression is a great baseline to compare against.

Learn Logistic Regression - the fundamental algorithm for classification problems in machine learning.

Classification Basics: Logistic Regression

# Decision Trees: How They Work

Decision Trees are exactly what they sound like—a tree of decisions. They're intuitive, interpretable, and surprisingly powerful.

## The Concept

Think of playing 20 Questions:
- Is it alive? → Yes
- Is it an animal? → Yes
- Does it have 4 legs? → Yes
- Is it bigger than a cat? → Yes
- Is it a dog? → Yes!

That's a decision tree!

## Visual Example

```
                    [Age > 30?]
                    /          \
                 Yes            No
                /                 \
        [Income > 50k?]      [Student?]
        /          \         /        \
      Yes          No       Yes        No
       |            |        |          |
    [BUY]      [MAYBE]    [BUY]    [NO BUY]
```

Each internal node = a question about a feature
Each leaf node = a prediction

## How Does It Build the Tree?

### The Goal: Find the Best Splits

At each step, the algorithm asks: "Which question separates the data best?"

### Measuring "Best" - Information Gain

Imagine you have 50 spam and 50 non-spam emails.

**Bad split:** Left has 45 spam + 40 non-spam, Right has 5 spam + 10 non-spam
(Still mixed up!)

**Good split:** Left has 48 spam + 2 non-spam, Right has 2 spam + 48 non-spam
(Much cleaner!)

This "cleanness" is measured using **Gini Impurity** or **Entropy**.

### Gini Impurity

```python
gini = 1 - (p_class1² + p_class2² + ...)

# Pure node (all same class): gini = 0
# Mixed node (50-50): gini = 0.5
```

Lower Gini = Better split

## Code Example

```python
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Load famous iris dataset
iris = load_iris()
X, y = iris.data, iris.target

# Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Create and train tree
tree = DecisionTreeClassifier(max_depth=3)  # Limit depth to prevent overfitting
tree.fit(X_train, y_train)

# Evaluate
accuracy = tree.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2%}")

# See feature importance
for name, importance in zip(iris.feature_names, tree.feature_importances_):
    print(f"{name}: {importance:.3f}")
```

Output:
```
Accuracy: 95.56%
sepal length (cm): 0.000
sepal width (cm): 0.000
petal length (cm): 0.587
petal width (cm): 0.413
```

Petal features are most important for classifying iris types!

## Visualizing the Tree

```python
from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(15, 10))
plot_tree(tree, 
          feature_names=iris.feature_names,
          class_names=iris.target_names,
          filled=True)
plt.show()
```

## For Regression Too!

Decision Trees can predict numbers, not just categories:

```python
from sklearn.tree import DecisionTreeRegressor

# Predict house prices
tree = DecisionTreeRegressor(max_depth=5)
tree.fit(X_train, y_train)
predictions = tree.predict(X_test)
```

Instead of voting (classification), leaf nodes average the training values.

## The Overfitting Problem

Decision Trees LOVE to overfit. Without limits, they'll create a rule for every single training example.

```
No limits:
- Accuracy on training: 100%
- Accuracy on test: 65%
(Memorized, didn't learn!)
```

### How to Prevent Overfitting

```python
tree = DecisionTreeClassifier(
    max_depth=5,              # Limit tree depth
    min_samples_split=10,     # Need at least 10 samples to split
    min_samples_leaf=5,       # Each leaf needs at least 5 samples
    max_features='sqrt'       # Only consider sqrt(n) features per split
)
```

## Pros and Cons

### Pros ✅
- **Interpretable**: You can explain every prediction
- **No scaling needed**: Works with raw features
- **Handles mixed data**: Numbers and categories
- **Finds non-linear patterns**: Unlike linear models
- **Fast**: Quick to train and predict

### Cons ❌
- **Overfits easily**: Needs careful tuning
- **Unstable**: Small data changes = very different tree
- **Greedy**: Might miss globally optimal splits
- **Biased**: Prefers features with many values

## Decision Tree vs Linear Models

| Aspect | Decision Tree | Linear Model |
|--------|--------------|--------------|
| Decision boundary | Rectangular | Straight line |
| Interpretability | Visual rules | Coefficients |
| Feature scaling | Not needed | Usually needed |
| Handles non-linearity | Yes | No |
| Stability | Low | High |

## Key Insight

Decision Trees are powerful alone but even more powerful together. **Random Forest** (many trees) and **Gradient Boosting** (trees that learn from mistakes) dominate machine learning competitions.

We'll cover those next!

Understand Decision Trees - one of the most intuitive and interpretable ML algorithms.

Decision Trees: How They Work

# Overfitting and Underfitting

These two concepts will make or break your ML models. Understanding them is crucial.

## The Core Problem

We want models that work on **new, unseen data**—not just the training data.

## Overfitting: The Memorizer

**Definition:** Model learns the training data TOO well, including noise and random patterns.

Think of a student who memorizes every answer word-for-word but can't handle slightly different questions.

```
Training accuracy: 99%
Test accuracy: 65%
← Huge gap = Overfitting!
```

### Visual

```
Data points: ∙

Overfit model tries to hit EVERY point:
  │    ∙
  │  ╱╲  ╱∙
  │ ∙  ╲╱  ╲
  │╱         ∙
  └───────────
  (Too wiggly!)
```

### Signs of Overfitting
- Training accuracy >> Test accuracy
- Model is very complex
- Performance varies wildly on different test sets

## Underfitting: The Oversimplifier

**Definition:** Model is too simple to capture the real patterns.

Think of a student who only learned "the answer is always C."

```
Training accuracy: 60%
Test accuracy: 58%
← Both low = Underfitting!
```

### Visual

```
Data follows a curve, but model is a straight line:
  │      ∙  ∙
  │    ∙ ────────
  │  ∙     (Too simple!)
  │∙
  └───────────
```

### Signs of Underfitting
- Both training and test accuracy are low
- Model is too simple for the data
- High bias

## The Sweet Spot

```
       │
Error  │╲
       │ ╲    ╱  Test Error
       │  ╲__╱   
       │   ╲
       │    ╲____  Training Error
       │
       └────────────────
          Model Complexity →
       
       Underfit │ Just Right │ Overfit
```

**Goal:** Find the complexity where test error is minimized.

## Bias vs Variance

This is the technical way to describe the tradeoff:

| | High Bias | High Variance |
|-|-----------|---------------|
| **Meaning** | Oversimplified | Overfit |
| **Training error** | High | Low |
| **Test error** | High | High |
| **Model** | Too simple | Too complex |
| **Fix** | More complexity | Less complexity |

**Ideal:** Low bias AND low variance (hard to achieve!)

## How to Fix Overfitting

### 1. Get More Data
More examples = harder to memorize = must learn real patterns

### 2. Simplify the Model
```python
# Reduce complexity
tree = DecisionTreeClassifier(max_depth=3)  # Limit depth
model = LinearRegression()  # Use simpler model
```

### 3. Regularization
Add penalty for complexity:
```python
from sklearn.linear_model import Ridge, Lasso

# Ridge (L2) - shrinks coefficients
model = Ridge(alpha=1.0)

# Lasso (L1) - can zero out features
model = Lasso(alpha=1.0)
```

### 4. Dropout (Neural Networks)
Randomly ignore neurons during training.

### 5. Early Stopping
Stop training before the model starts overfitting.
```python
# Monitor validation loss, stop when it starts increasing
```

### 6. Cross-Validation
Test on multiple splits to get reliable performance estimate.

## How to Fix Underfitting

### 1. Add More Features
Give the model more information to work with.

### 2. Use a More Complex Model
```python
# From linear to polynomial
from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(degree=3)
X_poly = poly.fit_transform(X)

# From decision tree to random forest
from sklearn.ensemble import RandomForestClassifier
```

### 3. Reduce Regularization
```python
model = Ridge(alpha=0.01)  # Less penalty
```

### 4. Train Longer
Give the model more time to learn.

## Practical Checklist

```
□ Compare training vs validation accuracy
  - Big gap → Overfitting
  - Both low → Underfitting
  - Small gap, both good → Just right!

□ Use cross-validation for reliable estimates

□ Start simple, add complexity gradually

□ Always have a held-out test set for final evaluation
```

## Code Example: Detecting Overfitting

```python
from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt

train_sizes, train_scores, val_scores = learning_curve(
    model, X, y, cv=5,
    train_sizes=np.linspace(0.1, 1.0, 10)
)

plt.plot(train_sizes, train_scores.mean(axis=1), label='Training')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validation')
plt.xlabel('Training Size')
plt.ylabel('Score')
plt.legend()
plt.title('Learning Curve')
plt.show()
```

If lines converge = Good fit
If big gap = Overfitting
If both low = Underfitting

## Key Takeaway

**Overfitting:** "I memorized the textbook but can't answer new questions"
**Underfitting:** "I barely studied and can't answer any questions"
**Good fit:** "I understood the concepts and can apply them"

Always validate on unseen data. Training accuracy lies!

Understand the critical concepts of overfitting and underfitting - the key to building models that actually work.

Overfitting and Underfitting Explained

# K-Nearest Neighbors (KNN)

KNN is beautifully simple: to classify something new, look at its closest neighbors and go with the majority.

## The Idea

"Tell me who your friends are, and I'll tell you who you are."

```
New point: ?
Nearest neighbors: 🔵 🔵 🔴

If k=3, vote:
🔵 = 2 votes
🔴 = 1 vote

Winner: 🔵
```

That's it! No training, no learned parameters—just find neighbors and vote.

## How It Works

### Step 1: Choose k (number of neighbors)
```python
k = 5  # Look at 5 nearest neighbors
```

### Step 2: Calculate distances to all training points
```python
# Euclidean distance (most common)
distance = sqrt((x1-x2)² + (y1-y2)²)
```

### Step 3: Find k nearest neighbors
Sort by distance, take top k.

### Step 4: Vote (classification) or Average (regression)
```python
# Classification: majority vote
prediction = most_common_class(neighbors)

# Regression: average value
prediction = mean(neighbor_values)
```

## Code Example

```python
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Load data
iris = load_iris()
X, y = iris.data, iris.target

# IMPORTANT: Scale features!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Split
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3)

# Create KNN classifier
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# Evaluate
accuracy = knn.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2%}")

# Predict new sample
new_flower = scaler.transform([[5.0, 3.4, 1.5, 0.2]])
prediction = knn.predict(new_flower)
print(f"Predicted class: {iris.target_names[prediction[0]]}")
```

## Choosing k

### k too small (like k=1)
- Sensitive to noise
- Overfitting
- Unstable predictions

### k too large (like k=100)
- Over-smoothing
- Underfitting
- Slow predictions

### Rule of Thumb
```python
k = int(sqrt(n_samples))  # Square root of sample size
```

For classification, use **odd k** to avoid ties.

### Find Best k with Cross-Validation

```python
from sklearn.model_selection import cross_val_score

k_values = range(1, 31)
cv_scores = []

for k in k_values:
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, X_train, y_train, cv=5)
    cv_scores.append(scores.mean())

best_k = k_values[cv_scores.index(max(cv_scores))]
print(f"Best k: {best_k}")
```

## Why Feature Scaling Is Critical

KNN uses distances. If features have different scales, larger ones dominate!

```
Without scaling:
- Income: 50,000 vs 80,000 (diff: 30,000)
- Age: 25 vs 45 (diff: 20)

Income dominates completely!

With scaling (both 0-1):
- Income: 0.5 vs 0.8 (diff: 0.3)
- Age: 0.25 vs 0.45 (diff: 0.2)

Now both contribute fairly.
```

**Always scale features before KNN!**

## Distance Metrics

### Euclidean (default)
```python
# Straight-line distance
d = sqrt(Σ(xi - yi)²)
```

### Manhattan
```python
# Grid distance (like walking city blocks)
d = Σ|xi - yi|
```

### Minkowski
```python
# Generalization of both
knn = KNeighborsClassifier(metric='minkowski', p=2)  # p=2 is Euclidean
```

## KNN for Regression

```python
from sklearn.neighbors import KNeighborsRegressor

# Predict house price based on neighbors
knn_reg = KNeighborsRegressor(n_neighbors=5)
knn_reg.fit(X_train, y_train)

# Prediction = average of 5 nearest neighbors' prices
predicted_price = knn_reg.predict(new_house)
```

## Pros and Cons

### Pros ✅
- Dead simple to understand
- No training phase (lazy learner)
- Works for classification AND regression
- Naturally handles multi-class
- Non-parametric (no assumptions)

### Cons ❌
- Slow predictions (must check all points)
- Memory hungry (stores all data)
- Sensitive to irrelevant features
- Requires feature scaling
- Struggles with high dimensions ("curse of dimensionality")

## When to Use KNN

**Good for:**
- Small to medium datasets
- When you need quick baseline
- Recommendation systems (find similar users/items)
- Anomaly detection (point far from all neighbors)

**Avoid when:**
- Very large datasets (slow)
- High-dimensional data (>20 features)
- Features have different importance

## Practical Tips

```python
# 1. Always scale
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 2. Use cross-validation to find k
# 3. Consider weighted voting (closer = more weight)
knn = KNeighborsClassifier(n_neighbors=5, weights='distance')

# 4. For large datasets, use approximate methods
from sklearn.neighbors import BallTree, KDTree
```

## Key Takeaway

KNN is the ultimate "common sense" algorithm—just look at what's nearby. It's a great starting point and often performs surprisingly well. Just remember: scale your features!

Learn KNN - the simplest and most intuitive classification algorithm based on similarity.

K-Nearest Neighbors (KNN) Algorithm

# Model Evaluation Metrics You Must Know

"My model is 95% accurate!" Sounds great, right? But what if 95% of your data is one class? Let's learn the RIGHT metrics.

## Classification Metrics

### The Confusion Matrix

The foundation of all classification metrics:

```
                 Predicted
                 Neg    Pos
Actual    Neg   [TN     FP]
          Pos   [FN     TP]
```

- **True Negative (TN):** Correctly predicted negative
- **True Positive (TP):** Correctly predicted positive
- **False Positive (FP):** Said positive, was negative (Type I error)
- **False Negative (FN):** Said negative, was positive (Type II error)

```python
from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_true, y_pred)
print(cm)
# [[TN, FP],
#  [FN, TP]]
```

### Accuracy

```python
accuracy = (TP + TN) / (TP + TN + FP + FN)
```

Percentage of correct predictions.

**When to use:** Balanced classes
**Problem:** Misleading with imbalanced data

```
Dataset: 950 non-fraud, 50 fraud
Model: Always predicts "non-fraud"
Accuracy: 95% 🎉 (but useless!)
```

### Precision

```python
precision = TP / (TP + FP)
```

Of all positive predictions, how many were correct?

**Use when:** False positives are costly
- Spam filter (don't mark good email as spam)
- Recommender systems (don't waste user's time)

### Recall (Sensitivity)

```python
recall = TP / (TP + FN)
```

Of all actual positives, how many did we find?

**Use when:** False negatives are costly
- Disease detection (don't miss sick patients!)
- Fraud detection (don't miss fraudsters!)

### Precision vs Recall Tradeoff

```
↑ Precision → ↓ Recall (more conservative predictions)
↑ Recall → ↓ Precision (more liberal predictions)
```

You can't have both perfect. Choose based on what's worse:
- Missing a positive (FN) → Focus on Recall
- False alarm (FP) → Focus on Precision

### F1 Score

```python
f1 = 2 * (precision * recall) / (precision + recall)
```

Harmonic mean of precision and recall. Balanced metric.

**Use when:** You care about both precision and recall equally.

```python
from sklearn.metrics import precision_score, recall_score, f1_score

print(f"Precision: {precision_score(y_true, y_pred):.3f}")
print(f"Recall: {recall_score(y_true, y_pred):.3f}")
print(f"F1: {f1_score(y_true, y_pred):.3f}")
```

### Classification Report

Get all metrics at once:

```python
from sklearn.metrics import classification_report

print(classification_report(y_true, y_pred))
```

```
              precision    recall  f1-score   support
     class 0       0.95      0.98      0.96       950
     class 1       0.72      0.56      0.63        50
    accuracy                           0.94      1000
```

### ROC Curve and AUC

**ROC Curve:** Plot of True Positive Rate vs False Positive Rate at different thresholds.

**AUC (Area Under Curve):** Single number summarizing ROC.
- AUC = 1.0: Perfect model
- AUC = 0.5: Random guessing
- AUC < 0.5: Worse than random

```python
from sklearn.metrics import roc_auc_score, roc_curve
import matplotlib.pyplot as plt

# Get probabilities, not predictions
y_proba = model.predict_proba(X_test)[:, 1]

# AUC score
auc = roc_auc_score(y_true, y_proba)
print(f"AUC: {auc:.3f}")

# Plot ROC curve
fpr, tpr, _ = roc_curve(y_true, y_proba)
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title(f'ROC Curve (AUC = {auc:.3f})')
plt.show()
```

## Regression Metrics

### Mean Absolute Error (MAE)

```python
mae = mean(|predicted - actual|)
```

Average absolute difference. Easy to interpret.

### Mean Squared Error (MSE)

```python
mse = mean((predicted - actual)²)
```

Penalizes large errors more heavily.

### Root Mean Squared Error (RMSE)

```python
rmse = sqrt(mse)
```

Same units as target variable. Most commonly used.

### R² Score

```python
r2 = 1 - (sum of squared errors) / (total variance)
```

- R² = 1: Perfect predictions
- R² = 0: As good as predicting the mean
- R² < 0: Worse than predicting the mean!

```python
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_true, y_pred)

print(f"MAE: {mae:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"R²: {r2:.3f}")
```

## Which Metric to Use?

| Problem | Recommended Metric |
|---------|-------------------|
| Balanced classification | Accuracy, F1 |
| Imbalanced classification | F1, AUC, Precision/Recall |
| Ranking | AUC |
| Regression (normal errors) | RMSE, R² |
| Regression (with outliers) | MAE |

## Quick Reference

```python
from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    roc_auc_score,
    confusion_matrix,
    classification_report,
    mean_absolute_error,
    mean_squared_error,
    r2_score
)
```

## Key Takeaway

Don't just report accuracy. Understand your problem:
- What's the cost of different errors?
- Is your data balanced?
- Do you need probabilities or hard predictions?

Choose metrics that match your real-world goals!

Learn the essential metrics for evaluating ML models - accuracy, precision, recall, F1, ROC, and more.

Model Evaluation Metrics You Must Know

# Feature Scaling: Normalization vs Standardization

Different features have different scales. A house's square footage (1000-5000) vs bedrooms (1-5) shouldn't be compared directly. Scaling fixes this.

## Why Scale Features?

### Problem Without Scaling

```
Feature 1 (Income): 30,000 - 200,000
Feature 2 (Age): 18 - 80
```

Distance-based algorithms (KNN, SVM, Neural Networks) will be dominated by income!

### Algorithms That NEED Scaling
- K-Nearest Neighbors (KNN)
- Support Vector Machines (SVM)
- Neural Networks
- Linear/Logistic Regression (for convergence)
- PCA

### Algorithms That DON'T Need Scaling
- Decision Trees
- Random Forest
- Gradient Boosting (XGBoost, LightGBM)
- Naive Bayes

## Two Main Techniques

### 1. Normalization (Min-Max Scaling)

Scales to a fixed range, usually [0, 1]:

```python
x_normalized = (x - min) / (max - min)
```

```python
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
X_normalized = scaler.fit_transform(X)

# All values now between 0 and 1
```

**Use when:**
- You need bounded values
- Data doesn't have outliers
- Neural networks (especially image data)

### 2. Standardization (Z-Score Scaling)

Centers around 0 with unit variance:

```python
x_standardized = (x - mean) / std
```

```python
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_standardized = scaler.fit_transform(X)

# Mean ≈ 0, Std ≈ 1
```

**Use when:**
- Data has outliers
- Algorithm assumes normally distributed data
- Default choice for most cases

## Quick Comparison

| Aspect | Normalization | Standardization |
|--------|---------------|-----------------|
| Range | [0, 1] fixed | No fixed range |
| Outlier handling | Poor | Better |
| Mean | Not centered | Centered at 0 |
| Use case | Image pixels, bounded data | Most other cases |

## Code Example

```python
import numpy as np
from sklearn.preprocessing import StandardScaler, MinMaxScaler

# Sample data
X = np.array([[30000, 25], [80000, 45], [50000, 35], [120000, 50]])
#             income  age

# Standardization
std_scaler = StandardScaler()
X_std = std_scaler.fit_transform(X)
print("Standardized:")
print(X_std)
print(f"Mean: {X_std.mean(axis=0)}")  # Should be ~0
print(f"Std: {X_std.std(axis=0)}")    # Should be ~1

# Normalization  
minmax_scaler = MinMaxScaler()
X_norm = minmax_scaler.fit_transform(X)
print("\nNormalized:")
print(X_norm)
print(f"Min: {X_norm.min(axis=0)}")   # Should be 0
print(f"Max: {X_norm.max(axis=0)}")   # Should be 1
```

## Critical: Fit on Train, Transform Both

```python
# WRONG - Data leakage!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # Learns from ALL data
X_train, X_test = split(X_scaled)

# RIGHT
X_train, X_test = train_test_split(X, test_size=0.2)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # Learn from train only
X_test_scaled = scaler.transform(X_test)        # Apply same transformation
```

The test set shouldn't influence the scaling parameters!

## Other Scaling Methods

### Robust Scaler (for outliers)
```python
from sklearn.preprocessing import RobustScaler

scaler = RobustScaler()  # Uses median and IQR, robust to outliers
```

### Max Abs Scaler (sparse data)
```python
from sklearn.preprocessing import MaxAbsScaler

scaler = MaxAbsScaler()  # Scales by max absolute value, keeps sparsity
```

## When NOT to Scale

1. **Tree-based models** - They split on thresholds, scale doesn't matter
2. **Categorical features** - One-hot encoded features (0/1) shouldn't be scaled
3. **Already scaled data** - Don't scale twice!

## Summary

| Situation | Recommendation |
|-----------|---------------|
| Default choice | StandardScaler |
| Bounded output needed | MinMaxScaler |
| Data has outliers | RobustScaler |
| Tree-based models | No scaling needed |
| Neural networks | MinMaxScaler or StandardScaler |

Remember: Always fit on training data only, then transform both train and test sets!

Learn when and how to scale your features for better ML model performance.

Feature Scaling: Normalization vs Standardization

# Handling Missing Data in Machine Learning

Real-world data is messy. Missing values are everywhere. Here's how to deal with them.

## Why Data Goes Missing

- User didn't fill a form field
- Sensor malfunction
- Data corruption
- Feature didn't exist before a certain date
- Intentionally not collected

## First: Understand Your Missing Data

```python
import pandas as pd

# Check missing values
df.isnull().sum()

# Percentage missing per column
(df.isnull().sum() / len(df)) * 100

# Visualize
import seaborn as sns
sns.heatmap(df.isnull(), cbar=True)
```

## Types of Missingness

### MCAR (Missing Completely At Random)
No pattern. Random chance.
Example: Survey responses lost in mail.

### MAR (Missing At Random)
Missing depends on OTHER observed variables.
Example: Men less likely to report weight (but you know gender).

### MNAR (Missing Not At Random)
Missing depends on the MISSING value itself.
Example: High earners don't report income.

**Why it matters:** MNAR is hardest to handle correctly.

## Strategy 1: Delete

### Delete Rows
```python
df_clean = df.dropna()  # Remove any row with missing values
df_clean = df.dropna(subset=['important_column'])  # Only check specific columns
```

**Use when:**
- Very few missing values (<5%)
- Large dataset (can afford to lose rows)
- Data is MCAR

**Don't use when:**
- Many missing values
- Missingness has a pattern

### Delete Columns
```python
# Remove columns with >50% missing
threshold = 0.5
df_clean = df.dropna(axis=1, thresh=len(df) * (1 - threshold))
```

**Use when:**
- Column is mostly missing
- Column isn't important

## Strategy 2: Impute (Fill In)

### Simple Imputation

```python
from sklearn.impute import SimpleImputer

# Numerical: fill with mean or median
imputer = SimpleImputer(strategy='mean')  # or 'median'
X_imputed = imputer.fit_transform(X)

# Categorical: fill with most frequent
imputer = SimpleImputer(strategy='most_frequent')
X_imputed = imputer.fit_transform(X)
```

**Mean vs Median:**
- Mean: Good for normal distribution
- Median: Better with outliers

### Constant Value
```python
imputer = SimpleImputer(strategy='constant', fill_value=0)
```

### Pandas Methods
```python
# Forward fill (use previous value)
df['col'].fillna(method='ffill')

# Backward fill
df['col'].fillna(method='bfill')

# Fill with specific value
df['col'].fillna(df['col'].median())
```

## Strategy 3: Advanced Imputation

### KNN Imputation
```python
from sklearn.impute import KNNImputer

imputer = KNNImputer(n_neighbors=5)
X_imputed = imputer.fit_transform(X)
```

Uses K nearest similar samples to estimate missing values.

### Iterative Imputation (MICE)
```python
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

imputer = IterativeImputer(max_iter=10)
X_imputed = imputer.fit_transform(X)
```

Models each feature as a function of other features. Iterates until convergence.

## Strategy 4: Add Missing Indicator

Sometimes "missing" is information itself!

```python
from sklearn.impute import SimpleImputer, MissingIndicator
from sklearn.pipeline import FeatureUnion

# Combine imputation + missing indicator
transformer = FeatureUnion([
    ('imputer', SimpleImputer(strategy='mean')),
    ('indicator', MissingIndicator())
])

X_transformed = transformer.fit_transform(X)
# Now includes original features (imputed) + binary missing indicators
```

## Practical Guidelines

| Missing % | Recommendation |
|-----------|---------------|
| <5% | Simple imputation or deletion |
| 5-25% | Imputation (consider indicator) |
| 25-50% | Advanced imputation + indicator |
| >50% | Consider dropping column |

## Important: Fit on Train Only!

```python
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)

imputer = SimpleImputer(strategy='median')
X_train_imputed = imputer.fit_transform(X_train)  # Fit on train
X_test_imputed = imputer.transform(X_test)        # Transform test
```

Don't let test data influence imputation values!

## Quick Decision Guide

```
Missing values?
    │
    ├─ <5%? → Delete rows or simple imputation
    │
    ├─ Numerical?
    │   ├─ Has outliers? → Median
    │   └─ No outliers? → Mean or KNN
    │
    └─ Categorical?
        └─ Most frequent or new category "Missing"
```

## Key Takeaway

There's no perfect solution. The best approach depends on:
- How much data is missing
- Why it's missing
- Your model's sensitivity to imputation

Always document your choices and test different approaches!

Learn practical techniques to handle missing values in your datasets effectively.

Handling Missing Data in Machine Learning

# Encoding Categorical Variables

ML models need numbers. But real data has categories like "red", "blue", "green" or "small", "medium", "large". Let's convert them properly.

## Types of Categorical Data

### Nominal (No Order)
- Colors: red, blue, green
- Countries: USA, UK, India
- Email domains: gmail, yahoo, outlook

### Ordinal (Has Order)
- Size: small < medium < large
- Education: high school < bachelor's < master's
- Rating: poor < average < good < excellent

The encoding method depends on the type!

## Method 1: Label Encoding

Convert categories to numbers: 0, 1, 2, ...

```python
from sklearn.preprocessing import LabelEncoder

colors = ['red', 'blue', 'green', 'blue', 'red']

encoder = LabelEncoder()
encoded = encoder.fit_transform(colors)
print(encoded)  # [2, 0, 1, 0, 2]

# Decode back
original = encoder.inverse_transform(encoded)
print(original)  # ['red', 'blue', 'green', 'blue', 'red']
```

**Use for:**
- Target variable (y)
- Ordinal data (but order might be wrong!)
- Tree-based models (they can handle it)

**Problem for nominal data:**
The model might think red (2) > green (1) > blue (0), but colors have no order!

## Method 2: One-Hot Encoding

Create a binary column for each category:

```
Original:    One-Hot Encoded:
color        red  blue  green
─────        ───  ────  ─────
red          1    0     0
blue         0    1     0
green        0    0     1
blue         0    1     0
```

```python
import pandas as pd

df = pd.DataFrame({'color': ['red', 'blue', 'green', 'blue']})

# Pandas get_dummies
encoded = pd.get_dummies(df, columns=['color'])
print(encoded)

# Or sklearn
from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder(sparse=False)
encoded = encoder.fit_transform(df[['color']])
```

**Use for:**
- Nominal data (no order)
- Most algorithms

**Problem:**
- Many categories = Many columns (high dimensionality)
- Rare categories might have very few 1s

### Drop First Column?

```python
# For linear models, drop one to avoid multicollinearity
pd.get_dummies(df, columns=['color'], drop_first=True)

# If red=0 and blue=0, it must be green!
```

## Method 3: Ordinal Encoding

Like label encoding, but YOU specify the order:

```python
from sklearn.preprocessing import OrdinalEncoder

sizes = [['small'], ['large'], ['medium'], ['large'], ['small']]

# Specify correct order
encoder = OrdinalEncoder(categories=[['small', 'medium', 'large']])
encoded = encoder.fit_transform(sizes)
print(encoded)  # [[0], [2], [1], [2], [0]]
```

**Use for:** Data with meaningful order (size, education, rating)

## Method 4: Binary Encoding

Converts categories to binary code. Good for many categories.

```
Label    Binary
  0    →  0 0
  1    →  0 1
  2    →  1 0
  3    →  1 1
```

Fewer columns than one-hot encoding!

```python
# Install: pip install category_encoders
import category_encoders as ce

encoder = ce.BinaryEncoder(cols=['city'])
encoded = encoder.fit_transform(df)
```

**Use when:** Many categories (>10), want fewer columns

## Method 5: Target Encoding

Replace category with mean of target variable:

```python
import category_encoders as ce

encoder = ce.TargetEncoder(cols=['city'])
encoder.fit(X_train, y_train)
X_encoded = encoder.transform(X_train)
```

```
city      target    encoded
────      ──────    ───────
NYC       100k      120k (mean of NYC)
LA        150k      110k (mean of LA)
NYC       140k      120k (mean of NYC)
```

**Use for:** High cardinality (many categories)
**Warning:** High risk of data leakage! Use cross-validation encoding.

## Method 6: Frequency/Count Encoding

Replace with how often each category appears:

```python
counts = df['city'].value_counts()
df['city_count'] = df['city'].map(counts)
```

**Use for:** When frequency is meaningful

## Quick Reference

| Method | Use Case | Categories | Creates Many Columns? |
|--------|----------|------------|----------------------|
| Label | Target, tree models | Any | No |
| One-Hot | Nominal, most models | <10 | Yes |
| Ordinal | Has meaningful order | Any | No |
| Binary | Many categories | >10 | Less than one-hot |
| Target | High cardinality | Many | No |

## Code Example: Full Pipeline

```python
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression

# Define column types
numerical = ['age', 'income']
nominal = ['city', 'gender']
ordinal = ['education']

# Preprocessor
preprocessor = ColumnTransformer([
    ('num', StandardScaler(), numerical),
    ('nom', OneHotEncoder(drop='first'), nominal),
    ('ord', OrdinalEncoder(categories=[['high school', 'bachelor', 'master']]), ordinal)
])

# Full pipeline
pipeline = Pipeline([
    ('prep', preprocessor),
    ('model', LogisticRegression())
])

pipeline.fit(X_train, y_train)
```

## Important: Handle Unknown Categories

```python
# What if test set has a category not seen in training?
encoder = OneHotEncoder(handle_unknown='ignore')  # Will create all zeros
```

## Key Takeaways

1. **Nominal data** → One-Hot Encoding (or Binary for many categories)
2. **Ordinal data** → Ordinal Encoding with correct order
3. **High cardinality** → Target/Binary/Frequency Encoding
4. **Tree models** → Can use Label Encoding (they don't assume order)
5. **Always fit on train, transform on test!**

Learn how to convert categorical data into numbers for machine learning models.

Encoding Categorical Variables for ML

# Cross-Validation: The Right Way to Evaluate Models

A single train-test split can be misleading. Cross-validation gives you reliable, robust performance estimates.

## The Problem with Single Split

```python
# Single split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model.fit(X_train, y_train)
score = model.score(X_test, y_test)  # 85%
```

But what if you got lucky (or unlucky) with that particular split?

Different random splits give different results:
- Split 1: 85%
- Split 2: 78%
- Split 3: 91%

Which one is the real performance?

## K-Fold Cross-Validation

Split data into K parts. Train on K-1 parts, test on 1 part. Repeat K times.

```
5-Fold CV:

Fold 1: [TEST][TRAIN][TRAIN][TRAIN][TRAIN] → Score: 84%
Fold 2: [TRAIN][TEST][TRAIN][TRAIN][TRAIN] → Score: 87%
Fold 3: [TRAIN][TRAIN][TEST][TRAIN][TRAIN] → Score: 82%
Fold 4: [TRAIN][TRAIN][TRAIN][TEST][TRAIN] → Score: 86%
Fold 5: [TRAIN][TRAIN][TRAIN][TRAIN][TEST] → Score: 85%

Average: 84.8% ± 1.8%
```

Every data point gets to be in the test set exactly once!

## Code Example

```python
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()

# 5-fold cross-validation
scores = cross_val_score(model, X, y, cv=5)

print(f"Scores: {scores}")
print(f"Mean: {scores.mean():.3f}")
print(f"Std: {scores.std():.3f}")
print(f"95% CI: {scores.mean():.3f} ± {scores.std() * 2:.3f}")
```

Output:
```
Scores: [0.84 0.87 0.82 0.86 0.85]
Mean: 0.848
Std: 0.018
95% CI: 0.848 ± 0.036
```

## Choosing K

| K Value | Pros | Cons |
|---------|------|------|
| K=5 | Good balance, common choice | - |
| K=10 | More reliable estimate | Slower |
| K=n (LOOCV) | Uses all data | Very slow, high variance |

**Rule of thumb:** K=5 or K=10 for most cases.

## Types of Cross-Validation

### Stratified K-Fold (for Classification)

Maintains class proportions in each fold:

```python
from sklearn.model_selection import StratifiedKFold

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv)
```

**Always use for classification!** Especially with imbalanced data.

### Leave-One-Out (LOOCV)

K = number of samples. Each sample is test set once.

```python
from sklearn.model_selection import LeaveOneOut

cv = LeaveOneOut()
scores = cross_val_score(model, X, y, cv=cv)
```

**Use when:** Very small dataset

### Time Series Split

For time-dependent data. Train on past, test on future.

```
Split 1: [TRAIN][TEST]
Split 2: [TRAIN][TRAIN][TEST]
Split 3: [TRAIN][TRAIN][TRAIN][TEST]
```

```python
from sklearn.model_selection import TimeSeriesSplit

cv = TimeSeriesSplit(n_splits=5)
scores = cross_val_score(model, X, y, cv=cv)
```

**Must use for:** Stock prices, sales forecasting, any time-ordered data

### Group K-Fold

When samples belong to groups that shouldn't be split.

```python
from sklearn.model_selection import GroupKFold

# Each patient's samples stay together
groups = patient_ids
cv = GroupKFold(n_splits=5)
scores = cross_val_score(model, X, y, cv=cv, groups=groups)
```

**Use when:** Multiple samples from same person/entity

## Getting More Information

### Cross-Validate with Multiple Metrics

```python
from sklearn.model_selection import cross_validate

scores = cross_validate(
    model, X, y, cv=5,
    scoring=['accuracy', 'precision', 'recall', 'f1'],
    return_train_score=True
)

print(f"Test Accuracy: {scores['test_accuracy'].mean():.3f}")
print(f"Test F1: {scores['test_f1'].mean():.3f}")
print(f"Train Accuracy: {scores['train_accuracy'].mean():.3f}")
```

### Get Predictions

```python
from sklearn.model_selection import cross_val_predict

# Predictions from each fold
predictions = cross_val_predict(model, X, y, cv=5)
```

## Nested Cross-Validation

For hyperparameter tuning + evaluation without data leakage:

```
Outer loop: Model evaluation
  Inner loop: Hyperparameter tuning
```

```python
from sklearn.model_selection import GridSearchCV, cross_val_score

# Inner CV for tuning
inner_cv = StratifiedKFold(n_splits=5)
param_grid = {'C': [0.1, 1, 10]}
grid_search = GridSearchCV(LogisticRegression(), param_grid, cv=inner_cv)

# Outer CV for evaluation
outer_cv = StratifiedKFold(n_splits=5)
nested_scores = cross_val_score(grid_search, X, y, cv=outer_cv)

print(f"Nested CV Score: {nested_scores.mean():.3f} ± {nested_scores.std():.3f}")
```

## Common Mistakes

### 1. Data Leakage in Preprocessing
```python
# WRONG
X_scaled = scaler.fit_transform(X)  # Learns from all data
scores = cross_val_score(model, X_scaled, y, cv=5)

# RIGHT - Use Pipeline
from sklearn.pipeline import Pipeline
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LogisticRegression())
])
scores = cross_val_score(pipe, X, y, cv=5)
```

### 2. Using Test Set Multiple Times
```python
# WRONG
score = model.score(X_test, y_test)  # Looked at test set
# ... tune model ...
score = model.score(X_test, y_test)  # Looked again!

# RIGHT
# Use CV for tuning, test set only at the very end
```

## Summary

| Scenario | CV Type |
|----------|---------|
| Classification | StratifiedKFold |
| Time series | TimeSeriesSplit |
| Grouped data | GroupKFold |
| Small data | LOOCV |
| General | KFold |

**Key takeaway:** Always use cross-validation. A single score is not reliable!

Learn cross-validation techniques to get reliable estimates of model performance.

Cross-Validation: The Right Way to Evaluate Models

# Introduction to Bias and Variance

The bias-variance tradeoff is at the heart of machine learning. Understanding it helps you diagnose and fix model problems.

## Simple Explanation

Imagine throwing darts at a target:

```
High Bias, Low Variance:   Low Bias, High Variance:
  ┌─────────┐                ┌─────────┐
  │         │                │ x     x │
  │   xxx   │                │    ◎    │
  │    ◎    │                │  x   x  │
  │         │                │         │
  └─────────┘                └─────────┘
  Consistent but wrong       Scattered around target

Low Bias, Low Variance:    High Bias, High Variance:
  ┌─────────┐                ┌─────────┐
  │         │                │ x       │
  │   x◎x   │                │       x │
  │    x    │                │    ◎    │
  │         │                │  x   x  │
  └─────────┘                └─────────┘
  What we want!              Worst case
```

## What is Bias?

**Bias** = Error from overly simple assumptions.

A model with high bias:
- Misses relevant patterns
- Underfits the data
- Is "too rigid"

Example: Fitting a straight line to curved data.

```
Data: curved pattern
Model: straight line

     ∙
   ∙   ∙
  ──────── ← Line misses the curve
 ∙       ∙
```

## What is Variance?

**Variance** = Error from being too sensitive to training data.

A model with high variance:
- Learns noise as if it were signal
- Overfits the data
- Changes dramatically with different training data

Example: A very complex polynomial that hits every point but generalizes poorly.

## The Tradeoff

```
Error
  │╲
  │ ╲    ╱╱  Total Error
  │  ╲__╱╱   
  │   ╲╱     Variance
  │    ╲____
  │         Bias
  └────────────────
    Simple → Complex
```

- **Simple models:** High bias, low variance
- **Complex models:** Low bias, high variance
- **Goal:** Find the sweet spot where total error is minimized

## Mathematical View

```
Total Error = Bias² + Variance + Irreducible Noise
```

- **Bias²**: How far off predictions are on average
- **Variance**: How much predictions vary with different training data
- **Irreducible Noise**: Random error you can't eliminate

## Examples by Model

| Model | Bias | Variance |
|-------|------|----------|
| Linear Regression | High | Low |
| Polynomial Regression (high degree) | Low | High |
| Decision Tree (no pruning) | Low | High |
| Decision Tree (limited depth) | Medium | Medium |
| k-NN (k=1) | Low | High |
| k-NN (k=n) | High | Low |

## Diagnosing Your Model

### High Bias (Underfitting)
- Training error is high
- Training and test error are similar (both bad)
- Model is too simple

**Fix:** Increase complexity
- Add features
- Use a more complex model
- Reduce regularization

### High Variance (Overfitting)
- Training error is low
- Test error is much higher than training
- Model is too complex

**Fix:** Decrease complexity
- Remove features
- Use simpler model
- Add regularization
- Get more data

## Learning Curves

Plot training and validation error vs. training size:

### High Bias Pattern
```
Error
  │ ────────── Validation (high)
  │ ────────── Training (high)
  └──────────────────
          Training Size
Both errors are high and converge
```

### High Variance Pattern
```
Error
  │ ──────  Validation (high)
  │        
  │ ______ Training (low)
  └──────────────────
          Training Size
Big gap between training and validation
```

## Code: Plotting Learning Curves

```python
from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt
import numpy as np

train_sizes, train_scores, val_scores = learning_curve(
    model, X, y,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5
)

train_mean = train_scores.mean(axis=1)
val_mean = val_scores.mean(axis=1)

plt.plot(train_sizes, train_mean, label='Training')
plt.plot(train_sizes, val_mean, label='Validation')
plt.xlabel('Training Size')
plt.ylabel('Score')
plt.legend()
plt.title('Learning Curve')
plt.show()
```

## Controlling Bias and Variance

### Model Complexity
More complex → Less bias, more variance

### Regularization
More regularization → More bias, less variance

### Training Data
More data → Helps reduce variance (not bias!)

### Feature Selection
Fewer features → More bias, less variance

## Practical Tips

1. **Start simple**: Begin with a simple model, add complexity as needed
2. **Use cross-validation**: Don't rely on single train-test split
3. **Plot learning curves**: Visualize the bias-variance situation
4. **Regularize**: When in doubt, add regularization
5. **Get more data**: Often the best solution for high variance

## Key Takeaway

You can't minimize both bias and variance simultaneously. The art of machine learning is finding the right balance for your specific problem.

- High training error? → Reduce bias
- High gap between train/test? → Reduce variance

Use learning curves to diagnose, then adjust accordingly!

Understand the bias-variance tradeoff - a fundamental concept in machine learning.

Introduction to Bias and Variance

# Regularization: Preventing Overfitting

Regularization is like telling your model: "Keep it simple!" It's one of the most important techniques to prevent overfitting.

## The Problem

Without regularization, models can become too complex:

```python
# Overfitted linear regression might have huge coefficients
weights = [23456.7, -12345.6, 98765.4, ...]

# Small input changes → Huge output changes = Unstable!
```

The model is "working too hard" to fit training data perfectly.

## The Solution: Add a Penalty

```
Original objective: Minimize error

New objective: Minimize error + λ × complexity penalty
```

λ (lambda) controls how much we penalize complexity.

## L2 Regularization (Ridge)

Penalizes the **sum of squared weights**:

```
Loss = Error + λ × (w₁² + w₂² + w₃² + ...)
```

**Effect:** Shrinks all weights toward zero, but doesn't make them exactly zero.

```python
from sklearn.linear_model import Ridge

# α is the regularization strength (λ)
model = Ridge(alpha=1.0)
model.fit(X_train, y_train)

print(f"Coefficients: {model.coef_}")  # Smaller than unregularized
```

## L1 Regularization (Lasso)

Penalizes the **sum of absolute weights**:

```
Loss = Error + λ × (|w₁| + |w₂| + |w₃| + ...)
```

**Effect:** Shrinks weights AND makes some exactly zero (feature selection!).

```python
from sklearn.linear_model import Lasso

model = Lasso(alpha=1.0)
model.fit(X_train, y_train)

print(f"Coefficients: {model.coef_}")  # Some are exactly 0
```

## Elastic Net (L1 + L2)

Combines both:

```python
from sklearn.linear_model import ElasticNet

model = ElasticNet(alpha=1.0, l1_ratio=0.5)  # 50% L1, 50% L2
```

**Use when:** Many correlated features

## Comparing L1 and L2

| Aspect | L1 (Lasso) | L2 (Ridge) |
|--------|------------|------------|
| Penalty | |w| | w² |
| Effect on weights | Some become 0 | All shrink |
| Feature selection | Yes | No |
| Correlated features | Picks one randomly | Keeps all |
| Computationally | Harder | Easier |

Visual comparison:

```
L1 penalty region:      L2 penalty region:
    ◇                      ○
   ╱ ╲                   ╱   ╲
  ╱   ╲                 ╱     ╲
(Diamond shape -       (Circle - 
 corners at axes)       touches at corners less often)
```

L1's corners make weights hit exactly zero more often.

## Choosing λ (Alpha)

```
λ = 0: No regularization (might overfit)
λ = ∞: All weights → 0 (will underfit)
```

Use cross-validation to find the best value:

```python
from sklearn.linear_model import RidgeCV, LassoCV

# Automatically finds best alpha using CV
ridge = RidgeCV(alphas=[0.1, 1.0, 10.0], cv=5)
ridge.fit(X_train, y_train)
print(f"Best alpha: {ridge.alpha_}")

lasso = LassoCV(alphas=[0.01, 0.1, 1.0], cv=5)
lasso.fit(X_train, y_train)
print(f"Best alpha: {lasso.alpha_}")
```

## Regularization in Logistic Regression

Same concept applies:

```python
from sklearn.linear_model import LogisticRegression

# C = 1/λ (smaller C = more regularization)
model = LogisticRegression(C=0.1, penalty='l2')  # Strong L2
model = LogisticRegression(C=10, penalty='l1', solver='saga')  # Weak L1
```

## Regularization in Other Models

### Decision Trees
```python
from sklearn.tree import DecisionTreeClassifier

# Regularization via constraints
tree = DecisionTreeClassifier(
    max_depth=5,            # Limit depth
    min_samples_split=10,   # Min samples to split
    min_samples_leaf=5      # Min samples per leaf
)
```

### Neural Networks
```python
# L2 (weight decay)
from keras.regularizers import l2
model.add(Dense(64, kernel_regularizer=l2(0.01)))

# Dropout (randomly zeros neurons)
model.add(Dropout(0.5))
```

## When to Use Regularization

**Always consider it for:**
- Linear/Logistic Regression
- Neural Networks
- Any model prone to overfitting

**Signs you need MORE regularization:**
- Training accuracy >> Test accuracy
- Large coefficients/weights
- Unstable predictions

**Signs you need LESS regularization:**
- Training accuracy is low
- Model is too simple
- Important features have zero weight

## Practical Example

```python
from sklearn.linear_model import Ridge, Lasso
from sklearn.model_selection import cross_val_score
import numpy as np

# Compare different regularization strengths
alphas = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]

for alpha in alphas:
    ridge = Ridge(alpha=alpha)
    scores = cross_val_score(ridge, X, y, cv=5)
    print(f"α={alpha:6.3f}: {scores.mean():.3f} ± {scores.std():.3f}")
```

Output:
```
α= 0.001: 0.812 ± 0.045  (underfitting slight)
α= 0.010: 0.845 ± 0.032
α= 0.100: 0.867 ± 0.028  ← Best!
α= 1.000: 0.854 ± 0.031
α=10.000: 0.798 ± 0.042  (overfitting)
α=100.00: 0.721 ± 0.058  (severe overfitting)
```

## Key Takeaways

1. **Regularization adds a penalty for complexity**
2. **L2 (Ridge):** Shrinks all weights
3. **L1 (Lasso):** Can zero out weights (feature selection)
4. **Always tune the regularization strength (λ/α)**
5. **Use cross-validation to find the best value**

Think of regularization as Occam's Razor for ML: simpler models often generalize better!

Learn how regularization techniques prevent overfitting and improve model generalization.

Regularization: Preventing Overfitting

# Understanding Gradient Descent

Gradient Descent is how machines "learn." It's the algorithm that finds the best parameters for your model.

## The Big Picture

Imagine you're blindfolded on a hilly terrain, trying to find the lowest point (valley).

Strategy:
1. Feel which direction goes downhill
2. Take a step that direction
3. Repeat until you can't go lower

That's gradient descent!

## The Math (Simple Version)

We have a **loss function** that measures how bad our model is:

```
Loss = f(weights)
```

Goal: Find weights that minimize this loss.

**Gradient** = Direction of steepest increase
**Negative gradient** = Direction of steepest decrease

Update rule:
```
new_weight = old_weight - learning_rate × gradient
```

## Visual Example

```
Loss
  │╲
  │ ╲     ← Start here
  │  ╲
  │   ╲   ← Take steps down
  │    ╲
  │     ╲___ ← Minimum!
  └────────────
        weights
```

## Learning Rate

The learning rate (α) controls step size.

```
Too small:              Too big:              Just right:
Loss                    Loss                   Loss
  │╲.                     │╲                     │╲
  │ ╲...                  │ ╲ /╲                │ ╲
  │  ╲....               │ ╲/  ╲              │  ╲
  │   ╲.....             │      ↑             │   ╲___
  └──────────            Overshoots!          └────────
  Takes forever                                Converges
```

**Typical values:** 0.001 to 0.1

## Types of Gradient Descent

### 1. Batch Gradient Descent
Uses ALL data to compute gradient each step.

```python
for epoch in range(num_epochs):
    gradient = compute_gradient(ALL_data)
    weights = weights - learning_rate * gradient
```

✅ Smooth convergence
❌ Slow for large datasets
❌ Needs all data in memory

### 2. Stochastic Gradient Descent (SGD)
Uses ONE sample per step.

```python
for epoch in range(num_epochs):
    shuffle(data)
    for sample in data:
        gradient = compute_gradient(sample)
        weights = weights - learning_rate * gradient
```

✅ Fast updates
✅ Can escape local minima
❌ Noisy, zigzags a lot

### 3. Mini-Batch Gradient Descent (Most Common!)
Uses a BATCH of samples (e.g., 32, 64, 128).

```python
batch_size = 32
for epoch in range(num_epochs):
    for batch in get_batches(data, batch_size):
        gradient = compute_gradient(batch)
        weights = weights - learning_rate * gradient
```

✅ Best of both worlds
✅ Efficient GPU usage
✅ Reasonably smooth

## Code Example: Linear Regression with GD

```python
import numpy as np

# Generate data
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1) * 0.5

# Add bias term
X_b = np.c_[np.ones((100, 1)), X]

# Gradient Descent
learning_rate = 0.1
n_iterations = 1000
m = len(X)

theta = np.random.randn(2, 1)  # Random initialization

for iteration in range(n_iterations):
    # Predictions
    predictions = X_b.dot(theta)
    
    # Error
    error = predictions - y
    
    # Gradient
    gradient = (2/m) * X_b.T.dot(error)
    
    # Update
    theta = theta - learning_rate * gradient

print(f"Learned parameters: {theta.flatten()}")
# Should be close to [4, 3]
```

## Convergence Issues

### Problem 1: Local Minima
```
Loss
  │  ╱╲    ╱╲
  │ ╱  ╲__╱  ╲
  │╱    ↑      ╲
  └──────────────
       Stuck here (local minimum)
       Not the global minimum!
```

**Solutions:**
- Random initialization (try multiple starting points)
- Momentum (helps roll past local minima)
- SGD noise can help escape

### Problem 2: Vanishing/Exploding Gradients
Gradients become very small or very large.

**Solutions:**
- Proper weight initialization
- Batch normalization
- Gradient clipping

### Problem 3: Saddle Points
```
        ↑ Up in one direction
        │
─────╲──┼──╱───── ← Flat here
        │
        ↓ Down in another direction
```

**Solution:** Advanced optimizers (Adam, RMSprop)

## Advanced Optimizers

### Momentum
Adds "velocity" to updates:

```python
velocity = momentum * velocity - learning_rate * gradient
weights = weights + velocity
```

Helps accelerate in consistent directions.

### Adam (Most Popular!)
Adaptive learning rates per parameter:

```python
from keras.optimizers import Adam

optimizer = Adam(learning_rate=0.001)  # Default settings work well
```

Usually the best default choice.

## Sklearn Gradient Descent

```python
from sklearn.linear_model import SGDClassifier, SGDRegressor

# Classification
clf = SGDClassifier(loss='log_loss', learning_rate='adaptive', eta0=0.01)
clf.fit(X_train, y_train)

# Regression
reg = SGDRegressor(learning_rate='adaptive', eta0=0.01)
reg.fit(X_train, y_train)
```

## Key Hyperparameters

| Parameter | What It Does | Typical Values |
|-----------|--------------|----------------|
| Learning rate | Step size | 0.001 - 0.1 |
| Batch size | Samples per update | 32, 64, 128 |
| Epochs | Passes through data | 10 - 1000 |
| Momentum | Velocity accumulation | 0.9 |

## Tips for Success

1. **Normalize features:** Gradient descent works better when features are on similar scales
2. **Start with Adam:** It's robust and works well by default
3. **Monitor training:** Plot loss over time to ensure convergence
4. **Learning rate schedules:** Start high, decrease over time

## Key Takeaway

Gradient Descent is iterative optimization:
1. Compute how wrong you are (loss)
2. Compute which direction improves things (gradient)
3. Take a small step that direction
4. Repeat until good enough

It's simple in concept but powers everything from linear regression to deep neural networks!

Learn how gradient descent works - the optimization algorithm behind most ML models.

Understanding Gradient Descent

# Naive Bayes Classifier Explained

Naive Bayes is fast, simple, and surprisingly effective. It's based on probability theory and a "naive" assumption.

## The Intuition

You get an email with words: "free", "winner", "click"

What's the probability it's spam?

Naive Bayes calculates:
```
P(spam | these words) vs P(not spam | these words)
```

Whichever is higher wins!

## Bayes' Theorem

```
P(A|B) = P(B|A) × P(A)
         ─────────────
              P(B)
```

For classification:
```
P(class|features) ∝ P(features|class) × P(class)
```

- **P(class):** Prior probability (how common is spam?)
- **P(features|class):** Likelihood (how common are these features in spam?)
- **P(class|features):** Posterior (what we want to know!)

## The "Naive" Assumption

Naive Bayes assumes features are **independent** given the class.

```
P(free, winner, click | spam) = P(free|spam) × P(winner|spam) × P(click|spam)
```

This is "naive" because features often ARE related. But it works anyway!

## Example: Spam Classification

Training data:
```
Email 1: "free money now" → Spam
Email 2: "meeting tomorrow" → Not Spam
Email 3: "free gift winner" → Spam
Email 4: "project update" → Not Spam
```

Calculate probabilities:
```
P(spam) = 2/4 = 0.5
P(not spam) = 2/4 = 0.5

P(free | spam) = 2/2 = 1.0  (appears in both spam)
P(free | not spam) = 0/2 = 0.0

P(winner | spam) = 1/2 = 0.5
P(winner | not spam) = 0/2 = 0.0
```

New email: "free winner"
```
P(spam | free, winner) ∝ 0.5 × 1.0 × 0.5 = 0.25
P(not spam | free, winner) ∝ 0.5 × 0.0 × 0.0 = 0.0

Verdict: SPAM!
```

## Types of Naive Bayes

### 1. Gaussian Naive Bayes
For continuous features. Assumes normal distribution.

```python
from sklearn.naive_bayes import GaussianNB

model = GaussianNB()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
```

### 2. Multinomial Naive Bayes
For discrete counts (word frequencies).

```python
from sklearn.naive_bayes import MultinomialNB

# Great for text classification!
model = MultinomialNB()
model.fit(X_train_counts, y_train)
```

### 3. Bernoulli Naive Bayes
For binary features (word present/absent).

```python
from sklearn.naive_bayes import BernoulliNB

model = BernoulliNB()
model.fit(X_train_binary, y_train)
```

## Text Classification Example

```python
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.model_selection import train_test_split

# Sample data
texts = [
    "free money click now",
    "meeting at 3pm tomorrow",
    "winner free gift claim",
    "project deadline friday",
    "cheap pills online",
    "team lunch next week"
]
labels = ['spam', 'ham', 'spam', 'ham', 'spam', 'ham']

# Convert text to word counts
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(texts)

# Split
X_train, X_test, y_train, y_test = train_test_split(X, labels, test_size=0.3)

# Train
model = MultinomialNB()
model.fit(X_train, y_train)

# Predict new email
new_email = vectorizer.transform(["free winner prize"])
prediction = model.predict(new_email)
probability = model.predict_proba(new_email)

print(f"Prediction: {prediction[0]}")
print(f"Probabilities: {probability}")
```

## Laplace Smoothing

What if a word never appears in spam during training?
```
P(word | spam) = 0 → Everything multiplies to 0!
```

**Solution:** Add a small count (Laplace smoothing):

```python
# alpha = smoothing parameter (default 1.0)
model = MultinomialNB(alpha=1.0)
```

```
P(word | spam) = (count + 1) / (total + vocabulary_size)
```

## Pros and Cons

### Pros ✅
- **Very fast:** Training and prediction are quick
- **Handles many features:** Scales well with high dimensions
- **Works with small data:** Doesn't need much training data
- **Good baseline:** Often surprisingly competitive
- **Probabilistic:** Gives probability estimates

### Cons ❌
- **Independence assumption:** Often violated in practice
- **Zero frequency problem:** Needs smoothing
- **Continuous features:** Assumes Gaussian (may not be true)

## When to Use Naive Bayes

**Great for:**
- Text classification (spam, sentiment, topic)
- Real-time prediction (very fast)
- Multi-class problems
- When you have little training data

**Less suitable for:**
- Complex feature interactions
- When independence assumption is badly violated

## Comparison with Other Classifiers

| Aspect | Naive Bayes | Logistic Regression | SVM |
|--------|-------------|--------------------| --- |
| Speed | Very fast | Fast | Slower |
| Training data needed | Less | Medium | More |
| Feature independence | Assumes yes | No assumption | No assumption |
| Interpretability | Good | Good | Poor |

## Key Takeaways

1. **Based on Bayes' theorem** - calculates P(class|features)
2. **"Naive" assumption** - features are independent (often wrong, still works!)
3. **Three types:** Gaussian, Multinomial, Bernoulli
4. **Great for text** - spam filtering, sentiment analysis
5. **Fast and simple** - excellent baseline model

Despite its simplicity, Naive Bayes often performs surprisingly well, especially for text classification. Always try it as a baseline!

Learn Naive Bayes - a simple but powerful probabilistic classifier based on Bayes theorem.

Naive Bayes Classifier Explained

# Building Your First ML Pipeline

Stop writing messy ML code! Pipelines make your workflow clean, reproducible, and bug-free.

## The Problem Without Pipelines

```python
# Messy approach
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)  # Easy to forget!

imputer = SimpleImputer()
X_train_imputed = imputer.fit_transform(X_train_scaled)
X_test_imputed = imputer.transform(X_test_scaled)

model = LogisticRegression()
model.fit(X_train_imputed, y_train)
predictions = model.predict(X_test_imputed)
```

Problems:
- Easy to forget to transform test data
- Messy variable names
- Hard to do cross-validation correctly
- Error-prone when deploying

## The Solution: Pipelines!

```python
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression

# Clean approach
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler()),
    ('model', LogisticRegression())
])

# One line to train
pipeline.fit(X_train, y_train)

# One line to predict
predictions = pipeline.predict(X_test)
```

All transformations are applied automatically in order!

## Creating Pipelines

### Basic Pipeline
```python
from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('step1_name', Transformer1()),
    ('step2_name', Transformer2()),
    ('model', Classifier())
])
```

### Using make_pipeline (Auto-names)
```python
from sklearn.pipeline import make_pipeline

pipeline = make_pipeline(
    SimpleImputer(),
    StandardScaler(),
    LogisticRegression()
)
# Steps named automatically: simpleimputer, standardscaler, logisticregression
```

## Handling Different Column Types

Real data has mixed types. Use **ColumnTransformer**:

```python
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer

# Define column groups
numerical_features = ['age', 'income', 'score']
categorical_features = ['city', 'gender', 'education']

# Different preprocessing for different types
preprocessor = ColumnTransformer([
    ('num', Pipeline([
        ('imputer', SimpleImputer(strategy='median')),
        ('scaler', StandardScaler())
    ]), numerical_features),
    
    ('cat', Pipeline([
        ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
        ('encoder', OneHotEncoder(handle_unknown='ignore'))
    ]), categorical_features)
])

# Full pipeline
pipeline = Pipeline([
    ('preprocessing', preprocessor),
    ('model', LogisticRegression())
])

pipeline.fit(X_train, y_train)
```

## Cross-Validation with Pipelines

```python
from sklearn.model_selection import cross_val_score

# Cross-validation is now SAFE
# Preprocessing is done correctly for each fold!
scores = cross_val_score(pipeline, X, y, cv=5)
print(f"CV Score: {scores.mean():.3f} ± {scores.std():.3f}")
```

Without a pipeline, preprocessing might leak information between folds!

## Hyperparameter Tuning with Pipelines

Access nested parameters with double underscore:

```python
from sklearn.model_selection import GridSearchCV

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LogisticRegression())
])

# Parameter names: stepname__parameter
param_grid = {
    'model__C': [0.1, 1, 10],
    'model__penalty': ['l1', 'l2']
}

grid_search = GridSearchCV(pipeline, param_grid, cv=5)
grid_search.fit(X_train, y_train)

print(f"Best params: {grid_search.best_params_}")
print(f"Best score: {grid_search.best_score_:.3f}")
```

## Complete Example

```python
import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
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 RandomForestClassifier

# Load data
df = pd.read_csv('data.csv')
X = df.drop('target', axis=1)
y = df['target']

# Identify column types
numerical = X.select_dtypes(include=['int64', 'float64']).columns.tolist()
categorical = X.select_dtypes(include=['object']).columns.tolist()

# Build preprocessing
num_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

cat_transformer = Pipeline([
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(handle_unknown='ignore'))
])

preprocessor = ColumnTransformer([
    ('num', num_transformer, numerical),
    ('cat', cat_transformer, categorical)
])

# Full pipeline
pipeline = Pipeline([
    ('prep', preprocessor),
    ('clf', RandomForestClassifier(n_estimators=100))
])

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Cross-validation
cv_scores = cross_val_score(pipeline, X_train, y_train, cv=5)
print(f"CV Scores: {cv_scores.mean():.3f} ± {cv_scores.std():.3f}")

# Train and evaluate
pipeline.fit(X_train, y_train)
test_score = pipeline.score(X_test, y_test)
print(f"Test Score: {test_score:.3f}")
```

## Saving and Loading Pipelines

```python
import joblib

# Save entire pipeline (preprocessing + model)
joblib.dump(pipeline, 'my_model_pipeline.pkl')

# Load later
loaded_pipeline = joblib.load('my_model_pipeline.pkl')

# Ready to predict!
new_data = pd.DataFrame({'age': [30], 'income': [50000], 'city': ['NYC']})
prediction = loaded_pipeline.predict(new_data)
```

## Pipeline Best Practices

1. **Include ALL preprocessing** in the pipeline
2. **Use ColumnTransformer** for mixed data types
3. **Use cross_val_score** for reliable evaluation
4. **Save the whole pipeline** for deployment
5. **Name your steps** clearly

## Benefits Summary

| Benefit | Why It Matters |
|---------|---------------|
| No data leakage | Preprocessing fitted only on training data |
| Reproducible | Same steps every time |
| Easy deployment | Save/load complete workflow |
| Clean code | No messy intermediate variables |
| Safe CV | Each fold preprocessed correctly |

## Key Takeaway

Pipelines aren't optional—they're essential for professional ML work. They prevent bugs, ensure reproducibility, and make your code cleaner.

Start every project with a pipeline. You'll thank yourself later!

Learn how to build clean, reproducible ML pipelines using scikit-learn.

Building Your First ML Pipeline

# Hyperparameter Tuning: Grid Search vs Random Search

Your model has knobs you can adjust. Tuning them properly can dramatically improve performance.

## Parameters vs Hyperparameters

**Parameters:** Learned from data during training
- Linear regression weights
- Neural network weights

**Hyperparameters:** Set before training, control the learning process
- Learning rate
- Number of trees in random forest
- Regularization strength (C, alpha)
- Max depth of decision tree

You choose hyperparameters. The model learns parameters.

## Why Tune Hyperparameters?

Default values aren't optimal for your specific data:

```python
# Default might give 78% accuracy
model = RandomForestClassifier()

# Tuned might give 89% accuracy!
model = RandomForestClassifier(n_estimators=200, max_depth=15, min_samples_split=5)
```

## Method 1: Grid Search

Try ALL combinations of specified values.

```python
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

# Define parameter grid
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10]
}

# Total combinations: 3 × 4 × 3 = 36

model = RandomForestClassifier()
grid_search = GridSearchCV(
    model,
    param_grid,
    cv=5,              # 5-fold cross-validation
    scoring='accuracy',
    n_jobs=-1          # Use all CPU cores
)

grid_search.fit(X_train, y_train)

print(f"Best parameters: {grid_search.best_params_}")
print(f"Best CV score: {grid_search.best_score_:.3f}")

# Use the best model
best_model = grid_search.best_estimator_
predictions = best_model.predict(X_test)
```

### Grid Search Pros/Cons

✅ Exhaustive - tries everything
✅ Guaranteed to find best combo in the grid
❌ Exponentially expensive: 3 params × 10 values each = 1000 combos!
❌ Wastes time on bad regions

## Method 2: Random Search

Sample random combinations from parameter distributions.

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

# Define parameter distributions
param_dist = {
    'n_estimators': randint(50, 300),        # Random integer 50-300
    'max_depth': randint(3, 30),             # Random integer 3-30
    'min_samples_split': randint(2, 20),     # Random integer 2-20
    'min_samples_leaf': randint(1, 10),      # Random integer 1-10
    'max_features': uniform(0.1, 0.9)        # Random float 0.1-1.0
}

model = RandomForestClassifier()
random_search = RandomizedSearchCV(
    model,
    param_dist,
    n_iter=50,         # Try 50 random combinations
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    random_state=42
)

random_search.fit(X_train, y_train)

print(f"Best parameters: {random_search.best_params_}")
print(f"Best CV score: {random_search.best_score_:.3f}")
```

### Random Search Pros/Cons

✅ Explores more of the space with fewer evaluations
✅ Better for high-dimensional spaces
✅ Often finds good solutions faster
❌ Might miss the optimal if unlucky
❌ Not exhaustive

## When to Use Which?

| Situation | Recommendation |
|-----------|---------------|
| Few hyperparameters (≤3) | Grid Search |
| Many hyperparameters (>3) | Random Search |
| Continuous parameters | Random Search |
| Quick exploration | Random Search |
| Final fine-tuning | Grid Search (narrow range) |

## Practical Strategy

### Step 1: Random Search (Broad)
```python
# Explore large range
param_dist = {
    'max_depth': randint(1, 50),
    'learning_rate': uniform(0.001, 0.5)
}
random_search.fit(X_train, y_train)
# Found: max_depth ≈ 10, learning_rate ≈ 0.1
```

### Step 2: Grid Search (Narrow)
```python
# Fine-tune around best values
param_grid = {
    'max_depth': [8, 9, 10, 11, 12],
    'learning_rate': [0.05, 0.08, 0.1, 0.12, 0.15]
}
grid_search.fit(X_train, y_train)
```

## Common Hyperparameters to Tune

### Logistic Regression
```python
param_grid = {
    'C': [0.001, 0.01, 0.1, 1, 10, 100],
    'penalty': ['l1', 'l2'],
    'solver': ['liblinear', 'saga']
}
```

### Random Forest
```python
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [10, 20, 30, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}
```

### XGBoost
```python
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [3, 5, 7],
    'learning_rate': [0.01, 0.1, 0.3],
    'subsample': [0.8, 0.9, 1.0]
}
```

### SVM
```python
param_grid = {
    'C': [0.1, 1, 10],
    'kernel': ['rbf', 'linear', 'poly'],
    'gamma': ['scale', 'auto', 0.1, 1]
}
```

## Visualizing Results

```python
import pandas as pd
import matplotlib.pyplot as plt

# Get results
results = pd.DataFrame(grid_search.cv_results_)

# Plot
plt.figure(figsize=(10, 6))
for depth in [5, 10, 15]:
    mask = results['param_max_depth'] == depth
    plt.plot(
        results[mask]['param_n_estimators'],
        results[mask]['mean_test_score'],
        label=f'max_depth={depth}'
    )

plt.xlabel('n_estimators')
plt.ylabel('CV Score')
plt.legend()
plt.title('Hyperparameter Tuning Results')
plt.show()
```

## Advanced: Bayesian Optimization

More efficient than grid/random search:

```python
# pip install scikit-optimize
from skopt import BayesSearchCV

search = BayesSearchCV(
    model,
    param_dist,
    n_iter=50,
    cv=5
)
search.fit(X_train, y_train)
```

Uses past evaluations to intelligently choose next points to try.

## Key Tips

1. **Use cross-validation** - Don't tune on a single train-test split
2. **Start broad, then narrow** - Random search → Grid search
3. **Don't over-tune** - Risk of overfitting to validation set
4. **Keep a holdout test set** - Final evaluation on unseen data
5. **Set random_state** - For reproducibility

## Code Template

```python
from sklearn.model_selection import RandomizedSearchCV, GridSearchCV
from sklearn.pipeline import Pipeline

# Include preprocessing in pipeline
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier())
])

# Use stepname__param for nested params
param_dist = {
    'model__n_estimators': randint(50, 300),
    'model__max_depth': randint(5, 30)
}

search = RandomizedSearchCV(pipeline, param_dist, n_iter=30, cv=5)
search.fit(X_train, y_train)

# Final test
print(f"Test score: {search.score(X_test, y_test):.3f}")
```

## Key Takeaway

Hyperparameter tuning is essential for good performance. Start with Random Search to explore, then Grid Search to refine. Always use cross-validation and keep a separate test set for final evaluation!

Learn how to find the best hyperparameters for your ML models using Grid Search and Random Search.

Hyperparameter Tuning: Grid Search vs Random Search

# Random Forest: Ensemble Learning Made Simple

One decision tree is decent. A hundred decision trees voting together? That's powerful. Welcome to Random Forest.

## The Core Idea

Random Forest = Many Decision Trees + Voting

Each tree gets:
- A random subset of training data (bagging)
- A random subset of features at each split

Final prediction = majority vote (classification) or average (regression)

## Why Does This Work?

**Single Tree Problems:**
- Prone to overfitting
- Sensitive to small data changes
- Can miss important patterns

**Forest Solutions:**
- Individual errors cancel out
- More stable predictions
- Captures diverse patterns

Think of it like asking 100 people for directions vs asking 1 person. The crowd is usually right.

## Implementation

```python
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Prepare data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Create and train Random Forest
rf = RandomForestClassifier(
    n_estimators=100,      # Number of trees
    max_depth=10,          # Limit tree depth
    min_samples_split=5,   # Min samples to split
    random_state=42
)
rf.fit(X_train, y_train)

# Predict
predictions = rf.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, predictions):.2f}")
```

## Key Parameters

| Parameter | What It Does | Typical Values |
|-----------|-------------|----------------|
| n_estimators | Number of trees | 100-500 |
| max_depth | Tree depth limit | 10-30 |
| min_samples_split | Min samples to split | 2-10 |
| max_features | Features per split | 'sqrt' or 'log2' |

## Feature Importance

Random Forest tells you which features matter most:

```python
import pandas as pd

# Get feature importance
importance = pd.DataFrame({
    'feature': feature_names,
    'importance': rf.feature_importances_
}).sort_values('importance', ascending=False)

print(importance.head(10))
```

## When to Use Random Forest

**Good for:**
- Tabular data
- When you need feature importance
- Classification and regression
- When you want decent results without much tuning

**Not ideal for:**
- Very high-dimensional sparse data
- When interpretability is critical
- Real-time predictions (slower than single tree)

## Key Takeaway

Random Forest is often the first algorithm to try for tabular data. It's robust, handles missing values, provides feature importance, and works well out of the box. Start with 100 trees and tune from there!

Learn how Random Forests combine multiple decision trees for better predictions and reduced overfitting.

Random Forest: Ensemble Learning Made Simple

# Gradient Boosting: Sequential Ensemble Learning

Random Forest builds trees in parallel. Gradient Boosting builds them sequentially, where each tree learns from the mistakes of all previous trees.

## The Core Idea

1. Train a simple model
2. Calculate errors (residuals)
3. Train next model to predict those errors
4. Add to ensemble
5. Repeat

Each new tree focuses on what the ensemble got wrong.

## Random Forest vs Gradient Boosting

| Aspect | Random Forest | Gradient Boosting |
|--------|--------------|-------------------|
| Tree Building | Parallel | Sequential |
| Tree Type | Deep, independent | Shallow, dependent |
| Speed | Faster training | Slower training |
| Overfitting | More resistant | Can overfit easily |
| Tuning | Less sensitive | Needs careful tuning |

## Implementation with XGBoost

XGBoost is the most popular gradient boosting library:

```python
import xgboost as xgb
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)

# Create and train
model = xgb.XGBClassifier(
    n_estimators=100,
    max_depth=3,           # Shallow trees
    learning_rate=0.1,     # Step size
    subsample=0.8,         # Row sampling
    colsample_bytree=0.8   # Column sampling
)
model.fit(X_train, y_train)

# Evaluate
accuracy = model.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2f}")
```

## Key Parameters

**n_estimators:** Number of boosting rounds
- More = potentially better, but slower
- Use early stopping to find optimal

**learning_rate:** How much each tree contributes
- Lower = more trees needed, but better generalization
- Typical: 0.01 - 0.3

**max_depth:** Tree depth
- Shallow (3-6) for boosting
- Deeper trees can overfit

## Early Stopping

Don't guess the number of trees. Let the data tell you:

```python
model = xgb.XGBClassifier(
    n_estimators=1000,
    learning_rate=0.1,
    early_stopping_rounds=50
)

model.fit(
    X_train, y_train,
    eval_set=[(X_val, y_val)],
    verbose=False
)

print(f"Best iteration: {model.best_iteration}")
```

## Popular Libraries

1. **XGBoost** - Fast, widely used
2. **LightGBM** - Even faster, good for large data
3. **CatBoost** - Great with categorical features

## When to Use

**Gradient Boosting shines when:**
- You need maximum accuracy
- You have time to tune
- Tabular/structured data
- Kaggle competitions!

**Consider alternatives when:**
- Training speed is critical
- You have limited data (may overfit)
- Interpretability is key

## Key Takeaway

Gradient Boosting often gives the best performance on tabular data. Start with XGBoost, use shallow trees (max_depth=3-6), and always use early stopping. The learning_rate and n_estimators work together - lower rate needs more estimators.

Understand how Gradient Boosting builds trees sequentially, each fixing the mistakes of the previous ones.

Gradient Boosting: Sequential Ensemble Learning

# Support Vector Machines (SVM) Explained

SVM finds the best line (or hyperplane) that separates your classes with the maximum margin. It's elegant math that works surprisingly well.

## The Core Idea

Imagine plotting two classes of points. Many lines could separate them. SVM finds the one that:
1. Correctly separates classes
2. Maximizes distance to nearest points

The nearest points are called "support vectors" - they support (define) the decision boundary.

## Visual Intuition

```
Class A: ●
Class B: ○

     ●  ●           ○  ○
  ●     ● |        ○  ○
    ●    |   ←margin→   ○
  ●   ●  |           ○  ○
         |
    Support vectors touch the margin
```

## Implementation

```python
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# SVM needs scaled features!
svm_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svm', SVC(kernel='rbf', C=1.0))
])

svm_pipeline.fit(X_train, y_train)
accuracy = svm_pipeline.score(X_test, y_test)
```

## The Kernel Trick

What if data isn't linearly separable? Kernels transform data to higher dimensions where it becomes separable.

**Common Kernels:**

| Kernel | Use Case |
|--------|----------|
| linear | Linearly separable data |
| rbf (default) | Most problems, non-linear |
| poly | Polynomial relationships |

```python
# Linear kernel - faster for high-dimensional data
SVC(kernel='linear')

# RBF kernel - default, handles non-linear
SVC(kernel='rbf', gamma='scale')

# Polynomial kernel
SVC(kernel='poly', degree=3)
```

## Key Parameters

**C (Regularization):**
- High C: Tries to classify all points correctly (risk of overfitting)
- Low C: Allows some misclassification (smoother boundary)

**gamma (for RBF kernel):**
- High gamma: Points must be close to affect boundary (complex boundary)
- Low gamma: Points far away still matter (simpler boundary)

## When to Use SVM

**Works well for:**
- Binary classification
- Small to medium datasets
- High-dimensional data (text classification)
- When you need a clear margin

**Not ideal for:**
- Large datasets (slow training)
- Multi-class problems (needs workarounds)
- When probability estimates are needed
- Noisy data with overlapping classes

## Important: Scale Your Features!

SVM is sensitive to feature scales. Always standardize:

```python
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
```

## Key Takeaway

SVM finds the optimal boundary with maximum margin. Use RBF kernel as default, always scale your features, and tune C for the bias-variance tradeoff. Great for smaller datasets with clear separation, but consider tree-based methods for large tabular data.

Learn how SVMs find the optimal boundary between classes and when to use them.

Support Vector Machines (SVM) Explained

# Introduction to Neural Networks

Neural networks are inspired by the brain but don't think of them as actual brains. They're mathematical functions that learn patterns through examples.

## The Building Block: Neuron

A single neuron does:
1. Takes inputs (x₁, x₂, ...)
2. Multiplies each by a weight (w₁, w₂, ...)
3. Adds them up plus a bias (b)
4. Applies an activation function

```
output = activation(w₁x₁ + w₂x₂ + ... + b)
```

## Network Architecture

Neurons are organized in layers:

```
Input Layer → Hidden Layer(s) → Output Layer
    ●              ●               ●
    ●    →         ●      →        ●
    ●              ●               
```

- **Input Layer:** Your features
- **Hidden Layers:** Where learning happens
- **Output Layer:** Predictions

## Activation Functions

Without activation functions, neural networks are just linear regression. Activation adds non-linearity.

**Common Activations:**

| Function | Formula | Use |
|----------|---------|-----|
| ReLU | max(0, x) | Hidden layers (default) |
| Sigmoid | 1/(1+e⁻ˣ) | Binary output (0-1) |
| Softmax | eˣ/Σeˣ | Multi-class output |
| Tanh | (eˣ-e⁻ˣ)/(eˣ+e⁻ˣ) | Hidden layers |

## How Networks Learn

1. **Forward Pass:** Input flows through, get prediction
2. **Calculate Loss:** How wrong was the prediction?
3. **Backward Pass:** Calculate how each weight contributed to error
4. **Update Weights:** Adjust to reduce error
5. **Repeat:** Many times over many examples

This is called **backpropagation** with **gradient descent**.

## Simple Implementation

```python
from sklearn.neural_network import MLPClassifier

# Create neural network
nn = MLPClassifier(
    hidden_layer_sizes=(100, 50),  # Two hidden layers
    activation='relu',
    max_iter=500,
    random_state=42
)

nn.fit(X_train, y_train)
accuracy = nn.score(X_test, y_test)
```

## With PyTorch (More Control)

```python
import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self, input_size, num_classes):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(input_size, 100),
            nn.ReLU(),
            nn.Linear(100, 50),
            nn.ReLU(),
            nn.Linear(50, num_classes)
        )
    
    def forward(self, x):
        return self.layers(x)
```

## Key Concepts

**Epochs:** One pass through entire training data
**Batch Size:** Number of samples before weight update
**Learning Rate:** How big the weight updates are

## When to Use Neural Networks

**Good for:**
- Image, text, audio data
- Large datasets
- Complex patterns
- When you have GPU

**Consider alternatives when:**
- Small datasets (will overfit)
- Tabular data (tree methods often better)
- Interpretability needed
- Limited compute

## Key Takeaway

Neural networks learn by adjusting weights to minimize prediction error. Start simple (1-2 hidden layers), use ReLU activation, and make sure you have enough data. For tabular data, try gradient boosting first - neural networks shine on unstructured data like images and text.

Understand the basics of neural networks - neurons, layers, activation functions, and how they learn.

Introduction to Neural Networks

# Feature Engineering: Creating Better Features

Good features can make a simple model outperform a complex one with bad features. Feature engineering is often the difference between a working model and a great one.

## What is Feature Engineering?

Creating new features from existing data to help models learn better.

Raw data → Transformed features → Better predictions

## Numerical Feature Techniques

### 1. Binning
Convert continuous to categorical:

```python
# Age bins
df['age_group'] = pd.cut(df['age'], 
    bins=[0, 18, 35, 50, 65, 100],
    labels=['child', 'young', 'middle', 'senior', 'elderly'])
```

### 2. Log Transform
Handles skewed data:

```python
import numpy as np

# For right-skewed data (income, prices)
df['log_income'] = np.log1p(df['income'])  # log1p handles zeros
```

### 3. Polynomial Features
Capture non-linear relationships:

```python
from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)
# Creates: x1, x2, x1², x2², x1*x2
```

## Date/Time Features

Dates are goldmines for features:

```python
df['date'] = pd.to_datetime(df['date'])

# Extract components
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day_of_week'] = df['date'].dt.dayofweek
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
df['quarter'] = df['date'].dt.quarter

# Time since event
df['days_since_signup'] = (pd.Timestamp.now() - df['signup_date']).dt.days
```

## Text Features

```python
# Length features
df['text_length'] = df['text'].str.len()
df['word_count'] = df['text'].str.split().str.len()

# Contains patterns
df['has_question'] = df['text'].str.contains('\?').astype(int)
df['has_url'] = df['text'].str.contains('http').astype(int)
```

## Aggregation Features

For grouped data (like customer transactions):

```python
# Customer-level features from transactions
customer_features = df.groupby('customer_id').agg({
    'amount': ['sum', 'mean', 'max', 'count'],
    'date': ['min', 'max']
}).reset_index()

# Flatten column names
customer_features.columns = ['customer_id', 'total_spent', 'avg_spent', 
                             'max_purchase', 'num_purchases', 
                             'first_purchase', 'last_purchase']
```

## Interaction Features

Combine features that might have joint effects:

```python
# Ratios
df['price_per_sqft'] = df['price'] / df['sqft']

# Products
df['total_value'] = df['quantity'] * df['unit_price']

# Combinations
df['age_income'] = df['age'] * df['income']
```

## Domain-Specific Features

**E-commerce:**
- Days since last purchase
- Average order value
- Purchase frequency

**Finance:**
- Debt-to-income ratio
- Moving averages
- Volatility measures

**Healthcare:**
- BMI from height/weight
- Age at diagnosis
- Time between visits

## Feature Selection After Engineering

More features isn't always better. Remove:
- Features with zero variance
- Highly correlated features (keep one)
- Features with little predictive power

```python
# Remove low variance
from sklearn.feature_selection import VarianceThreshold
selector = VarianceThreshold(threshold=0.01)
X_selected = selector.fit_transform(X)

# Check correlations
corr_matrix = df.corr()
high_corr = (corr_matrix.abs() > 0.95) & (corr_matrix != 1.0)
```

## Key Takeaway

Feature engineering is often more valuable than trying fancier models. Understand your data and domain, create features that capture meaningful patterns, and always validate that new features actually help. The best features often come from domain knowledge, not just mathematical transformations.

Learn practical feature engineering techniques that can dramatically improve your model performance.

Feature Engineering: The Art of Creating Better Features

# Dimensionality Reduction with PCA

Too many features? PCA (Principal Component Analysis) finds the most important directions in your data and lets you keep just those.

## Why Reduce Dimensions?

**Problems with high dimensions:**
- Curse of dimensionality (need exponentially more data)
- Overfitting
- Slow training
- Hard to visualize

**Benefits of PCA:**
- Fewer features, faster training
- Removes multicollinearity
- Enables visualization (reduce to 2-3D)
- Often improves performance

## How PCA Works (Intuition)

1. Find the direction of maximum variance (PC1)
2. Find the next direction, perpendicular to PC1 (PC2)
3. Continue for all dimensions
4. Keep only the top components

Think of it as finding the "natural axes" of your data.

## Implementation

```python
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# PCA requires scaled data!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Apply PCA
pca = PCA(n_components=0.95)  # Keep 95% of variance
X_pca = pca.fit_transform(X_scaled)

print(f"Original features: {X.shape[1]}")
print(f"Reduced features: {X_pca.shape[1]}")
```

## Choosing Number of Components

### Method 1: Variance Threshold

```python
# Keep 95% of total variance
pca = PCA(n_components=0.95)
```

### Method 2: Elbow Plot

```python
import matplotlib.pyplot as plt

pca = PCA()
pca.fit(X_scaled)

plt.plot(range(1, len(pca.explained_variance_ratio_) + 1),
         pca.explained_variance_ratio_.cumsum())
plt.xlabel('Number of Components')
plt.ylabel('Cumulative Variance Explained')
plt.axhline(y=0.95, color='r', linestyle='--')
plt.show()
```

### Method 3: Fixed Number

```python
# For visualization: 2 or 3 components
pca = PCA(n_components=2)
```

## Visualization Example

```python
from sklearn.datasets import load_iris

# Load data
iris = load_iris()
X, y = iris.data, iris.target

# Reduce to 2D
pca = PCA(n_components=2)
X_2d = pca.fit_transform(StandardScaler().fit_transform(X))

# Plot
plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y, cmap='viridis')
plt.xlabel('First Principal Component')
plt.ylabel('Second Principal Component')
plt.title('Iris Dataset - PCA')
plt.show()
```

## Important Considerations

### 1. Always Scale First

PCA is affected by scale. Standardize your data:

```python
# Always do this before PCA
X_scaled = StandardScaler().fit_transform(X)
```

### 2. Fit Only on Training Data

```python
# Correct way
pca = PCA(n_components=50)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)  # Only transform!
```

### 3. Interpretability is Lost

Original features become linear combinations. You can check contributions:

```python
# Feature importance for each component
components_df = pd.DataFrame(
    pca.components_,
    columns=feature_names
)
```

## When to Use PCA

**Good use cases:**
- High-dimensional data (100+ features)
- Visualization
- Preprocessing for other algorithms
- When features are correlated

**Not ideal when:**
- Interpretability is important
- Features are already independent
- Non-linear relationships (consider t-SNE or UMAP)

## Key Takeaway

PCA finds the most important directions in your data. Always scale first, use explained variance to choose components, and remember you're trading interpretability for dimensionality reduction. It's a powerful preprocessing step for high-dimensional data!

Learn how Principal Component Analysis reduces features while preserving important information.

Dimensionality Reduction with PCA

# K-Means Clustering: Finding Groups in Data

No labels? No problem. K-Means finds natural groupings in your data by itself. This is unsupervised learning.

## How K-Means Works

1. Pick K (number of clusters)
2. Randomly place K centroids
3. Assign each point to nearest centroid
4. Move centroids to center of their points
5. Repeat steps 3-4 until stable

```
Iteration 1:        Iteration 2:        Final:
    ●                  ●                  ●
  ● ★ ●             ●  ★  ●            ●  ★  ●
    ●                  ●                  ●
        
  ○   ○             ○  ☆  ○            ○  ☆  ○
    ○                  ○                  ○

★ ☆ = centroids (moving toward cluster centers)
```

## Implementation

```python
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Scale your data!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Apply K-Means
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)

# Add cluster labels to data
df['cluster'] = clusters
```

## Choosing K: The Elbow Method

How many clusters? Let the data tell you:

```python
inertias = []
K_range = range(1, 11)

for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(X_scaled)
    inertias.append(kmeans.inertia_)

plt.plot(K_range, inertias, 'bo-')
plt.xlabel('Number of Clusters (K)')
plt.ylabel('Inertia')
plt.title('Elbow Method')
plt.show()
```

Look for the "elbow" - where adding more clusters stops helping much.

## Choosing K: Silhouette Score

Measures how well points fit their cluster vs others:

```python
from sklearn.metrics import silhouette_score

scores = []
for k in range(2, 11):
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = kmeans.fit_predict(X_scaled)
    scores.append(silhouette_score(X_scaled, labels))

best_k = range(2, 11)[scores.index(max(scores))]
print(f"Best K by silhouette: {best_k}")
```

Higher silhouette score = better clustering (max is 1).

## Analyzing Clusters

```python
# Cluster statistics
cluster_stats = df.groupby('cluster').agg({
    'age': 'mean',
    'income': 'mean',
    'spending': 'mean'
})
print(cluster_stats)

# Cluster sizes
print(df['cluster'].value_counts())
```

## Limitations of K-Means

1. **Must specify K beforehand**
2. **Assumes spherical clusters** (bad for elongated shapes)
3. **Sensitive to outliers**
4. **Sensitive to initialization** (use n_init > 1)

## When to Use K-Means

**Good for:**
- Customer segmentation
- Image compression
- Data exploration
- When clusters are roughly spherical

**Not ideal for:**
- Unknown number of clusters (try DBSCAN)
- Non-spherical clusters
- Varying cluster sizes
- Data with many outliers

## Real-World Example: Customer Segmentation

```python
# Features: recency, frequency, monetary value
customer_features = df[['recency', 'frequency', 'monetary']]

# Scale
scaled = StandardScaler().fit_transform(customer_features)

# Cluster
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
df['segment'] = kmeans.fit_predict(scaled)

# Analyze segments
df.groupby('segment')[['recency', 'frequency', 'monetary']].mean()
```

## Key Takeaway

K-Means is simple and fast for finding groups. Scale your data, use the elbow method or silhouette score to choose K, and always run with multiple initializations (n_init). Remember: K-Means finds clusters even if none exist - always validate that your clusters make sense!

Learn how K-Means clustering finds natural groupings in your data without labels.

K-Means Clustering: Finding Groups in Data

# Hierarchical Clustering: Building a Cluster Tree

Unlike K-Means, hierarchical clustering doesn't need K upfront. It builds a tree of clusters you can cut at any level.

## Two Approaches

**Agglomerative (Bottom-up):** Start with each point as its own cluster, merge closest pairs
**Divisive (Top-down):** Start with one cluster, split recursively

Agglomerative is most common.

## How Agglomerative Works

1. Each point is a cluster
2. Find two closest clusters
3. Merge them
4. Repeat until one cluster remains

## Implementation

```python
from sklearn.cluster import AgglomerativeClustering
from sklearn.preprocessing import StandardScaler

# Scale data
X_scaled = StandardScaler().fit_transform(X)

# Cluster
hc = AgglomerativeClustering(n_clusters=3, linkage='ward')
clusters = hc.fit_predict(X_scaled)
```

## The Dendrogram

A dendrogram shows the merging process. Height indicates distance when clusters merged.

```python
from scipy.cluster.hierarchy import dendrogram, linkage
import matplotlib.pyplot as plt

# Create linkage matrix
Z = linkage(X_scaled, method='ward')

# Plot dendrogram
plt.figure(figsize=(10, 7))
dendrogram(Z)
plt.xlabel('Sample Index')
plt.ylabel('Distance')
plt.title('Hierarchical Clustering Dendrogram')
plt.show()
```

## Reading a Dendrogram

```
         _______________
        |               |
     ___|___         ___|___
    |       |       |       |
   _|_     _|_     _|_     _|_
  |   |   |   |   |   |   |   |
  1   2   3   4   5   6   7   8
  
  Cut here → 2 clusters
  Cut lower → More clusters
```

- Vertical lines = clusters being merged
- Height = distance when merged
- Cut horizontally to get clusters

## Linkage Methods

How to measure distance between clusters:

| Method | Description | Best For |
|--------|-------------|----------|
| ward | Minimize variance | Compact, equal-sized |
| complete | Max distance between points | Well-separated |
| average | Mean distance | General purpose |
| single | Min distance | Can find elongated shapes |

```python
# Ward - most common
AgglomerativeClustering(linkage='ward')

# Complete linkage
AgglomerativeClustering(linkage='complete')
```

## Choosing Number of Clusters

### From Dendrogram

Cut where there's a big jump in height:

```python
from scipy.cluster.hierarchy import fcluster

# Cut at specific distance
clusters = fcluster(Z, t=10, criterion='distance')

# Or specify number of clusters
clusters = fcluster(Z, t=3, criterion='maxclust')
```

### Using Metrics

```python
from sklearn.metrics import silhouette_score

for n in range(2, 10):
    hc = AgglomerativeClustering(n_clusters=n)
    labels = hc.fit_predict(X_scaled)
    score = silhouette_score(X_scaled, labels)
    print(f"n={n}: silhouette={score:.3f}")
```

## K-Means vs Hierarchical

| Aspect | K-Means | Hierarchical |
|--------|---------|--------------|
| Need K upfront | Yes | No |
| Speed | Fast | Slower |
| Scalability | Good | Poor for large data |
| Output | Flat clusters | Tree structure |
| Deterministic | No | Yes |

## When to Use Hierarchical

**Good for:**
- Small to medium datasets
- When you want to explore cluster structure
- When hierarchy makes sense (taxonomy, evolution)
- When K is unknown

**Not ideal for:**
- Large datasets (O(n²) memory)
- When you need to add new points later

## Key Takeaway

Hierarchical clustering gives you a complete picture of cluster structure through the dendrogram. Use it when you want to explore different numbers of clusters or when a hierarchy is meaningful. For large datasets, stick with K-Means.

Learn how hierarchical clustering builds a tree of clusters and how to read dendrograms.

Hierarchical Clustering: Building a Cluster Tree

# Model Selection: Choosing the Right Algorithm

With dozens of ML algorithms, how do you pick the right one? Here's a practical decision framework.

## Start with the Problem Type

**Classification** (predicting categories):
- Binary: spam/not spam, fraud/not fraud
- Multi-class: which category among several

**Regression** (predicting numbers):
- Prices, temperatures, quantities

**Clustering** (finding groups):
- Customer segments, document grouping

**Dimensionality Reduction**:
- Too many features, visualization

## The Decision Tree for Algorithm Selection

```
Is it supervised? (Do you have labels?)
├── Yes
│   ├── Classification?
│   │   ├── Small data (<10K) → SVM, KNN
│   │   ├── Tabular data → Random Forest, XGBoost
│   │   ├── Images → CNN (Deep Learning)
│   │   └── Text → Naive Bayes, Transformers
│   └── Regression?
│       ├── Linear relationship → Linear Regression
│       ├── Non-linear → Random Forest, XGBoost
│       └── Complex patterns → Neural Networks
└── No
    ├── Finding groups? → K-Means, DBSCAN
    └── Reducing dimensions? → PCA, t-SNE
```

## Quick Algorithm Guide

| Algorithm | Best For | Limitations |
|-----------|----------|-------------|
| Linear/Logistic Regression | Interpretability, baselines | Linear only |
| Decision Tree | Interpretability | Overfits |
| Random Forest | General tabular | Slow prediction |
| XGBoost | Best accuracy (tabular) | Needs tuning |
| SVM | Small/medium data | Slow on large data |
| KNN | Simple problems | Slow prediction |
| Neural Networks | Images, text, audio | Needs lots of data |

## Consider Your Constraints

### Data Size

```python
if n_samples < 1000:
    # Simple models, regularization important
    candidates = ['LogisticRegression', 'SVM', 'KNN']
elif n_samples < 100000:
    # Most algorithms work
    candidates = ['RandomForest', 'XGBoost', 'SVM']
else:
    # Need scalable algorithms
    candidates = ['XGBoost', 'LightGBM', 'NeuralNetwork']
```

### Interpretability Needed?

```
High Interpretability:
├── Linear Regression (coefficients)
├── Logistic Regression (coefficients)
├── Decision Tree (rules)
└── Rule-based models

Medium Interpretability:
├── Random Forest (feature importance)
└── Gradient Boosting (SHAP values)

Low Interpretability (Black Box):
├── Neural Networks
└── Complex ensembles
```

### Training Time Budget

```
Fast:
├── Linear models
├── Naive Bayes
└── Decision Tree

Medium:
├── Random Forest
├── SVM (small data)
└── XGBoost

Slow:
├── Neural Networks
├── SVM (large data)
└── Complex ensembles
```

## Practical Strategy

### Step 1: Start Simple

```python
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

# Always start with a baseline
baseline = LogisticRegression()
baseline.fit(X_train, y_train)
baseline_score = baseline.score(X_test, y_test)
print(f"Baseline: {baseline_score:.3f}")
```

### Step 2: Try Multiple Algorithms

```python
from sklearn.model_selection import cross_val_score

models = {
    'Logistic': LogisticRegression(),
    'RandomForest': RandomForestClassifier(n_estimators=100),
    'XGBoost': XGBClassifier(n_estimators=100)
}

for name, model in models.items():
    scores = cross_val_score(model, X, y, cv=5)
    print(f"{name}: {scores.mean():.3f} (+/- {scores.std():.3f})")
```

### Step 3: Tune the Best

Focus tuning efforts on the top 1-2 performers.

## Common Mistakes

1. **Starting with complex models** - Simple often works
2. **Ignoring data size** - Neural nets need lots of data
3. **Not considering inference time** - Training vs prediction speed
4. **Forgetting interpretability** - Sometimes you need to explain

## Key Takeaway

There's no universally best algorithm. Start simple, try a few approaches, and let cross-validation guide you. For tabular data, gradient boosting usually wins. For images/text, deep learning. For small data, simpler models with regularization. Match the algorithm to your data, constraints, and requirements.

Learn how to choose the right ML algorithm for your problem based on data and requirements.

Model Selection: Choosing the Right Algorithm

# Handling Imbalanced Datasets

When 99% of your data is class A and 1% is class B, your model might just predict A for everything and get 99% accuracy. That's the imbalanced data problem.

## Why It's a Problem

```
Fraud Detection:
  ████████████████████████████████ 99.9% Normal
  █ 0.1% Fraud

Model can get 99.9% accuracy by predicting "Normal" for everything.
But that's useless for catching fraud!
```

## Common Scenarios

- Fraud detection (rare frauds)
- Disease diagnosis (rare diseases)
- Anomaly detection
- Churn prediction (most don't churn)

## Solution 1: Use the Right Metrics

Accuracy is misleading. Use these instead:

```python
from sklearn.metrics import (
    precision_score, recall_score, f1_score,
    classification_report, roc_auc_score
)

# Get full picture
print(classification_report(y_test, y_pred))

# ROC-AUC works well for imbalanced data
auc = roc_auc_score(y_test, y_pred_proba)
```

**Key metrics:**
- **Precision:** Of predicted positives, how many are correct?
- **Recall:** Of actual positives, how many did we find?
- **F1:** Balance of precision and recall
- **ROC-AUC:** Overall ranking ability

## Solution 2: Class Weights

Tell the model to care more about the minority class:

```python
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

# Automatic balancing
model = LogisticRegression(class_weight='balanced')

# Manual weights
model = RandomForestClassifier(class_weight={0: 1, 1: 10})

# For XGBoost
model = XGBClassifier(scale_pos_weight=99)  # ratio of neg/pos
```

## Solution 3: Resampling

### Oversample Minority Class (SMOTE)

```python
from imblearn.over_sampling import SMOTE

smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

print(f"Before: {Counter(y_train)}")
print(f"After: {Counter(y_resampled)}")
```

### Undersample Majority Class

```python
from imblearn.under_sampling import RandomUnderSampler

rus = RandomUnderSampler(random_state=42)
X_resampled, y_resampled = rus.fit_resample(X_train, y_train)
```

### Combine Both

```python
from imblearn.combine import SMOTETomek

smt = SMOTETomek(random_state=42)
X_resampled, y_resampled = smt.fit_resample(X_train, y_train)
```

## Solution 4: Change the Threshold

Default threshold is 0.5. Adjust it:

```python
# Get probabilities
y_proba = model.predict_proba(X_test)[:, 1]

# Lower threshold to catch more positives
threshold = 0.3
y_pred = (y_proba >= threshold).astype(int)

# Find optimal threshold
from sklearn.metrics import precision_recall_curve

precision, recall, thresholds = precision_recall_curve(y_test, y_proba)
# Choose threshold based on your precision/recall needs
```

## Solution 5: Ensemble Methods

```python
from imblearn.ensemble import BalancedRandomForestClassifier

model = BalancedRandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)
```

## Which Solution to Use?

| Situation | Recommended Approach |
|-----------|---------------------|
| Quick fix | Class weights |
| Very imbalanced | SMOTE + class weights |
| Large dataset | Undersampling |
| Small dataset | SMOTE |
| Need high recall | Lower threshold |

## Complete Pipeline

```python
from imblearn.pipeline import Pipeline
from imblearn.over_sampling import SMOTE
from sklearn.ensemble import RandomForestClassifier

# Create balanced pipeline
pipeline = Pipeline([
    ('smote', SMOTE(random_state=42)),
    ('classifier', RandomForestClassifier(
        class_weight='balanced',
        n_estimators=100
    ))
])

pipeline.fit(X_train, y_train)

# Evaluate properly
from sklearn.metrics import classification_report
y_pred = pipeline.predict(X_test)
print(classification_report(y_test, y_pred))
```

## Key Takeaway

Never use accuracy alone for imbalanced data. Start with class weights (easiest), try SMOTE for synthetic oversampling, and always evaluate with precision/recall/F1/AUC. The right approach depends on your specific needs - sometimes missing frauds is worse than false alarms (prioritize recall), sometimes the opposite (prioritize precision).

Learn techniques to handle imbalanced classes when one class heavily outnumbers the other.

Handling Imbalanced Datasets

# Time Series Basics for Machine Learning

Time series data has a twist: the order matters. You can't randomly split it like regular data. Let's learn the fundamentals.

## What Makes Time Series Special

1. **Temporal order matters** - Can't shuffle data
2. **Autocorrelation** - Values correlate with past values
3. **Trends** - Long-term increase/decrease
4. **Seasonality** - Repeating patterns (daily, weekly, yearly)

## Loading and Exploring

```python
import pandas as pd
import matplotlib.pyplot as plt

# Load with datetime index
df = pd.read_csv('data.csv', parse_dates=['date'], index_col='date')

# Quick visualization
df['value'].plot(figsize=(12, 4))
plt.title('Time Series Data')
plt.show()

# Check for trends and seasonality
from statsmodels.tsa.seasonal import seasonal_decompose
decomposition = seasonal_decompose(df['value'], period=12)
decomposition.plot()
```

## Splitting Time Series Data

**NEVER use random splits!** Future data leaks into training.

```python
# Correct: Split by time
train_size = int(len(df) * 0.8)
train = df[:train_size]
test = df[train_size:]

# Visual check
plt.plot(train.index, train['value'], label='Train')
plt.plot(test.index, test['value'], label='Test')
plt.legend()
```

## Creating Lag Features

Past values as features for predicting future:

```python
def create_lag_features(df, column, lags):
    df_features = df.copy()
    for lag in lags:
        df_features[f'{column}_lag_{lag}'] = df[column].shift(lag)
    return df_features.dropna()

# Create lags 1-7
df_features = create_lag_features(df, 'value', range(1, 8))

# Features: value at t-1, t-2, ..., t-7
# Target: value at t
```

## Rolling Statistics

```python
# Moving average
df['rolling_mean_7'] = df['value'].rolling(window=7).mean()
df['rolling_std_7'] = df['value'].rolling(window=7).std()

# Exponential moving average (more weight on recent)
df['ema_7'] = df['value'].ewm(span=7).mean()
```

## Time-Based Features

```python
df['day_of_week'] = df.index.dayofweek
df['month'] = df.index.month
df['is_weekend'] = df.index.dayofweek.isin([5, 6]).astype(int)
df['quarter'] = df.index.quarter
```

## Cross-Validation for Time Series

Regular CV leaks future info. Use TimeSeriesSplit:

```python
from sklearn.model_selection import TimeSeriesSplit

tscv = TimeSeriesSplit(n_splits=5)

for train_idx, test_idx in tscv.split(X):
    X_train, X_test = X[train_idx], X[test_idx]
    y_train, y_test = y[train_idx], y[test_idx]
    # Train and evaluate

# With cross_val_score
from sklearn.model_selection import cross_val_score
scores = cross_val_score(model, X, y, cv=TimeSeriesSplit(n_splits=5))
```

## Simple Forecasting with ML

```python
from sklearn.ensemble import RandomForestRegressor

# Prepare features and target
X = df_features.drop('value', axis=1)
y = df_features['value']

# Time-based split
train_size = int(len(X) * 0.8)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

# Train model
model = RandomForestRegressor(n_estimators=100)
model.fit(X_train, y_train)

# Evaluate
from sklearn.metrics import mean_absolute_error, mean_squared_error
predictions = model.predict(X_test)
print(f"MAE: {mean_absolute_error(y_test, predictions):.2f}")
print(f"RMSE: {mean_squared_error(y_test, predictions)**0.5:.2f}")
```

## Common Mistakes

1. **Random train/test split** - Future leaks into training
2. **Using future data as features** - Check your lags!
3. **Ignoring seasonality** - Add time-based features
4. **Wrong evaluation** - Use time-aware CV

## When to Use ML vs Traditional Methods

**ML approaches work when:**
- Multiple features available
- Complex non-linear patterns
- External variables matter

**Traditional (ARIMA, etc.) better when:**
- Pure time series (no extra features)
- Strong seasonality
- Need confidence intervals

## Key Takeaway

Time series requires respecting temporal order in everything: splits, cross-validation, and feature creation. Create lag features and rolling statistics, add time-based features for seasonality, and always use TimeSeriesSplit for validation. Never let future information leak into your training data!

Learn the fundamentals of working with time series data in machine learning.

Time Series Basics for Machine Learning

# Text Preprocessing for Machine Learning

Machines don't understand text. They understand numbers. Text preprocessing converts words into numbers that models can learn from.

## The Pipeline

```
Raw Text → Clean → Tokenize → Vectorize → Model
```

## Step 1: Basic Cleaning

```python
import re

def clean_text(text):
    # Lowercase
    text = text.lower()
    
    # Remove URLs
    text = re.sub(r'http\S+|www\S+', '', text)
    
    # Remove special characters
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    
    # Remove extra whitespace
    text = ' '.join(text.split())
    
    return text

df['clean_text'] = df['text'].apply(clean_text)
```

## Step 2: Tokenization

Breaking text into words or subwords:

```python
from nltk.tokenize import word_tokenize
import nltk
nltk.download('punkt')

text = "Machine learning is amazing!"
tokens = word_tokenize(text)
# ['Machine', 'learning', 'is', 'amazing', '!']
```

## Step 3: Stopword Removal

Remove common words that don't carry meaning:

```python
from nltk.corpus import stopwords
nltk.download('stopwords')

stop_words = set(stopwords.words('english'))

def remove_stopwords(tokens):
    return [w for w in tokens if w not in stop_words]

# ['Machine', 'learning', 'amazing']
```

## Step 4: Stemming/Lemmatization

Reduce words to base form:

```python
from nltk.stem import PorterStemmer, WordNetLemmatizer

# Stemming (crude, fast)
stemmer = PorterStemmer()
stemmer.stem('running')  # 'run'
stemmer.stem('studies')  # 'studi'

# Lemmatization (proper words, slower)
lemmatizer = WordNetLemmatizer()
lemmatizer.lemmatize('running', pos='v')  # 'run'
lemmatizer.lemmatize('studies')  # 'study'
```

## Vectorization: Turning Text into Numbers

### Bag of Words

```python
from sklearn.feature_extraction.text import CountVectorizer

corpus = [
    'I love machine learning',
    'Machine learning is great',
    'I love programming'
]

vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)

# See vocabulary
print(vectorizer.get_feature_names_out())
# ['great', 'is', 'learning', 'love', 'machine', 'programming']

print(X.toarray())
# [[0, 0, 1, 1, 1, 0],
#  [1, 1, 1, 0, 1, 0],
#  [0, 0, 0, 1, 0, 1]]
```

### TF-IDF (Better!)

Weighs words by importance:

```python
from sklearn.feature_extraction.text import TfidfVectorizer

tfidf = TfidfVectorizer(
    max_features=5000,    # Limit vocabulary
    min_df=2,             # Ignore rare words
    max_df=0.95,          # Ignore very common words
    ngram_range=(1, 2)    # Include bigrams
)

X = tfidf.fit_transform(corpus)
```

**TF-IDF logic:**
- High frequency in document = higher score
- High frequency across ALL documents = lower score
- Rare but present = important!

## Complete Pipeline Example

```python
from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression

# Text classification pipeline
pipeline = Pipeline([
    ('tfidf', TfidfVectorizer(max_features=5000)),
    ('classifier', LogisticRegression())
])

pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)
```

## Modern Approach: Word Embeddings

Pre-trained embeddings capture semantic meaning:

```python
# Using sentence-transformers (recommended)
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = model.encode(texts)

# Now use embeddings as features
from sklearn.linear_model import LogisticRegression
clf = LogisticRegression()
clf.fit(embeddings_train, y_train)
```

## Choosing an Approach

| Method | Pros | Cons |
|--------|------|------|
| Bag of Words | Simple, interpretable | Ignores word order |
| TF-IDF | Better weighting | Still ignores semantics |
| Word Embeddings | Captures meaning | Less interpretable |
| Transformers | State-of-art | Computationally expensive |

## Key Takeaway

Start with TF-IDF for most text classification tasks - it's simple and works well. Use max_features to limit vocabulary, remove stopwords, and consider n-grams. For semantic understanding or if TF-IDF isn't enough, move to pre-trained embeddings. The preprocessing steps (cleaning, lowercasing) matter for traditional methods but less for modern transformers.

Learn how to prepare text data for machine learning models.

Text Preprocessing for Machine Learning

# Model Interpretability: Understanding Predictions

A model that says "loan denied" isn't enough. You need to know WHY. Interpretability techniques explain model decisions.

## Why Interpretability Matters

1. **Trust** - Can you trust the model?
2. **Debugging** - Why is it making mistakes?
3. **Compliance** - Regulations require explanations
4. **Fairness** - Is it using problematic features?

## Level 1: Feature Importance

Built into tree-based models:

```python
from sklearn.ensemble import RandomForestClassifier
import pandas as pd

# Train model
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Get importance
importance = pd.DataFrame({
    'feature': feature_names,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

print(importance.head(10))

# Plot
importance.head(15).plot(x='feature', y='importance', kind='barh')
```

**Limitation:** Global importance, doesn't explain individual predictions.

## Level 2: Permutation Importance

Works for any model:

```python
from sklearn.inspection import permutation_importance

# Calculate
result = permutation_importance(model, X_test, y_test, n_repeats=10)

# Display
importance = pd.DataFrame({
    'feature': feature_names,
    'importance': result.importances_mean
}).sort_values('importance', ascending=False)
```

**Logic:** Shuffle each feature and see how much performance drops.

## Level 3: SHAP (Best for Deep Explanation)

SHAP gives consistent, theoretically grounded explanations.

```python
import shap

# Create explainer
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# Global importance plot
shap.summary_plot(shap_values, X_test, feature_names=feature_names)

# Force plot for single prediction
shap.force_plot(
    explainer.expected_value[1],
    shap_values[1][0],
    X_test.iloc[0],
    feature_names=feature_names
)
```

### Understanding SHAP Values

```
Base value: 0.3 (average prediction)

Feature contributions:
  Income: +0.15 (pushes toward positive)
  Age: -0.05 (pushes toward negative)
  Debt: +0.10 (pushes toward positive)

Final prediction: 0.3 + 0.15 - 0.05 + 0.10 = 0.5
```

### SHAP Plots

```python
# Summary plot: importance + direction
shap.summary_plot(shap_values, X_test)

# Dependence plot: how one feature affects predictions
shap.dependence_plot('income', shap_values, X_test)

# Waterfall for single prediction
shap.waterfall_plot(shap.Explanation(
    values=shap_values[0],
    base_values=explainer.expected_value,
    data=X_test.iloc[0]
))
```

## Level 4: LIME (Local Explanations)

Explains individual predictions by approximating locally with simple model:

```python
from lime.lime_tabular import LimeTabularExplainer

# Create explainer
explainer = LimeTabularExplainer(
    X_train.values,
    feature_names=feature_names,
    class_names=['No', 'Yes'],
    mode='classification'
)

# Explain single prediction
exp = explainer.explain_instance(
    X_test.iloc[0].values,
    model.predict_proba,
    num_features=10
)

# Show explanation
exp.show_in_notebook()
# Or get as list
exp.as_list()
```

## SHAP vs LIME

| Aspect | SHAP | LIME |
|--------|------|------|
| Consistency | Theoretically grounded | Approximation |
| Speed | Can be slow | Faster per instance |
| Global view | Yes | No (local only) |
| Interpretability | Additive | Rule-based |

## Practical Workflow

```python
# 1. Train your model
model.fit(X_train, y_train)

# 2. Global understanding with feature importance
print(pd.DataFrame({
    'feature': feature_names,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False).head(10))

# 3. Deep dive with SHAP
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
shap.summary_plot(shap_values, X_test)

# 4. Explain specific predictions
idx = 0  # prediction to explain
shap.waterfall_plot(shap.Explanation(
    values=shap_values[idx],
    base_values=explainer.expected_value,
    data=X_test.iloc[idx],
    feature_names=feature_names
))
```

## Key Takeaway

Start with built-in feature importance for quick insights. Use SHAP for thorough understanding - it gives both global feature importance and individual prediction explanations. Remember: a model you can't explain is a model you shouldn't trust in production. Always be able to answer "why did the model make this prediction?"

Learn how to explain your ML model predictions using SHAP, LIME, and feature importance.

Model Interpretability: Understanding Predictions

# A/B Testing for Machine Learning Models

Your new model has better offline metrics. But does it actually perform better with real users? A/B testing tells you for sure.

## Why A/B Test ML Models?

Offline metrics can be misleading:
- Test data might not represent production
- User behavior might change
- Side effects you didn't measure

A/B testing measures what really matters: business outcomes.

## Basic A/B Test Setup

```
Users
  │
  ├── 50% → Model A (Control/Current)
  │           │
  │           └── Measure: clicks, conversions, revenue
  │
  └── 50% → Model B (Treatment/New)
              │
              └── Measure: clicks, conversions, revenue

Compare results → Statistical significance → Deploy winner
```

## Key Metrics to Track

**Primary metrics** (what you're trying to improve):
- Click-through rate
- Conversion rate
- Revenue
- Engagement time

**Guardrail metrics** (don't want to hurt):
- Page load time
- Error rate
- User complaints

## Sample Size Calculation

Don't stop early! Calculate required sample size:

```python
from scipy import stats
import numpy as np

def calculate_sample_size(baseline_rate, minimum_effect, alpha=0.05, power=0.8):
    """
    baseline_rate: current conversion rate (e.g., 0.05 for 5%)
    minimum_effect: smallest improvement worth detecting (relative, e.g., 0.1 for 10%)
    """
    effect_size = baseline_rate * minimum_effect
    
    # Using normal approximation
    z_alpha = stats.norm.ppf(1 - alpha/2)
    z_beta = stats.norm.ppf(power)
    
    p1 = baseline_rate
    p2 = baseline_rate + effect_size
    p_avg = (p1 + p2) / 2
    
    n = (2 * p_avg * (1 - p_avg) * (z_alpha + z_beta)**2) / effect_size**2
    
    return int(np.ceil(n))

# Example: 5% baseline, want to detect 10% relative improvement
sample_size = calculate_sample_size(0.05, 0.1)
print(f"Need {sample_size} users per group")
```

## Running the Test

```python
import hashlib

def assign_variant(user_id, experiment_name, variants=['A', 'B']):
    """Consistently assign user to variant"""
    hash_input = f"{user_id}_{experiment_name}"
    hash_value = int(hashlib.md5(hash_input.encode()).hexdigest(), 16)
    variant_index = hash_value % len(variants)
    return variants[variant_index]

# Usage
variant = assign_variant(user_id='user123', experiment_name='model_v2_test')
if variant == 'A':
    prediction = model_a.predict(features)
else:
    prediction = model_b.predict(features)
```

## Analyzing Results

```python
from scipy import stats

def analyze_ab_test(control_conversions, control_total,
                    treatment_conversions, treatment_total):
    # Conversion rates
    control_rate = control_conversions / control_total
    treatment_rate = treatment_conversions / treatment_total
    
    # Lift
    lift = (treatment_rate - control_rate) / control_rate
    
    # Statistical test
    contingency_table = [
        [control_conversions, control_total - control_conversions],
        [treatment_conversions, treatment_total - treatment_conversions]
    ]
    chi2, p_value, dof, expected = stats.chi2_contingency(contingency_table)
    
    print(f"Control rate: {control_rate:.4f}")
    print(f"Treatment rate: {treatment_rate:.4f}")
    print(f"Lift: {lift:.2%}")
    print(f"P-value: {p_value:.4f}")
    print(f"Significant: {p_value < 0.05}")
    
    return {
        'control_rate': control_rate,
        'treatment_rate': treatment_rate,
        'lift': lift,
        'p_value': p_value,
        'significant': p_value < 0.05
    }

# Example
results = analyze_ab_test(
    control_conversions=500, control_total=10000,
    treatment_conversions=550, treatment_total=10000
)
```

## Common Mistakes

### 1. Peeking and Stopping Early
```
Day 1: Treatment winning! Ship it? NO.
Day 3: Control winning! Stop? NO.
Day 7: Reached sample size. Now analyze.
```

### 2. Wrong Randomization Unit
- Testing recommendation model? Randomize by user, not by pageview
- Same user should always see same variant

### 3. Not Accounting for Novelty Effect
- Users might engage more with anything new
- Run test long enough for novelty to wear off

### 4. Multiple Testing Problem
- Testing 10 metrics? Some will be "significant" by chance
- Use Bonferroni correction or designate primary metric

## Decision Framework

```
Is treatment significantly better?
├── Yes, and guardrails OK → Deploy treatment
├── Yes, but guardrails hurt → Investigate, maybe don't deploy
├── No difference → Keep control (simpler)
└── Significantly worse → Definitely keep control
```

## Key Takeaway

A/B testing is the gold standard for ML model evaluation. Calculate required sample size upfront, don't peek at results, and always track guardrail metrics. Offline improvements don't always translate to online gains - let real users be the judge. Only deploy when you have statistically significant improvement in metrics that matter.

Learn how to properly A/B test ML models before deploying to production.

A/B Testing for Machine Learning Models

# ML in Production: From Notebook to Deployment

A model in a notebook is useless. Let's get it serving real predictions.

## The Production Pipeline

```
Training Pipeline:
Data → Preprocess → Train → Evaluate → Save Model

Inference Pipeline:
Request → Load Model → Preprocess → Predict → Response
```

## Step 1: Save Your Model

```python
import joblib
import pickle

# Method 1: joblib (recommended for sklearn)
joblib.dump(model, 'model.joblib')
model = joblib.load('model.joblib')

# Method 2: pickle
with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

# Save preprocessing too!
joblib.dump(scaler, 'scaler.joblib')
joblib.dump(encoder, 'encoder.joblib')
```

## Step 2: Create Inference Pipeline

Keep preprocessing consistent:

```python
class ModelPipeline:
    def __init__(self, model_path, scaler_path):
        self.model = joblib.load(model_path)
        self.scaler = joblib.load(scaler_path)
    
    def preprocess(self, data):
        # Same preprocessing as training
        return self.scaler.transform(data)
    
    def predict(self, data):
        processed = self.preprocess(data)
        return self.model.predict(processed)
    
    def predict_proba(self, data):
        processed = self.preprocess(data)
        return self.model.predict_proba(processed)
```

## Step 3: Create API Endpoint

Using FastAPI (recommended):

```python
from fastapi import FastAPI
from pydantic import BaseModel
import numpy as np

app = FastAPI()

# Load model at startup
pipeline = ModelPipeline('model.joblib', 'scaler.joblib')

class PredictionRequest(BaseModel):
    features: list[float]

class PredictionResponse(BaseModel):
    prediction: int
    probability: float

@app.post("/predict", response_model=PredictionResponse)
def predict(request: PredictionRequest):
    features = np.array(request.features).reshape(1, -1)
    prediction = pipeline.predict(features)[0]
    probability = pipeline.predict_proba(features)[0].max()
    
    return PredictionResponse(
        prediction=int(prediction),
        probability=float(probability)
    )

# Health check
@app.get("/health")
def health():
    return {"status": "healthy"}
```

## Step 4: Containerize with Docker

```dockerfile
FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY model.joblib .
COPY scaler.joblib .
COPY app.py .

EXPOSE 8000

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
```

```bash
# Build and run
docker build -t ml-model .
docker run -p 8000:8000 ml-model
```

## Step 5: Monitor Your Model

```python
import logging
from datetime import datetime

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@app.post("/predict")
def predict(request: PredictionRequest):
    start_time = datetime.now()
    
    features = np.array(request.features).reshape(1, -1)
    prediction = pipeline.predict(features)[0]
    probability = pipeline.predict_proba(features)[0].max()
    
    # Log for monitoring
    latency = (datetime.now() - start_time).total_seconds()
    logger.info(f"Prediction: {prediction}, Prob: {probability:.3f}, Latency: {latency:.3f}s")
    
    return PredictionResponse(
        prediction=int(prediction),
        probability=float(probability)
    )
```

## Common Production Issues

### 1. Training-Serving Skew

**Problem:** Preprocessing differs between training and serving.

**Solution:** Use the exact same preprocessing code:

```python
# Save the entire pipeline
from sklearn.pipeline import Pipeline

full_pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier())
])
full_pipeline.fit(X_train, y_train)
joblib.dump(full_pipeline, 'full_pipeline.joblib')
```

### 2. Model Drift

**Problem:** Model performance degrades over time.

**Solution:** Monitor predictions and retrain:

```python
# Track prediction distribution
def log_prediction_stats(predictions):
    logger.info(f"Mean: {np.mean(predictions):.3f}")
    logger.info(f"Std: {np.std(predictions):.3f}")
    logger.info(f"Class distribution: {np.bincount(predictions)}")
```

### 3. Latency Issues

**Solution:** Optimize or use lighter models:

```python
# Measure latency
import time

def benchmark_model(model, X_test, n_runs=100):
    times = []
    for _ in range(n_runs):
        start = time.time()
        model.predict(X_test[:1])
        times.append(time.time() - start)
    
    print(f"Mean latency: {np.mean(times)*1000:.2f}ms")
    print(f"P99 latency: {np.percentile(times, 99)*1000:.2f}ms")
```

## Production Checklist

- [ ] Model and preprocessing saved together
- [ ] API endpoint tested
- [ ] Input validation
- [ ] Error handling
- [ ] Health check endpoint
- [ ] Logging for monitoring
- [ ] Docker containerization
- [ ] Load testing done
- [ ] Rollback plan ready

## Key Takeaway

Production ML is about consistency and reliability. Save models with their preprocessing, create clean APIs, containerize for portability, and monitor everything. The best model is worthless if it can't serve predictions reliably. Start simple, add complexity only when needed!

Learn the essentials of deploying ML models to production, from saving models to serving predictions.

ML in Production: From Notebook to Deployment

# DBSCAN: Density-Based Clustering

K-Means assumes spherical clusters. DBSCAN finds clusters of any shape based on density, and bonus: it automatically identifies outliers.

## K-Means vs DBSCAN

```
K-Means struggles:          DBSCAN handles:
    ●●●●                       ●●●●
   ●    ●                     ●    ●
  ●      ●   ○○               ●      ●   ○○
   ●    ●   ○  ○              ●    ●   ○  ○
    ●●●●   ○○                  ●●●●   ○○
    
  (K-Means splits ring)    (DBSCAN finds both)
```

## How DBSCAN Works

Two parameters:
- **eps (ε):** Maximum distance between neighbors
- **min_samples:** Minimum points to form a dense region

Algorithm:
1. For each point, count neighbors within eps distance
2. If neighbors >= min_samples, it's a **core point**
3. Core points close together form clusters
4. Points near core points but not core themselves are **border points**
5. Points with few neighbors are **noise/outliers**

## Implementation

```python
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler

# Scale data first
X_scaled = StandardScaler().fit_transform(X)

# Apply DBSCAN
dbscan = DBSCAN(eps=0.5, min_samples=5)
clusters = dbscan.fit_predict(X_scaled)

# -1 means outlier
print(f"Clusters found: {len(set(clusters)) - (1 if -1 in clusters else 0)}")
print(f"Outliers: {sum(clusters == -1)}")
```

## Finding Good Parameters

### Method 1: K-Distance Plot

```python
from sklearn.neighbors import NearestNeighbors
import numpy as np

# Find distance to k-th nearest neighbor
k = 5  # Same as min_samples
neighbors = NearestNeighbors(n_neighbors=k)
neighbors.fit(X_scaled)
distances, _ = neighbors.kneighbors(X_scaled)

# Sort distances to k-th neighbor
k_distances = np.sort(distances[:, k-1])

# Plot - look for "elbow"
plt.plot(k_distances)
plt.xlabel('Points')
plt.ylabel(f'Distance to {k}th neighbor')
plt.title('K-Distance Plot (elbow = good eps)')
plt.show()
```

### Method 2: Silhouette Score

```python
from sklearn.metrics import silhouette_score

best_score = -1
best_params = None

for eps in [0.3, 0.5, 0.7, 1.0]:
    for min_samples in [3, 5, 10]:
        dbscan = DBSCAN(eps=eps, min_samples=min_samples)
        labels = dbscan.fit_predict(X_scaled)
        
        # Need at least 2 clusters
        if len(set(labels)) > 2:
            score = silhouette_score(X_scaled, labels)
            if score > best_score:
                best_score = score
                best_params = (eps, min_samples)

print(f"Best params: eps={best_params[0]}, min_samples={best_params[1]}")
```

## DBSCAN vs K-Means

| Aspect | K-Means | DBSCAN |
|--------|---------|--------|
| Clusters needed upfront | Yes | No |
| Cluster shapes | Spherical | Any shape |
| Outlier detection | No | Built-in |
| Cluster sizes | Similar | Can vary |
| Parameters | k | eps, min_samples |
| Speed | Faster | Slower |

## When to Use DBSCAN

**Good for:**
- Unknown number of clusters
- Non-spherical clusters
- Need outlier detection
- Clusters of varying density

**Not ideal for:**
- Very high-dimensional data
- Clusters with very different densities
- When you need soft assignments

## Handling Outliers

```python
# Get cluster assignments
clusters = dbscan.fit_predict(X_scaled)

# Separate normal points and outliers
normal_mask = clusters != -1
outlier_mask = clusters == -1

X_normal = X[normal_mask]
X_outliers = X[outlier_mask]

print(f"Normal points: {sum(normal_mask)}")
print(f"Outliers: {sum(outlier_mask)}")
```

## Key Takeaway

DBSCAN shines when clusters aren't spherical or when you don't know how many clusters exist. It automatically handles outliers, which K-Means can't do. Use the K-distance plot to find good eps values, and remember that min_samples should scale with your data size. Perfect for anomaly detection!

Learn DBSCAN clustering which finds clusters of any shape and automatically detects outliers.

DBSCAN: Density-Based Clustering

# Deep Dive into Classification Metrics

Accuracy can lie. A spam filter that blocks everything gets 0% spam through - but also blocks all your real emails. Let's understand metrics properly.

## The Confusion Matrix

Everything starts here:

```
                    Predicted
                  Neg    Pos
Actual   Neg      TN     FP    ← False Positive: "False alarm"
         Pos      FN     TP    ← False Negative: "Missed it"
                   ↑
            Type II error
```

```python
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm = confusion_matrix(y_test, y_pred)
ConfusionMatrixDisplay(cm, display_labels=['Negative', 'Positive']).plot()
```

## Precision vs Recall

**Precision:** Of predicted positives, how many are correct?
```
Precision = TP / (TP + FP)
```
"When I say yes, am I right?"

**Recall (Sensitivity):** Of actual positives, how many did we find?
```
Recall = TP / (TP + FN)
```
"Of all the positives, how many did I catch?"

## The Tradeoff

```
High threshold: "Only predict positive when very confident"
  → High precision (fewer false alarms)
  → Low recall (miss more positives)

Low threshold: "Predict positive more liberally"
  → Low precision (more false alarms)
  → High recall (catch more positives)
```

## When to Prioritize What

| Scenario | Prioritize | Why |
|----------|-----------|-----|
| Spam filter | Precision | Don't lose important emails |
| Cancer screening | Recall | Don't miss any cancer cases |
| Fraud detection | Usually recall | Don't let fraud through |
| Recommendation | Precision | Don't annoy users |

## F1 Score: The Balance

Harmonic mean of precision and recall:

```
F1 = 2 × (Precision × Recall) / (Precision + Recall)
```

Use when you need both precision and recall to be good.

```python
from sklearn.metrics import precision_score, recall_score, f1_score

precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

print(f"Precision: {precision:.3f}")
print(f"Recall: {recall:.3f}")
print(f"F1: {f1:.3f}")
```

## ROC Curve and AUC

ROC shows tradeoff across all thresholds:

```python
from sklearn.metrics import roc_curve, roc_auc_score

# Get probabilities
y_proba = model.predict_proba(X_test)[:, 1]

# ROC curve
fpr, tpr, thresholds = roc_curve(y_test, y_proba)

# Plot
plt.plot(fpr, tpr, label=f'AUC = {roc_auc_score(y_test, y_proba):.3f}')
plt.plot([0, 1], [0, 1], 'k--', label='Random')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate (Recall)')
plt.title('ROC Curve')
plt.legend()
```

**AUC Interpretation:**
- 1.0: Perfect
- 0.5: Random guessing
- <0.5: Worse than random (flip predictions!)

## Precision-Recall Curve

Better than ROC for imbalanced data:

```python
from sklearn.metrics import precision_recall_curve, average_precision_score

precision, recall, thresholds = precision_recall_curve(y_test, y_proba)

plt.plot(recall, precision)
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.title(f'AP = {average_precision_score(y_test, y_proba):.3f}')
```

## Multi-class Metrics

```python
from sklearn.metrics import classification_report

# Get detailed report per class
print(classification_report(y_test, y_pred))

# Averaging strategies
f1_score(y_test, y_pred, average='macro')   # Equal weight per class
f1_score(y_test, y_pred, average='weighted') # Weight by class size
f1_score(y_test, y_pred, average='micro')   # Global calculation
```

## Choosing Your Metric

```
Balanced classes?
├── Yes → Accuracy, F1, AUC all reasonable
└── No (Imbalanced)
    ├── Care more about finding positives → Recall, PR-AUC
    ├── Care more about being right when positive → Precision
    └── Need ranking ability → ROC-AUC
```

## Key Takeaway

No single metric tells the whole story. Understand the confusion matrix, know the precision-recall tradeoff, and choose metrics based on business impact. For imbalanced data, avoid accuracy and use F1, AUC, or precision/recall. Always ask: "What's worse - false positives or false negatives?" That guides your metric choice.

Master classification metrics beyond accuracy - precision, recall, F1, ROC-AUC, and when to use each.

Deep Dive into Classification Metrics

# Learning Curves: Diagnosing Model Performance

Should you get more data? Use a more complex model? Learning curves answer these questions visually.

## What Learning Curves Show

Plot model performance as training set size increases:

```
Performance
    │
    │    ╭─────── Training score
    │   ╱
    │  ╱    ╭───── Validation score
    │ ╱    ╱
    │╱    ╱
    └─────────────────
       Training set size
```

## Creating Learning Curves

```python
from sklearn.model_selection import learning_curve
import numpy as np
import matplotlib.pyplot as plt

def plot_learning_curve(model, X, y, cv=5):
    train_sizes, train_scores, val_scores = learning_curve(
        model, X, y,
        train_sizes=np.linspace(0.1, 1.0, 10),
        cv=cv,
        scoring='accuracy'
    )
    
    # Calculate mean and std
    train_mean = train_scores.mean(axis=1)
    train_std = train_scores.std(axis=1)
    val_mean = val_scores.mean(axis=1)
    val_std = val_scores.std(axis=1)
    
    # Plot
    plt.figure(figsize=(10, 6))
    plt.plot(train_sizes, train_mean, label='Training score')
    plt.fill_between(train_sizes, train_mean - train_std, 
                     train_mean + train_std, alpha=0.1)
    plt.plot(train_sizes, val_mean, label='Validation score')
    plt.fill_between(train_sizes, val_mean - val_std,
                     val_mean + val_std, alpha=0.1)
    
    plt.xlabel('Training set size')
    plt.ylabel('Score')
    plt.title('Learning Curve')
    plt.legend()
    plt.grid(True)
    plt.show()

# Usage
plot_learning_curve(RandomForestClassifier(), X, y)
```

## Pattern 1: High Bias (Underfitting)

```
Score
    │     ___________  Training
    │    ╱
    │___╱____________  Validation
    │
    └─────────────────
       Training size

Both scores low and converged.
More data won't help!
```

**Diagnosis:** Model too simple
**Solutions:**
- More complex model
- Add features
- Reduce regularization

## Pattern 2: High Variance (Overfitting)

```
Score
    │────────────────  Training (high)
    │
    │
    │    ╱───────────  Validation (gap!)
    │___╱
    └─────────────────
       Training size

Big gap between training and validation.
```

**Diagnosis:** Model memorizing training data
**Solutions:**
- More training data
- Simpler model
- More regularization
- Feature selection

## Pattern 3: Good Fit

```
Score
    │    ╭───────────  Training
    │   ╱  ╭─────────  Validation
    │  ╱  ╱
    │ ╱  ╱  Small gap, both high
    │╱  ╱
    └─────────────────
       Training size
```

Both scores high and close together.

## Will More Data Help?

```
Gap still present at max training size?
├── Yes → More data likely helps
│         (curves haven't converged)
└── No → More data won't help
         (need better model/features)
```

## Comparing Models

```python
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC

models = {
    'Logistic Regression': LogisticRegression(),
    'Random Forest': RandomForestClassifier(n_estimators=100),
    'SVM': SVC()
}

fig, axes = plt.subplots(1, 3, figsize=(15, 4))

for ax, (name, model) in zip(axes, models.items()):
    train_sizes, train_scores, val_scores = learning_curve(
        model, X, y, train_sizes=np.linspace(0.1, 1.0, 10), cv=5
    )
    
    ax.plot(train_sizes, train_scores.mean(axis=1), label='Train')
    ax.plot(train_sizes, val_scores.mean(axis=1), label='Val')
    ax.set_title(name)
    ax.legend()

plt.tight_layout()
plt.show()
```

## Validation Curves (Hyperparameter Effect)

Different from learning curves - shows effect of a hyperparameter:

```python
from sklearn.model_selection import validation_curve

param_range = [1, 10, 50, 100, 200, 500]
train_scores, val_scores = validation_curve(
    RandomForestClassifier(),
    X, y,
    param_name='n_estimators',
    param_range=param_range,
    cv=5
)

plt.plot(param_range, train_scores.mean(axis=1), label='Train')
plt.plot(param_range, val_scores.mean(axis=1), label='Validation')
plt.xlabel('n_estimators')
plt.ylabel('Score')
plt.legend()
```

## Key Takeaway

Learning curves are diagnostic tools that save time and money. Before collecting more data, check if curves have converged - if yes, more data won't help. Before trying complex models, check if you're underfitting (need more complexity) or overfitting (need less). Let the data guide your decisions!

Use learning curves to diagnose overfitting, underfitting, and determine if more data will help.

Learning Curves: Diagnosing Model Performance

# Ensemble Stacking: Combining Multiple Models

Random Forest averages trees. Gradient Boosting chains them. Stacking goes further: train different model types, then train another model to combine their predictions.

## Stacking Architecture

```
Level 0 (Base Models):
┌─────────────┬─────────────┬─────────────┐
│  Logistic   │   Random    │     SVM     │
│ Regression  │   Forest    │             │
└──────┬──────┴──────┬──────┴──────┬──────┘
       │             │             │
       v             v             v
     pred_1       pred_2       pred_3
       │             │             │
       └─────────────┼─────────────┘
                     │
                     v
Level 1 (Meta-Learner):
              ┌─────────────┐
              │   XGBoost   │
              └──────┬──────┘
                     │
                     v
              Final Prediction
```

## Why Stacking Works

Different models capture different patterns:
- Linear models: linear relationships
- Trees: non-linear interactions
- SVMs: complex boundaries

The meta-learner learns when to trust each model.

## Implementation with Scikit-Learn

```python
from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier

# Base models
base_models = [
    ('lr', LogisticRegression(max_iter=1000)),
    ('rf', RandomForestClassifier(n_estimators=100)),
    ('svm', SVC(probability=True)),
    ('knn', KNeighborsClassifier())
]

# Meta-learner
meta_model = GradientBoostingClassifier(n_estimators=50)

# Stack them
stacking_clf = StackingClassifier(
    estimators=base_models,
    final_estimator=meta_model,
    cv=5,  # Cross-validation for base model predictions
    stack_method='predict_proba'  # Use probabilities as features
)

stacking_clf.fit(X_train, y_train)
print(f"Accuracy: {stacking_clf.score(X_test, y_test):.3f}")
```

## Manual Implementation (More Control)

```python
from sklearn.model_selection import cross_val_predict
import numpy as np

class SimpleStacker:
    def __init__(self, base_models, meta_model):
        self.base_models = base_models
        self.meta_model = meta_model
        
    def fit(self, X, y):
        # Get cross-validated predictions from base models
        base_predictions = []
        for name, model in self.base_models:
            preds = cross_val_predict(model, X, y, cv=5, method='predict_proba')
            base_predictions.append(preds[:, 1])  # Probability of positive class
        
        # Create meta-features
        meta_features = np.column_stack(base_predictions)
        
        # Train base models on full data
        for name, model in self.base_models:
            model.fit(X, y)
        
        # Train meta-model
        self.meta_model.fit(meta_features, y)
        
        return self
    
    def predict(self, X):
        # Get predictions from base models
        base_predictions = []
        for name, model in self.base_models:
            preds = model.predict_proba(X)[:, 1]
            base_predictions.append(preds)
        
        meta_features = np.column_stack(base_predictions)
        return self.meta_model.predict(meta_features)
```

## Stacking for Regression

```python
from sklearn.ensemble import StackingRegressor
from sklearn.linear_model import Ridge, Lasso
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor

base_models = [
    ('ridge', Ridge()),
    ('lasso', Lasso()),
    ('rf', RandomForestRegressor(n_estimators=100))
]

stacking_reg = StackingRegressor(
    estimators=base_models,
    final_estimator=GradientBoostingRegressor(n_estimators=50),
    cv=5
)

stacking_reg.fit(X_train, y_train)
```

## Tips for Better Stacking

### 1. Use Diverse Base Models

```python
# Good: Different types
base_models = [
    ('linear', LogisticRegression()),      # Linear
    ('tree', RandomForestClassifier()),     # Tree-based
    ('svm', SVC(probability=True)),         # Kernel-based
    ('nn', MLPClassifier())                 # Neural network
]

# Less good: All trees
base_models = [
    ('rf1', RandomForestClassifier(n_estimators=100)),
    ('rf2', RandomForestClassifier(n_estimators=200)),
    ('gb', GradientBoostingClassifier())
]
```

### 2. Include Original Features (Optional)

```python
stacking_clf = StackingClassifier(
    estimators=base_models,
    final_estimator=meta_model,
    passthrough=True  # Include original features for meta-learner
)
```

### 3. Use Simple Meta-Learner

Complex meta-learners can overfit to the base predictions:

```python
# Often works well
meta_model = LogisticRegression()

# Or simple tree model
meta_model = GradientBoostingClassifier(n_estimators=50, max_depth=3)
```

## When to Use Stacking

**Good for:**
- Kaggle competitions (squeezing every bit of accuracy)
- When different models excel at different subsets
- Final boost after individual models are tuned

**Not ideal for:**
- When interpretability is needed
- Real-time predictions (slow)
- When you need a quick solution

## Key Takeaway

Stacking combines diverse models through a meta-learner that learns optimal weighting. Use diverse base models (different types, not just different hyperparameters), cross-validate to prevent data leakage, and keep the meta-learner simple. Stacking often gives 1-3% improvement over the best single model - small but can be decisive in competitions!

Learn how stacking combines predictions from multiple models using a meta-learner.

Ensemble Stacking: Combining Multiple Models

# Introduction to AutoML

Tired of trying hundreds of model configurations? AutoML does it for you. It automatically searches for the best model and hyperparameters.

## What AutoML Does

```
Manual ML:
You choose model → You tune hyperparameters → You engineer features

AutoML:
You provide data → AutoML searches → Best model returned
```

## Popular AutoML Libraries

| Library | Strengths | Best For |
|---------|-----------|----------|
| Auto-sklearn | Solid, well-tested | Classification, regression |
| TPOT | Genetic algorithm | Finding novel pipelines |
| H2O AutoML | Fast, scalable | Large datasets |
| AutoGluon | Easy, powerful | Quick wins |

## Auto-sklearn Example

```python
import autosklearn.classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Create AutoML classifier
automl = autosklearn.classification.AutoSklearnClassifier(
    time_left_for_this_task=300,  # 5 minutes total
    per_run_time_limit=30,         # 30 seconds per model
    n_jobs=-1
)

# Fit - it will try many models automatically
automl.fit(X_train, y_train)

# Evaluate
predictions = automl.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, predictions):.3f}")

# See what it found
print(automl.leaderboard())
```

## TPOT Example

TPOT uses genetic programming to evolve ML pipelines:

```python
from tpot import TPOTClassifier

tpot = TPOTClassifier(
    generations=5,
    population_size=50,
    cv=5,
    random_state=42,
    verbosity=2,
    n_jobs=-1
)

tpot.fit(X_train, y_train)
print(f"Score: {tpot.score(X_test, y_test):.3f}")

# Export the best pipeline as Python code
tpot.export('best_pipeline.py')
```

## AutoGluon Example (Easiest)

```python
from autogluon.tabular import TabularPredictor

# Just give it a DataFrame with target column
predictor = TabularPredictor(label='target').fit(
    train_data,
    time_limit=300  # 5 minutes
)

# Predict
predictions = predictor.predict(test_data)

# See leaderboard
predictor.leaderboard()
```

## What AutoML Actually Searches

1. **Algorithm selection:** Tries multiple model types
2. **Hyperparameter tuning:** Optimizes parameters
3. **Feature preprocessing:** Scaling, encoding, selection
4. **Ensembling:** Combines best models

## Time Budget Tips

```python
# Quick exploration (5 minutes)
time_left_for_this_task=300

# Serious attempt (1 hour)
time_left_for_this_task=3600

# Overnight run (8 hours)
time_left_for_this_task=28800
```

More time = better results (usually), but diminishing returns.

## When to Use AutoML

**Good for:**
- Quick baselines
- When you don't know which algorithm to use
- Hyperparameter search
- Kaggle competitions

**Not ideal for:**
- When you need to understand the model
- Highly specialized problems
- When inference speed matters (AutoML often picks ensembles)
- Very large datasets (can be slow)

## AutoML Limitations

1. **Black box:** May not explain why it chose certain models
2. **Compute intensive:** Tries many configurations
3. **May overfit:** Especially with small datasets
4. **No domain knowledge:** Doesn't understand your problem

## Best Practice: Use AutoML as a Starting Point

```python
# 1. Run AutoML to find good candidates
automl.fit(X_train, y_train)
print(automl.leaderboard())

# 2. See what models/parameters it found
print(automl.show_models())

# 3. Take best ideas and build simpler, interpretable model
# If AutoML found XGBoost with certain params works well,
# train your own XGBoost with those params
```

## Key Takeaway

AutoML is a powerful tool for quickly finding good models. Use it for baselines, exploration, and when you're stuck. But don't treat it as a complete solution - understand what it found, and consider building simpler models based on its insights. It's a tool to augment your skills, not replace understanding!

Learn how AutoML automates model selection, hyperparameter tuning, and feature engineering.

Introduction to AutoML

# Feature Selection Techniques

More features isn't always better. Feature selection removes noise, reduces overfitting, speeds up training, and improves interpretability.

## Why Select Features?

**Problems with too many features:**
- Curse of dimensionality
- Overfitting
- Slower training
- Harder to interpret

## Method 1: Filter Methods (Before Training)

Select features based on statistical tests, independent of any model.

### Variance Threshold

Remove features with low variance (near-constant):

```python
from sklearn.feature_selection import VarianceThreshold

# Remove features with variance below threshold
selector = VarianceThreshold(threshold=0.01)
X_selected = selector.fit_transform(X)

# See which features kept
kept_features = X.columns[selector.get_support()]
print(f"Kept {len(kept_features)} of {X.shape[1]} features")
```

### Correlation with Target

```python
import pandas as pd
import numpy as np

# For classification
from sklearn.feature_selection import f_classif, chi2

# Calculate F-scores
f_scores, p_values = f_classif(X, y)

# Rank features
feature_scores = pd.DataFrame({
    'feature': X.columns,
    'f_score': f_scores,
    'p_value': p_values
}).sort_values('f_score', ascending=False)

# Select top K
from sklearn.feature_selection import SelectKBest
selector = SelectKBest(f_classif, k=10)
X_selected = selector.fit_transform(X, y)
```

### Remove Correlated Features

```python
def remove_correlated(df, threshold=0.95):
    corr_matrix = df.corr().abs()
    upper = corr_matrix.where(
        np.triu(np.ones(corr_matrix.shape), k=1).astype(bool)
    )
    
    # Find columns with correlation above threshold
    to_drop = [col for col in upper.columns if any(upper[col] > threshold)]
    return df.drop(columns=to_drop)

X_reduced = remove_correlated(X)
```

## Method 2: Wrapper Methods (Use Model Performance)

### Recursive Feature Elimination (RFE)

```python
from sklearn.feature_selection import RFE
from sklearn.ensemble import RandomForestClassifier

# Create model and RFE
model = RandomForestClassifier(n_estimators=100)
rfe = RFE(estimator=model, n_features_to_select=10, step=1)
rfe.fit(X, y)

# Get selected features
selected = X.columns[rfe.support_]
print(f"Selected features: {list(selected)}")

# Feature ranking (1 = selected)
ranking = pd.DataFrame({
    'feature': X.columns,
    'ranking': rfe.ranking_
}).sort_values('ranking')
```

### RFE with Cross-Validation

```python
from sklearn.feature_selection import RFECV

rfecv = RFECV(
    estimator=RandomForestClassifier(n_estimators=100),
    step=1,
    cv=5,
    scoring='accuracy'
)
rfecv.fit(X, y)

print(f"Optimal number of features: {rfecv.n_features_}")

# Plot
plt.plot(range(1, len(rfecv.cv_results_['mean_test_score']) + 1),
         rfecv.cv_results_['mean_test_score'])
plt.xlabel('Number of features')
plt.ylabel('CV Score')
```

## Method 3: Embedded Methods (During Training)

### L1 Regularization (Lasso)

L1 drives some coefficients to exactly zero:

```python
from sklearn.linear_model import Lasso, LogisticRegression
from sklearn.feature_selection import SelectFromModel

# For regression
lasso = Lasso(alpha=0.01)
lasso.fit(X, y)

# For classification
lr = LogisticRegression(penalty='l1', solver='saga', C=1.0)
lr.fit(X, y)

# Select non-zero features
selector = SelectFromModel(lr, prefit=True)
X_selected = selector.transform(X)
```

### Tree-Based Feature Importance

```python
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import SelectFromModel

# Train model
rf = RandomForestClassifier(n_estimators=100)
rf.fit(X, y)

# Select important features
selector = SelectFromModel(rf, threshold='median')
X_selected = selector.fit_transform(X, y)

# Or manually select top features
importance = pd.DataFrame({
    'feature': X.columns,
    'importance': rf.feature_importances_
}).sort_values('importance', ascending=False)

top_features = importance.head(10)['feature'].tolist()
```

## Quick Comparison

| Method | Speed | Considers Model | Best For |
|--------|-------|-----------------|----------|
| Variance | Fast | No | Quick filtering |
| Correlation | Fast | No | Removing redundancy |
| SelectKBest | Fast | No | Simple selection |
| RFE | Slow | Yes | Optimal subset |
| L1/Lasso | Medium | Yes | Sparse models |
| Tree Importance | Medium | Yes | Tree models |

## Practical Pipeline

```python
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, f_classif

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('selector', SelectKBest(f_classif, k=20)),
    ('classifier', RandomForestClassifier())
])

pipeline.fit(X_train, y_train)
```

## Key Takeaway

Start with filter methods (fast, remove obvious noise), then use embedded methods (L1 or tree importance) for automatic selection. Use wrapper methods (RFE) when you need the optimal subset and have time. Always validate that feature selection actually improves your cross-validation score - sometimes all features are useful!

Learn how to select the most important features to improve model performance and reduce complexity.

Feature Selection Techniques

# Model Calibration: Reliable Probability Estimates

When your model says "80% probability of rain," it should actually rain 80% of the time. That's calibration - making probability estimates reliable.

## Why Calibration Matters

```
Uncalibrated model says 90% confidence:
- Sometimes right 90% of the time ✓
- Sometimes right only 60% of the time ✗

Calibrated model says 90% confidence:
- Right 90% of the time ✓
```

Important for:
- Medical diagnosis
- Risk assessment
- Decision making with costs/benefits

## Checking Calibration: Reliability Diagram

```python
from sklearn.calibration import calibration_curve
import matplotlib.pyplot as plt

# Get predicted probabilities
y_prob = model.predict_proba(X_test)[:, 1]

# Create calibration curve
prob_true, prob_pred = calibration_curve(y_test, y_prob, n_bins=10)

# Plot
plt.figure(figsize=(8, 6))
plt.plot(prob_pred, prob_true, 's-', label='Model')
plt.plot([0, 1], [0, 1], '--', label='Perfectly calibrated')
plt.xlabel('Mean predicted probability')
plt.ylabel('Fraction of positives')
plt.title('Calibration Curve')
plt.legend()
plt.show()
```

## Interpreting the Plot

```
Perfectly Calibrated:
Points on diagonal line

Under-confident:         Over-confident:
Above diagonal           Below diagonal
Says 60%, is 80%        Says 80%, is 60%
```

## Brier Score

Measures calibration quality (lower is better):

```python
from sklearn.metrics import brier_score_loss

brier = brier_score_loss(y_test, y_prob)
print(f"Brier Score: {brier:.4f}")  # 0 = perfect, 0.25 = random
```

## Which Models Need Calibration?

| Model | Typically Calibrated? |
|-------|----------------------|
| Logistic Regression | Usually good |
| Naive Bayes | Often extreme (needs calibration) |
| Random Forest | Usually under-confident |
| SVM | Often needs calibration |
| Neural Networks | Varies |
| XGBoost | Usually good |

## Calibration Methods

### 1. Platt Scaling (Sigmoid)

Fits a logistic regression to the outputs:

```python
from sklearn.calibration import CalibratedClassifierCV

# Wrap your model with calibration
calibrated = CalibratedClassifierCV(model, method='sigmoid', cv=5)
calibrated.fit(X_train, y_train)

# Now probabilities are calibrated
y_prob_calibrated = calibrated.predict_proba(X_test)[:, 1]
```

### 2. Isotonic Regression

Non-parametric, more flexible:

```python
calibrated = CalibratedClassifierCV(model, method='isotonic', cv=5)
calibrated.fit(X_train, y_train)
```

### Comparing Methods

```python
# Original model
model.fit(X_train, y_train)
prob_original = model.predict_proba(X_test)[:, 1]

# Sigmoid calibration
cal_sigmoid = CalibratedClassifierCV(model, method='sigmoid', cv=5)
cal_sigmoid.fit(X_train, y_train)
prob_sigmoid = cal_sigmoid.predict_proba(X_test)[:, 1]

# Isotonic calibration  
cal_isotonic = CalibratedClassifierCV(model, method='isotonic', cv=5)
cal_isotonic.fit(X_train, y_train)
prob_isotonic = cal_isotonic.predict_proba(X_test)[:, 1]

# Compare
print(f"Original Brier: {brier_score_loss(y_test, prob_original):.4f}")
print(f"Sigmoid Brier: {brier_score_loss(y_test, prob_sigmoid):.4f}")
print(f"Isotonic Brier: {brier_score_loss(y_test, prob_isotonic):.4f}")
```

## Choosing Calibration Method

| Method | Best When |
|--------|-----------|
| Sigmoid | Enough data, S-shaped miscalibration |
| Isotonic | Lots of data, arbitrary miscalibration |

Sigmoid is safer with less data (isotonic can overfit).

## Full Pipeline Example

```python
from sklearn.ensemble import RandomForestClassifier
from sklearn.calibration import CalibratedClassifierCV, calibration_curve
from sklearn.model_selection import train_test_split

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Train base model
rf = RandomForestClassifier(n_estimators=100)

# Create calibrated version
rf_calibrated = CalibratedClassifierCV(rf, method='sigmoid', cv=5)
rf_calibrated.fit(X_train, y_train)

# Compare calibration curves
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

for ax, (name, model) in zip(axes, [('Uncalibrated', rf), ('Calibrated', rf_calibrated)]):
    if name == 'Uncalibrated':
        model.fit(X_train, y_train)
    prob = model.predict_proba(X_test)[:, 1]
    prob_true, prob_pred = calibration_curve(y_test, prob, n_bins=10)
    
    ax.plot(prob_pred, prob_true, 's-')
    ax.plot([0, 1], [0, 1], '--')
    ax.set_title(f'{name}\nBrier: {brier_score_loss(y_test, prob):.4f}')

plt.tight_layout()
```

## Key Takeaway

Calibration makes probability predictions reliable. Always check calibration with reliability diagrams, especially when probabilities drive decisions. Random forests and Naive Bayes often need calibration, while logistic regression is usually well-calibrated. Use sigmoid calibration by default, isotonic if you have lots of data.

Learn how to calibrate your model so predicted probabilities reflect actual likelihoods.

Model Calibration: Reliable Probability Estimates

# Avoiding Data Leakage in Machine Learning

Data leakage is when your model learns from information it shouldn't have access to. Great test scores, disastrous production performance. It's one of the most common ML mistakes.

## What is Data Leakage?

```
Training with leakage:        Production (no leakage):
"Future" info available       Only past/present available
├── Test accuracy: 99%        ├── Actual accuracy: 60%
└── Model looks great!        └── Model fails!
```

## Type 1: Target Leakage

Features that contain information about the target but wouldn't be available at prediction time.

**Example:** Predicting loan default
```
Feature: "account_closed" = True
Problem: Account closed BECAUSE they defaulted!
         This wouldn't be known when making lending decision.
```

**Fix:** Think about what you'd know at prediction time.

```python
# Bad: These are consequences of the target
features_to_remove = [
    'account_closed',      # Result of default
    'sent_to_collections', # Result of default  
    'bankruptcy_filed'     # Result of default
]

X = df.drop(columns=features_to_remove + ['target'])
```

## Type 2: Train-Test Contamination

Test data information leaks into training.

**Common mistakes:**

### Fitting on All Data

```python
# WRONG: Scaler sees test data!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # Leaks test statistics
X_train, X_test = train_test_split(X_scaled, ...)

# RIGHT: Fit only on training data
X_train, X_test = train_test_split(X, ...)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)  # Only transform!
```

### Feature Selection on All Data

```python
# WRONG
selected_features = select_best_features(X, y)  # Uses test info
X_train, X_test = train_test_split(X[selected_features], ...)

# RIGHT
X_train, X_test = train_test_split(X, ...)
selected_features = select_best_features(X_train, y_train)
X_train = X_train[selected_features]
X_test = X_test[selected_features]
```

## Type 3: Temporal Leakage

Using future information to predict the past.

```python
# WRONG: Random split with time series
X_train, X_test = train_test_split(X, ...)  # 2023 data in train, 2020 in test!

# RIGHT: Split by time
train = df[df['date'] < '2023-01-01']
test = df[df['date'] >= '2023-01-01']
```

Also watch for features:
```python
# Bad: Uses future aggregations
df['user_total_purchases'] = df.groupby('user')['amount'].transform('sum')

# Better: Use only past data
df['user_purchases_before'] = df.groupby('user')['amount'].apply(
    lambda x: x.shift().expanding().sum()
)
```

## Type 4: Duplicate/Near-Duplicate Rows

```python
# If same row appears in train and test
# Model memorizes, doesn't generalize

# Check for duplicates before splitting
print(f"Duplicates: {df.duplicated().sum()}")

# Remove duplicates
df = df.drop_duplicates()

# Or split by unique entity (e.g., customer_id)
unique_customers = df['customer_id'].unique()
train_customers, test_customers = train_test_split(unique_customers)
train = df[df['customer_id'].isin(train_customers)]
test = df[df['customer_id'].isin(test_customers)]
```

## How to Detect Leakage

### 1. Suspiciously Good Performance

```python
if test_accuracy > 0.95:
    print("This seems too good. Check for leakage!")
```

### 2. Feature Importance Check

```python
# If a feature is unrealistically important, investigate
importance = model.feature_importances_
top_feature = feature_names[importance.argmax()]
print(f"Top feature: {top_feature}")
# Ask: "Would this be available at prediction time?"
```

### 3. Time-Based Validation

```python
# If time-based validation is much worse than random CV
cv_score = cross_val_score(model, X, y, cv=5).mean()
time_score = # time-based split score

if cv_score - time_score > 0.1:
    print("Possible temporal leakage!")
```

## Prevention Checklist

- [ ] Split data BEFORE any preprocessing
- [ ] Use pipelines to prevent leakage
- [ ] For time series, always split by time
- [ ] Check: "Would I have this feature at prediction time?"
- [ ] Remove duplicates before splitting
- [ ] Be suspicious of very high scores

## Safe Pipeline

```python
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest
from sklearn.ensemble import RandomForestClassifier

# Pipeline applies steps correctly during CV
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('selector', SelectKBest(k=20)),
    ('classifier', RandomForestClassifier())
])

# Safe cross-validation
scores = cross_val_score(pipeline, X, y, cv=5)
```

## Key Takeaway

Data leakage is silent and deadly - your model looks great until production. Always split data first, use pipelines, think carefully about what information would be available at prediction time, and be suspicious of results that seem too good. Prevention is much easier than detection!

Learn how to identify and prevent data leakage that causes models to fail in production.

Avoiding Data Leakage in Machine Learning

# Debugging Machine Learning Models

Your model isn't working. Before trying random things, follow a systematic debugging approach.

## The Debugging Checklist

```
1. Check your data
2. Start simple
3. Verify the pipeline
4. Analyze errors
5. Check for bugs in code
```

## Step 1: Check Your Data

Most ML problems are data problems.

### Look at Your Data

```python
# Basic stats
print(df.describe())
print(df.info())

# Target distribution
print(df['target'].value_counts(normalize=True))

# Missing values
print(df.isnull().sum())

# Actually look at examples
print(df.head(20))
```

### Check for Data Issues

```python
# Duplicates
print(f"Duplicates: {df.duplicated().sum()}")

# Outliers
for col in numeric_cols:
    q99 = df[col].quantile(0.99)
    q01 = df[col].quantile(0.01)
    print(f"{col}: 1%={q01:.2f}, 99%={q99:.2f}")

# Class imbalance
print(df['target'].value_counts())

# Leakage check - correlations with target
correlations = df.corr()['target'].sort_values(ascending=False)
print(correlations.head(10))
```

## Step 2: Start Simple

If a complex model doesn't work, try something simpler first.

```python
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression

# Baseline: How good is random/majority?
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
print(f"Dummy baseline: {dummy.score(X_test, y_test):.3f}")

# Simple model
lr = LogisticRegression()
lr.fit(X_train, y_train)
print(f"Logistic Regression: {lr.score(X_test, y_test):.3f}")

# If LR doesn't beat dummy, you have a data problem
```

## Step 3: Verify the Pipeline

### Can the Model Overfit?

A model should be able to memorize training data:

```python
# Train on small subset
X_small = X_train[:100]
y_small = y_train[:100]

model.fit(X_small, y_small)
train_score = model.score(X_small, y_small)

print(f"Train score on small data: {train_score:.3f}")
# Should be close to 1.0! If not, model can't learn at all.
```

### Check Preprocessing

```python
# Verify shapes at each step
print(f"Original: {X.shape}")
print(f"After preprocessing: {X_processed.shape}")
print(f"After train/test split: {X_train.shape}, {X_test.shape}")

# Check for NaN after preprocessing
print(f"NaN in processed: {np.isnan(X_processed).sum()}")

# Check for inf
print(f"Inf in processed: {np.isinf(X_processed).sum()}")
```

### Verify Labels

```python
# Are labels correct?
print(f"Unique labels: {np.unique(y)}")
print(f"Label types: {y.dtype}")

# Check alignment
assert len(X) == len(y), "X and y length mismatch!"
```

## Step 4: Analyze Errors

### Confusion Matrix

```python
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm = confusion_matrix(y_test, y_pred)
ConfusionMatrixDisplay(cm).plot()

# What's it getting wrong?
```

### Look at Misclassified Examples

```python
# Find errors
errors = X_test[y_test != y_pred]
error_true = y_test[y_test != y_pred]
error_pred = y_pred[y_test != y_pred]

# Look at them
for i in range(min(10, len(errors))):
    print(f"True: {error_true.iloc[i]}, Pred: {error_pred[i]}")
    print(errors.iloc[i])
    print("---")
```

### Error Analysis by Subgroup

```python
# Performance by category
for category in df['category'].unique():
    mask = X_test['category'] == category
    score = accuracy_score(y_test[mask], y_pred[mask])
    print(f"{category}: {score:.3f}")
```

## Step 5: Common Bugs

### Bug: Using Test Data for Training

```python
# WRONG
scaler.fit(X)  # Includes test data!
model.fit(X_train, y_train)

# RIGHT
scaler.fit(X_train)
model.fit(X_train, y_train)
```

### Bug: Shuffled Labels

```python
# Check if labels match data
# After any reshaping, verify alignment
print(f"First 5 X rows: {X.head()}")
print(f"First 5 y values: {y.head()}")
```

### Bug: Wrong Metric

```python
# For imbalanced data, accuracy is misleading
print(f"Accuracy: {accuracy_score(y_test, y_pred):.3f}")
print(f"F1: {f1_score(y_test, y_pred):.3f}")  # Much more informative
```

## Debugging Workflow

```
Model not learning?
├── Check: Can it overfit small data?
│   └── No → Bug in code or data
├── Check: Does simple model work?
│   └── No → Data problem
└── Check: Is training loss decreasing?
    └── No → Learning rate / architecture issue

Model overfitting?
├── Try regularization
├── Try simpler model
├── Get more data
└── Check for data leakage

Model underfitting?
├── Try more complex model
├── Add features
├── Reduce regularization
└── Check preprocessing
```

## Key Takeaway

Debug systematically, not randomly. Start with data checks, verify you can overfit, use simple baselines, and analyze actual errors. Most problems are data problems or bugs in preprocessing. When stuck, simplify until something works, then add complexity back gradually.

Learn systematic approaches to debugging when your ML model isn't performing as expected.

Debugging Machine Learning Models

# Reproducibility in Machine Learning

"It worked yesterday!" If you can't reproduce your results, you can't trust them. Reproducibility isn't optional - it's essential.

## Why Reproducibility Matters

- Debug issues (need to recreate the problem)
- Compare experiments fairly
- Share with colleagues
- Deploy to production with confidence
- Scientific integrity

## Level 1: Random Seeds

Set seeds everywhere:

```python
import numpy as np
import random
import os

def set_all_seeds(seed=42):
    np.random.seed(seed)
    random.seed(seed)
    os.environ['PYTHONHASHSEED'] = str(seed)
    
    # For TensorFlow
    try:
        import tensorflow as tf
        tf.random.set_seed(seed)
    except ImportError:
        pass
    
    # For PyTorch
    try:
        import torch
        torch.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        torch.backends.cudnn.deterministic = True
    except ImportError:
        pass

# Call at start of every experiment
set_all_seeds(42)
```

Also in model and data splitting:

```python
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# Always specify random_state
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

model = RandomForestClassifier(n_estimators=100, random_state=42)
```

## Level 2: Environment Management

### requirements.txt with Versions

```
# Save exact versions
pip freeze > requirements.txt

# requirements.txt
numpy==1.24.0
pandas==2.0.0
scikit-learn==1.3.0
xgboost==1.7.0
```

### Better: Use Poetry or Conda

```yaml
# environment.yml
name: ml-project
dependencies:
  - python=3.10
  - numpy=1.24.0
  - pandas=2.0.0
  - scikit-learn=1.3.0
  - pip:
    - xgboost==1.7.0
```

## Level 3: Track Experiments

### Simple: Log Everything

```python
import json
from datetime import datetime

def log_experiment(params, metrics, notes=""):
    experiment = {
        'timestamp': datetime.now().isoformat(),
        'params': params,
        'metrics': metrics,
        'notes': notes
    }
    
    with open('experiments.jsonl', 'a') as f:
        f.write(json.dumps(experiment) + '\n')

# Usage
log_experiment(
    params={'n_estimators': 100, 'max_depth': 10},
    metrics={'accuracy': 0.85, 'f1': 0.82},
    notes='First baseline'
)
```

### Better: Use MLflow

```python
import mlflow

mlflow.set_experiment("my_experiment")

with mlflow.start_run():
    # Log parameters
    mlflow.log_param("n_estimators", 100)
    mlflow.log_param("max_depth", 10)
    
    # Train model
    model.fit(X_train, y_train)
    
    # Log metrics
    mlflow.log_metric("accuracy", accuracy)
    mlflow.log_metric("f1", f1)
    
    # Log model
    mlflow.sklearn.log_model(model, "model")
```

## Level 4: Version Data

Data changes can break reproducibility:

```python
import hashlib
import pandas as pd

def hash_dataframe(df):
    return hashlib.md5(
        pd.util.hash_pandas_object(df).values
    ).hexdigest()

# Log data hash
data_hash = hash_dataframe(df)
print(f"Data hash: {data_hash}")

# Or use DVC for data versioning
# dvc add data/training_data.csv
```

## Level 5: Code Version Control

Always commit before running experiments:

```python
import subprocess

def get_git_commit():
    try:
        commit = subprocess.check_output(
            ['git', 'rev-parse', 'HEAD']
        ).decode().strip()
        return commit
    except:
        return "unknown"

# Log with experiment
log_experiment(
    params={...},
    metrics={...},
    git_commit=get_git_commit()
)
```

## Reproducibility Checklist

```
□ Random seeds set (numpy, python, framework)
□ Specific package versions documented
□ Data versioned or hashed
□ Code committed to git
□ Experiment parameters logged
□ Results logged with timestamp
□ Hardware/environment noted (GPU, OS)
```

## Quick Template

```python
import numpy as np
import random
from datetime import datetime

# 1. Set seeds
SEED = 42
np.random.seed(SEED)
random.seed(SEED)

# 2. Log experiment config
config = {
    'seed': SEED,
    'data_path': 'data/train.csv',
    'model': 'RandomForest',
    'params': {'n_estimators': 100, 'max_depth': 10},
    'timestamp': datetime.now().isoformat()
}
print(f"Config: {config}")

# 3. Load data (with hash for verification)
df = pd.read_csv(config['data_path'])
print(f"Data shape: {df.shape}")

# 4. Train with fixed seed
model = RandomForestClassifier(
    **config['params'],
    random_state=SEED
)

# 5. Log results
results = {
    'config': config,
    'metrics': {'accuracy': accuracy, 'f1': f1}
}
```

## Key Takeaway

Reproducibility is a habit, not an afterthought. Set random seeds everywhere, version your environment and data, log all experiments, and commit code before runs. Future you (and your colleagues) will thank you. Start simple with seeds and requirements.txt, add experiment tracking as needed.

Learn how to make your ML experiments reproducible for yourself and others.

Reproducibility in Machine Learning

# Introduction to Deep Learning

Traditional ML hits a ceiling with complex data like images, speech, and text. Deep Learning breaks through that ceiling.

## What is Deep Learning?

Deep Learning = Neural networks with many layers.

"Deep" refers to the depth (number of layers), not complexity. These layers automatically learn hierarchical features from raw data.

**Traditional ML:**
```
Raw Data → Hand-crafted Features → Model → Prediction
```

**Deep Learning:**
```
Raw Data → Neural Network → Prediction
(Features learned automatically)
```

## The Neuron

Everything starts with a single neuron:

```python
import numpy as np

def neuron(inputs, weights, bias):
    # Weighted sum
    z = np.dot(inputs, weights) + bias
    # Activation function
    output = 1 / (1 + np.exp(-z))  # Sigmoid
    return output

# Example
inputs = np.array([0.5, 0.3, 0.2])
weights = np.array([0.4, 0.6, 0.8])
bias = 0.1

result = neuron(inputs, weights, bias)
print(f"Neuron output: {result:.4f}")
```

## Building a Simple Neural Network

```python
import tensorflow as tf
from tensorflow import keras

# Simple neural network
model = keras.Sequential([
    keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

# Compile
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Train
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.2)
```

## Key Components

| Component | Purpose |
|-----------|---------|
| Layers | Transform data step by step |
| Weights | Learnable parameters |
| Activation | Adds non-linearity |
| Loss | Measures prediction error |
| Optimizer | Updates weights to reduce loss |

## Activation Functions

```python
# ReLU - Most common for hidden layers
def relu(x):
    return np.maximum(0, x)

# Sigmoid - For binary classification output
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Softmax - For multi-class output
def softmax(x):
    exp_x = np.exp(x - np.max(x))
    return exp_x / exp_x.sum()
```

## When to Use Deep Learning

**Use Deep Learning:**
- Images, video, audio, text
- Very large datasets (millions of samples)
- When feature engineering is hard
- State-of-the-art performance needed

**Stick with Traditional ML:**
- Tabular data (often)
- Small datasets (<10K samples)
- When interpretability matters
- Limited compute resources

## Key Takeaway

Deep Learning automates feature learning through layered neural networks. It excels at unstructured data (images, text, audio) but requires lots of data and compute. Start with simple architectures, understand the basics, then explore specialized architectures like CNNs and RNNs for specific tasks.

Understand what deep learning is, how neural networks work, and when to use deep learning over traditional ML.

Introduction to Deep Learning

# Convolutional Neural Networks (CNNs) Explained

Regular neural networks don't understand spatial structure. Feed an image as a flat array and you lose the fact that nearby pixels are related. CNNs solve this.

## The Problem with Regular Networks

A 224x224 color image has 224 × 224 × 3 = 150,528 inputs. A fully connected layer with 1000 neurons = 150 million parameters. That's insane and ignores spatial patterns.

## How Convolution Works

Instead of connecting every pixel to every neuron, slide a small filter across the image:

```
Image:          Filter (3x3):    Output:
1 2 3 4         1 0 1           
2 3 4 5   *     0 1 0     =     Result
3 4 5 6         1 0 1
4 5 6 7
```

The filter detects patterns (edges, textures, shapes). Multiple filters = multiple pattern detectors.

## CNN Architecture

```python
import tensorflow as tf
from tensorflow.keras import layers, models

model = models.Sequential([
    # Convolution + Pooling Block 1
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)),
    layers.MaxPooling2D((2, 2)),
    
    # Convolution + Pooling Block 2
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    # Convolution + Pooling Block 3
    layers.Conv2D(128, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    # Flatten and Dense layers
    layers.Flatten(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)
```

## Key Layers

**Convolutional Layer:**
- Applies filters to detect features
- Parameters: number of filters, filter size, stride, padding

**Pooling Layer:**
- Reduces spatial dimensions
- MaxPooling takes the maximum value in each region
- Makes features translation-invariant

**Flatten:**
- Converts 2D feature maps to 1D vector

## What CNNs Learn

Each layer learns different features:

| Layer | What It Learns |
|-------|---------------|
| Early layers | Edges, colors, simple textures |
| Middle layers | Shapes, patterns, object parts |
| Deep layers | Complex objects, faces, scenes |

## Practical Example: Image Classification

```python
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Data augmentation
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True
)

train_generator = train_datagen.flow_from_directory(
    'data/train',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical'
)

# Train
history = model.fit(
    train_generator,
    epochs=20,
    validation_data=val_generator
)
```

## Key Takeaway

CNNs use convolutions to efficiently process images by exploiting spatial structure. They learn hierarchical features automatically - edges in early layers, complex objects in deeper layers. Use them for any image-related task. Start with a simple architecture, add data augmentation, and consider transfer learning for faster results.

Learn how CNNs work for image recognition, the role of convolutions, pooling, and how to build your first CNN.

Convolutional Neural Networks (CNNs) Explained

# Recurrent Neural Networks (RNNs) for Sequences

Regular neural networks see each input independently. RNNs have memory - they remember what came before.

## Why Sequences Need Special Treatment

Consider predicting the next word:

"The cat sat on the ___"

To predict correctly, you need context from previous words. Regular networks can't do this naturally.

## How RNNs Work

RNNs have a loop that passes information from one step to the next:

```
       ┌──────────────────────────┐
       │                          │
       v                          │
   [Hidden State] ──────> [Hidden State]
       ^                          ^
       │                          │
   [Input t]               [Input t+1]
```

At each time step:
1. Take current input
2. Combine with previous hidden state
3. Produce output and new hidden state

## Simple RNN Implementation

```python
import numpy as np

class SimpleRNN:
    def __init__(self, input_size, hidden_size, output_size):
        # Initialize weights
        self.Wxh = np.random.randn(hidden_size, input_size) * 0.01
        self.Whh = np.random.randn(hidden_size, hidden_size) * 0.01
        self.Why = np.random.randn(output_size, hidden_size) * 0.01
        self.bh = np.zeros((hidden_size, 1))
        self.by = np.zeros((output_size, 1))
    
    def forward(self, inputs, h_prev):
        h = np.tanh(self.Wxh @ inputs + self.Whh @ h_prev + self.bh)
        y = self.Why @ h + self.by
        return y, h
```

## Using Keras for RNNs

```python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, Dense, Embedding

# Text classification with RNN
model = Sequential([
    Embedding(vocab_size, 128, input_length=max_length),
    SimpleRNN(64, return_sequences=False),
    Dense(1, activation='sigmoid')
])

model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

model.fit(X_train, y_train, epochs=10, batch_size=32)
```

## The Vanishing Gradient Problem

Simple RNNs struggle with long sequences. During backpropagation, gradients either:
- **Vanish:** Become tiny, learning stops
- **Explode:** Become huge, training unstable

This limits how far back RNNs can remember. Solution? LSTM and GRU (covered next).

## Common Applications

| Task | Description |
|------|-------------|
| Text Classification | Sentiment analysis, spam detection |
| Language Modeling | Predict next word |
| Machine Translation | Sequence-to-sequence |
| Time Series | Stock prices, weather |
| Speech Recognition | Audio to text |

## Bidirectional RNNs

Sometimes you need context from both directions:

"I love this ___. It's so ___."

```python
from tensorflow.keras.layers import Bidirectional

model = Sequential([
    Embedding(vocab_size, 128),
    Bidirectional(SimpleRNN(64)),  # Processes forward and backward
    Dense(1, activation='sigmoid')
])
```

## Key Takeaway

RNNs process sequences by maintaining hidden state that passes information across time steps. They're foundational for text, time series, and any sequential data. However, vanilla RNNs struggle with long sequences due to vanishing gradients. Use LSTM or GRU for better long-term memory.

Understand how RNNs process sequential data, their architecture, and common applications in text and time series.

Recurrent Neural Networks (RNNs) for Sequences

# LSTM Networks: Solving Long-Term Dependencies

Simple RNNs forget quickly. Try to remember something 100 steps ago? Nearly impossible. LSTMs (Long Short-Term Memory) fix this with a clever gating mechanism.

## The Problem

In vanilla RNNs, information gets diluted at each step. After 20-30 steps, early inputs barely influence the output. This is the vanishing gradient problem.

## LSTM's Solution: Memory Cell + Gates

LSTM adds a "memory highway" (cell state) that information can flow through unchanged. Three gates control what gets added, forgotten, or output:

1. **Forget Gate:** What to remove from memory
2. **Input Gate:** What new information to add
3. **Output Gate:** What to output from memory

## Visual Overview

```
        ┌─────────── Cell State ───────────┐
        │    ×           +           ×     │
        ▼    │           │           │     ▼
   [Forget Gate]   [Input Gate]   [Output Gate]
        │           │     │           │
        └───────────┴─────┴───────────┘
                    │
              [Hidden State]
```

## LSTM Step by Step

```python
import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def lstm_cell(x, h_prev, c_prev, weights):
    # Concatenate input and previous hidden state
    combined = np.concatenate([h_prev, x])
    
    # Forget gate: what to forget from cell state
    f = sigmoid(weights['Wf'] @ combined + weights['bf'])
    
    # Input gate: what new info to add
    i = sigmoid(weights['Wi'] @ combined + weights['bi'])
    
    # Candidate cell state
    c_candidate = np.tanh(weights['Wc'] @ combined + weights['bc'])
    
    # New cell state
    c = f * c_prev + i * c_candidate
    
    # Output gate: what to output
    o = sigmoid(weights['Wo'] @ combined + weights['bo'])
    
    # New hidden state
    h = o * np.tanh(c)
    
    return h, c
```

## Using LSTM in Keras

```python
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Embedding, Dropout

# Text classification with LSTM
model = Sequential([
    Embedding(vocab_size, 128, input_length=max_length),
    LSTM(128, dropout=0.2, recurrent_dropout=0.2),
    Dense(64, activation='relu'),
    Dropout(0.5),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.2)
```

## Stacked LSTMs

For complex patterns, stack multiple LSTM layers:

```python
model = Sequential([
    Embedding(vocab_size, 128),
    LSTM(128, return_sequences=True),   # Return full sequence for next layer
    LSTM(64, return_sequences=False),    # Only return final output
    Dense(1, activation='sigmoid')
])
```

## LSTM for Time Series

```python
from tensorflow.keras.layers import LSTM, Dense
import numpy as np

# Prepare sequences
def create_sequences(data, seq_length):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i+seq_length])
        y.append(data[i+seq_length])
    return np.array(X), np.array(y)

X, y = create_sequences(stock_prices, seq_length=60)
X = X.reshape(-1, 60, 1)  # (samples, timesteps, features)

# Model
model = Sequential([
    LSTM(50, return_sequences=True, input_shape=(60, 1)),
    LSTM(50),
    Dense(1)
])

model.compile(optimizer='adam', loss='mse')
model.fit(X, y, epochs=50, batch_size=32)
```

## LSTM vs GRU

GRU (Gated Recurrent Unit) is a simpler alternative:

| LSTM | GRU |
|------|-----|
| 3 gates | 2 gates |
| More parameters | Fewer parameters |
| Better for long sequences | Often similar performance |
| Slower training | Faster training |

## Key Takeaway

LSTM solves the vanishing gradient problem through its cell state and gating mechanism. Use it for sequences where long-term dependencies matter: language, long time series, music. Start with a single LSTM layer, add stacking if needed. Consider GRU as a faster alternative.

Learn how LSTM networks solve the vanishing gradient problem and enable learning of long-term dependencies in sequences.

LSTM Networks: Solving Long-Term Dependencies

# Attention Mechanism and Transformers

RNNs process sequences one step at a time. Transformers process everything at once with "attention" - and they've taken over NLP.

## The Attention Insight

When translating "The cat sat on the mat," the word "sat" mostly depends on "cat," not equally on all words. Attention learns these dependencies.

## How Attention Works

For each position, compute attention scores to all other positions:

```
Query (what am I looking for?)
Key (what do I contain?)
Value (what do I give back?)

Attention = softmax(Q × K^T / √d) × V
```

```python
import numpy as np

def attention(Q, K, V):
    d_k = K.shape[-1]
    
    # Compute attention scores
    scores = np.matmul(Q, K.T) / np.sqrt(d_k)
    
    # Convert to probabilities
    weights = softmax(scores)
    
    # Weighted sum of values
    output = np.matmul(weights, V)
    
    return output, weights
```

## Self-Attention

In self-attention, Q, K, V all come from the same sequence. Each position attends to all positions (including itself).

```python
import torch
import torch.nn as nn

class SelfAttention(nn.Module):
    def __init__(self, embed_dim, num_heads):
        super().__init__()
        self.attention = nn.MultiheadAttention(embed_dim, num_heads)
    
    def forward(self, x):
        # x shape: (seq_len, batch, embed_dim)
        attn_output, attn_weights = self.attention(x, x, x)
        return attn_output, attn_weights
```

## The Transformer Architecture

Transformers stack self-attention with feed-forward networks:

```
Input Embedding + Positional Encoding
            │
    ┌───────▼───────┐
    │  Multi-Head   │
    │   Attention   │
    └───────┬───────┘
            │ + Residual
    ┌───────▼───────┐
    │  Feed-Forward │
    │    Network    │
    └───────┬───────┘
            │ + Residual
            ▼
      (Repeat N times)
```

## Multi-Head Attention

Instead of one attention, use multiple "heads" that learn different patterns:

```python
class TransformerBlock(nn.Module):
    def __init__(self, embed_dim, num_heads, ff_dim, dropout=0.1):
        super().__init__()
        self.attention = nn.MultiheadAttention(embed_dim, num_heads)
        self.ffn = nn.Sequential(
            nn.Linear(embed_dim, ff_dim),
            nn.ReLU(),
            nn.Linear(ff_dim, embed_dim)
        )
        self.norm1 = nn.LayerNorm(embed_dim)
        self.norm2 = nn.LayerNorm(embed_dim)
        self.dropout = nn.Dropout(dropout)
    
    def forward(self, x):
        # Self-attention with residual
        attn_out, _ = self.attention(x, x, x)
        x = self.norm1(x + self.dropout(attn_out))
        
        # Feed-forward with residual
        ff_out = self.ffn(x)
        x = self.norm2(x + self.dropout(ff_out))
        
        return x
```

## Positional Encoding

Transformers have no inherent position sense. Positional encoding adds position information:

```python
def positional_encoding(seq_len, d_model):
    pos = np.arange(seq_len)[:, np.newaxis]
    i = np.arange(d_model)[np.newaxis, :]
    
    angle = pos / np.power(10000, (2 * (i // 2)) / d_model)
    
    # Apply sin to even indices, cos to odd
    encoding = np.zeros((seq_len, d_model))
    encoding[:, 0::2] = np.sin(angle[:, 0::2])
    encoding[:, 1::2] = np.cos(angle[:, 1::2])
    
    return encoding
```

## Using Pre-trained Transformers

```python
from transformers import AutoTokenizer, AutoModel

# Load pre-trained BERT
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
model = AutoModel.from_pretrained('bert-base-uncased')

# Tokenize
inputs = tokenizer("Hello, how are you?", return_tensors="pt")

# Get embeddings
outputs = model(**inputs)
embeddings = outputs.last_hidden_state
```

## Why Transformers Win

| RNN | Transformer |
|-----|-------------|
| Sequential processing | Parallel processing |
| Limited context | Full context |
| Vanishing gradients | Stable training |
| Slower training | Much faster |

## Key Takeaway

Attention lets models focus on relevant parts of the input. Transformers use self-attention to process entire sequences in parallel, enabling massive scale and better long-range dependencies. They power GPT, BERT, and most modern NLP. Use pre-trained models for most tasks - training from scratch requires enormous resources.

Understand the attention mechanism that revolutionized NLP and how Transformers work without recurrence.

Attention Mechanism and Transformers

# Transfer Learning: Leveraging Pre-trained Models

Training a deep network from scratch needs millions of examples. Transfer learning lets you use knowledge from one task to solve another - even with limited data.

## The Core Idea

A model trained on ImageNet (14 million images) learns general features:
- Early layers: edges, textures, colors
- Middle layers: shapes, patterns
- Deep layers: object parts, complex structures

These features transfer to new tasks. You don't start from scratch - you start from knowledge.

## Transfer Learning Strategies

**1. Feature Extraction:**
Use pre-trained model as fixed feature extractor. Only train the final classifier.

**2. Fine-tuning:**
Start with pre-trained weights, then train entire model (or parts) on new data with low learning rate.

## Feature Extraction (Keras)

```python
from tensorflow.keras.applications import ResNet50
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model

# Load pre-trained ResNet50 without top layers
base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Freeze base model
base_model.trainable = False

# Add custom classifier
x = GlobalAveragePooling2D()(base_model.output)
x = Dense(256, activation='relu')(x)
output = Dense(num_classes, activation='softmax')(x)

model = Model(inputs=base_model.input, outputs=output)

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10, batch_size=32)
```

## Fine-tuning

```python
# After training classifier, unfreeze some layers
base_model.trainable = True

# Freeze early layers, train later ones
for layer in base_model.layers[:100]:
    layer.trainable = False

# Recompile with lower learning rate
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

# Continue training
model.fit(X_train, y_train, epochs=10, batch_size=32)
```

## Transfer Learning for NLP

```python
from transformers import BertTokenizer, TFBertForSequenceClassification
import tensorflow as tf

# Load pre-trained BERT
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = TFBertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

# Prepare data
encodings = tokenizer(texts, truncation=True, padding=True, max_length=128, return_tensors='tf')

# Fine-tune
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=2e-5),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=['accuracy']
)

model.fit(
    dict(encodings),
    labels,
    epochs=3,
    batch_size=16
)
```

## Popular Pre-trained Models

| Domain | Models |
|--------|--------|
| Images | ResNet, VGG, EfficientNet, ViT |
| Text | BERT, GPT, RoBERTa, T5 |
| Audio | Wav2Vec, Whisper |

## When to Use Which Strategy

| Scenario | Strategy |
|----------|----------|
| Small dataset, similar task | Feature extraction |
| Medium dataset, similar task | Fine-tune top layers |
| Large dataset, similar task | Fine-tune all layers |
| Different task | Feature extraction + new head |

## Key Takeaway

Transfer learning is almost always better than training from scratch. For images, use ImageNet pre-trained CNNs. For text, use pre-trained transformers. Start with feature extraction (frozen base), then fine-tune if you have enough data. This is how you get state-of-the-art results with limited resources.

Learn how to use pre-trained models to achieve great results with limited data through transfer learning.

Transfer Learning: Leveraging Pre-trained Models

# Generative Adversarial Networks (GANs)

GANs generate data so realistic that humans can't tell it's fake. They do this through an adversarial game between two networks.

## The Game

**Generator (G):** Creates fake data from random noise
**Discriminator (D):** Tries to distinguish real from fake

They compete:
- G tries to fool D
- D tries to catch G

As they improve, G generates increasingly realistic data.

```
Random Noise ──> [Generator] ──> Fake Image
                                    │
                              [Discriminator] ──> Real or Fake?
                                    │
Real Image ─────────────────────────┘
```

## Simple GAN Implementation

```python
import tensorflow as tf
from tensorflow.keras.layers import Dense, LeakyReLU, BatchNormalization, Reshape, Flatten
from tensorflow.keras.models import Sequential

# Generator: noise -> image
def build_generator(latent_dim):
    model = Sequential([
        Dense(256, input_dim=latent_dim),
        LeakyReLU(0.2),
        BatchNormalization(),
        Dense(512),
        LeakyReLU(0.2),
        BatchNormalization(),
        Dense(1024),
        LeakyReLU(0.2),
        BatchNormalization(),
        Dense(784, activation='tanh'),
        Reshape((28, 28, 1))
    ])
    return model

# Discriminator: image -> real/fake
def build_discriminator():
    model = Sequential([
        Flatten(input_shape=(28, 28, 1)),
        Dense(512),
        LeakyReLU(0.2),
        Dense(256),
        LeakyReLU(0.2),
        Dense(1, activation='sigmoid')
    ])
    return model

latent_dim = 100
generator = build_generator(latent_dim)
discriminator = build_discriminator()
```

## Training Loop

```python
cross_entropy = tf.keras.losses.BinaryCrossentropy()
g_optimizer = tf.keras.optimizers.Adam(1e-4)
d_optimizer = tf.keras.optimizers.Adam(1e-4)

@tf.function
def train_step(real_images):
    batch_size = tf.shape(real_images)[0]
    noise = tf.random.normal([batch_size, latent_dim])
    
    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        # Generate fake images
        fake_images = generator(noise, training=True)
        
        # Discriminator predictions
        real_output = discriminator(real_images, training=True)
        fake_output = discriminator(fake_images, training=True)
        
        # Losses
        d_loss_real = cross_entropy(tf.ones_like(real_output), real_output)
        d_loss_fake = cross_entropy(tf.zeros_like(fake_output), fake_output)
        d_loss = d_loss_real + d_loss_fake
        
        g_loss = cross_entropy(tf.ones_like(fake_output), fake_output)
    
    # Update weights
    d_gradients = disc_tape.gradient(d_loss, discriminator.trainable_variables)
    g_gradients = gen_tape.gradient(g_loss, generator.trainable_variables)
    
    d_optimizer.apply_gradients(zip(d_gradients, discriminator.trainable_variables))
    g_optimizer.apply_gradients(zip(g_gradients, generator.trainable_variables))
    
    return g_loss, d_loss
```

## Common GAN Variants

| Type | Use Case |
|------|----------|
| DCGAN | Images using convolutions |
| StyleGAN | High-quality face generation |
| CycleGAN | Image-to-image translation |
| Pix2Pix | Paired image translation |
| WGAN | More stable training |

## Training Challenges

GANs are notoriously hard to train:

1. **Mode Collapse:** Generator produces limited variety
2. **Training Instability:** D or G dominates
3. **Vanishing Gradients:** G can't learn when D is too good

## Practical Tips

```python
# Tips for stable training:

# 1. Use labels wisely (label smoothing)
real_labels = 0.9  # Not 1.0
fake_labels = 0.0

# 2. Add noise to discriminator inputs
noisy_real = real_images + 0.1 * tf.random.normal(tf.shape(real_images))

# 3. Train D more often than G
for _ in range(2):  # Train D twice
    train_discriminator(real_images)
train_generator()

# 4. Use spectral normalization
from tensorflow_addons.layers import SpectralNormalization
Dense = SpectralNormalization(Dense(256))
```

## Applications

- Face generation and editing
- Image super-resolution
- Data augmentation
- Art creation
- Video generation
- Drug discovery

## Key Takeaway

GANs learn to generate data through adversarial training between generator and discriminator. They produce amazingly realistic images but are tricky to train. Start with DCGAN for images, use established architectures, and monitor both losses carefully. For production use, consider pre-trained StyleGAN models.

Understand how GANs work by pitting two networks against each other to generate realistic data.

Generative Adversarial Networks (GANs)

# Autoencoders: Learning Compressed Representations

Autoencoders learn to compress data into a smaller representation, then reconstruct it. This "bottleneck" forces them to learn the most important features.

## The Architecture

```
Input ──> [Encoder] ──> Latent Code ──> [Decoder] ──> Reconstruction
(784)      (256→64)       (32)         (64→256)        (784)
```

The encoder compresses, the decoder reconstructs. The latent code captures the essence.

## Simple Autoencoder

```python
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model

# Encoder
input_layer = Input(shape=(784,))
encoded = Dense(256, activation='relu')(input_layer)
encoded = Dense(64, activation='relu')(encoded)
latent = Dense(32, activation='relu')(encoded)  # Bottleneck

# Decoder
decoded = Dense(64, activation='relu')(latent)
decoded = Dense(256, activation='relu')(decoded)
output = Dense(784, activation='sigmoid')(decoded)

# Full autoencoder
autoencoder = Model(input_layer, output)

# Just the encoder
encoder = Model(input_layer, latent)

autoencoder.compile(optimizer='adam', loss='mse')
autoencoder.fit(X_train, X_train, epochs=50, batch_size=256)  # Input = Target
```

## Convolutional Autoencoder

For images, use convolutions:

```python
from tensorflow.keras.layers import Conv2D, MaxPooling2D, UpSampling2D

# Encoder
input_img = Input(shape=(28, 28, 1))
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(16, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)

# Decoder
x = Conv2D(16, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)

autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
```

## Denoising Autoencoder

Train on noisy input, reconstruct clean output:

```python
import numpy as np

# Add noise to training data
noise_factor = 0.3
X_train_noisy = X_train + noise_factor * np.random.normal(size=X_train.shape)
X_train_noisy = np.clip(X_train_noisy, 0., 1.)

# Train to reconstruct clean images from noisy ones
autoencoder.fit(
    X_train_noisy, X_train,  # Noisy input, clean target
    epochs=50,
    batch_size=256,
    validation_data=(X_test_noisy, X_test)
)
```

## Variational Autoencoder (VAE)

VAE learns a probability distribution in latent space, enabling generation:

```python
from tensorflow.keras.layers import Lambda
import tensorflow.keras.backend as K

# Sampling function
def sampling(args):
    z_mean, z_log_var = args
    epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim))
    return z_mean + K.exp(0.5 * z_log_var) * epsilon

# Encoder outputs mean and variance
z_mean = Dense(latent_dim)(encoded)
z_log_var = Dense(latent_dim)(encoded)

# Sample from distribution
z = Lambda(sampling)([z_mean, z_log_var])

# VAE loss = reconstruction loss + KL divergence
reconstruction_loss = K.mean(K.square(input_layer - output))
kl_loss = -0.5 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var))
vae_loss = reconstruction_loss + kl_loss
```

## Applications

| Application | How It Works |
|-------------|--------------|
| Dimensionality Reduction | Use encoder output as features |
| Denoising | Train on noisy data |
| Anomaly Detection | High reconstruction error = anomaly |
| Generation (VAE) | Sample from latent space |
| Image Compression | Encode → store → decode |

## Anomaly Detection Example

```python
# Train on normal data only
autoencoder.fit(normal_data, normal_data, epochs=50)

# Calculate reconstruction error
reconstructions = autoencoder.predict(test_data)
errors = np.mean(np.square(test_data - reconstructions), axis=1)

# Anomalies have high error
threshold = np.percentile(errors, 95)
anomalies = errors > threshold
```

## Key Takeaway

Autoencoders learn compressed representations by reconstructing their input through a bottleneck. They're great for dimensionality reduction, denoising, and anomaly detection. VAEs add probabilistic sampling for generation. Use them when you need to learn meaningful features in an unsupervised way.

Learn how autoencoders compress data into latent representations and their applications in denoising and generation.

Autoencoders: Learning Compressed Representations

# Introduction to Reinforcement Learning

Supervised learning needs labeled data. Reinforcement Learning (RL) learns from experience - through trial and error, guided by rewards.

## The RL Framework

```
     ┌────────────────────────────┐
     │                            │
     ▼                            │
  [Agent] ───action───> [Environment]
     ▲                            │
     │                            │
     └──reward, state─────────────┘
```

- **Agent:** The learner/decision maker
- **Environment:** The world the agent interacts with
- **State:** Current situation
- **Action:** What the agent can do
- **Reward:** Feedback signal (good or bad)

## Example: Game Playing

State: Current game screen
Action: Move left, right, jump
Reward: +1 for coins, -1 for dying, +100 for winning

The agent learns which actions lead to high rewards.

## Key Concepts

**Policy (π):** Strategy for choosing actions given states
```
π(state) → action
```

**Value Function (V):** Expected future reward from a state
```
V(state) = Expected total future reward
```

**Q-Function:** Expected reward for taking action a in state s
```
Q(state, action) = Expected total future reward
```

## Simple RL Environment

```python
import gym

# Create environment
env = gym.make('CartPole-v1')

# Reset and get initial state
state = env.reset()

total_reward = 0
done = False

while not done:
    # Choose action (random for now)
    action = env.action_space.sample()
    
    # Take action, get result
    next_state, reward, done, info = env.step(action)
    
    total_reward += reward
    state = next_state

print(f"Total reward: {total_reward}")
env.close()
```

## Exploration vs Exploitation

The fundamental tradeoff:
- **Exploitation:** Choose the best known action
- **Exploration:** Try new actions to learn more

Too much exploitation = miss better options
Too much exploration = waste time on bad actions

## Epsilon-Greedy Strategy

```python
import numpy as np

def epsilon_greedy(Q, state, epsilon):
    if np.random.random() < epsilon:
        # Explore: random action
        return np.random.randint(num_actions)
    else:
        # Exploit: best known action
        return np.argmax(Q[state])

# Decay epsilon over time
epsilon = 1.0
epsilon_decay = 0.995
epsilon_min = 0.01

for episode in range(1000):
    # ... training ...
    epsilon = max(epsilon_min, epsilon * epsilon_decay)
```

## Types of RL

**Value-Based:** Learn value function, derive policy
- Q-Learning, DQN

**Policy-Based:** Learn policy directly
- REINFORCE, Policy Gradients

**Actor-Critic:** Learn both
- A2C, PPO, SAC

## Reward Design

Good rewards are crucial:

```python
# Bad: Sparse reward
reward = 1 if goal_reached else 0  # Hard to learn

# Better: Shaped reward
reward = -distance_to_goal  # Continuous feedback

# Watch for reward hacking!
# Agent might find unexpected ways to maximize reward
```

## When to Use RL

**Good fit:**
- Sequential decision making
- Clear reward signal
- Can simulate many episodes
- Games, robotics, recommendations

**Not ideal:**
- One-shot decisions
- No clear reward
- Expensive to try actions (real robots)
- Labeled data is available (use supervised)

## Key Takeaway

RL learns through interaction - taking actions, receiving rewards, improving. It's powerful for sequential decision problems but requires careful reward design and lots of experience. Start with simple environments (CartPole, GridWorld), understand the exploration-exploitation tradeoff, then move to more complex algorithms.

Understand the fundamentals of reinforcement learning: agents, environments, rewards, and the exploration-exploitation tradeoff.

Introduction to Reinforcement Learning

# Q-Learning: Tabular Reinforcement Learning

Q-Learning is the foundational algorithm in reinforcement learning. It learns which action to take in each state to maximize future rewards.

## The Q-Table

Q-Learning maintains a table of Q-values: Q(state, action) = expected future reward.

```
        Action1  Action2  Action3
State1    0.5      0.2      0.8   ← Best action is Action3
State2    0.9      0.3      0.1   ← Best action is Action1
State3    0.1      0.7      0.4   ← Best action is Action2
```

## The Q-Learning Update

```
Q(s,a) ← Q(s,a) + α * [r + γ * max(Q(s',a')) - Q(s,a)]
```

Where:
- α (alpha): Learning rate
- γ (gamma): Discount factor (how much future matters)
- r: Immediate reward
- s': Next state
- max(Q(s',a')): Best possible future value

## Implementation

```python
import numpy as np

class QLearning:
    def __init__(self, n_states, n_actions, alpha=0.1, gamma=0.99, epsilon=1.0):
        self.Q = np.zeros((n_states, n_actions))
        self.alpha = alpha      # Learning rate
        self.gamma = gamma      # Discount factor
        self.epsilon = epsilon  # Exploration rate
        self.epsilon_decay = 0.995
        self.epsilon_min = 0.01
        self.n_actions = n_actions
    
    def choose_action(self, state):
        if np.random.random() < self.epsilon:
            return np.random.randint(self.n_actions)  # Explore
        return np.argmax(self.Q[state])  # Exploit
    
    def update(self, state, action, reward, next_state, done):
        if done:
            target = reward
        else:
            target = reward + self.gamma * np.max(self.Q[next_state])
        
        # Q-learning update
        self.Q[state, action] += self.alpha * (target - self.Q[state, action])
    
    def decay_epsilon(self):
        self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
```

## Training Loop

```python
import gym

# Environment with discrete state space
env = gym.make('FrozenLake-v1', is_slippery=False)

agent = QLearning(
    n_states=env.observation_space.n,
    n_actions=env.action_space.n
)

# Training
n_episodes = 10000
rewards_history = []

for episode in range(n_episodes):
    state = env.reset()
    total_reward = 0
    done = False
    
    while not done:
        action = agent.choose_action(state)
        next_state, reward, done, _ = env.step(action)
        
        agent.update(state, action, reward, next_state, done)
        
        state = next_state
        total_reward += reward
    
    agent.decay_epsilon()
    rewards_history.append(total_reward)
    
    if episode % 1000 == 0:
        avg_reward = np.mean(rewards_history[-100:])
        print(f"Episode {episode}, Avg Reward: {avg_reward:.2f}, Epsilon: {agent.epsilon:.3f}")
```

## Hyperparameters

| Parameter | Effect | Typical Range |
|-----------|--------|---------------|
| α (learning rate) | How fast to update Q | 0.01 - 0.5 |
| γ (discount) | Future reward importance | 0.9 - 0.99 |
| ε (exploration) | Random action probability | 1.0 → 0.01 |

## Visualizing the Policy

```python
# After training, visualize what the agent learned
def show_policy(Q, shape=(4, 4)):
    actions = ['←', '↓', '→', '↑']
    policy = np.argmax(Q, axis=1).reshape(shape)
    
    for row in policy:
        print(' '.join(actions[a] for a in row))

show_policy(agent.Q)
```

## Limitations

Q-Learning works for **discrete** state spaces. When states are continuous (like images), the table becomes infinite. Solution: Use neural networks to approximate Q → Deep Q-Network (DQN).

```python
# Can't have a table entry for every pixel combination!
# States like [0.523, 1.234, -0.891, 2.456] need function approximation
```

## Key Takeaway

Q-Learning is the cornerstone of value-based RL. It learns action values through the Bellman equation and balances exploration with exploitation. Works great for small, discrete problems. For larger state spaces, you'll need Deep Q-Networks (DQN), which we'll cover next.

Learn the Q-Learning algorithm, the foundation of value-based reinforcement learning.

Q-Learning: Tabular Reinforcement Learning

# Deep Q-Networks (DQN): Deep Reinforcement Learning

Q-Learning works great for small problems. But what if you have millions of states? You can't store a Q-table that big. DQN solves this by using a neural network to approximate Q-values.

## The Problem with Tabular Q-Learning

```
Atari Game State Space:
- Screen: 210 x 160 pixels
- Colors: 128 possible values
- States: 128^(210×160) ≈ Astronomical

Q-Table for this? Impossible.
```

## The DQN Solution

Instead of a table, use a neural network:

```
Q-Table: state → lookup → Q-values
DQN:     state → neural network → Q-values
```

The network learns to generalize across similar states.

## Basic DQN Architecture

```python
import torch
import torch.nn as nn

class DQN(nn.Module):
    def __init__(self, state_size, action_size):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_size, 128)
        self.fc2 = nn.Linear(128, 128)
        self.fc3 = nn.Linear(128, action_size)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)  # Q-values for each action

# For image inputs (like Atari)
class ConvDQN(nn.Module):
    def __init__(self, action_size):
        super(ConvDQN, self).__init__()
        self.conv1 = nn.Conv2d(4, 32, kernel_size=8, stride=4)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)
        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, stride=1)
        self.fc1 = nn.Linear(7 * 7 * 64, 512)
        self.fc2 = nn.Linear(512, action_size)
    
    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = torch.relu(self.conv3(x))
        x = x.view(x.size(0), -1)
        x = torch.relu(self.fc1(x))
        return self.fc2(x)
```

## Two Key Innovations

### 1. Experience Replay

Don't learn from experiences immediately. Store them and sample randomly:

```python
from collections import deque
import random

class ReplayBuffer:
    def __init__(self, capacity=10000):
        self.buffer = deque(maxlen=capacity)
    
    def push(self, state, action, reward, next_state, done):
        self.buffer.append((state, action, reward, next_state, done))
    
    def sample(self, batch_size):
        batch = random.sample(self.buffer, batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)
        return (torch.stack(states), torch.tensor(actions),
                torch.tensor(rewards), torch.stack(next_states),
                torch.tensor(dones))
    
    def __len__(self):
        return len(self.buffer)
```

**Why?** Breaks correlation between consecutive samples. More stable learning.

### 2. Target Network

Use a separate network for target Q-values:

```python
# Main network (updated every step)
policy_net = DQN(state_size, action_size)

# Target network (updated periodically)
target_net = DQN(state_size, action_size)
target_net.load_state_dict(policy_net.state_dict())

# Update target network every N steps
def update_target(policy_net, target_net):
    target_net.load_state_dict(policy_net.state_dict())
```

**Why?** Prevents "chasing a moving target" - stabilizes training.

## Complete Training Loop

```python
import torch.optim as optim

def train_dqn(env, episodes=1000):
    state_size = env.observation_space.shape[0]
    action_size = env.action_space.n
    
    policy_net = DQN(state_size, action_size)
    target_net = DQN(state_size, action_size)
    target_net.load_state_dict(policy_net.state_dict())
    
    optimizer = optim.Adam(policy_net.parameters(), lr=0.001)
    memory = ReplayBuffer(10000)
    
    epsilon = 1.0
    epsilon_min = 0.01
    epsilon_decay = 0.995
    gamma = 0.99
    batch_size = 64
    target_update = 10
    
    for episode in range(episodes):
        state = torch.tensor(env.reset(), dtype=torch.float32)
        total_reward = 0
        
        while True:
            # Epsilon-greedy action selection
            if random.random() < epsilon:
                action = env.action_space.sample()
            else:
                with torch.no_grad():
                    action = policy_net(state).argmax().item()
            
            next_state, reward, done, _ = env.step(action)
            next_state = torch.tensor(next_state, dtype=torch.float32)
            
            memory.push(state, action, reward, next_state, done)
            state = next_state
            total_reward += reward
            
            # Train when enough samples
            if len(memory) >= batch_size:
                train_step(policy_net, target_net, memory, 
                          optimizer, batch_size, gamma)
            
            if done:
                break
        
        # Update target network
        if episode % target_update == 0:
            target_net.load_state_dict(policy_net.state_dict())
        
        # Decay epsilon
        epsilon = max(epsilon_min, epsilon * epsilon_decay)
        
        print(f"Episode {episode}, Reward: {total_reward:.0f}, Epsilon: {epsilon:.2f}")

def train_step(policy_net, target_net, memory, optimizer, batch_size, gamma):
    states, actions, rewards, next_states, dones = memory.sample(batch_size)
    
    # Current Q values
    current_q = policy_net(states).gather(1, actions.unsqueeze(1))
    
    # Target Q values
    with torch.no_grad():
        max_next_q = target_net(next_states).max(1)[0]
        target_q = rewards + gamma * max_next_q * (1 - dones.float())
    
    # Loss and update
    loss = nn.MSELoss()(current_q.squeeze(), target_q)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
```

## DQN Improvements

| Variant | Improvement |
|---------|-------------|
| Double DQN | Reduces overestimation of Q-values |
| Dueling DQN | Separates state value and advantage |
| Prioritized Replay | Samples important experiences more |
| Rainbow | Combines all improvements |

## Key Takeaway

DQN enables reinforcement learning on complex, high-dimensional problems by using neural networks to approximate Q-values. The two key tricks - experience replay and target networks - make training stable. Start with basic DQN, then try Double DQN for better performance.

Learn how DQN combines deep learning with Q-learning to solve complex environments like video games.

Deep Q-Networks (DQN): Deep Reinforcement Learning

# Model Interpretability: SHAP and LIME Explained

Your model predicts a loan will default. But WHY? Without an explanation, you can't trust it, debug it, or deploy it responsibly. Enter SHAP and LIME.

## Why Interpretability Matters

- **Trust**: Stakeholders need to understand predictions
- **Debugging**: Find what your model actually learned
- **Compliance**: Regulations often require explanations (GDPR, banking)
- **Fairness**: Detect if model uses biased features

## LIME: Local Interpretable Model-agnostic Explanations

LIME explains individual predictions by fitting a simple model locally.

**How it works:**
1. Generate samples around the instance
2. Get predictions for these samples
3. Fit a simple model (linear) to explain locally

```python
import lime
import lime.lime_tabular
from sklearn.ensemble import RandomForestClassifier

# Train your complex model
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Create LIME explainer
explainer = lime.lime_tabular.LimeTabularExplainer(
    X_train.values,
    feature_names=X_train.columns.tolist(),
    class_names=['Not Default', 'Default'],
    mode='classification'
)

# Explain a single prediction
instance = X_test.iloc[0]
explanation = explainer.explain_instance(
    instance.values,
    model.predict_proba,
    num_features=10
)

# Show explanation
explanation.show_in_notebook()

# Or get as list
print(explanation.as_list())
# Output: [('income > 50000', -0.15), ('debt_ratio > 0.4', 0.23), ...]
```

**Interpretation:** Positive values push toward class 1, negative toward class 0.

## SHAP: SHapley Additive exPlanations

SHAP uses game theory to fairly distribute "credit" among features.

**The idea:** How much does each feature contribute to moving the prediction away from the average?

```python
import shap

# Train model
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# Create SHAP explainer
explainer = shap.TreeExplainer(model)

# Get SHAP values for test set
shap_values = explainer.shap_values(X_test)

# Single prediction explanation
shap.force_plot(
    explainer.expected_value[1],
    shap_values[1][0],  # SHAP values for instance 0, class 1
    X_test.iloc[0]
)
```

## SHAP Visualizations

### 1. Force Plot (Single Prediction)

```python
# Red features push prediction higher
# Blue features push prediction lower
shap.force_plot(
    explainer.expected_value[1],
    shap_values[1][0],
    X_test.iloc[0]
)
```

### 2. Summary Plot (Global Feature Importance)

```python
# Shows feature importance across all predictions
shap.summary_plot(shap_values[1], X_test)
```

Each dot is one prediction. Position shows SHAP value, color shows feature value.

### 3. Dependence Plot (Feature Interactions)

```python
# How does 'age' affect predictions?
shap.dependence_plot('age', shap_values[1], X_test)
```

### 4. Waterfall Plot (Single Prediction Breakdown)

```python
shap.waterfall_plot(shap.Explanation(
    values=shap_values[1][0],
    base_values=explainer.expected_value[1],
    data=X_test.iloc[0],
    feature_names=X_test.columns.tolist()
))
```

## LIME vs SHAP

| Aspect | LIME | SHAP |
|--------|------|------|
| Speed | Faster | Slower |
| Consistency | Less consistent | Mathematically consistent |
| Global view | No | Yes (summary plots) |
| Model types | Any | Best with trees, but works with any |

## Practical Tips

### 1. For Tree Models, Use TreeExplainer

```python
# Fast and exact for tree-based models
explainer = shap.TreeExplainer(model)
```

### 2. For Neural Networks, Use DeepExplainer

```python
explainer = shap.DeepExplainer(model, X_train[:100])
shap_values = explainer.shap_values(X_test[:10])
```

### 3. For Any Model, Use KernelExplainer

```python
# Slower but works with anything
explainer = shap.KernelExplainer(model.predict_proba, X_train[:100])
shap_values = explainer.shap_values(X_test[:10])
```

### 4. Feature Importance Report

```python
import pandas as pd
import numpy as np

# Global feature importance from SHAP
importance = pd.DataFrame({
    'feature': X_test.columns,
    'importance': np.abs(shap_values[1]).mean(axis=0)
}).sort_values('importance', ascending=False)

print("Top 10 Important Features:")
print(importance.head(10))
```

## When to Use What

**Use LIME when:**
- You need quick explanations
- Working with text or images
- Model-agnostic explanation needed

**Use SHAP when:**
- Consistency matters
- You need global + local explanations
- Working with tree-based models

## Key Takeaway

Model interpretability isn't optional - it's essential for trust, debugging, and compliance. LIME gives quick local explanations, while SHAP provides mathematically grounded attributions with beautiful visualizations. For production ML, always have an explanation strategy ready.

Learn how to explain ML model predictions using SHAP and LIME - essential for production ML and building trust.

Model Interpretability: SHAP and LIME Explained

# Neural Network Optimization: BatchNorm, Dropout & More

Training neural networks is tricky. Without the right techniques, they don't converge, overfit badly, or take forever to train. Here are the essential tools.

## 1. Batch Normalization

**Problem:** Internal covariate shift - each layer's input distribution changes during training, making optimization unstable.

**Solution:** Normalize inputs to each layer.

```python
import torch.nn as nn

class ModelWithBatchNorm(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.bn1 = nn.BatchNorm1d(256)  # Normalize after fc1
        self.fc2 = nn.Linear(256, 128)
        self.bn2 = nn.BatchNorm1d(128)
        self.fc3 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.bn1(torch.relu(self.fc1(x)))
        x = self.bn2(torch.relu(self.fc2(x)))
        return self.fc3(x)
```

**Benefits:**
- Faster training (use higher learning rates)
- Reduces sensitivity to initialization
- Acts as regularization

**For CNNs:** Use BatchNorm2d after conv layers.

```python
self.conv1 = nn.Conv2d(3, 64, 3, padding=1)
self.bn1 = nn.BatchNorm2d(64)  # Match number of channels
```

## 2. Dropout

**Problem:** Overfitting - network memorizes training data.

**Solution:** Randomly "drop" neurons during training.

```python
class ModelWithDropout(nn.Module):
    def __init__(self, dropout_rate=0.5):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.dropout1 = nn.Dropout(dropout_rate)
        self.fc2 = nn.Linear(256, 128)
        self.dropout2 = nn.Dropout(dropout_rate)
        self.fc3 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.dropout1(torch.relu(self.fc1(x)))
        x = self.dropout2(torch.relu(self.fc2(x)))
        return self.fc3(x)
```

**Key points:**
- Dropout rate 0.5 is common for fully connected layers
- Use 0.2-0.3 for input layer
- Automatically disabled during evaluation (model.eval())
- Don't use dropout after the final layer

## 3. Weight Initialization

**Problem:** Bad initialization → vanishing/exploding gradients.

**Solution:** Initialize weights properly for your activation function.

```python
def init_weights(model):
    for m in model.modules():
        if isinstance(m, nn.Linear):
            # Xavier for tanh/sigmoid
            # nn.init.xavier_uniform_(m.weight)
            
            # Kaiming/He for ReLU (recommended)
            nn.init.kaiming_uniform_(m.weight, nonlinearity='relu')
            
            if m.bias is not None:
                nn.init.zeros_(m.bias)
        
        elif isinstance(m, nn.Conv2d):
            nn.init.kaiming_uniform_(m.weight, nonlinearity='relu')

# Apply to model
model.apply(init_weights)
```

**Rule of thumb:**
- ReLU activation → Kaiming/He initialization
- Tanh/Sigmoid → Xavier/Glorot initialization

## 4. Learning Rate Scheduling

**Problem:** Fixed learning rate is suboptimal - need high LR early, low LR later.

```python
from torch.optim.lr_scheduler import StepLR, CosineAnnealingLR, ReduceLROnPlateau

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# Option 1: Step decay (reduce every N epochs)
scheduler = StepLR(optimizer, step_size=30, gamma=0.1)

# Option 2: Cosine annealing (smooth decay)
scheduler = CosineAnnealingLR(optimizer, T_max=100)

# Option 3: Reduce on plateau (reduce when metric stops improving)
scheduler = ReduceLROnPlateau(optimizer, mode='min', patience=10, factor=0.1)

# Training loop
for epoch in range(epochs):
    train_loss = train_one_epoch(model, train_loader)
    val_loss = validate(model, val_loader)
    
    # For StepLR or Cosine
    scheduler.step()
    
    # For ReduceLROnPlateau
    # scheduler.step(val_loss)
    
    print(f"LR: {optimizer.param_groups[0]['lr']}")
```

## 5. Gradient Clipping

**Problem:** Exploding gradients (especially in RNNs).

```python
# Clip by value
torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=1.0)

# Clip by norm (more common)
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# In training loop
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()
```

## 6. Layer Normalization (for Transformers)

BatchNorm doesn't work well for sequences. Use LayerNorm instead:

```python
class TransformerBlock(nn.Module):
    def __init__(self, d_model):
        super().__init__()
        self.attention = nn.MultiheadAttention(d_model, num_heads=8)
        self.norm1 = nn.LayerNorm(d_model)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, d_model * 4),
            nn.ReLU(),
            nn.Linear(d_model * 4, d_model)
        )
        self.norm2 = nn.LayerNorm(d_model)
    
    def forward(self, x):
        # Pre-norm architecture
        x = x + self.attention(self.norm1(x), self.norm1(x), self.norm1(x))[0]
        x = x + self.ffn(self.norm2(x))
        return x
```

## Complete Training Template

```python
import torch
import torch.nn as nn
from torch.optim import AdamW
from torch.optim.lr_scheduler import CosineAnnealingLR

# Model with all techniques
class OptimizedModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(784, 512),
            nn.BatchNorm1d(512),
            nn.ReLU(),
            nn.Dropout(0.3),
            
            nn.Linear(512, 256),
            nn.BatchNorm1d(256),
            nn.ReLU(),
            nn.Dropout(0.3),
            
            nn.Linear(256, 10)
        )
        self.apply(self._init_weights)
    
    def _init_weights(self, m):
        if isinstance(m, nn.Linear):
            nn.init.kaiming_uniform_(m.weight, nonlinearity='relu')
    
    def forward(self, x):
        return self.layers(x)

# Training setup
model = OptimizedModel()
optimizer = AdamW(model.parameters(), lr=0.001, weight_decay=0.01)
scheduler = CosineAnnealingLR(optimizer, T_max=100)

for epoch in range(100):
    model.train()
    for batch in train_loader:
        optimizer.zero_grad()
        loss = criterion(model(batch[0]), batch[1])
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
        optimizer.step()
    
    scheduler.step()
    model.eval()
    # Validate...
```

## Key Takeaway

These techniques aren't optional extras - they're essential for training deep networks effectively. BatchNorm speeds up training, Dropout prevents overfitting, proper initialization prevents gradient issues, and LR scheduling optimizes convergence. Use them all together for best results.

Master essential techniques for training better neural networks: batch normalization, dropout, weight initialization, and learning rate scheduling.

Neural Network Optimization: BatchNorm, Dropout & More

# Variational Autoencoders (VAEs) for Generative Modeling

Regular autoencoders compress data but can't generate new samples. VAEs fix this by learning a probabilistic latent space you can sample from.

## Autoencoder vs VAE

**Autoencoder:**
```
Input → Encoder → Latent Code (fixed point) → Decoder → Reconstruction
```

**VAE:**
```
Input → Encoder → Latent Distribution (mean, variance) → Sample → Decoder → Reconstruction
```

The key difference: VAE learns a distribution, not a fixed point.

## How VAE Works

1. **Encoder** outputs mean (μ) and variance (σ²) for each latent dimension
2. **Sample** from this distribution using the "reparameterization trick"
3. **Decoder** reconstructs from the sample
4. **Loss** = Reconstruction Loss + KL Divergence

## The Reparameterization Trick

Can't backpropagate through random sampling. Solution: sample from N(0,1) and transform:

```
z = μ + σ × ε    where ε ~ N(0,1)
```

Now gradients flow through μ and σ!

## VAE Implementation

```python
import torch
import torch.nn as nn
import torch.nn.functional as F

class VAE(nn.Module):
    def __init__(self, input_dim=784, latent_dim=20):
        super().__init__()
        
        # Encoder
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU()
        )
        
        # Latent space parameters
        self.fc_mu = nn.Linear(256, latent_dim)
        self.fc_logvar = nn.Linear(256, latent_dim)
        
        # Decoder
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.ReLU(),
            nn.Linear(256, 512),
            nn.ReLU(),
            nn.Linear(512, input_dim),
            nn.Sigmoid()  # For normalized inputs [0,1]
        )
    
    def encode(self, x):
        h = self.encoder(x)
        mu = self.fc_mu(h)
        logvar = self.fc_logvar(h)  # log(σ²) for numerical stability
        return mu, logvar
    
    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5 * logvar)  # σ = exp(0.5 * log(σ²))
        eps = torch.randn_like(std)    # ε ~ N(0,1)
        return mu + std * eps          # z = μ + σ × ε
    
    def decode(self, z):
        return self.decoder(z)
    
    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        reconstruction = self.decode(z)
        return reconstruction, mu, logvar
```

## VAE Loss Function

```python
def vae_loss(reconstruction, x, mu, logvar):
    # Reconstruction loss (how well we recreate input)
    recon_loss = F.binary_cross_entropy(reconstruction, x, reduction='sum')
    
    # KL divergence (how close latent distribution is to N(0,1))
    # Formula: -0.5 * sum(1 + log(σ²) - μ² - σ²)
    kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    
    return recon_loss + kl_loss
```

**Why KL divergence?** Forces the latent space to be:
- Continuous (similar inputs → similar latent codes)
- Centered around origin (can sample from N(0,1) to generate)

## Training VAE

```python
def train_vae(model, train_loader, epochs=50):
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    
    for epoch in range(epochs):
        total_loss = 0
        for batch_x, _ in train_loader:
            batch_x = batch_x.view(-1, 784)  # Flatten for MNIST
            
            optimizer.zero_grad()
            recon, mu, logvar = model(batch_x)
            loss = vae_loss(recon, batch_x, mu, logvar)
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        avg_loss = total_loss / len(train_loader.dataset)
        print(f"Epoch {epoch+1}, Loss: {avg_loss:.4f}")
```

## Generating New Samples

```python
def generate_samples(model, num_samples=16):
    model.eval()
    with torch.no_grad():
        # Sample from standard normal
        z = torch.randn(num_samples, 20)  # latent_dim = 20
        samples = model.decode(z)
    return samples

# Generate and visualize
samples = generate_samples(model)
# samples shape: (16, 784) - can reshape to (16, 28, 28) for MNIST
```

## Latent Space Interpolation

```python
def interpolate(model, x1, x2, steps=10):
    model.eval()
    with torch.no_grad():
        # Get latent representations
        mu1, _ = model.encode(x1.unsqueeze(0))
        mu2, _ = model.encode(x2.unsqueeze(0))
        
        # Interpolate in latent space
        interpolations = []
        for alpha in torch.linspace(0, 1, steps):
            z = (1 - alpha) * mu1 + alpha * mu2
            interpolations.append(model.decode(z))
        
        return torch.cat(interpolations)
```

## Convolutional VAE (for Images)

```python
class ConvVAE(nn.Module):
    def __init__(self, latent_dim=32):
        super().__init__()
        
        # Encoder
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 32, 3, stride=2, padding=1),  # 28→14
            nn.ReLU(),
            nn.Conv2d(32, 64, 3, stride=2, padding=1), # 14→7
            nn.ReLU(),
            nn.Flatten()
        )
        
        self.fc_mu = nn.Linear(64 * 7 * 7, latent_dim)
        self.fc_logvar = nn.Linear(64 * 7 * 7, latent_dim)
        
        # Decoder
        self.fc_decode = nn.Linear(latent_dim, 64 * 7 * 7)
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(64, 32, 3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 1, 3, stride=2, padding=1, output_padding=1),
            nn.Sigmoid()
        )
    
    def decode(self, z):
        h = self.fc_decode(z)
        h = h.view(-1, 64, 7, 7)
        return self.decoder(h)
```

## VAE vs GAN

| Aspect | VAE | GAN |
|--------|-----|-----|
| Training | Stable | Can be unstable |
| Sample quality | Blurrier | Sharper |
| Latent space | Structured, interpretable | Less structured |
| Mode coverage | Good (covers all modes) | May miss modes |
| Use case | When you need latent representations | When you need sharp samples |

## Key Takeaway

VAEs learn meaningful latent representations by combining autoencoders with probabilistic modeling. The KL divergence term ensures a smooth, continuous latent space you can sample from. Great for generating variations, interpolating between samples, and learning disentangled features. Start with simple VAE, then try β-VAE for better disentanglement.

Learn how VAEs combine autoencoders with probabilistic modeling to generate new data and learn meaningful latent representations.

Variational Autoencoders (VAEs) for Generative Modeling

# Graph Neural Networks (GNNs): Learning on Graph Data

CNNs work on grids (images). RNNs work on sequences. But what about data with irregular connections? Social networks, molecules, recommendation systems - these are graphs. GNNs are designed for them.

## What is Graph Data?

```
Graph = Nodes + Edges

Social Network:
- Nodes: People
- Edges: Friendships

Molecule:
- Nodes: Atoms
- Edges: Chemical bonds

Knowledge Graph:
- Nodes: Entities
- Edges: Relationships
```

## Why Can't We Use Regular Neural Networks?

**Problems:**
1. Graphs have variable size and structure
2. No fixed ordering of nodes
3. Need to capture connectivity patterns

**Solution:** Message Passing - nodes exchange information with neighbors.

## The Message Passing Framework

```
For each node:
1. AGGREGATE: Collect messages from neighbors
2. UPDATE: Combine with own features
3. Repeat for multiple layers
```

```python
# Conceptual pseudocode
def message_passing_layer(node_features, edge_index):
    messages = []
    for node in nodes:
        # Aggregate neighbor features
        neighbor_features = get_neighbors(node, edge_index)
        aggregated = aggregate(neighbor_features)  # sum, mean, max
        
        # Update node
        new_feature = update(node_features[node], aggregated)
        messages.append(new_feature)
    
    return messages
```

## GNN with PyTorch Geometric

```python
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv, global_mean_pool
from torch_geometric.data import Data

# Create a simple graph
edge_index = torch.tensor([
    [0, 1, 1, 2],  # Source nodes
    [1, 0, 2, 1]   # Target nodes
], dtype=torch.long)

x = torch.tensor([
    [1, 0],  # Node 0 features
    [0, 1],  # Node 1 features
    [1, 1]   # Node 2 features
], dtype=torch.float)

data = Data(x=x, edge_index=edge_index)
```

## Graph Convolutional Network (GCN)

```python
from torch_geometric.nn import GCNConv

class GCN(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)
    
    def forward(self, x, edge_index):
        # First message passing layer
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.5, training=self.training)
        
        # Second message passing layer
        x = self.conv2(x, edge_index)
        return x

# For node classification
model = GCN(in_channels=2, hidden_channels=16, out_channels=3)
out = model(data.x, data.edge_index)  # Shape: [num_nodes, 3]
```

## GraphSAGE: Scalable GNNs

GCN requires the full graph. GraphSAGE samples neighbors, making it scalable:

```python
from torch_geometric.nn import SAGEConv

class GraphSAGE(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = SAGEConv(in_channels, hidden_channels)
        self.conv2 = SAGEConv(hidden_channels, out_channels)
    
    def forward(self, x, edge_index):
        x = F.relu(self.conv1(x, edge_index))
        x = self.conv2(x, edge_index)
        return x
```

## Graph Attention Networks (GAT)

Not all neighbors are equally important. GAT learns attention weights:

```python
from torch_geometric.nn import GATConv

class GAT(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels, heads=8):
        super().__init__()
        self.conv1 = GATConv(in_channels, hidden_channels, heads=heads)
        self.conv2 = GATConv(hidden_channels * heads, out_channels, heads=1)
    
    def forward(self, x, edge_index):
        x = F.elu(self.conv1(x, edge_index))
        x = F.dropout(x, p=0.6, training=self.training)
        x = self.conv2(x, edge_index)
        return x
```

## Graph-Level Tasks (Graph Classification)

Sometimes you need to classify entire graphs, not nodes:

```python
from torch_geometric.nn import global_mean_pool, global_max_pool

class GraphClassifier(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, num_classes):
        super().__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, hidden_channels)
        self.classifier = torch.nn.Linear(hidden_channels, num_classes)
    
    def forward(self, x, edge_index, batch):
        # Node embeddings
        x = F.relu(self.conv1(x, edge_index))
        x = F.relu(self.conv2(x, edge_index))
        
        # Aggregate to graph-level
        x = global_mean_pool(x, batch)  # Average all nodes per graph
        
        # Classify
        return self.classifier(x)
```

## Link Prediction

Predict if an edge should exist between two nodes:

```python
def link_prediction(model, data, node_i, node_j):
    # Get node embeddings
    embeddings = model(data.x, data.edge_index)
    
    # Score the potential edge
    emb_i = embeddings[node_i]
    emb_j = embeddings[node_j]
    
    # Simple: dot product
    score = torch.dot(emb_i, emb_j)
    probability = torch.sigmoid(score)
    
    return probability
```

## Training a GNN

```python
from torch_geometric.datasets import Planetoid

# Load Cora dataset (citation network)
dataset = Planetoid(root='data', name='Cora')
data = dataset[0]

model = GCN(
    in_channels=dataset.num_features,
    hidden_channels=16,
    out_channels=dataset.num_classes
)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

def train():
    model.train()
    optimizer.zero_grad()
    out = model(data.x, data.edge_index)
    loss = F.cross_entropy(out[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()
    return loss.item()

def test():
    model.eval()
    out = model(data.x, data.edge_index)
    pred = out.argmax(dim=1)
    correct = pred[data.test_mask] == data.y[data.test_mask]
    return correct.sum() / data.test_mask.sum()

for epoch in range(200):
    loss = train()
    if epoch % 20 == 0:
        acc = test()
        print(f"Epoch {epoch}, Loss: {loss:.4f}, Test Acc: {acc:.4f}")
```

## GNN Applications

| Application | Node Task | Edge Task | Graph Task |
|-------------|-----------|-----------|------------|
| Social Networks | User classification | Friend recommendation | Community detection |
| Molecules | Atom property | Bond prediction | Drug discovery |
| Knowledge Graphs | Entity classification | Link prediction | - |
| Traffic | Road segment | - | Traffic prediction |

## Key Takeaway

GNNs extend deep learning to graph-structured data through message passing. Nodes aggregate information from neighbors, learning representations that capture graph structure. Start with GCN for simplicity, use GraphSAGE for large graphs, and GAT when attention matters. PyTorch Geometric makes implementation straightforward.

Learn how GNNs process graph-structured data like social networks, molecules, and knowledge graphs through message passing.

Graph Neural Networks (GNNs): Learning on Graph Data

This comprehensive guide covers 50 essential Machine Learning interview questions that every ML engineer should know. These questions cover fundamental algorithms, model evaluation, feature engineering, optimization, and practical ML concepts commonly asked in technical interviews.

## Core ML Algorithms

Understanding core machine learning algorithms is essential. These questions test your knowledge of linear regression, logistic regression, decision trees, random forests, and ensemble methods.

## Model Evaluation & Metrics

Proper evaluation is crucial for ML models. Master these questions to demonstrate your understanding of accuracy, precision, recall, ROC curves, cross-validation, and model selection.

## Feature Engineering

Feature engineering is often more important than algorithm choice. These questions cover feature selection, transformation, encoding, handling missing values, and feature scaling techniques.

## Optimization & Training

Understanding how models learn is key. These questions cover gradient descent variants, learning rates, regularization techniques, and optimization algorithms used in ML.

## Advanced ML Concepts

Advanced topics include bias-variance tradeoff, overfitting prevention, ensemble methods, and production ML considerations. These questions test your deep understanding of ML principles.

Comprehensive collection of 50 essential Machine Learning interview questions covering algorithms, model evaluation, feature engineering, and ML best practices. Free ML, Machine Learning interview questions with answers. ML AI interview prep guide.

Machine Learning Interview Questions: 50 Essential Questions for Developers

Feature engineering is where the magic happens in machine learning. Good features can make a simple model perform amazingly, while bad features can make even the best algorithms fail. Let's learn how to do it right.

## What is Feature Engineering?

Feature engineering is the process of transforming raw data into features that better represent the underlying problem to the predictive models. It's about creating new features or modifying existing ones to improve model performance.

## Common Techniques

I'll show you the most important techniques - handling missing values, encoding categorical variables, scaling features, creating interaction features, and dealing with outliers. These are used in almost every ML project.

## Feature Selection

Not all features are useful. Some can even hurt your model. Learn how to identify which features matter and remove the ones that don't. This makes your model faster and more accurate.

## Real-World Examples

I'll walk you through real examples - transforming dates into useful features, encoding text data, creating features from images. These patterns you'll use in every project.

Master feature engineering - the most important skill in ML. Learn how to transform raw data into features that make your models accurate. This is what separates good ML engineers from great ones.

Feature Engineering: Making Your Data ML-Ready

Overfitting and underfitting are the two enemies of every ML engineer. Understanding them is crucial for building models that actually work in the real world, not just on your training data.

## What is Overfitting?

Overfitting happens when your model learns the training data too well - including the noise and random fluctuations. It performs great on training data but poorly on new data. It's like memorizing answers instead of understanding concepts.

## What is Underfitting?

Underfitting happens when your model is too simple to capture the underlying patterns. It performs poorly on both training and test data. It's like trying to solve complex problems with simple tools.

## Finding the Balance

The goal is to find the sweet spot - a model that's complex enough to learn patterns but simple enough to generalize. I'll show you techniques like cross-validation, regularization, and early stopping.

## How to Fix Them

For overfitting: use more data, simplify the model, add regularization, or use dropout. For underfitting: use a more complex model, add features, or reduce regularization. I'll show you exactly how.

Understand overfitting and underfitting - the two biggest problems in ML. Learn how to detect them, prevent them, and find the perfect balance. Essential knowledge for building reliable models.

Overfitting and Underfitting: The ML Balance

Testing your model on the same data you trained it on is like taking an exam with the answer key. Cross-validation is the proper way to evaluate models and make sure they'll work on new data.

## What is Cross-Validation?

Cross-validation splits your data into multiple folds, trains on some folds and tests on others, then repeats this process. This gives you a more reliable estimate of how your model will perform on unseen data.

## K-Fold Cross-Validation

The most common type - split data into k folds (usually 5 or 10), train on k-1 folds, test on the remaining fold, repeat k times. You get k performance scores and can calculate the average and standard deviation.

## Stratified K-Fold

For classification problems with imbalanced classes, use stratified k-fold. It ensures each fold has the same proportion of each class, giving you more reliable results.

## When to Use What

I'll show you when to use simple train/test split, when to use k-fold, and when to use stratified. Understanding this helps you evaluate models correctly and avoid false confidence.

Master cross-validation - the right way to evaluate ML models. Learn k-fold, stratified k-fold, and when to use each. Essential for building reliable models that work in production.

Cross-Validation: Testing Your Model Properly

Choosing the right evaluation metric is crucial. Using the wrong metric can make a bad model look good or a good model look bad. Let's learn which metrics to use and when.

## Classification Metrics

For classification, accuracy isn't always enough. Learn about precision (how many positives are actually correct), recall (how many actual positives you found), and F1 score (balance of both). Each tells you something different.

## Regression Metrics

For regression, mean squared error, mean absolute error, and R-squared each have their place. I'll explain when to use which and what they actually mean for your model.

## ROC-AUC and Confusion Matrix

ROC-AUC is great for binary classification, especially with imbalanced data. Confusion matrix shows you exactly where your model makes mistakes. Both are essential tools.

## Real-World Examples

I'll show you real scenarios - when accuracy is misleading, when precision matters more than recall, and how to choose metrics based on your business goals. This is practical knowledge you'll use every day.

Learn which metrics to use for different ML problems. Accuracy, precision, recall, F1 score, ROC-AUC - understand when to use each and why. Essential for evaluating models correctly.

Model Evaluation Metrics: Choosing the Right One

Master Machine Learning algorithms, model training, data science, and ML best practices.

Machine Learning Resources - ML Guide

Browse ML Content

Tutorials

Interview Questions

Practice Problems

Articles & Blog