AI vs ML vs Deep Learning: Differences and Types of Learning

Imagine your aunt runs a small sweet shop in Sarafa. For years she has priced her poha-jalebi combo with a rule on a sticky note: "If it is Sunday, add 10 rupees." That sticky note is a program. Someone wrote the rule; the shop just follows it.

Now imagine she hands her nephew three years of sales notebooks and says, "Work out the pricing yourself." He studies the numbers and notices that rainy evenings, wedding season and cricket match days all change demand. Nobody told him those rules. He found them in the data.

Finally, imagine he is so good at this that he can look at a photo of the queue outside and guess how many plates will sell in the next hour. He is no longer reading neat columns; he is reading raw pixels and building up his own layers of understanding.

Those three scenes are the whole story of this article.

AI vs ML vs Deep Learning: The Nested Circles

Map the shop to the jargon. The overall wish, "make the shop behave smartly", is artificial intelligence. The nephew learning pricing rules from notebooks is machine learning. The nephew reading photos through layers of perception is deep learning.

Artificial intelligence is the field of building systems that perform tasks we would call intelligent; machine learning is the part of AI where the system learns those behaviours from data; deep learning is the part of ML that uses neural networks with many layers.

Each circle is a subset of the one around it: all deep learning is machine learning, and all machine learning is AI, but not the other way round.

Read the circles from the outside in:

• AI (outer circle) includes things that do not learn at all: a chess engine searching moves, a rule-based chatbot, a route planner in a maps app. They look smart because a human encoded the smartness.
• ML (middle circle) replaces hand-written rules with patterns learned from examples. Spam filters, loan-risk scores and price predictors live here.
• Deep learning (inner circle) stacks many layers of artificial neurons so the model can learn its own features from raw input such as images, audio or text. Face unlock and speech-to-text live here.

A rule vs a learned rule, in code

The quickest way to feel the difference is to write both. The first function is "AI by hand". The second one is ML: it looks at examples and picks the threshold itself.

# Hand-written rule (classic AI): a human chooses the number 30
def rule_based(temp_c):
    return "sell cold lassi" if temp_c > 30 else "sell hot chai"

# Learned rule (ML): try every threshold, keep the one with fewest mistakes
temps  = [18, 22, 25, 27, 29, 31, 33, 35, 38, 40]
best   = ["chai", "chai", "chai", "chai", "lassi", "lassi", "lassi", "lassi", "lassi", "lassi"]

def errors(threshold):
    return sum((t > threshold) != (b == "lassi") for t, b in zip(temps, best))

learned = min(range(15, 41), key=errors)
print("Human rule threshold: 30")
print("Learned threshold:", learned, "with", errors(learned), "mistakes")
print("Rule says at 29C:", rule_based(29))

In this data lassi starts winning at 29°C, so the search lands on 27 with zero mistakes. The human guessed 30 and tells you to sell hot chai on a 29°C afternoon, which the notebook says is wrong. That one small gap is why ML exists: data notices what people miss.

The Three Types of Machine Learning

Once you are inside the ML circle, the next question is what kind of signal does the model learn from? There are three common answers.

The three types of machine learning differ in the feedback they get: correct answers, no answers, or rewards after actions.

Supervised learning: learning with an answer key

You give the model inputs and the correct outputs, like a student practising with a solved answer key. It learns a mapping from input to output, then predicts for new inputs.

• Predicting a flat's rent in Vijay Nagar from its size and floor (a number: regression).
• Marking an email as spam or not spam (a category: classification).
• Checking whether a loan applicant is likely to repay.

from sklearn.linear_model import LogisticRegression

# hours studied, practice tests taken -> passed exam (1) or not (0)
X = [[1, 0], [2, 1], [3, 1], [4, 2], [5, 2], [6, 3], [7, 4], [8, 4], [2, 0], [6, 2]]
y = [0, 0, 0, 1, 1, 1, 1, 1, 0, 1]

model = LogisticRegression().fit(X, y)
for student in [[1, 1], [4, 1], [7, 3]]:
    p = model.predict_proba([student])[0][1]
    print(f"{student} -> pass probability {p:.2f}")

The model was never told "four hours is the line". It inferred it from ten labelled rows.

