Zomato's data team collects millions of orders — timestamps, locations, ratings, cuisine type, weather, festivals, and more.

A data scientist cleans this data (removing duplicates, fixing missing pincodes) and runs an analysis:

They build dashboards showing trends city-by-city, cuisine-by-cuisine. The operations team uses this to plan restaurant partnerships and delivery fleet allocation.

Tools used: Python, Pandas, SQL, Matplotlib, Power BI

Key takeaway: Data Science answers "What happened?" and "Why?"

Now Zomato wants to predict, not just report. The ML team takes the cleaned data and trains a model:

The model learns patterns without being explicitly programmed — it figures out rules on its own from thousands of order histories.

🏷️ Features vs Labels

Before training a model, you split your data into two parts:

✂️ Training Data vs Testing Data

You never test a model on the same data it was trained on — that's like giving a student the exact same exam they practiced with. Instead, you split:

Types at play:

• Supervised ML: Predict delivery time (labeled data: past delivery times)
• Unsupervised ML: Group users into segments (budget eaters, health-conscious, party orderers)
• Reinforcement: Optimize delivery routes — the system tries different paths and learns which are fastest

Tools used: Scikit-learn, XGBoost, feature engineering on order data

Key takeaway: ML answers "What will happen?" — it learns patterns and makes predictions.

Some problems are too complex for traditional ML. Zomato needs to:

• 📸 Analyze food photos users upload — is it biryani or pulao? Is the presentation good? (Computer Vision using CNNs)
• 💬 Understand reviews — "The butter chicken was to die for but the naan was stale" → extract sentiment per dish, not just per restaurant (NLP using Transformers)
• 🎙️ Voice ordering — "Order my usual from Paradise Biryani" → understand spoken Hindi/English and map it to an order (Speech Recognition using RNNs)

Tools used: PyTorch, TensorFlow, Hugging Face Transformers, CNNs, BERT

Key takeaway: Deep Learning handles unstructured data (images, text, audio) that traditional ML can't.

Now put it all together. When you open Zomato at 8 PM on a rainy Sunday in Hyderabad:

1. 📊 Data Science already found that biryani + rain + Sunday = peak demand
2. 📈 ML predicts you'll order biryani (based on your past orders) and suggests a gulab jamun combo
3. 🧠 Deep Learning shows you restaurants with the best food photos and filters out places with negative review sentiment
4. 🤖 AI orchestrates everything: personalizes your home screen, estimates delivery in 35 min, assigns the nearest rider, adjusts pricing based on demand, and sends you a push notification: "Craving biryani? Paradise has 20% off tonight!"

Key takeaway: AI is not just one technique — it's the intelligent system that ties DS + ML + DL together to act automatically.

What is it?

The model is trained on labeled data — every input comes with the correct output (the "answer"). The model learns the mapping from input → output, then predicts answers for new, unseen data.

Two sub-types

Real-world examples

Common algorithms

What is it?

The model is given data without labels — no correct answers. It must find hidden patterns, groupings, or structure on its own.

Key techniques

Real-world examples

Common algorithms

🎓 Easy examples to explain in class

The choice depends on one simple question: Do you have labeled data (answers)?

📊 Side-by-side comparison

🎯 Quick classroom recap

Given some input (X), predict a continuous number (Y) by fitting a straight line through the data.

Imagine plotting student study hours (X) vs exam marks (Y) on a graph:

The best fit line is the one that is closest to all the points on average. Some points are above the line, some below — but the line minimizes the total error.

The model doesn't guess the line randomly. It uses a process called Gradient Descent:

1. Start with a random line (random m and b)
2. Predict Y for every X in training data
3. Measure error — how far are predictions from actual values?
4. Adjust m and b slightly to reduce the error
5. Repeat steps 2–4 hundreds/thousands of times until the line fits best

Error measurement (Cost Function)

Linear regression works best when these conditions are roughly true:

After training, you need to measure how good the model is:

Step 1: Collect the data

HR pulls salary records of 10 current employees:

X = Feature (what we know)  |  Y = Label (what we want to predict)

Step 2: Plot it — do we see a line?

Step 3: Understand Y = mX + c

Step 4: Make predictions!

Now a candidate walks in with 4 years of experience. What salary should we offer?

Let's try a few more:

Step 5: Check — is the prediction good?

Compare predicted vs actual for data we already have:

Step 6: What does the slope and intercept MEAN?

Step 7: What changes when m or c changes?

📝 Summary

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

📐 What is IQR (Interquartile Range)?

Imagine you lined up all employee salaries from lowest to highest. Now split them into 4 equal groups:

🤔 Why do we need IQR?

💻 The Code

# Calculate Q1 (25th percentile) and Q3 (75th percentile) for 'monthly_salary'
Q1 = df['monthly_salary'].quantile(0.25)
Q3 = df['monthly_salary'].quantile(0.75)

# Calculate the Interquartile Range (IQR)
IQR = Q3 - Q1

# Define the lower and upper bounds for outlier detection
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

print(f"Q1 (25th percentile): ₹{Q1:,.0f}")
print(f"Q3 (75th percentile): ₹{Q3:,.0f}")
print(f"IQR: ₹{IQR:,.0f}")
print(f"Lower Bound for Outliers: ₹{lower_bound:,.0f}")
print(f"Upper Bound for Outliers: ₹{upper_bound:,.0f}")

🧹 Remove Outliers

# Count rows before outlier removal
rows_before = len(df)

# Filter out rows where 'monthly_salary' is outside the bounds
df = df[(df['monthly_salary'] >= lower_bound) & (df['monthly_salary'] <= upper_bound)]

