AI vs ML vs Deep Learning

Real-world analogy:
AI is the broad concept of "making machines smart."
It's like the term "science" — it encompasses physics, chemistry, biology.
ML and deep learning are specific branches of AI.

┌────────────────────────────────────────────────────────┐
│                  Artificial Intelligence                │
│            (making machines "smart")                    │
│                                                         │
│   ┌──────────────────────────────────────────────┐    │
│   │              Machine Learning                 │    │
│   │        (learning from data)                   │    │
│   │                                               │    │
│   │   ┌──────────────────────────────────────┐   │    │
│   │   │           Deep Learning               │   │    │
│   │   │   (multi-layer neural networks)       │   │    │
│   │   └──────────────────────────────────────┘   │    │
│   └──────────────────────────────────────────────┘    │
└────────────────────────────────────────────────────────┘

Traditional Programming:
  Rules + Data → Program → Output

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

Example:
Traditional: if word == "spam_word" or sender in blacklist: mark_as_spam()
ML: Feed 1 million emails (labeled spam/not-spam) → model learns the pattern
    → detects spam you never explicitly programmed for

Training data:
  Email text → "spam"
  Email text → "not spam"
  Email text → "spam"
  ... (millions of examples)

Trained model:
  New email → predict probability it's spam

Input: 10,000 customer purchase histories (no labels)
Output: "We found 5 distinct customer segments:
         Group 1: Young high-spenders on electronics
         Group 2: Families buying household goods
         ..."

Analogy: Training a dog.
Action: dog sits → treat (reward +1)
Action: dog bites furniture → scolding (reward -10)
Dog learns: sit more, bite furniture less

RL equivalent:
Agent: AI playing chess
Environment: chess board
Action: moves pieces
Reward: +1 for winning, -1 for losing, 0 otherwise
Agent learns: sequences of moves that lead to winning

Example: GPT language models
  Input: "The cat sat on the ___"
  Label: "mat" (generated from the actual next token)
  No human labeling needed!
  
Train on all text on the internet → learns language, facts, reasoning

1. Problem Definition
   What are we predicting? What data do we have?
   Success metric: accuracy, F1, RMSE, revenue impact

2. Data Collection
   Where does the data come from?
   How much is enough? (Rule of thumb: 10x examples per feature)

3. Data Preprocessing (most of the work!)
   - Handle missing values
   - Remove outliers
   - Feature engineering (create useful inputs)
   - Normalize/scale features
   - Split: train (70%) / validation (15%) / test (15%)

4. Model Selection
   Start simple (logistic regression), increase complexity if needed

5. Training
   Feed training data → model adjusts its parameters

6. Evaluation
   How does it perform on UNSEEN data (validation/test set)?

7. Hyperparameter Tuning
   Optimize model settings (learning rate, depth, etc.)

8. Deployment
   Serve predictions via API, monitor for drift

Underfitting (too simple):
  Model fails even on training data
  Like memorizing 2+2=4 but not learning how addition works

Overfitting (too complex):
  Perfect on training data, terrible on new data
  Like memorizing every question in practice exam without understanding

The goal: good generalization — performs well on UNSEEN data

Fixes for overfitting:
  - More training data (most effective)
  - Regularization (L1, L2 — penalize complex models)
  - Dropout (for neural networks — randomly disable neurons during training)
  - Early stopping (stop training before the model memorizes training data)
  - Cross-validation (k-fold CV for reliable evaluation)

High Bias (underfitting):
  Model makes the same types of mistakes consistently
  → Too simple, misses real patterns

High Variance (overfitting):
  Model makes different mistakes on different data
  → Too complex, memorizes noise

Goal: find the sweet spot (bias-variance tradeoff)

from sklearn.model_selection import train_test_split

# NEVER touch test set until final evaluation
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

# Training set: model learns from this
# Validation set: tune hyperparameters, make decisions
# Test set: final unbiased evaluation (touch ONCE, at the end)

# Classification
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

accuracy  = correct_predictions / total_predictions
# Misleading for imbalanced classes (99% accuracy on fraud when 99% is not fraud)

precision = true_positives / (true_positives + false_positives)
# "When I say spam, how often am I right?"

recall    = true_positives / (true_positives + false_negatives)
# "What fraction of actual spam did I catch?"

f1_score  = 2 * (precision * recall) / (precision + recall)
# Harmonic mean — balances precision and recall

# Regression
from sklearn.metrics import mean_squared_error, mean_absolute_error
rmse = sqrt(mean_squared_error(y_true, y_pred))
mae  = mean_absolute_error(y_true, y_pred)

import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
from sklearn.preprocessing import LabelEncoder

# 1. Load data
df = pd.read_csv("titanic.csv")

# 2. Preprocess
df["Age"].fillna(df["Age"].median(), inplace=True)
df["Embarked"].fillna("S", inplace=True)
df = pd.get_dummies(df, columns=["Sex", "Embarked"])
features = ["Pclass", "Age", "SibSp", "Parch", "Fare", "Sex_female", "Sex_male"]
X = df[features]
y = df["Survived"]

# 3. Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 4. Train
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 5. Evaluate
y_pred = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.3f}")
print(classification_report(y_test, y_pred))

# 6. Feature importance
for feat, imp in sorted(zip(features, model.feature_importances_), key=lambda x: -x[1]):
    print(f"{feat}: {imp:.3f}")