Unsupervised learning: finding groups with no answer key

Here you only have inputs. There is no "correct" column. The model looks for structure: groups, outliers or a simpler way to describe the data.

• Grouping shoppers at a Treasure Island store by spending pattern (clustering).
• Flagging an unusual card transaction (anomaly detection).
• Squeezing 50 survey questions into 3 underlying themes (dimensionality reduction).

import numpy as np
from sklearn.cluster import KMeans

# monthly visits, average bill in rupees (no labels anywhere)
customers = np.array([[2, 300], [3, 350], [2, 280], [12, 400], [14, 450],
                      [13, 420], [4, 2500], [3, 2700], [5, 2600]])
km = KMeans(n_clusters=3, n_init=10, random_state=0).fit(customers)
for c in range(3):
    group = customers[km.labels_ == c]
    print(f"Group {c}: {len(group)} customers, avg visits {group[:,0].mean():.1f}, avg bill {group[:,1].mean():.0f}")

KMeans finds three kinds of customer: occasional small spenders, frequent regulars and rare big spenders. The business names them; the algorithm only groups them.

Reinforcement learning: learning from rewards

An agent takes an action, the environment gives a reward, and the agent slowly prefers actions that pay off. Nobody labels the right move in advance. Think of a child learning to ride a cycle: wobble, fall, adjust.

• Game-playing agents that learn by playing millions of rounds.
• A warehouse robot learning an efficient path.
• Choosing which of three app banners to show so that clicks go up.

import random
random.seed(1)

true_click_rate = {"banner_A": 0.05, "banner_B": 0.12, "banner_C": 0.08}  # hidden from agent
shown  = {b: 0 for b in true_click_rate}
clicks = {b: 0 for b in true_click_rate}

for visitor in range(3000):
    if random.random() < 0.1:                      # explore 10% of the time
        b = random.choice(list(true_click_rate))
    else:                                          # exploit the best so far
        b = max(shown, key=lambda k: clicks[k] / shown[k] if shown[k] else 1)
    shown[b] += 1
    clicks[b] += random.random() < true_click_rate[b]

for b in shown:
    print(b, "shown", shown[b], "times, observed rate", round(clicks[b] / shown[b], 3))

The agent ends up showing banner B most, because that is where the rewards came from. This tiny loop (an epsilon-greedy bandit) is the seed of reinforcement learning.

When to Use Which Type of Learning

Start from your data and the decision you need, not from the algorithm you find exciting.

Two practical rules help:

1. If a clear rule works, write the rule. ML is for problems where the rule is fuzzy or keeps changing.
2. Labels are the expensive part. If you have 500 labelled rows and 500,000 unlabelled ones, a common approach is to cluster or explore first, then label smartly.

Where deep learning fits

Deep learning is not a fourth type. It is a model family you can use inside any of the three. A neural network can be trained supervised (image classification), unsupervised (autoencoders) or with rewards (game agents). You will build one by hand in the neural network from scratch lab.

For tabular data such as sales sheets, simpler models like decision trees often match or beat deep networks and are far easier to explain to a manager.

Common Mistakes Beginners Make

• Using "AI" and "ML" as synonyms. In interviews, say which one you mean. A rule engine is AI but not ML.
• Assuming deep learning is always better. On a 2,000-row spreadsheet it usually adds complexity, training time and overfitting risk.
• Calling clustering "prediction". Clusters describe your data; they do not come with correct answers to check against.
• Forgetting the baseline. Before training any model, check how a simple rule performs. If the rule gets 90% right, your model must beat that.
• Skipping Python basics. If loops or lists still feel shaky, revise the for loop tutorial first. Every lab here uses them.

If you prefer to learn these ideas with a mentor and a batch of classmates, a hands-on ML programme taught at Debugshala covers the same path from rules to models with hands-on labs.

Key takeaways

• AI is the goal, ML learns the behaviour from data, and deep learning is ML with many-layered neural networks.
• Supervised learning needs labelled examples; unsupervised learning finds structure without labels; reinforcement learning learns from rewards after actions.
• Choose the type from what your data looks like and what decision you need to make.
• Deep learning is a model family, not a learning type, and it shines on raw images, audio and text.
• Always compare against a simple rule or baseline before trusting a model.