AI vs Machine Learning vs Deep Learning

By the end of this page you'll be able to read a job advert that says "AI/ML", a vendor deck that says "deep learning platform", or a manager asking "do we have AI?", and know which of three different things is meant. Interviewers in Karachi and Lahore ask for this distinction as a warm-up, and a muddled answer sets the tone for the rest of the interview.

Three circles, one inside the other

• Artificial intelligence (AI) is the broad goal of machines doing tasks that need intelligence. Rule engines, search algorithms, planning, robotics and everything below all count.
• Machine learning (ML) is the main way we get there today. Algorithms that learn patterns from data instead of following hand-written rules. Linear regression, decision trees, random forests, gradient boosting and clustering are all ML.
• Deep learning (DL) is the part of ML built on neural networks with many layers. It shines on messy, unstructured input such as images, audio, video and text. Large language models are deep learning.

So every deep learning system is machine learning, and every machine learning system is AI, but never the other way round. A chess engine that searches moves is AI without ML. A sales forecast built on gradient boosting is ML without DL.

Who writes the rules?

That's the real dividing line. In traditional programming a person writes the rules and the computer applies them to data to get answers. In machine learning a person supplies data and known answers, and a training algorithm produces the rules. That bundle of rules is the model, used like a rule book on data it has never seen.

Deep learning goes one step further. Classic ML usually needs a human to design the features ("transactions in the last hour", say), while a deep network learns its own features from raw pixels, sound waves or text. That's why it wins on photos and loses on spreadsheets.

Side by side

	Rule-based AI	Classic machine learning	Deep learning
Rules come from	Human experts	Learned from data with human-chosen features	Learned from raw data, features included
Data needed	None (needs expertise)	Hundreds to millions of rows	Very large, or a pre-trained model
Best for	Clear, stable rules (tax, compliance)	Tabular business data (sales, churn, credit)	Images, speech, text, video
Explainability	Fully transparent	Often good (trees, coefficients)	Hard; needs special tools
Hardware	Any	Laptop	GPUs for training; can run smaller models on CPU
Typical tools	SQL, Python if/else	scikit-learn, XGBoost	PyTorch, TensorFlow, hosted LLM APIs

Three ways to predict a late delivery

A Lahore e-commerce warehouse wants to know which orders will arrive late. Same problem, three approaches.

1. Rule-based. "Late if the destination is outside Punjab and the order came in after 6 p.m." Built in an afternoon, misses a lot, and someone has to keep editing it.
2. Classic ML. Train a decision tree on 200,000 past orders with features such as distance, courier, weight, day of week and city. Accuracy goes up, and you can print the tree and walk the operations team through it.
3. Deep learning. Feed the raw address text, product photos and rider GPS traces into a neural network. Possibly the most accurate, but it wants far more data, GPUs and expertise, and it's harder to explain when it gets one wrong.

We'd pick option 2, and so would most working analysts. Deep learning earns its cost when the input is unstructured (images, free text, audio) or when someone has already trained a model you can reuse.

Here's "learning a rule" at its smallest, in standard-library Python. It fits a straight line to predict delivery days from distance. If the code looks unfamiliar, the free Python track covers everything used here.

from statistics import mean

distance_km = [10, 150, 400, 900, 1200]
delivery_days = [1, 2, 3, 5, 6]

x_bar, y_bar = mean(distance_km), mean(delivery_days)
slope = sum((x - x_bar) * (y - y_bar) for x, y in zip(distance_km, delivery_days)) /         sum((x - x_bar) ** 2 for x in distance_km)
intercept = y_bar - slope * x_bar

print(f"days = {intercept:.2f} + {slope:.4f} * km")
print("Karachi to Peshawar (1400 km):", round(intercept + slope * 1400, 1), "days")

The two numbers it prints, the intercept and the slope, are the learned rules. A deep network learns millions of such numbers, and each one plays exactly the same role.

Three problems, one Faisalabad mill. A textile exporter asked us for "AI quality control", one phrase covering three jobs. Spotting fabric defects from camera images is vision, so deep learning, using a pre-trained model fine-tuned on a few thousand photos of their own cloth. Predicting which orders would miss the shipping date was classic ML on their ERP data. Checking that export documents follow customs rules stayed as plain rules, because rules set by regulation shouldn't be learned from history. Three problems, three circles, one project.

If you take one idea away, take the circles. AI is the goal, ML is the main method, and DL is the family of ML built on layered neural networks. ML swaps hand-written rules for rules learned from data, which we call the model. Classic ML for tabular business data, deep learning for images, audio and text, and always match the method to the data volume and how much you'll need to explain the result.

Homework

1. Classify each as rule-based, classic ML or deep learning: Zakat calculator, customer churn score, Urdu speech-to-text, credit limit policy, product photo search.
2. Run the regression snippet and add a data point for a 2,000 km route. How does the slope change?
3. For a Karachi hospital, propose one problem for each of the three approaches and justify your choice in one sentence each.