# Count rows after outlier removal
rows_after = len(df)
rows_removed = rows_before - rows_after

# Print how many rows were removed and the threshold
print(f"\nRemoved {rows_removed} rows with salary above ₹{upper_bound:,.0f} or below ₹{lower_bound:,.0f}")

📊 Visual Summary — Box Plot View

🔤 What is One-Hot Encoding?

Machine Learning models only understand numbers, not text. If your data has a column like department with values "HR", "IT", "Sales" — you must convert it to numbers before training.

One-Hot Encoding creates a new column for each category and fills it with 1 (yes, belongs) or 0 (no, doesn't belong):

🗑️ Why drop_first=True? — The Multicollinearity Trap

Multicollinearity = when one column can be perfectly predicted from other columns. This confuses the model.

💻 The Code

# Apply one-hot encoding to the 'department' column
df = pd.get_dummies(df, columns=['department'], drop_first=True)

# Print the new column names to show the encoded 'department' columns
print("New column names after encoding 'department':")
print(df.columns.tolist())

📋 Expected Output

New column names after encoding 'department':
['name', 'monthly_salary', 'department_IT', 'department_Sales']

# 'department_HR' is gone — it's the baseline (drop_first dropped it)
# When department_IT=0 AND department_Sales=0 → the employee is in HR

🤔 Why do we split data?

Imagine a student who memorises all the answers but can't solve a new question. That's what happens when a model trains AND tests on the same data — it just memorises, it doesn't learn.

🎯 Features (X) vs Target (y)

Full DataFrame (df):

💻 The Code

from sklearn.model_selection import train_test_split

# Define features (X) as all columns except 'monthly_salary'
X = df.drop('monthly_salary', axis=1)

# Define the target variable (y) as 'monthly_salary'
y = df['monthly_salary']

# Split the data into training and testing sets
# 80% for training, 20% for testing
# random_state ensures reproducibility of the split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Print the shapes of the resulting datasets
print(f"Shape of X_train (training features): {X_train.shape}")
print(f"Shape of X_test (testing features): {X_test.shape}")
print(f"Shape of y_train (training target): {y_train.shape}")
print(f"Shape of y_test (testing target): {y_test.shape}")

📦 What do the 4 variables contain?

🏋️ What does "Training" mean?

Training = the model looks at X_train (features) and y_train (correct salaries) and figures out the best equation that connects them.

model.fit(X_train, y_train) — What the model sees during training:

🔮 What does "Predict" mean?

model.predict(X_test) = give the model new inputs it has never seen, and it uses the learned equation to guess the salary.

y_pred = model.predict(X_test) — Model predicts on unseen data:

💻 The Code

from sklearn.linear_model import LinearRegression
import pandas as pd

# Create an instance of the Linear Regression model
model = LinearRegression()

# Train the model using the training features (X_train) and target (y_train)
model.fit(X_train, y_train)

# Make predictions on the test set using the trained model
y_pred = model.predict(X_test)

print(y_pred)

⚡ fit() vs predict() — Key Difference

📊 Why do we evaluate?

The model made predictions (y_pred). But how good are they? We need numbers to measure accuracy — not just "looks okay".

💻 The Code

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

# Calculate R-squared score
R_squared = r2_score(y_test, y_pred)
print(f"R-squared (R²): {R_squared:.2f}")
print(f"Our model explains {R_squared*100:.2f}% of salary variation.\n")

# Calculate Mean Absolute Error (MAE)
MAE = mean_absolute_error(y_test, y_pred)
print(f"Mean Absolute Error (MAE): ₹{MAE:,.2f}")
print(f"On average, our prediction is off by ₹{MAE:,.0f}.\n")

# Calculate Root Mean Squared Error (RMSE)
RMSE = np.sqrt(mean_squared_error(y_test, y_pred))
print(f"Root Mean Squared Error (RMSE): ₹{RMSE:,.2f}")
print(f"RMSE is ₹{RMSE:,.0f} — larger errors are penalised more.")

📈 R² (R-Squared) — "How much does the model explain?"

📏 MAE (Mean Absolute Error) — "By how much am I off?"

MAE Calculation Example:

📐 RMSE (Root Mean Squared Error) — "How bad are the big mistakes?"

RMSE Calculation Example:

⚔️ MAE vs RMSE — When to use which?

📋 Evaluation Cheat Sheet

📈 What does this chart show?

This scatter plot answers one question: "How close are our predictions to reality?" Every dot is one employee from the test set.

🎯 Reading the dots — Example

💻 The Code

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(10, 7))

# Create a scatter plot of actual vs predicted salaries
sns.scatterplot(x=y_test, y=y_pred, alpha=0.9)

# Plot a perfect prediction line (diagonal line from min to max)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()],
         color='orange', linestyle='--', linewidth=2, label='Perfect Prediction')

# Set title and axis labels
plt.title('How close are our salary predictions?', fontsize=16)
plt.xlabel('Actual Salary (in ₹)', fontsize=12)
plt.ylabel('Predicted Salary (in ₹)', fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.legend()
plt.tight_layout()
plt.show()

✅ How to judge your model from this chart

Define the question + success metric (ex: predict churn).

Collect from apps, logs, sensors, databases, surveys.

Fix missing values, duplicates, outliers, formats.

Explore patterns using statistics and visualizations.

Train classification/regression/clustering models.

Validate on unseen data using correct metrics.

Expose model via API, batch jobs, or apps.

Watch drift, retrain, and improve iteratively.