AI, ML & Deep Learning

1. Why the vocabulary is confusing

Open any tech article from the last few years and you'll see AI, machine learning, and deep learning swapped in for one another like they're the same thing. They aren't, and the differences matter.

Part of the confusion is historical. The term artificial intelligence was coined in 1956 at the Dartmouth workshop, and for decades it meant "any system that does something we'd consider intelligent" — including hand-written rules, search algorithms, and logical inference. Machine learning showed up as a distinct discipline in the 1960s for systems that learn from data instead of being told what to do. Deep learning is the most recent of the three — it's the subset of machine learning that uses neural networks with many layers, and it's what powers nearly every AI system that made the news after 2012.

The reason these three terms get used as synonyms today is that, in the public imagination, every visible "AI" right now happens to be deep learning. ChatGPT is deep learning. Image generators are deep learning. Self-driving perception is deep learning. So the labels collapse together in everyday speech — but they sit in a strict hierarchy underneath.

2. The nested-set picture

The cleanest way to hold the three terms in your head is as concentric rings — each one strictly contained in the next.

Read the diagram from the inside out and you've named the whole field. Every deep-learning system is a machine-learning system. Every machine-learning system is, in the standard usage, an AI system. The reverse direction doesn't hold — most things that count as AI are not machine learning, and most machine learning isn't deep.

The strict containment matters. When someone says "this is built with AI," they could mean almost anything. When someone says "this is built with deep learning," they've told you something specific: there's a neural network in there, probably with millions or billions of parameters, that learned what to do from a large dataset.

3. AI: the broadest set

The original definition of AI, from Russell & Norvig's standard textbook, is famously squishy: a system that acts rationally toward a goal, given what it perceives. Under that definition, a thermostat that uses a rule like "if temp < 68°F, turn on the heater" is technically a (very simple) AI agent. So is a chess engine, a flight planner, a spam filter, and ChatGPT.

The historical research that fits under "AI but not machine learning" is mostly built from two ingredients: search (explore possible moves, pick the best one) and symbolic rules (if-then statements composed by hand). A few examples:

• Minimax chess engines — explore the game tree to some depth, score each leaf with a hand-crafted evaluation function, propagate the best move back up. Deep Blue, which beat Kasparov in 1997, was overwhelmingly this kind of system.
• Expert systems — encyclopedias of "if a patient has X and Y, suspect Z" rules, written by domain experts. MYCIN (1970s) diagnosed bacterial infections this way.
• Classical planning — given a set of actions and goal conditions, search for a sequence of actions that achieves the goal. Used in robotics and logistics long before deep learning.
• Pathfinding — Dijkstra, A* — the algorithms behind GPS routing and game-world navigation.

None of these systems learn. The rules are baked in. If the world changes, a human has to rewrite them. That's the limitation that made researchers reach for the next ring.

4. Machine learning: programming by example

Tom Mitchell's classic 1997 definition captures the shift cleanly:

"A computer program is said to learn from experience E with respect to some task T and performance measure P, if its performance at tasks in T, as measured by P, improves with experience E."

In other words: the program does better at something because it saw more data. The hand-written rule disappears. In its place: a function with adjustable parameters, and an algorithm that tunes those parameters to make the function fit the data.

Mathematically, almost all of ML boils down to picking a function $f_\theta(x)$ with parameters $\theta$, choosing a loss function $\mathcal{L}$ that measures how wrong the function's outputs are, and finding the parameters that minimize the loss:

That's the recipe — whether $f_\theta$ is a one-line linear regression or a 100-billion-parameter neural network.

The classical ML toolkit (the stuff that lives in ML-but-not-DL) is rich and still very much in use:

• Linear and logistic regression — fit a line (or a soft decision boundary). Still the workhorse of medicine, economics, credit scoring.
• Decision trees and random forests — recursive yes/no splits, optionally averaged across many trees. Dominant on tabular data; the technique behind most production fraud-detection systems.
• Support vector machines (SVMs) — find the boundary that separates classes with the widest margin. Hot in the 2000s, still strong on small datasets.
• k-means and other clustering — unsupervised methods that group similar examples without labels.
• Naive Bayes — count word frequencies, apply Bayes' rule. Spam filters for two decades.

Here's a one-screen version of classical ML in code — a linear classifier trained on labeled data:

from sklearn.linear_model import LogisticRegression
from sklearn.feature_extraction.text import TfidfVectorizer