Career ladder analogy:

  Data Analyst → answers "what happened?"
  Data Scientist → answers "why did it happen and what will happen?"
  ML Engineer → answers "how do we deploy and scale that prediction?"
  AI Engineer → answers "how do we build applications powered by foundation models?"

Most entry-level DS/ML roles require:
  ✓ Python + Pandas + NumPy (data manipulation)
  ✓ SQL (data querying — often more important than ML!)
  ✓ Classical ML (sklearn: logistic regression, trees, cross-validation)
  ✓ Statistics (hypothesis testing, A/B testing, distributions)
  ✓ Communication (presenting findings to non-technical stakeholders)

NUMERICAL FEATURES (numbers that have magnitude):
  Continuous:  age=28.5, salary=72000.0, temperature=98.6
               → can be any decimal value
               → use StandardScaler or MinMaxScaler before distance models
  Discrete:    num_children=2, purchases_this_month=5
               → whole numbers only

CATEGORICAL FEATURES (labels, no inherent ordering):
  Nominal:  city="Mumbai", department="Engineering", color="red"
            → no order between values
            → encode with One-Hot Encoding (pd.get_dummies)
  Ordinal:  education="Bachelor" < "Master" < "PhD"
            → has meaningful order
            → encode with LabelEncoder or map to integers manually

BOOLEAN FEATURES:
  is_subscriber=True, has_paid=False
  → often used directly as 0/1

TEMPORAL FEATURES:
  signup_date, last_login, created_at
  → extract: hour_of_day, day_of_week, is_weekend, days_since_event
  → never feed raw timestamps to models

TEXT FEATURES:
  reviews, descriptions, support tickets
  → TF-IDF, bag of words, or transformer embeddings

IMAGE / AUDIO / VIDEO:
  → pixel arrays, spectrograms, frame tensors
  → require CNNs or pre-trained feature extractors

import pandas as pd
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer

# Sample data with mixed feature types
data = pd.DataFrame({
    "age":          [25, 30, 35, 28],              # numerical continuous
    "salary":       [50000, 75000, 90000, 60000],  # numerical continuous
    "num_products": [2, 5, 8, 1],                  # numerical discrete
    "city":         ["Mumbai", "Delhi", "Pune", "Mumbai"],  # categorical nominal
    "education":    ["Bachelor", "Master", "PhD", "Bachelor"],  # categorical ordinal
    "joined":       ["2020-01-15", "2019-03-22", "2018-07-01", "2022-05-20"],  # temporal
})

# --- Feature engineering pipeline ---
# 1. Parse dates and extract useful features
data["joined"] = pd.to_datetime(data["joined"])
data["tenure_days"] = (pd.Timestamp.now() - data["joined"]).dt.days
data["join_year"] = data["joined"].dt.year

# 2. Encode categorical: nominal → one-hot
data = pd.get_dummies(data, columns=["city"], prefix="city")

# 3. Encode ordinal: education has meaningful order
edu_map = {"Bachelor": 0, "Master": 1, "PhD": 2}
data["education_level"] = data["education"].map(edu_map)
data = data.drop(columns=["education", "joined"])

print(data.columns.tolist())
# All features are now numeric → ready for any ML model!

Step 1: Load and inspect
  df.head(), df.info(), df.describe(), df.shape

Step 2: Missing value analysis
  df.isnull().sum(), visualize with heatmap

Step 3: Univariate analysis (one variable at a time)
  Numerical: histogram, box plot → check for skew and outliers
  Categorical: bar chart, value_counts()

Step 4: Bivariate analysis (variable vs target)
  Numerical vs target: scatter plot, correlation coefficient
  Categorical vs target: grouped bar chart, crosstab

Step 5: Multivariate analysis
  Correlation matrix (heatmap), pairplot
  Feature importance from a quick Random Forest

import pandas as pd
import numpy as np

# Minimal EDA checklist (works on any dataset)
def quick_eda(df: pd.DataFrame, target: str = None):
    print("=" * 50)
    print(f"Shape: {df.shape[0]} rows × {df.shape[1]} columns")
    print("=" * 50)

    # Missing values
    missing = df.isnull().sum()
    missing_pct = (missing / len(df) * 100).round(1)
    missing_report = pd.DataFrame({"missing_count": missing, "missing_pct": missing_pct})
    missing_report = missing_report[missing_report["missing_count"] > 0]
    if not missing_report.empty:
        print("\n📊 MISSING VALUES:")
        print(missing_report.sort_values("missing_pct", ascending=False))
    else:
        print("\n✅ No missing values")

    # Numerical summary
    numerical_cols = df.select_dtypes(include=np.number).columns.tolist()
    print(f"\n📈 NUMERICAL FEATURES ({len(numerical_cols)}): {numerical_cols}")
    print(df[numerical_cols].describe().round(2))

    # Categorical summary
    categorical_cols = df.select_dtypes(include=object).columns.tolist()
    print(f"\n📝 CATEGORICAL FEATURES ({len(categorical_cols)}): {categorical_cols}")
    for col in categorical_cols:
        print(f"\n  {col} — {df[col].nunique()} unique values:")
        print(f"  {df[col].value_counts().head(5).to_dict()}")

    # Target distribution
    if target and target in df.columns:
        print(f"\n🎯 TARGET: {target}")
        print(df[target].value_counts(normalize=True).round(3))

# Example usage
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
df = pd.DataFrame(data.data, columns=data.feature_names)
df["target"] = data.target
quick_eda(df, target="target")