# Turn each email into a vector of word counts
vectorizer = TfidfVectorizer()
X_train = vectorizer.fit_transform(emails_train)

# Fit one layer of weights — one number per word in the vocabulary
model = LogisticRegression()
model.fit(X_train, labels_train)

# Predict on a new email
X_test = vectorizer.transform(["Free money, click here!"])
print(model.predict(X_test))   # → ['spam']

That's a complete, useful spam filter in eight lines. It's machine learning, it's AI, and it's not deep learning — there's exactly one layer of learned weights.

5. Deep learning: the inner ring

The key idea, and the reason "deep" earns its name, is representation learning. In classical ML, a human has to pick good features — for spam filtering, you'd decide that word counts matter, that capitalization matters, that exclamation points matter. The model only learns the weights on those hand-chosen features.

In deep learning, the model learns the features too. Early layers learn small, local patterns; middle layers compose them into bigger patterns; later layers compose those into concepts. For images: edges → textures → shapes → objects. For text: characters → words → phrases → meaning. Nobody writes down what each layer should do — they emerge from training.

Here's the spam classifier from above, rebuilt as a small deep network. The shape is recognizably similar; the difference is that the layers compose:

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(input_dim, 256),   # layer 1 — learned features
    nn.ReLU(),
    nn.Linear(256, 128),         # layer 2 — features of features
    nn.ReLU(),
    nn.Linear(128, 64),          # layer 3 — higher-level features
    nn.ReLU(),
    nn.Linear(64, 1),            # layer 4 — final decision
    nn.Sigmoid(),
)

# Train with gradient descent on the same loss as before:
# binary cross-entropy between model(emails) and labels.

The deep version has four layers of learned weights instead of one, and roughly a hundred times the parameters. On a clean tabular task like spam, it doesn't necessarily beat the one-line logistic regression — classical ML is hard to dethrone on small structured data. Where deep learning wins is on perception-heavy tasks (images, audio, raw text) where the right features are hard or impossible to specify by hand.

The famous deep-learning architectures specialize the basic idea for different data shapes:

• Convolutional Neural Networks (CNNs) — designed for images. Each layer learns small spatial filters that slide across the image.
• Recurrent Neural Networks (RNNs, LSTMs) — designed for sequences. Each step takes the previous step's hidden state plus the new input. Largely superseded by transformers.
• Transformers — the architecture behind every modern language model. Uses attention to let every token in the input see every other token.
• Diffusion models — the architecture behind every modern image, video, and audio generator. Learns to reverse a noise process.

You'll see each of these in detail in later topics. For now, the only thing you need to keep: deep learning is machine learning where the function is a multi-layer neural network. Nothing more, nothing less.

6. Classifying real systems

The fastest way to internalize the nested-set picture is to take a handful of real systems and place each one. Here are the obvious cases:

Notice that AlphaGo and GPT-4 are checked all the way across, but Deep Blue and Google Maps stop at the first column. The deeper the check goes, the more the system learned its behavior rather than having it specified.

7. How the terms get used in practice

Here's the awkward truth: in 2026, "AI" is mostly marketing for "deep learning." The companies selling products call everything "AI" because that's what the market responds to. The researchers building those products usually say "the model" or "the network" — they reserve "AI" for the field, not for individual systems.

A few patterns to recognize:

• "AI-powered" in a product description almost always means a deep neural network is doing the work — usually a transformer if it's a language feature, a CNN or transformer if it's a vision feature.
• "Machine learning" in a job description or research paper often still implies the classical toolkit (regression, trees, SVMs) — especially in domains like finance, biology, or operations research where the data is tabular and the models stay shallow.
• "GenAI" (generative AI) is a marketing-era term for the deep-learning subset that generates new content — text, images, audio, video — rather than just classifying existing content. Every GenAI system is deep learning, but not every deep-learning system is GenAI (an image classifier doesn't generate anything).
• "Foundation models" are the very large, general-purpose deep-learning models — GPT, Claude, Gemini, Llama — pre-trained once on enormous datasets and then adapted to many downstream tasks. We'll devote a whole later topic to them.

The labels matter less than the question "what's actually inside?". When you read about a new system, the useful questions are: Does it learn? From what data? With what architecture? What's the training signal? Those answers tell you what the system can and can't do — far better than any three-letter label.

8. Common pitfalls

9. Worked examples

For each system below, place it in the rings: AI, ML, DL — or some subset. Try to answer before opening the explanation.